fnoperators.h

精确的函数表达模板,里面包含了许多C和C++的函数表达模板

               , Equal< double                           // Oper
                         , typename Expr<B>::result_type
                         , bool > > >
   operator==(const double& l, const Expr<B>& b)
   {
      typedef double   arg1_t;
      typedef typename Expr<B>::result_type arg2_t;
      typedef typename BinExpr<LiteralExpr<arg1_t>, Expr<B>, Equal<arg1_t, arg2_t, bool> >binExprT;

      return Expr<binExprT>(binExprT(LiteralExpr<arg1_t>(l),b));
   }

   // operator==(Expr, double)
   template<class A>
   Expr<BinExpr< Expr<A>                                   // Arg1
               , LiteralExpr<double>                       // Arg2
               , Equal< typename Expr<A>::result_type           // Oper
                         , double
                         , bool > > >
   operator==(const Expr<A>& a, const double& l)
   {
      typedef double   arg2_t;
      typedef typename Expr<A>::result_type arg1_t;
      typedef typename BinExpr<Expr<A>, LiteralExpr<arg2_t>, Equal<arg1_t, arg2_t, bool> > binExprT;

      return Expr<binExprT>(binExprT(a, LiteralExpr<arg2_t>(l)));
   }

   // operator==(int, Expr)
   template<class B>
   Expr<BinExpr< LiteralExpr<int>                           // Arg1
               , Expr<B>                                    // Arg2
               , Equal< int                                  // Oper
                     , typename Expr<B>::result_type
                     , bool > > >
   operator==(const int& l, const Expr<B>& b)
   {
      typedef int      arg1_t;
      typedef typename Expr<B>::result_type arg2_t;
      typedef typename BinExpr<LiteralExpr<arg1_t>, Expr<B>, Equal<arg1_t, arg2_t, bool> >binExprT;

      return Expr<binExprT>(binExprT(LiteralExpr<arg1_t>(l),b));
   }

   // operator==(Expr, int)
   template<class A>
   Expr<BinExpr< Expr<A>                                   // Arg1
               , LiteralExpr<int>                          // Arg2
               , Equal< typename Expr<A>::result_type       // Oper
                     , int
                     , bool > > >
   operator==(const Expr<A>& a, const int& l)
   {
      typedef int      arg2_t;
      typedef typename Expr<A>::result_type arg1_t;
      typedef typename BinExpr<Expr<A>, LiteralExpr<arg2_t>, Equal<arg1_t, arg2_t, bool> > binExprT;

      return Expr<binExprT>(binExprT(a, LiteralExpr<arg2_t>(l)));
   }

   /////////////////////////////////////////////////////////////////////////////
   // operator!=(Expr, Expr)
   template<class A, class B>
   Expr<BinExpr< Expr<A>                                   // Arg1
               , Expr<B>                                   // Arg2
               , NotEqual< typename Expr<A>::result_type   // Oper
                      , typename Expr<B>::result_type
                      , bool > > >
   operator!=(const Expr<A>& a, const Expr<B>& b)
   {
      typedef typename Expr<A>::result_type arg1_t;
      typedef typename Expr<B>::result_type arg2_t;
      typedef typename BinExpr<Expr<A>, Expr<B>, NotEqual<arg1_t, arg2_t, bool> > binExprT;

      return Expr<binExprT>(binExprT(a,b));
   }

   // operator!=(double, Expr)
   template<class B>
   Expr<BinExpr< LiteralExpr<double>                        // Arg1
               , Expr<B>                                    // Arg2
               , NotEqual< double                           // Oper
                         , typename Expr<B>::result_type
                         , bool > > >
   operator!=(const double& l, const Expr<B>& b)
   {
      typedef double   arg1_t;
      typedef typename Expr<B>::result_type arg2_t;
      typedef typename BinExpr<LiteralExpr<arg1_t>, Expr<B>, NotEqual<arg1_t, arg2_t, bool> >binExprT;

      return Expr<binExprT>(binExprT(LiteralExpr<arg1_t>(l),b));
   }

   // operator!=(Expr, double)
   template<class A>
   Expr<BinExpr< Expr<A>                                   // Arg1
               , LiteralExpr<double>                       // Arg2
               , NotEqual< typename Expr<A>::result_type   // Oper
                         , double
                         , bool > > >
   operator!=(const Expr<A>& a, const double& l)
   {
      typedef double   arg2_t;
      typedef typename Expr<A>::result_type arg1_t;
      typedef typename BinExpr<Expr<A>, LiteralExpr<arg2_t>, NotEqual<arg1_t, arg2_t, bool> > binExprT;

      return Expr<binExprT>(binExprT(a, LiteralExpr<arg2_t>(l)));
   }

   // operator!=(int, Expr)
   template<class B>
   Expr<BinExpr< LiteralExpr<int>                           // Arg1
               , Expr<B>                                    // Arg2
               , NotEqual< int                              // Oper
                     , typename Expr<B>::result_type
                     , bool > > >
   operator!=(const int& l, const Expr<B>& b)
   {
      typedef int      arg1_t;
      typedef typename Expr<B>::result_type arg2_t;
      typedef typename BinExpr<LiteralExpr<arg1_t>, Expr<B>, NotEqual<arg1_t, arg2_t, bool> >binExprT;

      return Expr<binExprT>(binExprT(LiteralExpr<arg1_t>(l),b));
   }

   // operator!=(Expr, int)
   template<class A>
   Expr<BinExpr< Expr<A>                                   // Arg1
               , LiteralExpr<int>                          // Arg2
               , NotEqual< typename Expr<A>::result_type   // Oper
                     , int
                     , bool > > >
   operator!=(const Expr<A>& a, const int& l)
   {
      typedef int      arg2_t;
      typedef typename Expr<A>::result_type arg1_t;
      typedef typename BinExpr<Expr<A>, LiteralExpr<arg2_t>, NotEqual<arg1_t, arg2_t, bool> > binExprT;

      return Expr<binExprT>(binExprT(a, LiteralExpr<arg2_t>(l)));
   }
   /////////////////////////////////////////////////////////////////////////////
   // operator||(Expr, Expr)
   template<class A, class B>
   Expr<BinExpr< Expr<A>                                   // Arg1
               , Expr<B>                                   // Arg2
               , Or< typename Expr<A>::result_type       // Oper
                     , typename Expr<B>::result_type
                     , bool > > >
   operator||(const Expr<A>& a, const Expr<B>& b)
   {
      typedef typename Expr<A>::result_type arg1_t;
      typedef typename Expr<B>::result_type arg2_t;
      typedef typename BinExpr<Expr<A>, Expr<B>, Or<arg1_t, arg2_t, bool> > binExprT;

      return Expr<binExprT>(binExprT(a,b));
   }

   // operator||(double, Expr)
   template<class B>
   Expr<BinExpr< LiteralExpr<double>                        // Arg1
               , Expr<B>                                    // Arg2
               , Or< double                           // Oper
                         , typename Expr<B>::result_type
                         , bool > > >
   operator||(const double& l, const Expr<B>& b)
   {
      typedef double   arg1_t;
      typedef typename Expr<B>::result_type arg2_t;
      typedef typename BinExpr<LiteralExpr<arg1_t>, Expr<B>, Or<arg1_t, arg2_t, bool> >binExprT;

      return Expr<binExprT>(binExprT(LiteralExpr<arg1_t>(l),b));
   }

   // operator||(Expr, double)
   template<class A>
   Expr<BinExpr< Expr<A>                                   // Arg1
               , LiteralExpr<double>                       // Arg2
               , Or< typename Expr<A>::result_type           // Oper
                         , double
                         , bool > > >
   operator||(const Expr<A>& a, const double& l)
   {
      typedef double   arg2_t;
      typedef typename Expr<A>::result_type arg1_t;
      typedef typename BinExpr<Expr<A>, LiteralExpr<arg2_t>, Or<arg1_t, arg2_t, bool> > binExprT;

      return Expr<binExprT>(binExprT(a, LiteralExpr<arg2_t>(l)));
   }

   // operator||(int, Expr)
   template<class B>
   Expr<BinExpr< LiteralExpr<int>                           // Arg1
               , Expr<B>                                    // Arg2
               , Or< int                                  // Oper
                     , typename Expr<B>::result_type
                     , bool > > >
   operator||(const int& l, const Expr<B>& b)
   {
      typedef int      arg1_t;
      typedef typename Expr<B>::result_type arg2_t;
      typedef typename BinExpr<LiteralExpr<arg1_t>, Expr<B>, Or<arg1_t, arg2_t, bool> >binExprT;

      return Expr<binExprT>(binExprT(LiteralExpr<arg1_t>(l),b));
   }

   // operator||(Expr, int)
   template<class A>
   Expr<BinExpr< Expr<A>                                   // Arg1
               , LiteralExpr<int>                          // Arg2
               , Or< typename Expr<A>::result_type       // Oper
                     , int
                     , bool > > >
   operator||(const Expr<A>& a, const int& l)
   {
      typedef int      arg2_t;
      typedef typename Expr<A>::result_type arg1_t;
      typedef typename BinExpr<Expr<A>, LiteralExpr<arg2_t>, Or<arg1_t, arg2_t, bool> > binExprT;

      return Expr<binExprT>(binExprT(a, LiteralExpr<arg2_t>(l)));
   }

   /////////////////////////////////////////////////////////////////////////////
   // operator&&(Expr, Expr)
   template<class A, class B>
   Expr<BinExpr< Expr<A>                                   // Arg1
               , Expr<B>                                   // Arg2
               , And< typename Expr<A>::result_type       // Oper
                     , typename Expr<B>::result_type
                     , bool > > >
   operator&&(const Expr<A>& a, const Expr<B>& b)
   {
      typedef typename Expr<A>::result_type arg1_t;
      typedef typename Expr<B>::result_type arg2_t;
      typedef typename BinExpr<Expr<A>, Expr<B>, And<arg1_t, arg2_t, bool> > binExprT;

      return Expr<binExprT>(binExprT(a,b));
   }

   // operator&&(double, Expr)
   template<class B>
   Expr<BinExpr< LiteralExpr<double>                        // Arg1
               , Expr<B>                                    // Arg2
               , And< double                           // Oper
                         , typename Expr<B>::result_type
                         , bool > > >
   operator&&(const double& l, const Expr<B>& b)
   {
      typedef double   arg1_t;
      typedef typename Expr<B>::result_type arg2_t;
      typedef typename BinExpr<LiteralExpr<arg1_t>, Expr<B>, And<arg1_t, arg2_t, bool> >binExprT;

      return Expr<binExprT>(binExprT(LiteralExpr<arg1_t>(l),b));
   }

   // operator&&(Expr, double)
   template<class A>
   Expr<BinExpr< Expr<A>                                   // Arg1
               , LiteralExpr<double>                       // Arg2
               , And< typename Expr<A>::result_type           // Oper
                         , double
                         , bool > > >
   operator&&(const Expr<A>& a, const double& l)
   {
      typedef double   arg2_t;
      typedef typename Expr<A>::result_type arg1_t;
      typedef typename BinExpr<Expr<A>, LiteralExpr<arg2_t>, And<arg1_t, arg2_t, bool> > binExprT;

      return Expr<binExprT>(binExprT(a, LiteralExpr<arg2_t>(l)));
   }

   // operator&&(int, Expr)
   template<class B>
   Expr<BinExpr< LiteralExpr<int>                           // Arg1
               , Expr<B>                                    // Arg2
               , And< int                                  // Oper
                     , typename Expr<B>::result_type
                     , bool > > >
   operator&&(const int& l, const Expr<B>& b)
   {
      typedef int      arg1_t;
      typedef typename Expr<B>::result_type arg2_t;
      typedef typename BinExpr<LiteralExpr<arg1_t>, Expr<B>, And<arg1_t, arg2_t, bool> >binExprT;

      return Expr<binExprT>(binExprT(LiteralExpr<arg1_t>(l),b));
   }

   // operator&&(Expr, int)
   template<class A>
   Expr<BinExpr< Expr<A>                                   // Arg1
               , LiteralExpr<int>                          // Arg2
               , And< typename Expr<A>::result_type       // Oper
                     , int
                     , bool > > >
   operator&&(const Expr<A>& a, const int& l)
   {
      typedef int      arg2_t;
      typedef typename Expr<A>::result_type arg1_t;
      typedef typename BinExpr<Expr<A>, LiteralExpr<arg2_t>, And<arg1_t, arg2_t, bool> > binExprT;

      return Expr<binExprT>(binExprT(a, LiteralExpr<arg2_t>(l)));
   }

#endif