Overview | Modules | Class Hierarchy | Classes | Members

Class List
Here are the classes, structs, unions and interfaces with brief descriptions:

tlp::AbstractProperty< Tnode, Tedge, TPROPERTY > | This class is used to store a property of a graph. It implements PropertyInterface and add new methods to deal with two distinct type of values :
tlp::AbstractVectorProperty< vectType, eltType > |
tlp::AcyclicTest | Class for testing if the graph is acyclic

tlp::Algorithm

This abstract class describes a basic algorithm plugin. It inherits on WithParameter and WithDependency for convenience. Basic functionality consists in checking the algorithm can run on the current Graph (e.g. is the graph simple ?), running the algorithm and resetting the algorithm to re-apply it. The algorithm can and should report progress and which task it is performing if it is decomposed in multiple phases (e.g. layouting the graph, coloring it, ...)

tlp::AlgorithmContext | Parameter for calling clustering plugins
tlp::AlgorithmPlugin | A class for algorithm plug-ins The factory the registers itself in the Tulip plug-in system (through the static initFactory() method when the library is loaded.. The actual registration is delegated to a TemplateFactory for code factorization
tlp::Array< Obj, SIZE > | Fixed-size array encapsulation. In debug mode, a bound check is performed at each access
tlp::Bfs |
tlp::BiconnectedTest | Class for testing if the graph is biconnected
tlp::BooleanAlgorithm | Interface for selection plug-ins
tlp::BooleanProperty |
tlp::BooleanType |
tlp::BooleanVectorProperty |
tlp::BooleanVectorType |
tlp::BoundingBox | This class represents the 3D bounding box of an object. It is mostly used to determine whether or not two object are in a state of collision
tlp::CheckAllFunctor< TYPE > | That class implement a default functor that always return true
tlp::Circle< Obj > | Class for circle
tlp::Color |
tlp::ColorAlgorithm | Interface for color plug-ins
tlp::ColorProperty |
tlp::ColorScale | This class represents a color scale to perform color mapping. The color scale can be either gradient or predefined colors steps. If the color scale is a gradient, returned colors are interpolated in function of the position. If the color scale isn't a gradient returned colors are the predefined colors steps
tlp::ColorType |
tlp::ColorVectorProperty |
tlp::ConcatIterator< itType > | This Iterator iterates over the sequence formed by the concatenation of the sequences it is given
tlp::ConnectedTest | Class for testing if the graph is connected
tlp::ConversionIterator< TYPEIN, TYPEOUT, CONVERSIONFUNCTOR > | Iterator that enables to convert an Iterator of type TYPEIN to an Iterator if type TYPEOUT
tlp::Coord | This class represents a point in 3-D space, with float precision
tlp::CoordVectorProperty |
tlp::DataMem |
tlp::DataSet | A container which can store data of any type, as long as it has a well-defined copy constructor
tlp::DataType |
tlp::DataTypeSerializer |
tlp::DataTypeSerializerContainer |
tlp::Dependency | Represents a single Tulip plug-in
tlp::DoubleAlgorithm | Interface for metric plug-ins
tlp::DoubleProperty |
tlp::DoubleType |
tlp::DoubleVectorProperty |
tlp::edge | Class edge
tlp::EdgeProperty< TYPE > | That class enables to define a property/attribute on edges on a VectorGraph
tlp::EdgeSetType |
tlp::Event | Event is the base class for all events used in the Observable/listener/Observer mechanism
tlp::ExportModule | Interface for exportModule plug-ins
tlp::ExportModuleFactory |
tlp::Face | Class face
tlp::FilterIterator< TYPE, FILTER > | Iterator that enables to filter an other Iterator
tlp::FloatType |
tlp::Graph | Interface for a graph
tlp::GraphEvent | Event class for specific events on Graph
tlp::GraphObserver | That class receives a message (call back/handler function) after each modification of a Graph
tlp::GraphProperty |
tlp::GraphStorage | That class provide a simple implementation for the storage of graph elts (nodes edges)
tlp::GraphStorageIdsMemento | That class provides a simple interface to save the state of the ids manage by the GraphStorage class
tlp::GraphType |
stdext::hash< const std::string > |
stdext::hash< double > |
stdext::hash< float > |
stdext::hash< std::string > |
tlp::ImportModule | Base class for import plug-ins
tlp::ImportModuleFactory |
tlp::IntegerAlgorithm | Interface for int plug-ins
tlp::IntegerProperty |
tlp::IntegerType |
tlp::IntegerVectorProperty |
tlp::Iterator< itType > | Interface for Tulip iterators. Allows basic iteration operations only
tlp::LayoutAlgorithm | Interface for layout plug-ins
tlp::LayoutProperty |
tlp::LineType |
tlp::LongType |
tlp::Matrix< Obj, SIZE > | Class for mathematical square matrix
tlp::MemoryBlocks |
tlp::MemoryPool< TYPE > | That class enables to easily create a memory pool for an a class
tlp::PropertyInterface::MetaValueCalculator |
tlp::AbstractProperty< Tnode, Tedge, TPROPERTY >::MetaValueCalculator | This class is used to delegate the computation of the values associated to meta nodes or edges
tlp::MPConversionIterator< TYPEIN, TYPEOUT, CONVERSIONFUNCTOR > | MPConversionIterator implements memory pool for ConversionIterator
tlp::MPFilterIterator< TYPE, FILTER > | MPFilterIterator implements memory pool for FilterIterator
tlp::MPStlFilterIterator< VALUE, ITERATOR, FILTER > | MPStlFilterIterator implements memory pool for StlFilterIterator
tlp::MPStlIterator< VALUE, ITERATOR > | MPStlIterator implements memory pool for StlIterator
tlp::MPUniqueIterator< TYPE, TOCHECKFUNCTOR > | MPUniqueIterator implements memory pool for UniqueIterator
tlp::MutableContainer< TYPE > |
tlp::node | Class node
tlp::NodeProperty< TYPE > | That class enables to define a property/attribute on nodes on a VectorGraph
tlp::Observable | Observable is the base class for the implementation of observable Object by Listener or Observer objects
tlp::ObservableException | ObservableException is the base class of all exceptions sent by the Observable/Listener/Observer system
ObservableObject | ObservableObject is the base class of the Observable/Listener/Observer object hierachy. It manages storage of a unique id for these objects as well as the storage of relations between them. It also manages destruction of these objects
tlp::OuterPlanarTest | Class for testing the outerplanarity of a graph
tlp::ParameterDescription | Describes a parameter with a type, default value, whether or not is it mandatory and a help string describing what this parameter should be used for
tlp::ParameterDescriptionList | This class describes parameters taken by a plugin
tlp::PlanarityTest | Class for testing the planarity of a graph

tlp::PluginInfoInterface

Base interface for plug-in description. This class is not intented to be subclassed by plug-ins themselves, but by the factories who create the plug-ins. This class holds user informations, such as name of the author, date of creation, and miscellaneous informations. It also holds informations for the Tulip plug-in system, such as the version (used to know when there is an update for a plug-in), the name (used as unique identifier to register the plug-in), the Tulip version the plug-in was built with (to know whether the plug-in is compatible with the currently running version of TUlip), and the group this plug-in belongs to (e.g. trees)

tlp::PluginLoader |
tlp::PluginLoaderTxt |
tlp::PluginProgress | Interface to notify and control the progression of a process
tlp::PointType |
tlp::PreferenceManager | Class to manage preference Singleton class to load/store preference need by Tulip
tlp::PropertyEvent | Event class for specific events on PropertyInterface
tlp::PropertyInterface |
tlp::PropertyObserver | Observer for Property
tlp::QuadTreeNode< TYPE > | QuadTree template class
tlp::Rectangle< Obj > | Class for rectangle
tlp::SelfLoops |
tlp::SerializableType< T > |
tlp::SerializableVectorType< VT, openParen > |
tlp::SimplePluginProgress | Basic implementation for PluginProgress interface
tlp::SimpleTest |
tlp::Size |
tlp::SizeAlgorithm | Interface for sizes plug-ins
tlp::SizeProperty |
tlp::SizeType |
tlp::SizeVectorProperty |
tlp::SortNodeIterator | This Iterator sorts the nodes in a sequence based on their values in a DoubleProperty
tlp::SortTargetEdgeIterator | This Iterator sorts the edges based on the values of their target nodes in a DoubleProperty
tlp::StableIterator< itType > | Stores the elements of an iterator and iterates on a copy
tlp::StlFilterIterator< VALUE, ITERATOR, FILTER > | Iterator that enables to filter a Stl Iterator
tlp::StlIterator< VALUE, ITERATOR > |
tlp::StlMapIterator< KEY, VALUE > |
tlp::StlMapValueIterator< KEY, VALUE > |
tlp::StringAlgorithm | Interface for String plug-ins
tlp::StringCollection |
tlp::StringProperty |
tlp::StringType |
tlp::StringVectorProperty |
tlp::StringVectorType |
tlp::StructDef | This class enables to define a structure
tlp::TemplateFactory< ObjectFactory, ObjectType, Context > | This template class takes 3 parameters :
tlp::TemplateFactoryInterface | This interface lists functions used to regroup plug-ins
TextBgColorSetup |
TextEffectSetup |
TextFgColorSetup |
tlp::TreeTest | Class for testing if the graph is a tree
tlp::TriconnectedTest | Class for testing if a graph is triconnected
tlp::TulipException | TulipException is a basic class to build exceptions from string
tlp::TypedData< T > |
tlp::TypedDataSerializer< T > |
tlp::TypedValueContainer< TYPE > |
tlp::TypeInterface< T > |
tlp::UniqueIterator< TYPE, TOCHECKFUNCTOR > | UniqueIterator enables to remove duplicated elements in an iterator
tlp::UnsignedIntegerType |
tlp::ValArray< TYPE > | Internal class to access to a stl::vector in VectorGraph
tlp::ValArrayInterface | Internal class to access to a stl::vector in VectorGraph
tlp::Vector | Class for mathematical vector
tlp::VectorCast | Class for mathematical vector
tlp::VectorGraph | That class provide a simple implementation of graph structure (without subgraphs, observer, metagraph) it enables to obtain very efficient access/modification time
tlp::VectorGraphProperty< TYPE > | That class enables to factorize code for NodeProperty and EdgeProperty in VectorGraph, it could not be used directly
tlp::VoronoiDiagram |
tlp::WithDependency | Describes the dependencies of a plug-in on other plug-ins, identified by their name. This allows to have a plug-in inner workings depend on other plug-ins without linking them statically, or hoping depended plug-in will be there
tlp::WithParameter | This class describes parameters on a plug-in

Tulip Software by LaBRI Visualization Team 2001 - 2012