| 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::AlgorithmFactory | A base class for algorithm plug-ins factory. Each plug-in declares (through a macro) its own factory. 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 to factorize code |
| 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::VoronoiDiagram::Cell | |
| 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 | Use this class to create a color scale and perform color mapping. The color scale can be either gradient or predefined colors steps. If the color scale is a gradient, returned color 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::ColorVectorType | |
| 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::CoordVectorType | |
| 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::Dependency | Represents a single Tulip plug-in |
| tlp::DoubleAlgorithm | Interface for metric plug-ins |
| tlp::DoubleProperty | |
| tlp::DoubleType | |
| tlp::DoubleVectorProperty | |
| tlp::DoubleVectorType | |
| tlp::edge | Class edge |
| tlp::VoronoiDiagram::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::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 | |
| tlp::ImportModule | Base class for import plug-ins |
| tlp::ImportModuleFactory | |
| tlp::IntegerAlgorithm | Interface for int plug-ins |
| tlp::IntegerProperty | |
| tlp::IntegerType | |
| tlp::IntegerVectorProperty | |
| tlp::IntegerVectorType | |
| tlp::Iterator< itType > | Interface for Tulip iterators. Allows basic iteration operations only |
| tlp::LayoutAlgorithm | Interface for layout plug-ins |
| tlp::LayoutProperty | |
| tlp::LineType | |
| Listener | Listener is the base class for the implementation of an Observbale listener |
| tlp::Matrix< Obj, SIZE > | Class for mathematical square matrix |
| 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 |
| Observer | Observer is the base class for the implementation of an Observbale Observer |
| tlp::OLOException | OLOException is the base class of all exceptions sent by the Observable/Listener/Observer system |
| tlp::OLOObject | OLOObject 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 |
| Onlooker | Onlooker is the base class for Observer and Listener, it enbales to unify these two classes |
| tlp::OuterPlanarTest | Class for testing the outerplanarity of a graph |
| 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::PropertyAlgorithm | This base class describes plug-ins who only modify one property, e.g. selection |
| tlp::PropertyContext | This class is used as only parameter when calling Property plug-ins. It contains a Graph on whyich to run the plug-in, a PropertyInterface which will hold the result of the plug-in, and a PluginProgress to give feedback on the plug-in's progress |
| tlp::PropertyEvent | Event class for specific events on PropertyInterface |
| tlp::PropertyFactory< T > | |
| tlp::PropertyInterface | |
| tlp::PropertyObserver | Observer for Property |
| tlp::QuadTreeNode< TYPE > | QuadTree template class |
| tlp::VoronoiDiagram::Ray | |
| tlp::Rectangle< Obj > | Class for rectangle |
| tlp::SelfLoops | |
| 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::SizeVectorType | |
| 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::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 |
| tlp::TreeTest | Class for testing if the graph is a tree |
| tlp::TriconnectedTest | Class for testing if a graph is triconnected |
| tlp::TypedData< T > | |
| tlp::TypedDataSerializer< T > | |
| tlp::TypedValueContainer< TYPE > | |
| tlp::UniqueIterator< TYPE, TOCHECKFUNCTOR > | UniqueIterator enables to remove duplicated elements in an iterator |
| 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. These parameters can be of any type, and are used to generate a GUI that will be shown when the plug-in in invoked by the user. It is mainly used by algorithms to display options to the user, e.g. a clustering algorithm can let the user choose which measure to use |