SkelGIS  3.0
/home/helene/Documents/These/SkelGIS/SkelGIS_Library/SkelGIS_V3/skelgis/data_structures/DDAG/dpmap_edges.hpp
00001 /*! \file pmap_edges.hpp
00002  *  \brief Definitions of the object PMap_Edges used by the user to map data to the edges of a DDAG. Three template specializations are available.
00003  */
00004 #ifndef DPMAP_EDGES_H
00005 #define DPMAP_EDGES_H
00006 
00007 #include "dpmap_edges_impl.hpp"
00008 
00009 namespace skelgis{
00010 
00011   //-------------------------------------------------------------------------------
00012   //!  base template class of Property map on edges
00013   /*!
00014     This template class defines the base PMap_Edges
00015     \tparam DD is the type of the DDAG
00016     \tparam T is the type of data in the property map
00017     \tparam node_access indicates if nodes have to have access to this property during calculation (>=1) or not (=0)
00018 
00019     In the case of a basic type T, node_access can't be >1
00020     In the case of a pointer type T*, if node_access>0 then it indicates the number of elements to shared at the end and at the beginning of the pointer
00021   */
00022   //-------------------------------------------------------------------------------
00023   template<class DD, class T, int node_access> struct DPMap_Edges;
00024   //-------------------------------------------------------------------------------
00025   //!  first specialization of DPMap_Edges
00026   /*!
00027     \tparam DD is the type of the DDAG
00028     \tparam T is the type of data in the property map
00029 
00030     The type T is a simple type in this case as float, double, int etc.
00031     The node_access is specialized to the value 1
00032     The size is used with its default value 1
00033   */
00034   //-------------------------------------------------------------------------------
00035   template<class DD, class T> struct DPMap_Edges<DD,T,1>
00036   //-------------------------------------------------------------------------------
00037   {
00038   protected :
00039     bool ptr_const;
00040     DPMap_Edges_impl<DD,T,1> * dpmap;
00041 
00042   public:
00043     typedef DPMap_Edges_impl<DD,T,1> impl_type;
00044 
00045     //-------------------------------------------------------------------------------
00046     //!  constructor of DPMap_Edges
00047     /*!
00048       \param dag is the DDAG object associated to this map
00049       \param file is the file with initial values of edges wanted (each line is the value of the node "number of this line" associated in the .dot file)
00050     */
00051     //-------------------------------------------------------------------------------
00052     DPMap_Edges(DD &dag, const char * file)
00053     {
00054       ptr_const=false;
00055       dpmap = new DPMap_Edges_impl<DD,T,1>(dag,file);
00056     }
00057     //-------------------------------------------------------------------------------
00058     //!  constructor of DPMap_Edges
00059     /*!
00060       \param dag is the DDAG object associated to this map
00061       \param val is the default value of edges for the map
00062     */
00063     //-------------------------------------------------------------------------------
00064     DPMap_Edges(DD &dag, T val)
00065     {
00066       ptr_const=false;
00067       dpmap = new DPMap_Edges_impl<DD,T,1>(dag,val);
00068     }
00069     //-------------------------------------------------------------------------------
00070     //!  constructor from a DPMap_Edges_impl pointer
00071     /*!
00072       \param pointer to a DPMap_Edges_impl
00073     */
00074     //-------------------------------------------------------------------------------
00075     DPMap_Edges(DPMap_Edges_impl<DD,T,1> * p)
00076     {
00077       ptr_const=true;
00078       dpmap = p;
00079     }
00080     //-------------------------------------------------------------------------------
00081     //!  destructor of DPMap_Edges
00082     /*!
00083     */
00084     //-------------------------------------------------------------------------------
00085     ~DPMap_Edges()
00086     {
00087       //do not destroy the pointer if the DPMap was constructed from an existing dpmap_impl
00088       if(dpmap!=NULL && !ptr_const)
00089         {delete dpmap;dpmap=NULL;}
00090     };
00091     //-------------------------------------------------------------------------------
00092     //!  to get the pointer on dpmap_impl
00093     /*!
00094       \return the dpmap implementation pointer
00095     */
00096     //-------------------------------------------------------------------------------
00097     inline DPMap_Edges_impl<DD,T,1> * getDPMap(){return dpmap;}
00098     //-------------------------------------------------------------------------------
00099     //!  to get the begin iterator on edges
00100     /*!
00101       \return the begin iterator on edges
00102     */
00103     //-------------------------------------------------------------------------------
00104     inline iterator_dag begin(){return dpmap->begin();}
00105     //-------------------------------------------------------------------------------
00106     //!  to get the end iterator on edges
00107     /*!
00108       \return the end iterator on edges
00109     */
00110     //-------------------------------------------------------------------------------
00111     inline iterator_dag end(){return dpmap->end();}
00112     //-------------------------------------------------------------------------------
00113     //!  to get the value of the property map at the iterator position
00114     /*!
00115       \return a reference on the value (to be modified)
00116     */
00117     //-------------------------------------------------------------------------------
00118     inline T& operator[](iterator_dag it) { return dpmap->data[it._rank]; }
00119     //-------------------------------------------------------------------------------
00120     //!  to get an iterator on the source node of the edge
00121     /*!
00122       \return the iterator on the source node
00123     */
00124     //-------------------------------------------------------------------------------
00125     inline iterator_dag getSrcNode(iterator_dag it){return dpmap->getSrcNode(it);}
00126     //-------------------------------------------------------------------------------
00127     //!  to get an iterator on the destination node of the edge
00128     /*!
00129       \return the iterator on the destination node
00130     */
00131     //-------------------------------------------------------------------------------
00132     inline iterator_dag getDstNode(iterator_dag it){return dpmap->getDstNode(it);}
00133     //-------------------------------------------------------------------------------
00134     //!  start the communication process for the dpmap_edges property
00135     /*!
00136       prepare data to send
00137       launch non blocking MPI communications
00138     */
00139     //-------------------------------------------------------------------------------
00140     void start_communications(){dpmap->start_communications();}
00141     //-------------------------------------------------------------------------------
00142     //!  end the communication process for the dpmap_edges property
00143     /*!
00144       wait for the end of non-blocking communications
00145       put received values in the dpmap_edges property
00146     */
00147     //-------------------------------------------------------------------------------
00148     void end_communications(){dpmap->end_communications();}
00149     //-------------------------------------------------------------------------------
00150     
00151   };
00152   //-------------------------------------------------------------------------------
00153   //!  second specialization of DPMap_Edges
00154   /*!
00155     \tparam DD is the type of the DDAG
00156     \tparam T is the type of data in the property map
00157 
00158     The type T is a simple type in this case as float, double, int etc.
00159     The node_access is specialized to the value 0
00160     The size is used with its default value 1
00161   */
00162   //-------------------------------------------------------------------------------
00163   template<class DD, class T> struct DPMap_Edges<DD,T,0>
00164   {
00165   protected :
00166     bool ptr_const;
00167     DPMap_Edges_impl<DD,T,0> * dpmap;
00168 
00169   public:
00170     typedef DPMap_Edges_impl<DD,T,0> impl_type;
00171 
00172     //-------------------------------------------------------------------------------
00173     //!  constructor of DPMap_Edges
00174     /*!
00175       \param dag is the DDAG object associated to this map
00176       \param file is the file with initial values of edges wanted (each line is the value of the node "number of this line" associated in the .dot file)
00177     */
00178     //-------------------------------------------------------------------------------
00179     DPMap_Edges(DD &dag, const char * file)
00180     {
00181       ptr_const=false;
00182       dpmap = new DPMap_Edges_impl<DD,T,0>(dag,file);
00183     }
00184     //-------------------------------------------------------------------------------
00185     //!  constructor of DPMap_Edges
00186     /*!
00187       \param dag is the DDAG object associated to this map
00188       \param val is the default value of edges for the map
00189     */
00190     //-------------------------------------------------------------------------------
00191     DPMap_Edges(DD &dag, T val)
00192     {
00193       ptr_const=false;
00194       dpmap = new DPMap_Edges_impl<DD,T,0>(dag,val);
00195     }
00196     //-------------------------------------------------------------------------------
00197     //!  constructor from a DPMap_Edges_impl pointer
00198     /*!
00199       \param pointer to a DPMap_Edges_impl
00200     */
00201     //-------------------------------------------------------------------------------
00202     DPMap_Edges(DPMap_Edges_impl<DD,T,0> * p)
00203     {
00204       ptr_const=true;
00205       dpmap = p;
00206     }
00207     //-------------------------------------------------------------------------------
00208     //!  destructor of DPMap_Edges
00209     /*!
00210     */
00211     //-------------------------------------------------------------------------------
00212     ~DPMap_Edges()
00213     {
00214       //do not destroy the pointer if the DPMap was constructed from an existing dpmap_impl
00215       if(dpmap!=NULL && !ptr_const)
00216         {delete dpmap;dpmap=NULL;}
00217     };
00218     //-------------------------------------------------------------------------------
00219     //!  to get the pointer on dpmap_impl
00220     /*!
00221       \return the dpmap implementation pointer
00222     */
00223     //-------------------------------------------------------------------------------
00224     inline DPMap_Edges_impl<DD,T,0> * getDPMap(){return dpmap;}
00225     //-------------------------------------------------------------------------------
00226     //!  to get the begin iterator on edges
00227     /*!
00228       \return the begin iterator on edges
00229     */
00230     //-------------------------------------------------------------------------------
00231     inline iterator_dag begin(){return dpmap->begin();}
00232     //-------------------------------------------------------------------------------
00233     //!  to get the end iterator on edges
00234     /*!
00235       \return the end iterator on edges
00236     */
00237     //-------------------------------------------------------------------------------
00238     inline iterator_dag end(){return dpmap->end();}
00239     //-------------------------------------------------------------------------------
00240     //!  to get the value of the property map at the iterator position
00241     /*!
00242       \return a reference on the value (to be modified)
00243     */
00244     //-------------------------------------------------------------------------------
00245     inline T& operator[](iterator_dag it) { return dpmap->data[it._rank]; }
00246     //-------------------------------------------------------------------------------
00247     //!  to get an iterator on the source node of the edge
00248     /*!
00249       \return the iterator on the source node
00250     */
00251     //-------------------------------------------------------------------------------
00252     inline iterator_dag getSrcNode(iterator_dag it){return dpmap->getSrcNode(it);}
00253     //-------------------------------------------------------------------------------
00254     //!  to get an iterator on the destination node of the edge
00255     /*!
00256       \return the iterator on the destination node
00257     */
00258     //-------------------------------------------------------------------------------
00259     inline iterator_dag getDstNode(iterator_dag it){return dpmap->getDstNode(it);}
00260     //-------------------------------------------------------------------------------
00261   };
00262   //-------------------------------------------------------------------------------
00263   //!  third specialization of DPMap_Edges
00264   /*!
00265     \tparam DD is the type of the DDAG
00266     \tparam T is the type of data in the property map
00267     \tparam node_access indicates if nodes have to have access to this property during calculation (>=1) or not (=0)
00268 
00269     In the case of a basic type T, node_access can't be >1
00270     In the case of a pointer type T*, if node_access>0 then it indicates the number of elements to shared at the end and at the beginning of the pointer
00271 
00272     The type T is specialized with a specific pointer type in this case as float*, double*, int* etc.
00273     The node_access is not specialized and is [0,...,size] size is precised at constructor call
00274     The size is not specialized, it is the number of elements in the pointer table to map
00275   */
00276   //-------------------------------------------------------------------------------
00277   template<class DD, class T,int node_access> struct DPMap_Edges<DD,T*,node_access>
00278   {
00279     protected :
00280     bool ptr_const;
00281     DPMap_Edges_impl<DD,T*,node_access> * dpmap;
00282 
00283   public:
00284     typedef DPMap_Edges_impl<DD,T*,node_access> impl_type;
00285 
00286     //-------------------------------------------------------------------------------
00287     //!  constructor of DPMap_Edges from a file
00288     /*!
00289       \param dag is the DDAG object associated to this map
00290       \param file is the file with initial values of edges wanted (each line is the value of the node "number of this line" associated in the .dot file)
00291       \param size is the size of the pointer table mapped on edges
00292     */
00293     //-------------------------------------------------------------------------------
00294     DPMap_Edges(DD &dag, const char * file,unsigned int size)
00295     {
00296       ptr_const=false;
00297       dpmap = new DPMap_Edges_impl<DD,T*,node_access>(dag,file,size);
00298     }
00299     //-------------------------------------------------------------------------------
00300     //!  constructor of DPMap_Edges from a value
00301     /*!
00302       \param dag is the DDAG object associated to this map
00303       \param val is the default value of edges for the map
00304       \param size is the size of the pointer table mapped on edges
00305     */
00306     //-------------------------------------------------------------------------------
00307     DPMap_Edges(DD &dag, T val,unsigned int size)
00308     {
00309       ptr_const=false;
00310       dpmap = new DPMap_Edges_impl<DD,T*,node_access>(dag,val,size);
00311     }
00312     //-------------------------------------------------------------------------------
00313     //!  constructor from a DPMap_Edges_impl pointer
00314     /*!
00315       \param pointer to a DPMap_Edges_impl
00316     */
00317     //-------------------------------------------------------------------------------
00318     DPMap_Edges(DPMap_Edges_impl<DD,T*,node_access> * p)
00319     {
00320       ptr_const=true;
00321       dpmap = p;
00322     }
00323     //-------------------------------------------------------------------------------
00324     //!  destructor of DPMap_Edges
00325     /*!
00326     */
00327     //-------------------------------------------------------------------------------
00328     ~DPMap_Edges()
00329     {
00330       //do not destroy the pointer if the DPMap was constructed from an existing dpmap_impl
00331       if(dpmap!=NULL && !ptr_const)
00332         {delete dpmap;dpmap=NULL;}
00333     };
00334     //-------------------------------------------------------------------------------
00335     //!  to get the pointer on dpmap_impl
00336     /*!
00337       \return the dpmap implementation pointer
00338     */
00339     //-------------------------------------------------------------------------------
00340     inline DPMap_Edges_impl<DD,T*,node_access> * getDPMap(){return dpmap;}
00341     //-------------------------------------------------------------------------------
00342     //!  to get the begin iterator on edges
00343     /*!
00344       \return the begin iterator on edges
00345     */
00346     //-------------------------------------------------------------------------------
00347     inline iterator_dag begin(){return dpmap->begin();}
00348     //-------------------------------------------------------------------------------
00349     //!  to get the end iterator on edges
00350     /*!
00351       \return the end iterator on edges
00352     */
00353     //-------------------------------------------------------------------------------
00354     inline iterator_dag end(){return dpmap->end();}
00355     //-------------------------------------------------------------------------------
00356     //!  to get the value of the property map at the iterator position
00357     /*!
00358       \return a reference on the value (to be modified)
00359     */
00360     //-------------------------------------------------------------------------------
00361     inline T* operator[](iterator_dag it) { return dpmap->data[it._rank]; }
00362     //-------------------------------------------------------------------------------
00363     //!  to get an iterator on the source node of the edge
00364     /*!
00365       \return the iterator on the source node
00366     */
00367     //-------------------------------------------------------------------------------
00368     inline iterator_dag getSrcNode(iterator_dag it){return dpmap->getSrcNode(it);}
00369     //-------------------------------------------------------------------------------
00370     //!  to get an iterator on the destination node of the edge
00371     /*!
00372       \return the iterator on the destination node
00373     */
00374     //-------------------------------------------------------------------------------
00375     inline iterator_dag getDstNode(iterator_dag it){return dpmap->getDstNode(it);}
00376     //-------------------------------------------------------------------------------
00377     //!  start the communication process for the dpmap_edges property
00378     /*!
00379       prepare data to send
00380       launch non blocking MPI communications
00381     */
00382     //-------------------------------------------------------------------------------
00383     void start_communications(){dpmap->start_communications();}
00384     //-------------------------------------------------------------------------------
00385     //!  end the communication process for the dpmap_edges property
00386     /*!
00387       wait for the end of non-blocking communications
00388       put received values in the dpmap_edges property
00389     */
00390     //-------------------------------------------------------------------------------
00391     void end_communications(){dpmap->end_communications();}
00392     //-------------------------------------------------------------------------------
00393   };
00394 
00395   //-------------------------------------------------------------------------------
00396   //!  third specialization of DPMap_Edges
00397   /*!
00398     \tparam DD is the type of the DDAG
00399     \tparam T is the type of data in the property map
00400     \tparam node_access indicates if nodes have to have access to this property during calculation (>=1) or not (=0)
00401 
00402     In the case of a basic type T, node_access can't be >1
00403     In the case of a pointer type T*, if node_access>0 then it indicates the number of elements to shared at the end and at the beginning of the pointer
00404 
00405     The type T is specialized with a specific pointer type in this case as float*, double*, int* etc.
00406     The node_access is not specialized and is [0,...,size] size is precised at construction
00407     The size is not specialized, it is the number of elements in the pointer table to map
00408   */
00409   //-------------------------------------------------------------------------------
00410   template<class DD, class T> struct DPMap_Edges<DD,T*,1>
00411   {
00412     protected :
00413     bool ptr_const;
00414     DPMap_Edges_impl<DD,T*,1> * dpmap;
00415 
00416   public:
00417     typedef DPMap_Edges_impl<DD,T*,1> impl_type;
00418 
00419     //-------------------------------------------------------------------------------
00420     //!  constructor of DPMap_Edges
00421     /*!
00422       \param dag is the DDAG object associated to this map
00423       \param file is the file with initial values of edges wanted (each line is the value of the node "number of this line" associated in the .dot file)
00424     */
00425     //-------------------------------------------------------------------------------
00426     DPMap_Edges(DD &dag, const char * file,unsigned int size)
00427     {
00428       ptr_const=false;
00429       dpmap = new DPMap_Edges_impl<DD,T*,1>(dag,file,size);
00430     }
00431     //-------------------------------------------------------------------------------
00432     //!  constructor of DPMap_Edges
00433     /*!
00434       \param dag is the DDAG object associated to this map
00435       \param val is the default value of edges for the map
00436     */
00437     //-------------------------------------------------------------------------------
00438     DPMap_Edges(DD &dag, T val,unsigned int size)
00439     {
00440       ptr_const=false;
00441       dpmap = new DPMap_Edges_impl<DD,T*,1>(dag,val,size);
00442     }
00443     //-------------------------------------------------------------------------------
00444     //!  constructor from a DPMap_Edges_impl pointer
00445     /*!
00446       \param pointer to a DPMap_Edges_impl
00447     */
00448     //-------------------------------------------------------------------------------
00449     DPMap_Edges(DPMap_Edges_impl<DD,T*,1> * p)
00450     {
00451       ptr_const=true;
00452       dpmap = p;
00453     }
00454     //-------------------------------------------------------------------------------
00455     //!  destructor of DPMap_Edges
00456     /*!
00457     */
00458     //-------------------------------------------------------------------------------
00459     ~DPMap_Edges()
00460     {
00461       //do not destroy the pointer if the DPMap was constructed from an existing dpmap_impl
00462       if(dpmap!=NULL && !ptr_const)
00463         {delete dpmap;dpmap=NULL;}
00464     };
00465     //-------------------------------------------------------------------------------
00466     //!  to get the pointer on dpmap_impl
00467     /*!
00468       \return the dpmap implementation pointer
00469     */
00470     //-------------------------------------------------------------------------------
00471     inline DPMap_Edges_impl<DD,T*,1> * getDPMap(){return dpmap;}
00472     //-------------------------------------------------------------------------------
00473     //!  to get the begin iterator on edges
00474     /*!
00475       \return the begin iterator on edges
00476     */
00477     //-------------------------------------------------------------------------------
00478     inline iterator_dag begin(){return dpmap->begin();}
00479     //-------------------------------------------------------------------------------
00480     //!  to get the end iterator on edges
00481     /*!
00482       \return the end iterator on edges
00483     */
00484     //-------------------------------------------------------------------------------
00485     inline iterator_dag end(){return dpmap->end();}
00486     //-------------------------------------------------------------------------------
00487     //!  to get the value of the property map at the iterator position
00488     /*!
00489       \return a reference on the value (to be modified)
00490     */
00491     //-------------------------------------------------------------------------------
00492     inline T* operator[](iterator_dag it) { return dpmap->data[it._rank]; }
00493     //-------------------------------------------------------------------------------
00494     //!  to get an iterator on the source node of the edge
00495     /*!
00496       \return the iterator on the source node
00497     */
00498     //-------------------------------------------------------------------------------
00499     inline iterator_dag getSrcNode(iterator_dag it){return dpmap->getSrcNode(it);}
00500     //-------------------------------------------------------------------------------
00501     //!  to get an iterator on the destination node of the edge
00502     /*!
00503       \return the iterator on the destination node
00504     */
00505     //-------------------------------------------------------------------------------
00506     inline iterator_dag getDstNode(iterator_dag it){return dpmap->getDstNode(it);}
00507     //-------------------------------------------------------------------------------
00508     //!  start the communication process for the dpmap_edges property
00509     /*!
00510       prepare data to send
00511       launch non blocking MPI communications
00512     */
00513     //-------------------------------------------------------------------------------
00514     void start_communications(){dpmap->start_communications();}
00515     //-------------------------------------------------------------------------------
00516     //!  end the communication process for the dpmap_edges property
00517     /*!
00518       wait for the end of non-blocking communications
00519       put received values in the dpmap_edges property
00520     */
00521     //-------------------------------------------------------------------------------
00522     void end_communications(){dpmap->end_communications();}
00523     //-------------------------------------------------------------------------------
00524   };
00525 
00526   //-------------------------------------------------------------------------------
00527   //!  fourth specialization of DPMap_Edges
00528   /*!
00529     \tparam DD is the type of the DDAG
00530     \tparam T is the type of data in the property map
00531     \tapram overlap is the overlap size needed to compute the data
00532     \tparam size is the number of elements at each node
00533 
00534     The type T is specialized with a specific pointer type in this case as float*, double*, int* etc.
00535     The overlap is specialized to the value 0
00536     The size is not specialized, it is the number of elements in the pointer table to map
00537   */
00538   //-------------------------------------------------------------------------------
00539   template<class DD, class T> struct DPMap_Edges<DD,T*,0>
00540   {
00541   protected :
00542     bool ptr_const;
00543     DPMap_Edges_impl<DD,T*,0> * dpmap;
00544 
00545   public:
00546     typedef DPMap_Edges_impl<DD,T*,0> impl_type;
00547 
00548     //-------------------------------------------------------------------------------
00549     //!  constructor of DPMap_Edges
00550     /*!
00551       \param dag is the DDAG object associated to this map
00552       \param file is the file with initial values of edges wanted (each line is the value of the node "number of this line" associated in the .dot file)
00553     */
00554     //-------------------------------------------------------------------------------
00555     DPMap_Edges(DD &dag, const char * file,unsigned int size)
00556     {
00557       ptr_const=false;
00558       dpmap = new DPMap_Edges_impl<DD,T*,0>(dag,file,size);
00559     }
00560     //-------------------------------------------------------------------------------
00561     //!  constructor of DPMap_Edges
00562     /*!
00563       \param dag is the DDAG object associated to this map
00564       \param val is the default value of edges for the map
00565     */
00566     //-------------------------------------------------------------------------------
00567     DPMap_Edges(DD &dag, T val,const unsigned int size)
00568     {
00569       ptr_const=false;
00570       dpmap = new DPMap_Edges_impl<DD,T*,0>(dag,val,size);
00571     }
00572     //-------------------------------------------------------------------------------
00573     //!  constructor from a DPMap_Edges_impl pointer
00574     /*!
00575       \param pointer to a DPMap_Edges_impl
00576     */
00577     //-------------------------------------------------------------------------------
00578     DPMap_Edges(DPMap_Edges_impl<DD,T*,0> * p)
00579     {
00580       ptr_const=true;
00581       dpmap = p;
00582     }
00583     //-------------------------------------------------------------------------------
00584     //!  destructor of DPMap_Edges
00585     /*!
00586     */
00587     //-------------------------------------------------------------------------------
00588     ~DPMap_Edges()
00589     {
00590       //do not destroy the pointer if the DPMap was constructed from an existing dpmap_impl
00591       if(dpmap!=NULL && !ptr_const)
00592         {delete dpmap;dpmap=NULL;}
00593     };
00594     //-------------------------------------------------------------------------------
00595     //!  to get the pointer on dpmap_impl
00596     /*!
00597       \return the dpmap implementation pointer
00598     */
00599     //-------------------------------------------------------------------------------
00600     inline DPMap_Edges_impl<DD,T*,0> * getDPMap(){return dpmap;}
00601     //-------------------------------------------------------------------------------
00602     //!  to get the begin iterator on edges
00603     /*!
00604       \return the begin iterator on edges
00605     */
00606     //-------------------------------------------------------------------------------
00607     inline iterator_dag begin(){return dpmap->begin();}
00608     //-------------------------------------------------------------------------------
00609     //!  to get the end iterator on edges
00610     /*!
00611       \return the end iterator on edges
00612     */
00613     //-------------------------------------------------------------------------------
00614     inline iterator_dag end(){return dpmap->end();}
00615     //-------------------------------------------------------------------------------
00616     //!  to get the value of the property map at the iterator position
00617     /*!
00618       \return a reference on the value (to be modified)
00619     */
00620     //-------------------------------------------------------------------------------
00621     inline T* operator[](iterator_dag it) { return dpmap->data[it._rank]; }
00622     //-------------------------------------------------------------------------------
00623     //!  to get an iterator on the source node of the edge
00624     /*!
00625       \return the iterator on the source node
00626     */
00627     //-------------------------------------------------------------------------------
00628     inline iterator_dag getSrcNode(iterator_dag it){return dpmap->getSrcNode(it);}
00629     //-------------------------------------------------------------------------------
00630     //!  to get an iterator on the destination node of the edge
00631     /*!
00632       \return the iterator on the destination node
00633     */
00634     //-------------------------------------------------------------------------------
00635     inline iterator_dag getDstNode(iterator_dag it){return dpmap->getDstNode(it);}
00636     //-------------------------------------------------------------------------------
00637   };
00638   
00639 };
00640 
00641 
00642 #endif
 All Classes Files Functions Variables Defines