Tulip 5.7.1
Large graphs analysis and drawing
Loading...
Searching...
No Matches
minmaxproperty.h
1/*
2 *
3 * This file is part of Tulip (https://tulip.labri.fr)
4 *
5 * Authors: David Auber and the Tulip development Team
6 * from LaBRI, University of Bordeaux
7 *
8 * Tulip is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU Lesser General Public License
10 * as published by the Free Software Foundation, either version 3
11 * of the License, or (at your option) any later version.
12 *
13 * Tulip is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
16 * See the GNU General Public License for more details.
17 *
18 */
19
20#ifndef MINMAXPROPERTY_H
21#define MINMAXPROPERTY_H
22
23#include <unordered_map>
24
25#include <tulip/Observable.h>
26#include <tulip/AbstractProperty.h>
27
28#define MINMAX_PAIR(TYPE) std::pair<typename TYPE::RealType, typename TYPE::RealType>
29#define MINMAX_MAP(TYPE) typename std::unordered_map<unsigned int, MINMAX_PAIR(TYPE)>
30
31#define NODE_VALUE typename nodeType::RealType
32#define CONST_NODE_VALUE typename tlp::StoredType<typename nodeType::RealType>::ReturnedConstValue
33#define EDGE_VALUE typename edgeType::RealType
34#define CONST_EDGE_VALUE typename tlp::StoredType<typename edgeType::RealType>::ReturnedConstValue
35
36namespace tlp {
37
38/**
39 * @brief Abstracts the computation of minimal and maximal values on node and edge values of
40 *properties.
41 *
42 * The value is lazily computed on first request.
43 * The value is cached, and the cache is invalidated whenever it cannot be simply updated.
44 **/
45template <typename nodeType, typename edgeType, typename propType = PropertyInterface>
46class MinMaxProperty : public tlp::AbstractProperty<nodeType, edgeType, propType> {
47
48 const MINMAX_PAIR(nodeType) & getNodeMinMax(const Graph *graph = nullptr);
49 const MINMAX_PAIR(edgeType) & getEdgeMinMax(const Graph *graph = nullptr);
50
51public:
52 /**
53 * @brief Constructs a MinMaxProperty.
54 *
55 * @param graph The graph to attach the property to.
56 * @param name The name of the property.
57 * @param NodeMin The minimal value the property can take for nodes (e.g. INT_MIN)
58 * @param NodeMax The maximal value the property can take for nodes (e.g. INT_MIN)
59 * @param EdgeMin The minimal value the property can take for edges (e.g. INT_MIN)
60 * @param EdgeMax The maximal value the property can take for edges (e.g. INT_MIN)
61 **/
62 MinMaxProperty(tlp::Graph *graph, const std::string &name, NODE_VALUE NodeMin, NODE_VALUE NodeMax,
63 EDGE_VALUE EdgeMin, EDGE_VALUE EdgeMax);
64
65 void treatEvent(const tlp::Event &ev) override;
66
67 /**
68 * @brief Gets the minimum value on the nodes.
69 * It is only computed if it has never been retrieved before, or if the cached value could not be
70 *updated.
71 *
72 * @param graph The graph on which to compute.
73 * @return The minimal value on this graph for this property.
74 **/
75 CONST_NODE_VALUE getNodeMin(const Graph *graph = nullptr) {
76 return getNodeMinMax(graph).first;
77 }
78
79 /**
80 * @brief Computes the maximum value on the nodes.
81 * It is only computed if it has never been retrieved before, or if the cached value could not be
82 *updated.
83 *
84 * @param graph The graph on which to compute.
85 * @return The maximal value on this graph for this property.
86 **/
87 CONST_NODE_VALUE getNodeMax(const Graph *graph = nullptr) {
88 return getNodeMinMax(graph).second;
89 }
90
91 /**
92 * @brief Computes the minimum value on the edges.
93 * It is only computed if it has never been retrieved before, or if the cached value could not be
94 *updated.
95 *
96 * @param graph The graph on which to compute.
97 * @return The minimal value on this graph for this property.
98 **/
99 CONST_EDGE_VALUE getEdgeMin(const Graph *graph = nullptr) {
100 return getEdgeMinMax(graph).first;
101 }
102
103 /**
104 * @brief Computes the maximum value on the edges.
105 * It is only computed if it has never been retrieved before, or if the cached value could not be
106 *updated.
107 *
108 * @param graph The graph on which to compute.
109 * @return The maximal value on this graph for this property.
110 **/
111 CONST_EDGE_VALUE getEdgeMax(const Graph *graph = nullptr) {
112 return getEdgeMinMax(graph).second;
113 }
114
115 /**
116 * @brief Updates the value on a node, and updates the minimal/maximal cached values if necessary.
117 * Should be called by subclasses in order to keep the cache up to date.
118 *
119 * @param n The node for which the value is updated.
120 * @param newValue The new value on this node.
121 **/
122 void updateNodeValue(tlp::node n, CONST_NODE_VALUE newValue);
123
124 /**
125 * @brief Updates the value on an edge, and updates the minimal/maximal cached values if
126 *necessary.
127 * Should be called by subclasses in order to keep the cache up to date.
128 *
129 * @param e The edge for which the value is updated.
130 * @param newValue The new value on this edge.
131 **/
132 void updateEdgeValue(tlp::edge e, CONST_EDGE_VALUE newValue);
133
134 /**
135 * @brief Updates the value of all nodes, setting the maximum and minimum values to this.
136 * Should be called by subclasses in order to keep the cache up to date.
137 *
138 * @param newValue The new maximal and minimal value.
139 **/
140 void updateAllNodesValues(CONST_NODE_VALUE newValue);
141
142 /**
143 * @brief Updates the value of all edges, setting the maximum and minimum values to this.
144 * Should be called by subclasses in order to keep the cache up to date.
145 *
146 * @param newValue The new maximal and minimal value.
147 **/
148 void updateAllEdgesValues(CONST_EDGE_VALUE newValue);
149
150protected:
151 MINMAX_MAP(nodeType) minMaxNode;
152 MINMAX_MAP(edgeType) minMaxEdge;
153
154 NODE_VALUE _nodeMin;
155 NODE_VALUE _nodeMax;
156 EDGE_VALUE _edgeMin;
157 EDGE_VALUE _edgeMax;
158
159 // this will indicate if we can stop propType::graph observation
160 bool needGraphListener; // default is false
161
162 const MINMAX_PAIR(nodeType) & computeMinMaxNode(const Graph *graph);
163 const MINMAX_PAIR(edgeType) & computeMinMaxEdge(const Graph *graph);
164 void removeListenersAndClearNodeMap();
165 void removeListenersAndClearEdgeMap();
166};
167} // namespace tlp
168
169#include "cxx/minmaxproperty.cxx"
170
171#endif // MINMAXPROPERTY_H
This class extends upon PropertyInterface, and adds type-safe methods to get and set the node and edg...
Event is the base class for all events used in the Observation mechanism.
Definition: Observable.h:52
Abstracts the computation of minimal and maximal values on node and edge values of properties.
void updateNodeValue(tlp::node n, CONST_NODE_VALUE newValue)
Updates the value on a node, and updates the minimal/maximal cached values if necessary....
void updateEdgeValue(tlp::edge e, CONST_EDGE_VALUE newValue)
Updates the value on an edge, and updates the minimal/maximal cached values if necessary....
void updateAllEdgesValues(CONST_EDGE_VALUE newValue)
Updates the value of all edges, setting the maximum and minimum values to this. Should be called by s...
void treatEvent(const tlp::Event &ev) override
This function is called when events are sent to the Listeners, and Listeners only.
CONST_EDGE_VALUE getEdgeMax(const Graph *graph=nullptr)
Computes the maximum value on the edges. It is only computed if it has never been retrieved before,...
void updateAllNodesValues(CONST_NODE_VALUE newValue)
Updates the value of all nodes, setting the maximum and minimum values to this. Should be called by s...
CONST_NODE_VALUE getNodeMin(const Graph *graph=nullptr)
Gets the minimum value on the nodes. It is only computed if it has never been retrieved before,...
CONST_NODE_VALUE getNodeMax(const Graph *graph=nullptr)
Computes the maximum value on the nodes. It is only computed if it has never been retrieved before,...
CONST_EDGE_VALUE getEdgeMin(const Graph *graph=nullptr)
Computes the minimum value on the edges. It is only computed if it has never been retrieved before,...
The edge struct represents an edge in a Graph object.
Definition: Edge.h:40
The node struct represents a node in a Graph object.
Definition: Node.h:40