20 #ifndef ABSTRACT_PROPERTY_H 
   21 #define ABSTRACT_PROPERTY_H 
   26 #include <tulip/tulipconf.h> 
   27 #include <tulip/StoredType.h> 
   28 #include <tulip/MutableContainer.h> 
   29 #include <tulip/PropertyInterface.h> 
   30 #include <tulip/Iterator.h> 
   31 #include <tulip/DataSet.h> 
   32 #include <tulip/Graph.h> 
   54 template <
class Tnode, 
class Tedge, 
class Tprop = PropertyInterface>
 
   57   friend class GraphView;
 
   66   typename Tnode::RealType getNodeDefaultValue() 
const;
 
   72   typename Tedge::RealType getEdgeDefaultValue() 
const;
 
   82   typename tlp::StoredType<typename Tnode::RealType>::ReturnedConstValue
 
   83   getNodeValue(
const node n) 
const;
 
   88   const typename tlp::StoredType<typename Tnode::RealType>::ReturnedConstValue
 
   90     return getNodeValue(n);
 
  101   typename tlp::StoredType<typename Tedge::RealType>::ReturnedConstValue
 
  102   getEdgeValue(
const edge e) 
const;
 
  107   typename tlp::StoredType<typename Tedge::RealType>::ReturnedConstValue 
operator[](
edge e)
 const {
 
  108     return getEdgeValue(e);
 
  117   getNodesEqualTo(
typename tlp::StoredType<typename Tnode::RealType>::ReturnedConstValue v,
 
  118                   const Graph *g = 
nullptr) 
const;
 
  126   getEdgesEqualTo(
typename tlp::StoredType<typename Tedge::RealType>::ReturnedConstValue v,
 
  127                   const Graph *g = 
nullptr) 
const;
 
  136   setNodeValue(
const node n,
 
  137                typename tlp::StoredType<typename Tnode::RealType>::ReturnedConstValue v);
 
  150     typename tlp::StoredType<typename Tnode::RealType>::ReturnedConstValue getValue()
 const {
 
  159     operator=(
typename tlp::StoredType<typename Tnode::RealType>::ReturnedConstValue val) noexcept {
 
  177     operator typename tlp::StoredType<typename Tnode::RealType>::ReturnedConstValue() {
 
  196   setEdgeValue(
const edge e,
 
  197                typename tlp::StoredType<typename Tedge::RealType>::ReturnedConstValue v);
 
  210     typename tlp::StoredType<typename Tedge::RealType>::ReturnedConstValue getValue()
 const {
 
  219     operator=(
typename tlp::StoredType<typename Tedge::RealType>::ReturnedConstValue val) noexcept {
 
  237     operator typename tlp::StoredType<typename Tedge::RealType>::ReturnedConstValue() {
 
  258   setAllNodeValue(
typename tlp::StoredType<typename Tnode::RealType>::ReturnedConstValue v);
 
  271   setNodeDefaultValue(
typename tlp::StoredType<typename Tnode::RealType>::ReturnedConstValue v);
 
  290   setValueToGraphNodes(
typename tlp::StoredType<typename Tnode::RealType>::ReturnedConstValue v,
 
  304   setEdgeDefaultValue(
typename tlp::StoredType<typename Tedge::RealType>::ReturnedConstValue v);
 
  315   setAllEdgeValue(
typename tlp::StoredType<typename Tedge::RealType>::ReturnedConstValue v);
 
  334   setValueToGraphEdges(
typename tlp::StoredType<typename Tedge::RealType>::ReturnedConstValue v,
 
  345     setNodeValue(n, nodeDefaultValue);
 
  356     setEdgeValue(e, edgeDefaultValue);
 
  373       if (Tprop::graph == 
nullptr)
 
  374         Tprop::graph = prop.Tprop::graph;
 
  376       if (Tprop::graph == prop.Tprop::graph) {
 
  390         for (
auto n : Tprop::graph->nodes()) {
 
  391           if (prop.Tprop::graph->isElement(n))
 
  395         for (
auto e : Tprop::graph->edges()) {
 
  396           if (prop.Tprop::graph->isElement(e))
 
  409     typename Tnode::RealType v = getNodeDefaultValue();
 
  410     return Tnode::toString(v);
 
  413     typename Tedge::RealType v = getEdgeDefaultValue();
 
  414     return Tedge::toString(v);
 
  417     typename Tnode::RealType v = getNodeValue(n);
 
  418     return Tnode::toString(v);
 
  421     typename Tedge::RealType v = getEdgeValue(e);
 
  422     return Tedge::toString(v);
 
  425     typename Tnode::RealType v;
 
  427     if (!Tnode::fromString(v, inV))
 
  430     setNodeValue(inN, v);
 
  434     typename Tedge::RealType v;
 
  436     if (!Tedge::fromString(v, inV))
 
  439     setEdgeValue(inE, v);
 
  443     typename Tnode::RealType v;
 
  445     if (!Tnode::fromString(v, inV))
 
  448     setNodeDefaultValue(v);
 
  452     typename Tnode::RealType v;
 
  454     if (!Tnode::fromString(v, inV))
 
  461     typename Tnode::RealType v;
 
  463     if (!Tnode::fromString(v, inV))
 
  466     setValueToGraphNodes(v, graph);
 
  470     typename Tedge::RealType v;
 
  472     if (!Tedge::fromString(v, inV))
 
  475     setEdgeDefaultValue(v);
 
  479     typename Tedge::RealType v;
 
  481     if (!Tedge::fromString(v, inV))
 
  488     typename Tedge::RealType v;
 
  490     if (!Tedge::fromString(v, inV))
 
  493     setValueToGraphEdges(v, graph);
 
  497   bool hasNonDefaultValuatedNodes(
const Graph *g = 
nullptr) 
const override;
 
  498   unsigned int numberOfNonDefaultValuatedNodes(
const Graph *g = 
nullptr) 
const override;
 
  499   unsigned int nodeValueSize() 
const override;
 
  500   void writeNodeDefaultValue(std::ostream &) 
const override;
 
  501   void writeNodeValue(std::ostream &, 
node) 
const override;
 
  502   bool readNodeDefaultValue(std::istream &) 
override;
 
  503   bool readNodeValue(std::istream &, 
node) 
override;
 
  505   bool hasNonDefaultValuatedEdges(
const Graph *g = 
nullptr) 
const override;
 
  506   unsigned int numberOfNonDefaultValuatedEdges(
const Graph * = 
nullptr) 
const override;
 
  507   unsigned int edgeValueSize() 
const override;
 
  508   void writeEdgeDefaultValue(std::ostream &) 
const override;
 
  509   void writeEdgeValue(std::ostream &, 
edge) 
const override;
 
  510   bool readEdgeDefaultValue(std::istream &) 
override;
 
  511   bool readEdgeValue(std::istream &, 
edge) 
override;
 
  513             bool ifNotDefault = 
false)
 override {
 
  514     if (property == 
nullptr)
 
  521     typename StoredType<typename Tnode::RealType>::ReturnedValue value =
 
  522         tp->nodeProperties.get(source.
id, notDefault);
 
  524     if (ifNotDefault && !notDefault)
 
  527     setNodeValue(destination, value);
 
  531             bool ifNotDefault = 
false)
 override {
 
  532     if (property == 
nullptr)
 
  539     typename StoredType<typename Tedge::RealType>::ReturnedValue value =
 
  540         tp->edgeProperties.get(source.
id, notDefault);
 
  542     if (ifNotDefault && !notDefault)
 
  545     setEdgeValue(destination, value);
 
  551     assert(prop != 
nullptr);
 
  556     return new TypedValueContainer<typename Tnode::RealType>(getNodeDefaultValue());
 
  559     return new TypedValueContainer<typename Tedge::RealType>(getEdgeDefaultValue());
 
  562     return new TypedValueContainer<typename Tnode::RealType>(getNodeValue(n));
 
  565     return new TypedValueContainer<typename Tedge::RealType>(getEdgeValue(e));
 
  569     typename StoredType<typename Tnode::RealType>::ReturnedValue value =
 
  570         nodeProperties.get(n.
id, notDefault);
 
  573       return new TypedValueContainer<typename Tnode::RealType>(value);
 
  579     typename StoredType<typename Tedge::RealType>::ReturnedValue value =
 
  580         edgeProperties.get(e.
id, notDefault);
 
  583       return new TypedValueContainer<typename Tedge::RealType>(value);
 
  588     setNodeValue(n, 
static_cast<const TypedValueContainer<typename Tnode::RealType> *
>(v)->value);
 
  591     setEdgeValue(e, 
static_cast<const TypedValueContainer<typename Tedge::RealType> *
>(v)->value);
 
  594     setAllNodeValue(
static_cast<const TypedValueContainer<typename Tnode::RealType> *
>(v)->value);
 
  597     setAllEdgeValue(
static_cast<const TypedValueContainer<typename Tedge::RealType> *
>(v)->value);
 
  604     if (Tprop::metaValueCalculator)
 
  606           Tprop::metaValueCalculator)
 
  607           ->computeMetaValue(
this, n, sg, mg);
 
  612     if (Tprop::metaValueCalculator)
 
  614           Tprop::metaValueCalculator)
 
  615           ->computeMetaValue(
this, e, itE, mg);
 
  622           << 
"Warning : " << __PRETTY_FUNCTION__ << 
" ... invalid conversion of " 
  623           << 
typeid(mvCalc).name() << 
"into " 
  630     Tprop::metaValueCalculator = mvCalc;
 
  633   int compare(
const node n1, 
const node n2) 
const override;
 
  634   int compare(
const edge e1, 
const edge e2) 
const override;
 
  660   MutableContainer<typename Tnode::RealType> nodeProperties;
 
  661   MutableContainer<typename Tedge::RealType> edgeProperties;
 
  662   typename Tnode::RealType nodeDefaultValue;
 
  663   typename Tedge::RealType edgeDefaultValue;
 
  666 template <
typename vectType, 
typename eltType, 
typename propType = VectorPropertyInterface>
 
  667 class TLP_SCOPE AbstractVectorProperty : 
public AbstractProperty<vectType, vectType, propType> {
 
  669   AbstractVectorProperty(Graph *, 
const std::string &name = 
"");
 
  670   using AbstractProperty<vectType, vectType, propType>::operator=;
 
  673   bool tokenize(
const std::string &str, std::vector<std::string> &vect, 
char openChar = 
'(',
 
  674                 char sepChar = 
',', 
char closeChar = 
')') 
override;
 
  676   bool setNodeStringValueAsVector(
const node n, 
const std::vector<std::string> &values) 
override;
 
  678   bool setNodeStringValueAsVector(
const node, 
const std::string &, 
char, 
char, 
char) 
override;
 
  680   bool setEdgeStringValueAsVector(
const edge e, 
const std::vector<std::string> &values) 
override;
 
  682   bool setEdgeStringValueAsVector(
const edge, 
const std::string &, 
char, 
char, 
char) 
override;
 
  692   void setNodeEltValue(
const node n, 
unsigned int i,
 
  693                        typename tlp::StoredType<typename eltType::RealType>::ReturnedConstValue v);
 
  701   typename tlp::StoredType<typename eltType::RealType>::ReturnedConstValue
 
  702   getNodeEltValue(
const node n, 
unsigned int i) 
const;
 
  712   pushBackNodeEltValue(
const node n,
 
  713                        typename tlp::StoredType<typename eltType::RealType>::ReturnedConstValue v);
 
  721   void popBackNodeEltValue(
const node n);
 
  731   void resizeNodeValue(
const node n, 
size_t size,
 
  732                        typename eltType::RealType elt = eltType::defaultValue());
 
  741   void setEdgeEltValue(
const edge e, 
unsigned int i,
 
  742                        typename tlp::StoredType<typename eltType::RealType>::ReturnedConstValue v);
 
  750   typename tlp::StoredType<typename eltType::RealType>::ReturnedConstValue
 
  751   getEdgeEltValue(
const edge n, 
unsigned int i) 
const;
 
  761   pushBackEdgeEltValue(
const edge e,
 
  762                        typename tlp::StoredType<typename eltType::RealType>::ReturnedConstValue v);
 
  770   void popBackEdgeEltValue(
const edge e);
 
  780   void resizeEdgeValue(
const edge e, 
size_t size,
 
  781                        typename eltType::RealType elt = eltType::defaultValue());
 
  784 #if !defined(_MSC_VER) || defined(DLL_TULIP)  
  787 #include "cxx/AbstractProperty.cxx" 
inner class used to overload the operator[] to set an edge value
 
edgeValueRef & operator=(const edgeValueRef &ref) noexcept
overloading of operator= to assign an edge value which allow to write: prop1[e1] = prop2[e2]
 
edgeValueRef & operator=(typename tlp::StoredType< typename Tedge::RealType >::ReturnedConstValue val) noexcept
overloading of operator= to assign an edge value which allow to write: prop[n] = val
 
inner class used to overload the operator[] to set a node value
 
nodeValueRef & operator=(typename tlp::StoredType< typename Tnode::RealType >::ReturnedConstValue val) noexcept
overloading of operator= to assign a node value which allow to write: prop[n] = val
 
nodeValueRef & operator=(const nodeValueRef &ref) noexcept
overloading of operator= to assign a node value which allow to write: prop1[n] = prop2[m]
 
This class extends upon PropertyInterface, and adds type-safe methods to get and set the node and edg...
 
void erase(const edge e) override
Resets the value of an edge to the default value.
 
virtual void clone_handler(AbstractProperty< Tnode, Tedge, Tprop > &)
Enable to clone part of sub_class.
 
bool setNodeStringValue(const node inN, const std::string &inV) override
Sets a new value on the node, represented by the string parameter.
 
void setNodeDataMemValue(const node n, const DataMem *v) override
Sets the node value.
 
virtual void setEdgeValue(const edge e, typename tlp::StoredType< typename Tedge::RealType >::ReturnedConstValue v)
Set the value of an edge and notify the observers of a modification.
 
bool setStringValueToGraphNodes(const std::string &inV, const Graph *graph) override
Sets all the nodes value to the value represented by the string for a graph. For some types,...
 
tlp::Iterator< node > * getNonDefaultValuatedNodes(const Graph *g=nullptr) const override
Gets an Iterator on all non-default valuated nodes. When given a Graph as parameter,...
 
void setMetaValueCalculator(PropertyInterface::MetaValueCalculator *mvCalc) override
Sets the Calculator for meta nodes and edges.
 
constexpr nodeValueRef operator[](node n)
overloading of operator[] to set a node value
 
bool setAllNodeStringValue(const std::string &inV) override
Sets all the nodes value to the value represented by the string. For some types, some parsing will be...
 
void setEdgeDataMemValue(const edge e, const DataMem *v) override
Sets the edge value.
 
bool setStringValueToGraphEdges(const std::string &inV, const Graph *graph) override
Sets all the edges value to the value represented by the string for a graph. For some types,...
 
tlp::StoredType< typename Tnode::RealType >::ReturnedConstValue getNodeValue(const node n) const
Returns the value associated with the node n in this property. If there is no value,...
 
virtual AbstractProperty< Tnode, Tedge, Tprop > & operator=(AbstractProperty< Tnode, Tedge, Tprop > &prop)
This operator overload allows to copy a property using the following syntax :
 
DataMem * getNodeDefaultDataMemValue() const override
Gets a pointer to the tlp::DataMem structure that contains the node default value.
 
bool setEdgeStringValue(const edge inE, const std::string &inV) override
Sets a new value on the edge, represented by the string parameter.
 
void setAllNodeDataMemValue(const DataMem *v) override
Sets all the nodes value to the value contained in the given DataMem structure. All previous values a...
 
void computeMetaValue(node n, Graph *sg, Graph *mg) override
Sets the value of the metanode to a computed value.
 
bool setAllEdgeStringValue(const std::string &inV) override
Sets all the edges value to the value represented by the string. For some types, some parsing will be...
 
bool setNodeDefaultStringValue(const std::string &inV) override
Sets the value assigned as the default one to the future added nodes from a string representation.
 
std::string getNodeDefaultStringValue() const override
Gets a string representation of the node default value.
 
DataMem * getEdgeDataMemValue(const edge e) const override
Gets the edge value, contained in a tlp::DataMem structure.
 
void setAllEdgeDataMemValue(const DataMem *v) override
Sets all the edges value to the value contained in the given DataMem structure. All previous values a...
 
tlp::StoredType< typename Tedge::RealType >::ReturnedConstValue getEdgeValue(const edge e) const
Returns the value associated to the edge e in this property. If there is no value,...
 
bool setEdgeDefaultStringValue(const std::string &inV) override
Sets the value assigned as the default one to the future added edges from a string representation.
 
std::string getNodeStringValue(const node n) const override
Gets a string representation of the node value.
 
Tnode::RealType getNodeDefaultValue() const
Gets the default node value of the property.
 
void erase(const node n) override
Resets the value of a node to the default value.
 
virtual void setNodeValue(const node n, typename tlp::StoredType< typename Tnode::RealType >::ReturnedConstValue v)
Sets the value of a node and notify the observers of a modification.
 
bool copy(const edge destination, const edge source, PropertyInterface *property, bool ifNotDefault=false) override
Copies the value of an edge in another property to an edge in this property.
 
void computeMetaValue(edge e, tlp::Iterator< edge > *itE, Graph *mg) override
Sets the value of the metaedge to a computed value.
 
std::string getEdgeStringValue(const edge e) const override
Gets a string representation of the edge value.
 
DataMem * getNonDefaultDataMemValue(const node n) const override
Returns the value in a DataMem if it is not default, otherwise returns nullptr.
 
const tlp::StoredType< typename Tnode::RealType >::ReturnedConstValue operator[](node n) const
overloading of operator[] to get a node value
 
bool copy(const node destination, const node source, PropertyInterface *property, bool ifNotDefault=false) override
Copies the value of a node in another property to a node in this property.
 
Tedge::RealType getEdgeDefaultValue() const
Gets the default edge value of the property.
 
tlp::StoredType< typename Tedge::RealType >::ReturnedConstValue operator[](edge e) const
overloading of operator[] to get an edge value
 
void copy(PropertyInterface *property) override
Copies the values of the source property to this property.
 
constexpr edgeValueRef operator[](edge e)
overloading of operator[] to set an edge value
 
tlp::Iterator< edge > * getNonDefaultValuatedEdges(const Graph *g=nullptr) const override
Gets an Iterator on all non-default valuated edges. When given a Graph as parameter,...
 
DataMem * getNodeDataMemValue(const node n) const override
Gets the node value, contained in a tlp::DataMem structure.
 
DataMem * getEdgeDefaultDataMemValue() const override
Gets a pointer to the tlp::DataMem structure that contains the edge default value.
 
std::string getEdgeDefaultStringValue() const override
Gets a string representation of the edge default value.
 
DataMem * getNonDefaultDataMemValue(const edge e) const override
Returns the value in a DataMem if it is not default, otherwise returns nullptr.
 
PropertyInterface describes the interface of a graph property.
 
Interface for Tulip iterators. Allows basic iteration operations only.
 
The edge struct represents an edge in a Graph object.
 
unsigned int id
id The identifier of the edge.
 
The node struct represents a node in a Graph object.
 
unsigned int id
id The identifier of the node.