Vaucanson: nodes.hxx Source File

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