 tlp::AlgorithmContext | Parameter for calling clustering plugins |
 tlp::Array< Obj, SIZE > | Fixed-size array encapsulation. In debug mode, a bound check is performed at each access |
 tlp::Array< TYPE, SIZE > | |
  tlp::Vector | Class for mathematical vector |
 tlp::Array< Vec3f, 2 > | |
  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::Array< Vector< Obj, 2 >, 2 > | |
  tlp::Rectangle< Obj > | Class for rectangle |
 tlp::Array< Vector< Obj, SIZE >, SIZE > | |
  tlp::Matrix< Obj, SIZE > | Class for mathematical square matrix |
 tlp::Bfs | |
 tlp::VoronoiDiagram::Cell | |
 tlp::CheckAllFunctor< TYPE > | That class implement a default functor that always return true |
 tlp::DataMem | |
  tlp::DataType | |
   tlp::TypedData< T > | |
  tlp::TypedValueContainer< TYPE > | |
 tlp::DataSet | A container which can store data of any type, as long as it has a well-defined copy constructor |
 tlp::DataTypeSerializer | |
  tlp::TypedDataSerializer< T > | |
 tlp::DataTypeSerializerContainer | |
 tlp::Dependency | Represents a single Tulip plug-in |
 tlp::edge | Class edge |
 tlp::VoronoiDiagram::Edge | |
 tlp::Event | Event is the base class for all events used in the Observable/listener/Observer mechanism |
  tlp::GraphEvent | Event class for specific events on Graph |
  tlp::PropertyEvent | Event class for specific events on PropertyInterface |
 tlp::Face | Class face |
 tlp::GraphObserver | That class receives a message (call back/handler function) after each modification of a Graph |
  tlp::AcyclicTest | Class for testing if the graph is acyclic |
  tlp::BiconnectedTest | Class for testing if the graph is biconnected |
  tlp::ConnectedTest | Class for testing if the graph is connected |
  tlp::DoubleProperty | |
  tlp::GraphProperty | |
  tlp::IntegerProperty | |
  tlp::LayoutProperty | |
  tlp::OuterPlanarTest | Class for testing the outerplanarity of a graph |
  tlp::PlanarityTest | Class for testing the planarity of a graph |
  tlp::SimpleTest | |
  tlp::TreeTest | Class for testing if the graph is a tree |
  tlp::TriconnectedTest | Class for testing if a graph is triconnected |
 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 |
 stdext::hash< const std::string > | |
 stdext::hash< double > | |
 stdext::hash< std::string > | |
 tlp::Iterator< itType > | Interface for Tulip iterators. Allows basic iteration operations only |
  tlp::ConcatIterator< itType > | This Iterator iterates over the sequence formed by the concatenation of the sequences it is given |
  tlp::StableIterator< itType > | Stores the elements of an iterator and iterates on a copy |
 tlp::Iterator< edge > | |
  tlp::StableIterator< edge > | |
   tlp::SortTargetEdgeIterator | This Iterator sorts the edges based on the values of their target nodes in a DoubleProperty |
 tlp::Iterator< node > | |
  tlp::StableIterator< node > | |
   tlp::SortNodeIterator | This Iterator sorts the nodes in a sequence based on their values in a DoubleProperty |
 tlp::Iterator< std::pair< KEY, VALUE > > | |
  tlp::StlMapIterator< KEY, VALUE > | |
 tlp::Iterator< TYPE > | |
  tlp::FilterIterator< TYPE, FILTER > | Iterator that enables to filter an other Iterator |
   tlp::MPFilterIterator< TYPE, FILTER > | MPFilterIterator implements memory pool for FilterIterator |
  tlp::UniqueIterator< TYPE, TOCHECKFUNCTOR > | UniqueIterator enables to remove duplicated elements in an iterator |
   tlp::MPUniqueIterator< TYPE, TOCHECKFUNCTOR > | MPUniqueIterator implements memory pool for UniqueIterator |
 tlp::Iterator< TYPEOUT > | |
  tlp::ConversionIterator< TYPEIN, TYPEOUT, CONVERSIONFUNCTOR > | Iterator that enables to convert an Iterator of type TYPEIN to an Iterator if type TYPEOUT |
   tlp::MPConversionIterator< TYPEIN, TYPEOUT, CONVERSIONFUNCTOR > | MPConversionIterator implements memory pool for ConversionIterator |
 tlp::Iterator< VALUE > | |
  tlp::StlFilterIterator< VALUE, ITERATOR, FILTER > | Iterator that enables to filter a Stl Iterator |
   tlp::MPStlFilterIterator< VALUE, ITERATOR, FILTER > | MPStlFilterIterator implements memory pool for StlFilterIterator |
  tlp::StlIterator< VALUE, ITERATOR > | |
   tlp::MPStlIterator< VALUE, ITERATOR > | MPStlIterator implements memory pool for StlIterator |
  tlp::StlMapValueIterator< KEY, VALUE > | |
 Listener | Listener is the base class for the implementation of an Observbale listener |
 tlp::MemoryBlocks | |
 tlp::MemoryPool< TYPE > | That class enables to easily create a memory pool for an a class |
 tlp::MemoryPool< MPConversionIterator< TYPEIN, TYPEOUT, CONVERSIONFUNCTOR > > | |
  tlp::MPConversionIterator< TYPEIN, TYPEOUT, CONVERSIONFUNCTOR > | MPConversionIterator implements memory pool for ConversionIterator |
 tlp::MemoryPool< MPFilterIterator< TYPE, FILTER > > | |
  tlp::MPFilterIterator< TYPE, FILTER > | MPFilterIterator implements memory pool for FilterIterator |
 tlp::MemoryPool< MPStlFilterIterator< VALUE, ITERATOR, FILTER > > | |
  tlp::MPStlFilterIterator< VALUE, ITERATOR, FILTER > | MPStlFilterIterator implements memory pool for StlFilterIterator |
 tlp::MemoryPool< MPStlIterator< VALUE, ITERATOR > > | |
  tlp::MPStlIterator< VALUE, ITERATOR > | MPStlIterator implements memory pool for StlIterator |
 tlp::MemoryPool< MPUniqueIterator< TYPE, TOCHECKFUNCTOR > > | |
  tlp::MPUniqueIterator< TYPE, TOCHECKFUNCTOR > | MPUniqueIterator implements memory pool for UniqueIterator |
 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::MutableContainer< TYPE > | |
 tlp::MutableContainer< typename tlp::BooleanType::RealType > | |
 tlp::MutableContainer< typename tlp::BooleanVectorType::RealType > | |
 tlp::MutableContainer< typename tlp::ColorVectorType::RealType > | |
 tlp::MutableContainer< typename tlp::CoordVectorType::RealType > | |
 tlp::MutableContainer< typename tlp::DoubleVectorType::RealType > | |
 tlp::MutableContainer< typename tlp::IntegerVectorType::RealType > | |
 tlp::MutableContainer< typename tlp::SizeVectorType::RealType > | |
 tlp::MutableContainer< typename tlp::StringVectorType::RealType > | |
 tlp::MutableContainer< typename vectType::RealType > | |
 tlp::node | Class node |
 Observer | Observer is the base class for the implementation of an Observbale Observer |
 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 |
  tlp::Observable | Observable is the base class for the implementation of observable Object by Listener or Observer objects |
   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::Graph | Interface for a graph |
   tlp::PropertyInterface | |
    tlp::AbstractProperty< tlp::BooleanType, tlp::BooleanType, tlp::BooleanAlgorithm > | |
     tlp::BooleanProperty | |
    tlp::AbstractProperty< tlp::BooleanVectorType, tlp::BooleanVectorType > | |
     tlp::AbstractVectorProperty< tlp::BooleanVectorType, tlp::BooleanType > | |
      tlp::BooleanVectorProperty | |
    tlp::AbstractProperty< tlp::ColorVectorType, tlp::ColorVectorType > | |
     tlp::AbstractVectorProperty< tlp::ColorVectorType, tlp::ColorType > | |
      tlp::ColorVectorProperty | |
    tlp::AbstractProperty< tlp::CoordVectorType, tlp::CoordVectorType > | |
     tlp::AbstractVectorProperty< tlp::CoordVectorType, tlp::PointType > | |
      tlp::CoordVectorProperty | |
    tlp::AbstractProperty< tlp::DoubleVectorType, tlp::DoubleVectorType > | |
     tlp::AbstractVectorProperty< tlp::DoubleVectorType, tlp::DoubleType > | |
      tlp::DoubleVectorProperty | |
    tlp::AbstractProperty< tlp::IntegerVectorType, tlp::IntegerVectorType > | |
     tlp::AbstractVectorProperty< tlp::IntegerVectorType, tlp::IntegerType > | |
      tlp::IntegerVectorProperty | |
    tlp::AbstractProperty< tlp::SizeVectorType, tlp::SizeVectorType > | |
     tlp::AbstractVectorProperty< tlp::SizeVectorType, tlp::SizeType > | |
      tlp::SizeVectorProperty | |
    tlp::AbstractProperty< tlp::StringVectorType, tlp::StringVectorType > | |
     tlp::AbstractVectorProperty< tlp::StringVectorType, tlp::StringType > | |
      tlp::StringVectorProperty | |
    tlp::AbstractProperty< vectType, vectType > | |
     tlp::AbstractVectorProperty< vectType, eltType > | |
    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::ColorProperty | |
     tlp::DoubleProperty | |
     tlp::GraphProperty | |
     tlp::IntegerProperty | |
     tlp::LayoutProperty | |
     tlp::SizeProperty | |
     tlp::StringProperty | |
 Onlooker | Onlooker is the base class for Observer and Listener, it enbales to unify these two classes |
 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::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::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::ExportModuleFactory | |
  tlp::ImportModuleFactory | |
 tlp::PluginLoader | |
  tlp::PluginLoaderTxt | |
 tlp::PluginProgress | Interface to notify and control the progression of a process |
  tlp::SimplePluginProgress | Basic implementation for PluginProgress interface |
 tlp::PreferenceManager | Class to manage preference Singleton class to load/store preference need by Tulip |
 tlp::PropertyObserver | Observer for Property |
 tlp::QuadTreeNode< TYPE > | QuadTree template class |
 tlp::VoronoiDiagram::Ray | |
 tlp::SelfLoops | |
 tlp::StringCollection | |
 tlp::StructDef | This class enables to define a structure |
 tlp::TemplateFactoryInterface | This interface lists functions used to regroup plug-ins |
  tlp::TemplateFactory< ObjectFactory, ObjectType, Context > | This template class takes 3 parameters : |
 TextBgColorSetup | |
 TextEffectSetup | |
 TextFgColorSetup | |
 tlp::TulipException | TulipException is a basic class to build exceptions from string |
  tlp::OLOException | OLOException is the base class of all exceptions sent by the Observable/Listener/Observer system |
 tlp::TypeInterface< T > | |
  tlp::SerializableType< T > | |
 tlp::TypeInterface< bool > | |
  tlp::BooleanType | |
 tlp::TypeInterface< double > | |
  tlp::SerializableType< double > | |
   tlp::DoubleType | |
 tlp::TypeInterface< float > | |
  tlp::SerializableType< float > | |
   tlp::FloatType | |
 tlp::TypeInterface< int > | |
  tlp::SerializableType< int > | |
   tlp::IntegerType | |
 tlp::TypeInterface< long > | |
  tlp::SerializableType< long > | |
   tlp::LongType | |
 tlp::TypeInterface< std::set< edge > > | |
  tlp::EdgeSetType | |
 tlp::TypeInterface< std::string > | |
  tlp::StringType | |
 tlp::TypeInterface< std::vector< bool > > | |
  tlp::BooleanVectorType | |
 tlp::TypeInterface< std::vector< std::string > > | |
  tlp::StringVectorType | |
 tlp::TypeInterface< std::vector< tlp::Coord > > | |
  tlp::SerializableVectorType< tlp::Coord, false > | |
   tlp::LineType | |
 tlp::TypeInterface< std::vector< VT > > | |
  tlp::SerializableVectorType< VT, openParen > | |
 tlp::TypeInterface< tlp::Color > | |
  tlp::ColorType | |
 tlp::TypeInterface< tlp::Coord > | |
  tlp::SerializableType< tlp::Coord > | |
   tlp::PointType | |
 tlp::TypeInterface< tlp::Graph * > | |
  tlp::GraphType | |
 tlp::TypeInterface< tlp::Size > | |
  tlp::SerializableType< tlp::Size > | |
   tlp::SizeType | |
 tlp::TypeInterface< unsigned int > | |
  tlp::SerializableType< unsigned int > | |
   tlp::UnsignedIntegerType | |
 tlp::ValArrayInterface | Internal class to access to a stl::vector in VectorGraph |
  tlp::ValArray< TYPE > | Internal class to access to a stl::vector in VectorGraph |
 tlp::Vector< Obj, 2 > | |
  tlp::Circle< Obj > | Class for circle |
 tlp::Vector< Obj, SIZE > | |
  tlp::VectorCast | Class for mathematical vector |
 tlp::Vector< unsigned char, 4 > | |
  tlp::Color | |
 tlp::VectorCast< float, 3, tlp::Coord > | |
  tlp::Coord | This class represents a point in 3-D space, with float precision |
 tlp::VectorCast< float, 3, tlp::Size > | |
  tlp::Size | |
 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::EdgeProperty< TYPE > | That class enables to define a property/attribute on edges on a VectorGraph |
  tlp::NodeProperty< TYPE > | That class enables to define a property/attribute on nodes on a VectorGraph |
 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::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::BooleanAlgorithm | Interface for selection plug-ins |
   tlp::ColorAlgorithm | Interface for color plug-ins |
   tlp::DoubleAlgorithm | Interface for metric plug-ins |
   tlp::IntegerAlgorithm | Interface for int plug-ins |
   tlp::LayoutAlgorithm | Interface for layout plug-ins |
   tlp::SizeAlgorithm | Interface for sizes plug-ins |
   tlp::StringAlgorithm | Interface for String plug-ins |
  tlp::ExportModule | Interface for exportModule plug-ins |
  tlp::ImportModule | Base class for import plug-ins |
  tlp::PropertyAlgorithm | This base class describes plug-ins who only modify one property, e.g. selection |
 tlp::WithParameter | This class describes parameters on a plug-in |
  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::ExportModule | Interface for exportModule plug-ins |
  tlp::ImportModule | Base class for import plug-ins |
  tlp::PropertyAlgorithm | This base class describes plug-ins who only modify one property, e.g. selection |