|
Vaucanson 1.4
|
00001 // nodes.hxx: this file is part of the Vaucanson project. 00002 // 00003 // Vaucanson, a generic library for finite state machines. 00004 // 00005 // Copyright (C) 2001, 2002, 2003, 2004, 2005, 2008 The Vaucanson Group. 00006 // 00007 // This program is free software; you can redistribute it and/or 00008 // modify it under the terms of the GNU General Public License 00009 // as published by the Free Software Foundation; either version 2 00010 // of the License, or (at your option) any later version. 00011 // 00012 // The complete GNU General Public Licence Notice can be found as the 00013 // `COPYING' file in the root directory. 00014 // 00015 // The Vaucanson Group consists of people listed in the `AUTHORS' file. 00016 // 00017 #ifndef VCSN_ALGEBRA_IMPLEMENTATION_SERIES_RAT_NODES_HXX 00018 # define VCSN_ALGEBRA_IMPLEMENTATION_SERIES_RAT_NODES_HXX 00019 00020 # include <vaucanson/algebra/implementation/series/rat/nodes.hh> 00021 00022 namespace vcsn { 00023 00024 namespace rat { 00025 00026 template<class M_, class W_> 00027 void 00028 DefaultMutableNodeVisitor<M_,W_>::product(Node<M_, W_>* lhs, 00029 Node<M_, W_>* rhs) 00030 { 00031 lhs->accept(*this); 00032 rhs->accept(*this); 00033 } 00034 00035 template<class M_, class W_> 00036 void DefaultMutableNodeVisitor<M_,W_>::sum(Node<M_, W_>* lhs, 00037 Node<M_, W_>* rhs) 00038 { 00039 lhs->accept(*this); 00040 rhs->accept(*this); 00041 } 00042 00043 template<class M_, class W_> 00044 void DefaultMutableNodeVisitor<M_,W_>::star(Node<M_, W_>* n) 00045 { 00046 n->accept(*this); 00047 } 00048 00049 template<class M_, class W_> 00050 void DefaultMutableNodeVisitor<M_,W_>::left_weight(W_&, 00051 Node<M_, W_>* n) 00052 { 00053 n->accept(*this); 00054 } 00055 00056 template<class M_, class W_> 00057 void DefaultMutableNodeVisitor<M_,W_>::right_weight(W_&, 00058 Node<M_, W_>*n) 00059 { 00060 n->accept(*this); 00061 } 00062 00063 template<class M_, class W_> 00064 void DefaultMutableNodeVisitor<M_,W_>::constant( M_&) 00065 {} 00066 00067 template<class M_, class W_> 00068 void DefaultMutableNodeVisitor<M_,W_>::zero() 00069 {} 00070 00071 template<class M_, class W_> 00072 void DefaultMutableNodeVisitor<M_,W_>::one() 00073 {} 00074 00075 /*-----. 00076 | Node | 00077 `-----*/ 00078 00079 // Defined methods 00080 template<typename M_, typename W_> 00081 Node<M_,W_>::~Node() 00082 { 00083 } 00084 00085 template<typename M_, typename W_> 00086 Node<M_,W_>::Node() 00087 {} 00088 00089 /*-----. 00090 | Zero | 00091 `-----*/ 00092 template <class M_, class W_> 00093 Zero<M_,W_>::Zero() 00094 {} 00095 00096 template <class M_, class W_> 00097 typename Node<M_, W_>::type 00098 Zero<M_,W_>::what() const 00099 { 00100 return Node<M_, W_>::zero; 00101 } 00102 00103 template <class M_, class W_> 00104 Node<M_, W_>* 00105 Zero<M_,W_>::clone() const 00106 { 00107 Node<M_, W_>* p = new Zero<M_, W_>; 00108 return p; 00109 } 00110 00111 template <class M_, class W_> 00112 void 00113 Zero<M_,W_>::accept(ConstNodeVisitor<M_, W_>& v) const 00114 { 00115 v.zero(); 00116 } 00117 00118 template <class M_, class W_> 00119 bool 00120 Zero<M_,W_>::operator!=(const Node<M_, W_>& other) const 00121 { 00122 return (dynamic_cast<const Zero<M_, W_>*>(&other) == 0); 00123 } 00124 00125 template <class M_, class W_> 00126 bool 00127 Zero<M_,W_>::operator<(const Node<M_, W_>& other) const 00128 { 00129 return what() < other.what(); 00130 } 00131 00132 template <class M_, class W_> 00133 00134 Zero<M_,W_>::~Zero() 00135 {} 00136 00137 /*----. 00138 | One | 00139 `----*/ 00140 00141 template<typename M_, typename W_> 00142 One<M_,W_>::One() 00143 {} 00144 00145 template<typename M_, typename W_> 00146 typename Node<M_, W_>::type 00147 One<M_,W_>::what() const 00148 { 00149 return Node<M_, W_>::one; 00150 } 00151 00152 template<typename M_, typename W_> 00153 Node<M_, W_>* 00154 One<M_,W_>::clone() const 00155 { 00156 Node<M_, W_>* p = new One<M_, W_>; 00157 return p; 00158 } 00159 00160 template<typename M_, typename W_> 00161 void 00162 One<M_,W_>::accept(ConstNodeVisitor<M_, W_>& v) const 00163 { 00164 v.one(); 00165 } 00166 00167 template<typename M_, typename W_> 00168 bool 00169 One<M_,W_>::operator!=(const Node<M_, W_>& other) const 00170 { 00171 return (dynamic_cast<const One<M_, W_>*>(&other) == 0); 00172 } 00173 00174 template<typename M_, typename W_> 00175 bool 00176 One<M_,W_>::operator<(const Node<M_, W_>& other) const 00177 { 00178 return what() < other.what(); 00179 } 00180 00181 template<typename M_, typename W_> 00182 00183 One<M_,W_>::~One() 00184 {} 00185 00186 /*---------. 00187 | Constant | 00188 `---------*/ 00189 00190 template<typename M_, typename W_> 00191 Constant<M_,W_>::Constant(const M_ &v) : value_(v) 00192 {} 00193 00194 template<typename M_, typename W_> 00195 typename Node<M_, W_>::type 00196 Constant<M_,W_>::what() const 00197 { 00198 return Node<M_, W_>::constant; 00199 } 00200 00201 template<typename M_, typename W_> 00202 Node<M_, W_>* 00203 Constant<M_,W_>::clone() const 00204 { 00205 Node<M_, W_>* p = new Constant<M_, W_>(value_); 00206 return p; 00207 } 00208 00209 template<typename M_, typename W_> 00210 void 00211 Constant<M_,W_>::accept(ConstNodeVisitor<M_, W_>& v) const 00212 { 00213 v.constant(value_); 00214 } 00215 00216 template<typename M_, typename W_> 00217 bool 00218 Constant<M_,W_>::operator!=(const Node<M_, W_>& other) const 00219 { 00220 const Constant<M_, W_>* otherp = 00221 dynamic_cast<const Constant<M_, W_>*>(&other); 00222 if(!otherp) 00223 return true; 00224 return (value_ != otherp->value_); 00225 } 00226 00227 template<typename M_, typename W_> 00228 bool 00229 Constant<M_,W_>::operator<(const Node<M_, W_>& other) const 00230 { 00231 const Constant<M_, W_>* otherp = 00232 dynamic_cast<const Constant<M_, W_>*>(&other); 00233 if (otherp) 00234 return value_ < otherp->value_; 00235 else 00236 return what() < other.what(); 00237 } 00238 00239 template<typename M_, typename W_> 00240 00241 Constant<M_,W_>::~Constant() 00242 {}; 00243 00244 /*-------------. 00245 | LeftWeighted | 00246 `-------------*/ 00247 template<typename M_, typename W_> 00248 LeftWeighted<M_,W_>::LeftWeighted(const W_& w, const Node<M_, W_>& c) 00249 : weight_(w), child_(c.clone()) 00250 {} 00251 00252 template<typename M_, typename W_> 00253 LeftWeighted<M_,W_>::LeftWeighted(const W_& w, Node<M_, W_>* c) 00254 : weight_(w), child_(c) 00255 {} 00256 00257 template<typename M_, typename W_> 00258 LeftWeighted<M_,W_>::LeftWeighted(const W_& w) 00259 : weight_(w), 00260 child_(new One<M_, W_>) 00261 {} 00262 00263 template<typename M_, typename W_> 00264 typename Node<M_, W_>::type 00265 LeftWeighted<M_,W_>::what() const 00266 { 00267 return Node<M_, W_>::lweight; 00268 } 00269 00270 template<typename M_, typename W_> 00271 Node<M_, W_>* 00272 LeftWeighted<M_,W_>::clone() const 00273 { 00274 Node<M_, W_>* p = new LeftWeighted<M_, W_>(weight_, *child_); 00275 return p; 00276 } 00277 00278 template<typename M_, typename W_> 00279 void 00280 LeftWeighted<M_,W_>::accept(ConstNodeVisitor<M_, W_>& v) const 00281 { 00282 v.left_weight(weight_, child_); 00283 } 00284 00285 template<typename M_, typename W_> 00286 bool 00287 LeftWeighted<M_,W_>::operator!=(const Node<M_, W_>& other) const 00288 { 00289 const LeftWeighted<M_, W_>* otherp = 00290 dynamic_cast<const LeftWeighted<M_, W_>*>(&other); 00291 if(!otherp || (weight_ != otherp->weight_)) 00292 return true; 00293 return (*child_ != *otherp->child_); 00294 } 00295 00296 template<typename M_, typename W_> 00297 bool 00298 LeftWeighted<M_,W_>::operator<(const Node<M_, W_>& other) const 00299 { 00300 const LeftWeighted<M_, W_>* otherp = 00301 dynamic_cast<const LeftWeighted<M_, W_>*>(&other); 00302 if (otherp) 00303 { 00304 if (weight_ == otherp->weight_) 00305 return *child_ < *otherp->child_; 00306 else 00307 return weight_ < otherp->weight_; 00308 } 00309 else 00310 return what() < other.what(); 00311 } 00312 00313 template<typename M_, typename W_> 00314 00315 LeftWeighted<M_,W_>::~LeftWeighted() 00316 { 00317 delete child_; 00318 } 00319 00320 /*--------------. 00321 | RightWeighted | 00322 `--------------*/ 00323 template<typename M_, typename W_> 00324 RightWeighted<M_,W_>::RightWeighted(const W_& w, const Node<M_, W_>& c) 00325 : weight_(w), child_(c.clone()) 00326 {} 00327 00328 template<typename M_, typename W_> 00329 RightWeighted<M_,W_>::RightWeighted(const W_& w, Node<M_, W_>* c) 00330 : weight_(w), child_(c) 00331 {} 00332 00333 template<typename M_, typename W_> 00334 RightWeighted<M_,W_>::RightWeighted(const W_& w) 00335 : weight_(w), 00336 child_(new One<M_, W_>) 00337 {} 00338 00339 template<typename M_, typename W_> 00340 typename Node<M_, W_>::type 00341 RightWeighted<M_,W_>::what() const 00342 { 00343 return Node<M_, W_>::rweight; 00344 } 00345 00346 template<typename M_, typename W_> 00347 Node<M_, W_>* 00348 RightWeighted<M_,W_>::clone() const 00349 { 00350 Node<M_, W_>* p = new RightWeighted<M_, W_>(weight_, *child_); 00351 return p; 00352 } 00353 00354 template<typename M_, typename W_> 00355 void 00356 RightWeighted<M_,W_>::accept(ConstNodeVisitor<M_, W_>& v) const 00357 { 00358 v.right_weight(weight_, child_); 00359 } 00360 00361 template<typename M_, typename W_> 00362 bool 00363 RightWeighted<M_,W_>::operator!=(const Node<M_, W_>& other) const 00364 { 00365 const RightWeighted<M_, W_>* otherp = 00366 dynamic_cast<const RightWeighted<M_, W_>*>(&other); 00367 if(!otherp || (weight_ != otherp->weight_)) 00368 return true; 00369 return (*child_ != *otherp->child_); 00370 } 00371 00372 template<typename M_, typename W_> 00373 bool 00374 RightWeighted<M_,W_>::operator<(const Node<M_, W_>& other) const 00375 { 00376 const RightWeighted<M_, W_>* otherp = 00377 dynamic_cast<const RightWeighted<M_, W_>*>(&other); 00378 if (otherp) 00379 { 00380 if (weight_ == otherp->weight_) 00381 return *child_ < *otherp->child_; 00382 else 00383 return weight_ < otherp->weight_; 00384 } 00385 else 00386 return what() < other.what(); 00387 } 00388 00389 template<typename M_, typename W_> 00390 00391 RightWeighted<M_,W_>::~RightWeighted() 00392 { 00393 delete child_; 00394 } 00395 00396 /*-----. 00397 | Star | 00398 `-----*/ 00399 template <class M_,class W_> 00400 Star<M_,W_>::Star(const Node<M_, W_>& other) 00401 : child_(other.clone()) 00402 {} 00403 00404 template <class M_,class W_> 00405 Star<M_,W_>::Star(Node<M_, W_>* other) 00406 : child_(other) 00407 {} 00408 00409 template <class M_,class W_> 00410 typename Node<M_, W_>::type 00411 Star<M_,W_>::what() const 00412 { 00413 return Node<M_, W_>::star; 00414 } 00415 00416 template <class M_,class W_> 00417 Node<M_, W_>* 00418 Star<M_,W_>::clone() const 00419 { 00420 Node<M_, W_>* p = new Star<M_, W_>(*child_); 00421 return p; 00422 } 00423 00424 template <class M_,class W_> 00425 void 00426 Star<M_,W_>::accept(ConstNodeVisitor<M_, W_>& v) const 00427 { 00428 v.star(child_); 00429 } 00430 00431 template <class M_,class W_> 00432 bool 00433 Star<M_,W_>::operator!=(const Node<M_, W_>& other) const 00434 { 00435 const Star<M_, W_>* otherp = 00436 dynamic_cast<const Star<M_, W_>*>(&other); 00437 if(!otherp) 00438 return true; 00439 return (*child_ != *otherp->child_); 00440 } 00441 00442 template <class M_,class W_> 00443 bool 00444 Star<M_,W_>::operator<(const Node<M_, W_>& other) const 00445 { 00446 const Star<M_, W_>* otherp = 00447 dynamic_cast<const Star<M_, W_>*>(&other); 00448 if (otherp) 00449 return *child_ < *otherp->child_; 00450 else 00451 return what() < other.what(); 00452 } 00453 00454 template <class M_,class W_> 00455 00456 Star<M_,W_>::~Star() 00457 { 00458 delete child_; 00459 } 00460 00461 /*--------. 00462 | Product | 00463 `--------*/ 00464 template <class M_,class W_> 00465 Product<M_,W_>::Product(const Node<M_, W_>& left, 00466 const Node<M_, W_>& right) 00467 : left_(left.clone()), right_(right.clone()) 00468 {} 00469 00470 template <class M_,class W_> 00471 Product<M_,W_>::Product(Node<M_, W_>* left, Node<M_, W_>* right) 00472 : left_(left), right_(right) 00473 {} 00474 00475 template <class M_,class W_> 00476 typename Node<M_, W_>::type 00477 Product<M_,W_>::what() const 00478 { 00479 return Node<M_, W_>::prod; 00480 } 00481 00482 template <class M_,class W_> 00483 Node<M_, W_>* 00484 Product<M_,W_>::clone() const 00485 { 00486 Node<M_, W_>* p = new Product<M_, W_>(*left_, *right_); 00487 return p; 00488 } 00489 00490 template <class M_,class W_> 00491 void 00492 Product<M_,W_>::accept(ConstNodeVisitor<M_, W_>& v) const 00493 { 00494 return v.product(left_, right_); 00495 } 00496 00497 template <class M_,class W_> 00498 bool 00499 Product<M_,W_>::operator!=(const Node<M_, W_>& other) const 00500 { 00501 const Product<M_, W_>* otherp = 00502 dynamic_cast<const Product<M_, W_>*>(&other); 00503 if(!otherp || (*left_ != *otherp->left_)) 00504 return true; 00505 return (*right_ != *otherp->right_); 00506 } 00507 00508 template <class M_,class W_> 00509 bool 00510 Product<M_,W_>::operator<(const Node<M_, W_>& other) const 00511 { 00512 const Product<M_, W_>* otherp = 00513 dynamic_cast<const Product<M_, W_>*>(&other); 00514 if (otherp) 00515 { 00516 if (*left_ != *otherp->left_) 00517 return *left_ < *otherp->left_; 00518 else 00519 return *right_ < *otherp->right_; 00520 } 00521 else 00522 return what() < other.what(); 00523 } 00524 00525 template <class M_,class W_> 00526 00527 Product<M_,W_>::~Product() 00528 { 00529 delete right_; 00530 delete left_; 00531 } 00532 00533 /*----. 00534 | Sum | 00535 `----*/ 00536 template<typename M_, typename W_> 00537 Sum<M_,W_>::Sum(const Node<M_, W_>& left, const Node<M_, W_>& right) 00538 : left_(left.clone()), right_(right.clone()) 00539 {} 00540 00541 template<typename M_, typename W_> 00542 Sum<M_,W_>::Sum(Node<M_, W_>* left, Node<M_, W_>* right) 00543 : left_(left), right_(right) 00544 {} 00545 00546 template<typename M_, typename W_> 00547 void 00548 Sum<M_,W_>::accept(ConstNodeVisitor<M_, W_>& v) const 00549 { 00550 return v.sum(left_, right_); 00551 } 00552 00553 template<typename M_, typename W_> 00554 typename Node<M_, W_>::type 00555 Sum<M_,W_>::what() const 00556 { 00557 return Node<M_, W_>::sum; 00558 } 00559 00560 template<typename M_, typename W_> 00561 Node<M_, W_>* 00562 Sum<M_,W_>::clone() const 00563 { 00564 Node<M_, W_>* p = new Sum<M_, W_>(*left_, *right_); 00565 return p; 00566 } 00567 00568 template<typename M_, typename W_> 00569 bool 00570 Sum<M_,W_>::operator!=(const Node<M_, W_>& other) const 00571 { 00572 const Sum<M_, W_>* otherp = 00573 dynamic_cast<const Sum<M_, W_>*>(&other); 00574 if(!otherp) 00575 return true; 00576 // X + Y and Y + X are NOT equal 00577 // Indeed : if b + X < a + c and a + c = c + a 00578 // then b + X > a + c ! 00579 return (*left_ != *otherp->left_) || (*right_ != *otherp->right_); 00580 } 00581 00582 template<typename M_, typename W_> 00583 bool 00584 Sum<M_,W_>::operator<(const Node<M_, W_>& other) const 00585 { 00586 const Sum<M_, W_>* otherp = 00587 dynamic_cast<const Sum<M_, W_>*>(&other); 00588 if (otherp) 00589 { 00590 if (*left_ != *otherp->left_) 00591 return *left_ < *otherp->left_; 00592 else 00593 return *right_ < *otherp->right_; 00594 } 00595 else 00596 return what() < other.what(); 00597 } 00598 00599 template<typename M_, typename W_> 00600 00601 Sum<M_,W_>::~Sum() 00602 { 00603 delete right_; 00604 delete left_; 00605 } 00606 00607 } // End of namespace rat. 00608 00609 } // End of namespace vcsn. 00610 00611 #endif // ! VCSN_ALGEBRA_IMPLEMENTATION_SERIES_RAT_NODES_HXX
1.7.4