/usr/include/tulip/ObservableGraph.h is in libtulip-dev 3.1.2-2.3ubuntu3.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 | //-*-c++-*-
/**
Authors: David Auber, Patrick Mary, Morgan Mathiaut
from the LaBRI Visualization Team
Email : auber@tulip-software.org
Last modification : 13/03/2009
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
*/
#ifndef GRAPHOBSERVABLE_H
#define GRAPHOBSERVABLE_H
#include <ext/slist>
#include "tulip/Node.h"
#include "tulip/Edge.h"
namespace tlp {
struct Graph;
struct PropertyInterface;
//=========================================================
/** \addtogroup graphs */
/*@{*/
/// Observer for Graph
/**
* The Observer pattern is described in the lecture notes and pp293-304
* of Design Patterns by Gamma, Helm, Johnson, and Vlissides. It is a
* framework for handling state dependency between observer and observed
* object.
*/
class TLP_SCOPE GraphObserver {
public:
virtual ~GraphObserver() {}
virtual void addNode(Graph *,const node ){}
virtual void addEdge(Graph *,const edge ){}
virtual void delNode(Graph *,const node ){}
virtual void delEdge(Graph *,const edge ){}
virtual void reverseEdge(Graph *,const edge ){}
virtual void destroy(Graph *){}
virtual void addSubGraph(Graph*, Graph *){}
virtual void delSubGraph(Graph*, Graph*){}
virtual void addLocalProperty(Graph*, const std::string&){}
virtual void delLocalProperty(Graph*, const std::string&){}
};
/*@}*/
}
#ifndef DOXYGEN_NOTFOR_DEVEL
/*namespace std {
template <>
struct less<tlp::GraphObserver *> {
size_t operator()(const tlp::GraphObserver * obs1,const tlp::GraphObserver *obs2) const {
return (unsigned long)obs1<(unsigned long)obs2;
}
};
}*/
#endif // DOXYGEN_NOTFOR_DEVEL
namespace tlp {
/** \addtogroup graphs */
/*@{*/
/**
*/
/// Observable object for graph
class TLP_SCOPE ObservableGraph {
public:
virtual ~ObservableGraph() {}
/**
* Register a new observer
*/
void addGraphObserver(GraphObserver *) const;
/**
* Returns the number of observers
*/
unsigned int countGraphObservers();
/**
* Remove an observer
*/
void removeGraphObserver(GraphObserver *) const;
/**
* Remove all observers
*/
void removeGraphObservers();
protected:
void notifyAddNode(Graph *,const node n);
void notifyAddEdge(Graph *,const edge e);
void notifyDelNode(Graph *,const node n);
void notifyDelEdge(Graph *,const edge e);
void notifyReverseEdge(Graph *,const edge e);
void notifyAddSubGraph(Graph*, Graph*);
void notifyDelSubGraph(Graph*, Graph*);
void notifyAddLocalProperty(Graph*, const std::string&);
void notifyDelLocalProperty(Graph*, const std::string&);
void notifyDestroy(Graph*);
mutable stdext::slist<GraphObserver*> observers;
};
/*@}*/
inline void ObservableGraph::addGraphObserver(GraphObserver *obs) const {
observers.push_front(obs);
}
inline unsigned int ObservableGraph::countGraphObservers() {
return observers.size();
}
inline void ObservableGraph::removeGraphObserver(GraphObserver *item) const{
observers.remove(item);
}
inline void ObservableGraph::removeGraphObservers() {
observers.clear();
}
}
#endif
|