In Tulip, a property is an attribute of an element of a graph. It is called a property in order to prevent confusion with attributes of a graph: properties are for elements and attributes are for graphs. In Tulip, a property is always defined for both kinds of elements (nodes and edges), so one can always query for the value of the property associated with any edge or node.
To access the value of an elements one must query the graph for a property. This makes the use of the library less intuitive, but it minimizes memory usage for properties.
A property can be seen as an associative table where you can set and get the value for every element. All property operations have a TYPE argument, so there is no need to cast the result of a property query. The standard operations of a property are:
List of available modification operations
void setNodeValue(node,TYPE) : sets the value of a node.
void setAllNodeValue(TYPE) : sets the value of all nodes.
void setEdgeValue(edge,TYPE) : sets the value of an edge.
void setAllEdgeValue(TYPE) : sets the value of all edges.
List of available access operations
TYPE getNodeValue(node) : returns the value of a node.
TYPE getEdgeValue(edge) : returns the value of an edge.
For each property type there is a specific implementation (subclass) that allows operations which
are specific to the property type (see Tulip libraries documentation). For instance, it is possible to obtain
the maximum value of a property if the property type is
A graph includes a set of functions that enables to obtain/create/delete a property. Because
the C++ signature of functions does not include the return type, the syntax for this call is not
very simple. For instance, if one wants to obtain a property containing double (called DoubleProperty in Tulip) one must use
the following syntax :
DoubleProperty *metric=graph->getProperty<DoubleProperty>("name of the property");
In the graph each property is identified by its name which is a std::string, when one asks for a property the type of this
property is checked using the run time type interrogation mechanism of C++. Warning: This test only happens when one
compiles its sources in DEBUG mode (default mode). In order to facilitate the navigation/edition of the set of properties, a
set of functions is accessible through the graph interface.
List of available operations
Iterator * getLocalProperties() : returns an iterator on all properties of this graph.
void delLocalProperty(const std::string&) : deletes a property.
bool existLocalProperty(const std::string&) : returns true if the property exists.
PropertyType * getLocalProperty (const std::string&) : returns the property.
If it did not exist, creates it first
For the property mechanism described above to work with a hierarchy of graphs, a mechanism have been added to share properties between graphs, which works like this: if a property exists in an ancestor of a graph G, it also exists in the graph G. Thus, properties of graphs are inherited like members of objects in object-oriented languages. In order to facilitate the navigation/edition of properties, a set of function is accessible through the graph interface.
List of available operations
Iterators * getInheritedProperties() : returns an iterator on all properties (both inherited and local).
bool existProperty(const std::string&) : returns true if the property exists (inherited or local).
PropertyType * getProperty(const std::string&) : returns the property (inherited or local).
If it did not exist, creates it first (locally)