- Main Page
- Related Pages
- Modules
- Namespaces
- Classes
- Files

- File List
- File Members

# krat_exp_pattern.hxx

    00001 // krat_exp_pattern.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 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_KRAT_EXP_PATTERN_HXX
    00018 # define VCSN_ALGEBRA_IMPLEMENTATION_SERIES_KRAT_EXP_PATTERN_HXX
    00019
    00020 # include <vaucanson/algebra/implementation/series/krat_exp_pattern.hh>
    00021
    00022 namespace vcsn {
    00023
    00024   namespace algebra {
    00025
    00026     template <class T, class U>
    00027     BinaryOp<T, U>::BinaryOp()
    00028     {}
    00029
    00030     template <class T, class U>
    00031     BinaryOp<T, U>::BinaryOp(const BinaryOp& b) :
    00032       lhs_(b.lhs_),
    00033       rhs_(b.rhs_)
    00034     {}
    00035
    00036     template <class T, class U>
    00037     BinaryOp<T, U>::BinaryOp(const T& lhs, const U& rhs) :
    00038       lhs_(lhs),
    00039       rhs_(rhs)
    00040     {}
    00041
    00042     template <class T, class U>
    00043     T&
    00044     BinaryOp<T, U>::lhs()
    00045     {
    00046       return lhs_;
    00047     }
    00048
    00049     template <class T, class U>
    00050     const T&
    00051     BinaryOp<T, U>::lhs() const
    00052     {
    00053       return lhs_;
    00054     }
    00055
    00056     template <class T, class U>
    00057     U&
    00058     BinaryOp<T, U>::rhs()
    00059     {
    00060       return rhs_;
    00061     }
    00062
    00063     template <class T, class U>
    00064     const U&
    00065     BinaryOp<T, U>::rhs() const
    00066     {
    00067       return rhs_;
    00068     }
    00069
    00070     template <class T>
    00071     UnaryOp<T>::UnaryOp()
    00072     {}
    00073
    00074     template <class T>
    00075     UnaryOp<T>::UnaryOp(const UnaryOp& b) :
    00076       node_(b.node_)
    00077     {}
    00078
    00079     template <class T>
    00080     UnaryOp<T>::UnaryOp(const T& node) :
    00081       node_(node)
    00082     {}
    00083
    00084     template <class T>
    00085     T&
    00086     UnaryOp<T>::value()
    00087     {
    00088       return node_;
    00089     }
    00090
    00091     template <class T>
    00092     const T&
    00093     UnaryOp<T>::value() const
    00094     {
    00095       return node_;
    00096     }
    00097
    00098     template <class T>
    00099     Value<T>::Value()
    00100     {}
    00101
    00102     template <class T>
    00103     Value<T>::Value(const Value& v) :
    00104       v_ (v.v_)
    00105     {}
    00106
    00107     template <class T>
    00108     Value<T>::Value(const T& v) :
    00109       v_(v)
    00110     {}
    00111
    00112     template <class T>
    00113     T&
    00114     Value<T>::value()
    00115     {
    00116       return v_;
    00117     }
    00118
    00119     template <class T>
    00120     const T&
    00121     Value<T>::value() const
    00122     {
    00123       return v_;
    00124     }
    00125
    00126     template <class Self, class T, class U, class F>
    00127     U
    00128     GenericMatcher<Self, T, U, F>::match(const T& ast)
    00129     {
    00130       return F::d(*static_cast<Self*>(this), ast);
    00131     }
    00132
    00133     template <class Self, class T, class U, class F>
    00134     GenericMatcher<Self, T, U, F>::GenericMatcher()
    00135     {}
    00136
    00137   } // algebra
    00138
    00139 } // vcsn
    00140
    00141 #endif // ! VCSN_ALGEBRA_IMPLEMENTATION_SERIES_KRAT_EXP_PATTERN_HXX