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

# element_ops.hh

Go to the documentation of this file.

    00001 // element_ops.hh: 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, 2006 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_DESIGN_PATTERN_ELEMENT_OPS_HH
    00018 # define VCSN_DESIGN_PATTERN_ELEMENT_OPS_HH
    00019
    00029 # include <vaucanson/design_pattern/element_op_traits.hh>
    00030
    00031 namespace vcsn {
    00032
    00036   /*-------------------.
    00037   | Ordered comparison |
    00038   `-------------------*/
    00039
    00041   template<typename S1, typename T1, typename S2, typename T2>
    00042   static
    00043   bool operator<(const vcsn::Element<S1, T1>& e1,
    00044                  const vcsn::Element<S2, T2>& e2);
    00045
    00047   template<typename S1, typename T1, typename S2, typename T2>
    00048   static
    00049   bool operator>(const vcsn::Element<S1, T1>& e1,
    00050                  const vcsn::Element<S2, T2>& e2);
    00051
    00053   template<typename S1, typename T1, typename S2, typename T2>
    00054   static
    00055   bool operator<=(const vcsn::Element<S1, T1>& e1,
    00056                   const vcsn::Element<S2, T2>& e2);
    00057
    00059   template<typename S1, typename T1, typename S2, typename T2>
    00060   static
    00061   bool operator>=(const vcsn::Element<S1, T1>& e1,
    00062                   const vcsn::Element<S2, T2>& e2);
    00063
    00065   template<typename S, typename T, typename U>
    00066   static
    00067   bool operator <(const vcsn::Element<S, T>& e,
    00068                   const U& v);
    00069
    00071   template<typename S, typename T, typename U>
    00072   static
    00073   bool operator >(const vcsn::Element<S, T>& e,
    00074                   const U& v);
    00075
    00077   template<typename S, typename T, typename U>
    00078   static
    00079   bool operator >=(const vcsn::Element<S, T>& e,
    00080                    const U& v);
    00081
    00083   template<typename S, typename T, typename U>
    00084   static
    00085   bool operator <=(const vcsn::Element<S, T>& e,
    00086                    const U& v);
    00087
    00089   template<typename U, typename S, typename T>
    00090   static
    00091   bool operator <(const U& v,
    00092                   const vcsn::Element<S, T>& e);
    00093
    00095   template<typename U, typename S, typename T>
    00096   static
    00097   bool operator >(const U& v,
    00098                   const vcsn::Element<S, T>& e);
    00099
    00101   template<typename U, typename S, typename T>
    00102   static
    00103   bool operator >=(const U& v,
    00104                    const vcsn::Element<S, T>& e);
    00105
    00107   template<typename U, typename S, typename T>
    00108   static
    00109   bool operator <=(const U& v,
    00110                    const vcsn::Element<S, T>& e);
    00111
    00112   /*---------.
    00113   | Equality |
    00114   `---------*/
    00115
    00117   template<typename S1, typename T1, typename S2, typename T2>
    00118   static
    00119   bool operator ==(const vcsn::Element<S1, T1>& e1,
    00120                   const vcsn::Element<S2, T2>& e2);
    00121
    00123   template<typename S, typename T, typename U>
    00124   static
    00125   bool operator ==(const vcsn::Element<S, T>& e,
    00126                    const U& v);
    00127
    00129   template<typename U, typename S, typename T>
    00130   static
    00131   bool operator ==(const U& v,
    00132                    const vcsn::Element<S, T>& e);
    00133
    00134   /*-----------.
    00135   | Difference |
    00136   `-----------*/
    00137
    00139   template<typename S1, typename T1, typename S2, typename T2>
    00140   static
    00141   bool operator !=(const vcsn::Element<S1, T1>& e1,
    00142                   const vcsn::Element<S2, T2>& e2);
    00143
    00145   template<typename S, typename T, typename U>
    00146   static
    00147   bool operator !=(const vcsn::Element<S, T>& e,
    00148                    const U& v);
    00149
    00151   template<typename U, typename S, typename T>
    00152   static
    00153   bool operator !=(const U& v,
    00154                    const vcsn::Element<S, T>& e);
    00155
    00156   /*---------.
    00157   | Addition |
    00158   `---------*/
    00159
    00161   template<typename S1, typename T1, typename S2, typename T2>
    00162   static
    00163   typename vcsn::op_add_traits<S1, S2, T1, T2>::ret_t
    00164   operator+(const vcsn::Element<S1, T1>& e1,
    00165             const vcsn::Element<S2, T2>& e2);
    00166
    00168   template<typename S, typename T, typename U>
    00169   static vcsn::Element<S, T>
    00170   operator +(const vcsn::Element<S, T>& e,
    00171              const U& v);
    00172
    00174   template<typename U, typename S, typename T>
    00175   static vcsn::Element<S, T>
    00176   operator +(const U& v,
    00177              const vcsn::Element<S, T>& e);
    00178
    00179   /*-------------.
    00180   | Substraction |
    00181   `-------------*/
    00182
    00184   template<typename S1, typename T1, typename S2, typename T2>
    00185   static
    00186   typename vcsn::op_sub_traits<S1, S2, T1, T2>::ret_t
    00187   operator-(const vcsn::Element<S1, T1>& e1,
    00188             const vcsn::Element<S2, T2>& e2);
    00189
    00191   template<typename S, typename T, typename U>
    00192   static vcsn::Element<S, T>
    00193   operator-(const vcsn::Element<S, T>& e,
    00194             const U& v);
    00195
    00197   template<typename U, typename S, typename T>
    00198   static vcsn::Element<S, T>
    00199   operator-(const U& v,
    00200             const vcsn::Element<S, T>& e);
    00201
    00202   /*---------------.
    00203   | Multiplication |
    00204   `---------------*/
    00205
    00207   template<typename S1, typename T1, typename S2, typename T2>
    00208   static
    00209   typename vcsn::op_mul_traits<S1, S2, T1, T2>::ret_t
    00210   operator*(const vcsn::Element<S1, T1>& e1,
    00211             const vcsn::Element<S2, T2>& e2);
    00212
    00214   template<typename S, typename T, typename U>
    00215   static vcsn::Element<S, T>
    00216   operator*(const vcsn::Element<S, T>& e,
    00217             const U& v);
    00218
    00220   template<typename U, typename S, typename T>
    00221   static vcsn::Element<S, T>
    00222   operator*(const U& v,
    00223             const vcsn::Element<S, T>& e);
    00224
    00225   /*---------.
    00226   | Division |
    00227   `---------*/
    00228
    00230   template<typename S1, typename T1, typename S2, typename T2>
    00231   static
    00232   typename vcsn::op_div_traits<S1, S2, T1, T2>::ret_t
    00233   operator/(const vcsn::Element<S1, T1>& e1,
    00234             const vcsn::Element<S2, T2>& e2);
    00235
    00237   template<typename S, typename T, typename U>
    00238   static vcsn::Element<S, T>
    00239   operator/(const vcsn::Element<S, T>& e,
    00240             const U& v);
    00241
    00243   template<typename U, typename S, typename T>
    00244   static vcsn::Element<S, T>
    00245   operator/(const U& v,
    00246             const vcsn::Element<S, T>& e);
    00247
    00248   /*--------.
    00249   | Modulus |
    00250   `--------*/
    00251
    00253   template<typename S1, typename T1, typename S2, typename T2>
    00254   static
    00255   typename vcsn::op_mod_traits<S1, S2, T1, T2>::ret_t
    00256   operator%(const vcsn::Element<S1, T1>& e1,
    00257             const vcsn::Element<S2, T2>& e2);
    00258
    00260   template<typename S, typename T, typename U>
    00261   static vcsn::Element<S, T>
    00262   operator%(const vcsn::Element<S, T>& e,
    00263             const U& v);
    00264
    00266   template<typename U, typename S, typename T>
    00267   static vcsn::Element<S, T>
    00268   operator%(const U& v,
    00269             const vcsn::Element<S, T>& e);
    00270
    00271   /*---------------.
    00272   | Unary negation |
    00273   `---------------*/
    00274
    00276   template<typename S, typename T>
    00277   static vcsn::Element<S, T>
    00278   operator -(const vcsn::Element<S, T>&);
    00279
    00280   /*-----------------.
    00281   | Input and Output |
    00282   `-----------------*/
    00283
    00285   template<typename St, typename S, typename T>
    00286   static St&
    00287   operator <<(St& s, const vcsn::Element<S, T>& e);
    00288
    00290   template<typename St, typename S, typename T>
    00291   static St&
    00292   operator >>(St& s, const vcsn::Element<S, T>& e);
    00293
    00294   // This operator does not exist.
    00295
    00296 //   template<typename S1, typename T1, typename S2, typename T2>
    00297 //   static void /* do not use or specialize */
    00298 //   operator <<(const vcsn::Element<S1, T1>& e1,
    00299 //            const vcsn::Element<S2, T2>& e2);
    00300
    00301
    00305 } // vcsn
    00306
    00307 namespace std {
    00308
    00312   /*-----.
    00313   | Swap |
    00314   `-----*/
    00315
    00320   template<typename S, typename T1, typename T2>
    00321   void swap(vcsn::Element<S, T1>& e1,
    00322             vcsn::Element<S, T2>& e2);
    00323
    00325   template<typename S, typename T>
    00326   void swap(vcsn::Element<S, T>& e1, T& v2);
    00327
    00329   template<typename T, typename S>
    00330   void swap(T& v1, vcsn::Element<S, T>& e2);
    00331
    00335 } // std
    00336
    00337 # if !defined VCSN_USE_INTERFACE_ONLY || defined VCSN_USE_LIB
    00338 #  include <vaucanson/design_pattern/element_ops.hxx>
    00339 # endif // VCSN_USE_INTERFACE_ONLY
    00340
    00341 #endif // ! VCSN_DESIGN_PATTERN_ELEMENT_OPS_HH