SkelGIS
3.0
|
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