jacint@109: // -*- C++ -*-
jacint@372:
jacint@109: /*
jacint@109: Heuristics:
jacint@109: 2 phase
jacint@109: gap
jacint@109: list 'level_list' on the nodes on level i implemented by hand
jacint@451: stack 'active' on the active nodes on level i
jacint@109: runs heuristic 'highest label' for H1*n relabels
jacint@113: runs heuristic 'bound decrease' for H0*n relabels, starts with 'highest label'
jacint@109:
jacint@451: Parameters H0 and H1 are initialized to 20 and 1.
jacint@109:
jacint@211: Constructors:
jacint@109:
jacint@372: Preflow(Graph, Node, Node, CapMap, FlowMap, bool) : bool must be false if
jacint@372: FlowMap is not constant zero, and should be true if it is
jacint@109:
jacint@109: Members:
jacint@109:
jacint@211: void run()
jacint@109:
jacint@211: T flowValue() : returns the value of a maximum flow
jacint@109:
jacint@109: void minMinCut(CutMap& M) : sets M to the characteristic vector of the
jacint@451: minimum min cut. M should be a map of bools initialized to false. ??Is it OK?
jacint@109:
jacint@109: void maxMinCut(CutMap& M) : sets M to the characteristic vector of the
jacint@109: maximum min cut. M should be a map of bools initialized to false.
jacint@109:
jacint@109: void minCut(CutMap& M) : sets M to the characteristic vector of
jacint@109: a min cut. M should be a map of bools initialized to false.
jacint@109:
jacint@109: */
jacint@109:
jacint@211: #ifndef HUGO_PREFLOW_H
jacint@211: #define HUGO_PREFLOW_H
jacint@109:
jacint@109: #define H0 20
jacint@109: #define H1 1
jacint@109:
jacint@109: #include <vector>
jacint@109: #include <queue>
jacint@451: #include <stack>
jacint@109:
jacint@109: namespace hugo {
jacint@109:
jacint@109: template <typename Graph, typename T,
marci@389: typename CapMap=typename Graph::template EdgeMap<T>,
marci@389: typename FlowMap=typename Graph::template EdgeMap<T> >
jacint@211: class Preflow {
jacint@109:
jacint@211: typedef typename Graph::Node Node;
jacint@109: typedef typename Graph::NodeIt NodeIt;
jacint@109: typedef typename Graph::OutEdgeIt OutEdgeIt;
jacint@109: typedef typename Graph::InEdgeIt InEdgeIt;
jacint@451:
jacint@451: typedef typename std::vector<std::stack<Node> > VecStack;
jacint@451: typedef typename Graph::template NodeMap<Node> NNMap;
jacint@451: typedef typename std::vector<Node> VecNode;
jacint@451:
jacint@211: const Graph& G;
jacint@211: Node s;
jacint@211: Node t;
jacint@451: CapMap* capacity;
jacint@451: FlowMap* flow;
jacint@451: int n; //the number of nodes of G
jacint@451: typename Graph::template NodeMap<int> level;
jacint@451: typename Graph::template NodeMap<T> excess;
jacint@451:
jacint@109:
jacint@109: public:
jacint@451:
jacint@451: enum flowEnum{
jacint@451: ZERO_FLOW=0,
jacint@451: GEN_FLOW=1,
jacint@451: PREFLOW=2
jacint@451: };
jacint@451:
jacint@372: Preflow(Graph& _G, Node _s, Node _t, CapMap& _capacity,
jacint@451: FlowMap& _flow) :
jacint@451: G(_G), s(_s), t(_t), capacity(&_capacity),
jacint@451: flow(&_flow), n(_G.nodeNum()), level(_G), excess(_G,0) {}
jacint@451:
jacint@451: void run() {
jacint@451: preflow( ZERO_FLOW );
jacint@451: }
jacint@372:
jacint@451: void preflow( flowEnum fe ) {
jacint@451: preflowPhase0(fe);
jacint@451: preflowPhase1();
jacint@451: }
jacint@451:
jacint@451: void preflowPhase0( flowEnum fe ) {
jacint@372:
jacint@109: int heur0=(int)(H0*n); //time while running 'bound decrease'
jacint@109: int heur1=(int)(H1*n); //time while running 'highest label'
jacint@109: int heur=heur1; //starting time interval (#of relabels)
jacint@451: int numrelabel=0;
jacint@451:
jacint@109: bool what_heur=1;
jacint@451: //It is 0 in case 'bound decrease' and 1 in case 'highest label'
jacint@451:
jacint@109: bool end=false;
jacint@451: //Needed for 'bound decrease', true means no active nodes are above bound b.
jacint@451:
jacint@109: int k=n-2; //bound on the highest level under n containing a node
jacint@109: int b=k; //bound on the highest level under n of an active node
jacint@109:
jacint@451: VecStack active(n);
jacint@451:
jacint@451: NNMap left(G,INVALID);
jacint@451: NNMap right(G,INVALID);
jacint@451: VecNode level_list(n,INVALID);
jacint@451: //List of the nodes in level i<n, set to n.
jacint@109:
jacint@451: NodeIt v;
jacint@451: for(G.first(v); G.valid(v); G.next(v)) level.set(v,n);
jacint@451: //setting each node to level n
jacint@451:
jacint@451: switch ( fe ) {
jacint@451: case PREFLOW:
jacint@451: {
jacint@451: //counting the excess
jacint@451: NodeIt v;
jacint@451: for(G.first(v); G.valid(v); G.next(v)) {
jacint@451: T exc=0;
jacint@372:
jacint@451: InEdgeIt e;
jacint@451: for(G.first(e,v); G.valid(e); G.next(e)) exc+=(*flow)[e];
jacint@451: OutEdgeIt f;
jacint@451: for(G.first(f,v); G.valid(f); G.next(f)) exc-=(*flow)[f];
jacint@451:
jacint@451: excess.set(v,exc);
jacint@451:
jacint@451: //putting the active nodes into the stack
jacint@451: int lev=level[v];
jacint@451: if ( exc > 0 && lev < n && v != t ) active[lev].push(v);
jacint@451: }
jacint@451: break;
jacint@451: }
jacint@451: case GEN_FLOW:
jacint@451: {
jacint@451: //Counting the excess of t
jacint@451: T exc=0;
jacint@372:
jacint@372: InEdgeIt e;
jacint@451: for(G.first(e,t); G.valid(e); G.next(e)) exc+=(*flow)[e];
jacint@451: OutEdgeIt f;
jacint@451: for(G.first(f,t); G.valid(f); G.next(f)) exc-=(*flow)[f];
jacint@451:
jacint@451: excess.set(t,exc);
jacint@451:
jacint@451: break;
jacint@451: }
jacint@451: }
jacint@451:
jacint@451: preflowPreproc( fe, active, level_list, left, right );
jacint@451: //End of preprocessing
jacint@451:
jacint@451:
jacint@451: //Push/relabel on the highest level active nodes.
jacint@451: while ( true ) {
jacint@451: if ( b == 0 ) {
jacint@451: if ( !what_heur && !end && k > 0 ) {
jacint@451: b=k;
jacint@451: end=true;
jacint@451: } else break;
jacint@451: }
jacint@451:
jacint@451: if ( active[b].empty() ) --b;
jacint@451: else {
jacint@451: end=false;
jacint@451: Node w=active[b].top();
jacint@451: active[b].pop();
jacint@451: int newlevel=push(w,active);
jacint@451: if ( excess[w] > 0 ) relabel(w, newlevel, active, level_list,
jacint@451: left, right, b, k, what_heur);
jacint@451:
jacint@451: ++numrelabel;
jacint@451: if ( numrelabel >= heur ) {
jacint@451: numrelabel=0;
jacint@451: if ( what_heur ) {
jacint@451: what_heur=0;
jacint@451: heur=heur0;
jacint@451: end=false;
jacint@451: } else {
jacint@451: what_heur=1;
jacint@451: heur=heur1;
jacint@451: b=k;
jacint@372: }
jacint@109: }
jacint@451: }
jacint@451: }
jacint@451: }
jacint@451:
jacint@451:
jacint@451: void preflowPhase1() {
jacint@451:
jacint@451: int k=n-2; //bound on the highest level under n containing a node
jacint@451: int b=k; //bound on the highest level under n of an active node
jacint@451:
jacint@451: VecStack active(n);
jacint@451: level.set(s,0);
jacint@451: std::queue<Node> bfs_queue;
jacint@451: bfs_queue.push(s);
jacint@451:
jacint@451: while (!bfs_queue.empty()) {
jacint@451:
jacint@451: Node v=bfs_queue.front();
jacint@451: bfs_queue.pop();
jacint@451: int l=level[v]+1;
jacint@451:
jacint@451: InEdgeIt e;
jacint@451: for(G.first(e,v); G.valid(e); G.next(e)) {
jacint@451: if ( (*capacity)[e] == (*flow)[e] ) continue;
jacint@451: Node u=G.tail(e);
jacint@451: if ( level[u] >= n ) {
jacint@451: bfs_queue.push(u);
jacint@451: level.set(u, l);
jacint@451: if ( excess[u] > 0 ) active[l].push(u);
jacint@451: }
jacint@109: }
jacint@451:
jacint@451: OutEdgeIt f;
jacint@451: for(G.first(f,v); G.valid(f); G.next(f)) {
jacint@451: if ( 0 == (*flow)[f] ) continue;
jacint@451: Node u=G.head(f);
jacint@451: if ( level[u] >= n ) {
jacint@451: bfs_queue.push(u);
jacint@451: level.set(u, l);
jacint@451: if ( excess[u] > 0 ) active[l].push(u);
jacint@109: }
jacint@109: }
jacint@372: }
jacint@451: b=n-2;
jacint@372:
jacint@109: while ( true ) {
jacint@109:
jacint@451: if ( b == 0 ) break;
jacint@451:
jacint@451: if ( active[b].empty() ) --b;
jacint@109: else {
jacint@451: Node w=active[b].top();
jacint@451: active[b].pop();
jacint@451: int newlevel=push(w,active);
jacint@109:
jacint@451: //relabel
jacint@451: if ( excess[w] > 0 ) {
jacint@109: level.set(w,++newlevel);
jacint@451: active[newlevel].push(w);
jacint@109: b=newlevel;
jacint@451: }
jacint@109: } // if stack[b] is nonempty
jacint@109: } // while(true)
jacint@109: }
jacint@109:
jacint@109:
jacint@451: //Returns the maximum value of a flow.
jacint@451: T flowValue() {
jacint@451: return excess[t];
jacint@451: }
jacint@109:
jacint@451: //should be used only between preflowPhase0 and preflowPhase1
jacint@451: template<typename _CutMap>
jacint@451: void actMinCut(_CutMap& M) {
jacint@211: NodeIt v;
jacint@451: for(G.first(v); G.valid(v); G.next(v))
jacint@451: if ( level[v] < n ) M.set(v,false);
jacint@451: else M.set(v,true);
jacint@211: }
jacint@109:
jacint@109:
jacint@109:
jacint@109: /*
jacint@109: Returns the minimum min cut, by a bfs from s in the residual graph.
jacint@109: */
jacint@109: template<typename _CutMap>
jacint@109: void minMinCut(_CutMap& M) {
jacint@109:
jacint@211: std::queue<Node> queue;
jacint@109:
jacint@109: M.set(s,true);
jacint@109: queue.push(s);
jacint@109:
jacint@109: while (!queue.empty()) {
jacint@211: Node w=queue.front();
jacint@109: queue.pop();
jacint@109:
jacint@211: OutEdgeIt e;
jacint@211: for(G.first(e,w) ; G.valid(e); G.next(e)) {
jacint@211: Node v=G.head(e);
jacint@451: if (!M[v] && (*flow)[e] < (*capacity)[e] ) {
jacint@109: queue.push(v);
jacint@109: M.set(v, true);
jacint@109: }
jacint@109: }
jacint@109:
jacint@211: InEdgeIt f;
jacint@211: for(G.first(f,w) ; G.valid(f); G.next(f)) {
jacint@211: Node v=G.tail(f);
jacint@451: if (!M[v] && (*flow)[f] > 0 ) {
jacint@109: queue.push(v);
jacint@109: M.set(v, true);
jacint@109: }
jacint@109: }
jacint@109: }
jacint@109: }
jacint@109:
jacint@109:
jacint@109:
jacint@109: /*
jacint@109: Returns the maximum min cut, by a reverse bfs
jacint@109: from t in the residual graph.
jacint@109: */
jacint@109:
jacint@109: template<typename _CutMap>
jacint@109: void maxMinCut(_CutMap& M) {
jacint@451:
jacint@451: NodeIt v;
jacint@451: for(G.first(v) ; G.valid(v); G.next(v)) {
jacint@451: M.set(v, true);
jacint@451: }
jacint@451:
jacint@211: std::queue<Node> queue;
jacint@109:
jacint@451: M.set(t,false);
jacint@109: queue.push(t);
jacint@109:
jacint@109: while (!queue.empty()) {
jacint@211: Node w=queue.front();
jacint@109: queue.pop();
jacint@109:
jacint@211:
jacint@211: InEdgeIt e;
jacint@211: for(G.first(e,w) ; G.valid(e); G.next(e)) {
jacint@211: Node v=G.tail(e);
jacint@451: if (M[v] && (*flow)[e] < (*capacity)[e] ) {
jacint@109: queue.push(v);
jacint@451: M.set(v, false);
jacint@109: }
jacint@109: }
jacint@211:
jacint@211: OutEdgeIt f;
jacint@211: for(G.first(f,w) ; G.valid(f); G.next(f)) {
jacint@211: Node v=G.head(f);
jacint@451: if (M[v] && (*flow)[f] > 0 ) {
jacint@109: queue.push(v);
jacint@451: M.set(v, false);
jacint@109: }
jacint@109: }
jacint@109: }
jacint@109: }
jacint@109:
jacint@109:
jacint@109: template<typename CutMap>
jacint@109: void minCut(CutMap& M) {
jacint@109: minMinCut(M);
jacint@109: }
jacint@109:
jacint@372:
jacint@451: void resetTarget (const Node _t) {t=_t;}
jacint@451:
jacint@451: void resetSource (const Node _s) {s=_s;}
jacint@372:
jacint@451: void resetCap (const CapMap& _cap) {
jacint@451: capacity=&_cap;
jacint@451: }
jacint@451:
jacint@451: void resetFlow (FlowMap& _flow) {
jacint@451: flow=&_flow;
jacint@372: }
jacint@372:
jacint@372:
jacint@451: private:
jacint@451:
jacint@451: int push(const Node w, VecStack& active) {
jacint@451:
jacint@451: int lev=level[w];
jacint@451: T exc=excess[w];
jacint@451: int newlevel=n; //bound on the next level of w
jacint@451:
jacint@451: OutEdgeIt e;
jacint@451: for(G.first(e,w); G.valid(e); G.next(e)) {
jacint@451:
jacint@451: if ( (*flow)[e] == (*capacity)[e] ) continue;
jacint@451: Node v=G.head(e);
jacint@451:
jacint@451: if( lev > level[v] ) { //Push is allowed now
jacint@451:
jacint@451: if ( excess[v]==0 && v!=t && v!=s ) {
jacint@451: int lev_v=level[v];
jacint@451: active[lev_v].push(v);
jacint@451: }
jacint@451:
jacint@451: T cap=(*capacity)[e];
jacint@451: T flo=(*flow)[e];
jacint@451: T remcap=cap-flo;
jacint@451:
jacint@451: if ( remcap >= exc ) { //A nonsaturating push.
jacint@451:
jacint@451: flow->set(e, flo+exc);
jacint@451: excess.set(v, excess[v]+exc);
jacint@451: exc=0;
jacint@451: break;
jacint@451:
jacint@451: } else { //A saturating push.
jacint@451: flow->set(e, cap);
jacint@451: excess.set(v, excess[v]+remcap);
jacint@451: exc-=remcap;
jacint@451: }
jacint@451: } else if ( newlevel > level[v] ) newlevel = level[v];
jacint@451: } //for out edges wv
jacint@451:
jacint@451: if ( exc > 0 ) {
jacint@451: InEdgeIt e;
jacint@451: for(G.first(e,w); G.valid(e); G.next(e)) {
jacint@451:
jacint@451: if( (*flow)[e] == 0 ) continue;
jacint@451: Node v=G.tail(e);
jacint@451:
jacint@451: if( lev > level[v] ) { //Push is allowed now
jacint@451:
jacint@451: if ( excess[v]==0 && v!=t && v!=s ) {
jacint@451: int lev_v=level[v];
jacint@451: active[lev_v].push(v);
jacint@451: }
jacint@451:
jacint@451: T flo=(*flow)[e];
jacint@451:
jacint@451: if ( flo >= exc ) { //A nonsaturating push.
jacint@451:
jacint@451: flow->set(e, flo-exc);
jacint@451: excess.set(v, excess[v]+exc);
jacint@451: exc=0;
jacint@451: break;
jacint@451: } else { //A saturating push.
jacint@451:
jacint@451: excess.set(v, excess[v]+flo);
jacint@451: exc-=flo;
jacint@451: flow->set(e,0);
jacint@451: }
jacint@451: } else if ( newlevel > level[v] ) newlevel = level[v];
jacint@451: } //for in edges vw
jacint@451:
jacint@451: } // if w still has excess after the out edge for cycle
jacint@451:
jacint@451: excess.set(w, exc);
jacint@451:
jacint@451: return newlevel;
jacint@451: }
jacint@451:
jacint@451:
jacint@451: void preflowPreproc ( flowEnum fe, VecStack& active,
jacint@451: VecNode& level_list, NNMap& left, NNMap& right ) {
jacint@451:
jacint@451: std::queue<Node> bfs_queue;
jacint@451:
jacint@451: switch ( fe ) {
jacint@451: case ZERO_FLOW:
jacint@451: {
jacint@451: //Reverse_bfs from t, to find the starting level.
jacint@451: level.set(t,0);
jacint@451: bfs_queue.push(t);
jacint@451:
jacint@451: while (!bfs_queue.empty()) {
jacint@451:
jacint@451: Node v=bfs_queue.front();
jacint@451: bfs_queue.pop();
jacint@451: int l=level[v]+1;
jacint@451:
jacint@451: InEdgeIt e;
jacint@451: for(G.first(e,v); G.valid(e); G.next(e)) {
jacint@451: Node w=G.tail(e);
jacint@451: if ( level[w] == n && w != s ) {
jacint@451: bfs_queue.push(w);
jacint@451: Node first=level_list[l];
jacint@451: if ( G.valid(first) ) left.set(first,w);
jacint@451: right.set(w,first);
jacint@451: level_list[l]=w;
jacint@451: level.set(w, l);
jacint@451: }
jacint@451: }
jacint@451: }
jacint@451:
jacint@451: //the starting flow
jacint@451: OutEdgeIt e;
jacint@451: for(G.first(e,s); G.valid(e); G.next(e))
jacint@451: {
jacint@451: T c=(*capacity)[e];
jacint@451: if ( c == 0 ) continue;
jacint@451: Node w=G.head(e);
jacint@451: if ( level[w] < n ) {
jacint@451: if ( excess[w] == 0 && w!=t ) active[level[w]].push(w);
jacint@451: flow->set(e, c);
jacint@451: excess.set(w, excess[w]+c);
jacint@451: }
jacint@451: }
jacint@451: break;
jacint@451: }
jacint@451:
jacint@451: case GEN_FLOW:
jacint@451: case PREFLOW:
jacint@451: {
jacint@451: //Reverse_bfs from t in the residual graph,
jacint@451: //to find the starting level.
jacint@451: level.set(t,0);
jacint@451: bfs_queue.push(t);
jacint@451:
jacint@451: while (!bfs_queue.empty()) {
jacint@451:
jacint@451: Node v=bfs_queue.front();
jacint@451: bfs_queue.pop();
jacint@451: int l=level[v]+1;
jacint@451:
jacint@451: InEdgeIt e;
jacint@451: for(G.first(e,v); G.valid(e); G.next(e)) {
jacint@451: if ( (*capacity)[e] == (*flow)[e] ) continue;
jacint@451: Node w=G.tail(e);
jacint@451: if ( level[w] == n && w != s ) {
jacint@451: bfs_queue.push(w);
jacint@451: Node first=level_list[l];
jacint@451: if ( G.valid(first) ) left.set(first,w);
jacint@451: right.set(w,first);
jacint@451: level_list[l]=w;
jacint@451: level.set(w, l);
jacint@451: }
jacint@451: }
jacint@451:
jacint@451: OutEdgeIt f;
jacint@451: for(G.first(f,v); G.valid(f); G.next(f)) {
jacint@451: if ( 0 == (*flow)[f] ) continue;
jacint@451: Node w=G.head(f);
jacint@451: if ( level[w] == n && w != s ) {
jacint@451: bfs_queue.push(w);
jacint@451: Node first=level_list[l];
jacint@451: if ( G.valid(first) ) left.set(first,w);
jacint@451: right.set(w,first);
jacint@451: level_list[l]=w;
jacint@451: level.set(w, l);
jacint@451: }
jacint@451: }
jacint@451: }
jacint@451:
jacint@451:
jacint@451: //the starting flow
jacint@451: OutEdgeIt e;
jacint@451: for(G.first(e,s); G.valid(e); G.next(e))
jacint@451: {
jacint@451: T rem=(*capacity)[e]-(*flow)[e];
jacint@451: if ( rem == 0 ) continue;
jacint@451: Node w=G.head(e);
jacint@451: if ( level[w] < n ) {
jacint@451: if ( excess[w] == 0 && w!=t ) active[level[w]].push(w);
jacint@451: flow->set(e, (*capacity)[e]);
jacint@451: excess.set(w, excess[w]+rem);
jacint@451: }
jacint@451: }
jacint@451:
jacint@451: InEdgeIt f;
jacint@451: for(G.first(f,s); G.valid(f); G.next(f))
jacint@451: {
jacint@451: if ( (*flow)[f] == 0 ) continue;
jacint@451: Node w=G.tail(f);
jacint@451: if ( level[w] < n ) {
jacint@451: if ( excess[w] == 0 && w!=t ) active[level[w]].push(w);
jacint@451: excess.set(w, excess[w]+(*flow)[f]);
jacint@451: flow->set(f, 0);
jacint@451: }
jacint@451: }
jacint@451: break;
jacint@451: } //case PREFLOW
jacint@451: }
jacint@451: } //preflowPreproc
jacint@451:
jacint@451:
jacint@451:
jacint@451: void relabel( const Node w, int newlevel, VecStack& active,
jacint@451: VecNode& level_list, NNMap& left,
jacint@451: NNMap& right, int& b, int& k, const bool what_heur ) {
jacint@451:
jacint@451: T lev=level[w];
jacint@451:
jacint@451: Node right_n=right[w];
jacint@451: Node left_n=left[w];
jacint@451:
jacint@451: //unlacing starts
jacint@451: if ( G.valid(right_n) ) {
jacint@451: if ( G.valid(left_n) ) {
jacint@451: right.set(left_n, right_n);
jacint@451: left.set(right_n, left_n);
jacint@451: } else {
jacint@451: level_list[lev]=right_n;
jacint@451: left.set(right_n, INVALID);
jacint@451: }
jacint@451: } else {
jacint@451: if ( G.valid(left_n) ) {
jacint@451: right.set(left_n, INVALID);
jacint@451: } else {
jacint@451: level_list[lev]=INVALID;
jacint@451: }
jacint@451: }
jacint@451: //unlacing ends
jacint@451:
jacint@451: if ( !G.valid(level_list[lev]) ) {
jacint@451:
jacint@451: //gapping starts
jacint@451: for (int i=lev; i!=k ; ) {
jacint@451: Node v=level_list[++i];
jacint@451: while ( G.valid(v) ) {
jacint@451: level.set(v,n);
jacint@451: v=right[v];
jacint@451: }
jacint@451: level_list[i]=INVALID;
jacint@451: if ( !what_heur ) {
jacint@451: while ( !active[i].empty() ) {
jacint@451: active[i].pop(); //FIXME: ezt szebben kene
jacint@451: }
jacint@451: }
jacint@451: }
jacint@451:
jacint@451: level.set(w,n);
jacint@451: b=lev-1;
jacint@451: k=b;
jacint@451: //gapping ends
jacint@451:
jacint@451: } else {
jacint@451:
jacint@451: if ( newlevel == n ) level.set(w,n);
jacint@451: else {
jacint@451: level.set(w,++newlevel);
jacint@451: active[newlevel].push(w);
jacint@451: if ( what_heur ) b=newlevel;
jacint@451: if ( k < newlevel ) ++k; //now k=newlevel
jacint@451: Node first=level_list[newlevel];
jacint@451: if ( G.valid(first) ) left.set(first,w);
jacint@451: right.set(w,first);
jacint@451: left.set(w,INVALID);
jacint@451: level_list[newlevel]=w;
jacint@451: }
jacint@451: }
jacint@451:
jacint@451: } //relabel
jacint@451:
jacint@109:
jacint@109: };
jacint@109:
marci@174: } //namespace hugo
jacint@109:
jacint@451: #endif //HUGO_PREFLOW_H
jacint@109:
jacint@109:
marci@174:
marci@174: