/ray/src/lib/tl/defop.h

Go to the documentation of this file.

/*
 * lib/tl/defop.h 
 * 
 * C++ operator template used by several other templates to access 
 * relational operators as well as constructors/destructors. 
 * 
 * Copyright (c) 2004 by Wolfgang Wieser ] wwieser (a) gmx <*> de [ 
 * 
 * This file may be distributed and/or modified under the terms of the 
 * GNU General Public License version 2 as published by the Free Software 
 * Foundation. (See COPYING.GPL for details.)
 * 
 * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 * 
 */

#ifndef _TemplateLibrary_DefaultOperators_H_
#define _TemplateLibrary_DefaultOperators_H_ 1

#include <lib/sconfig.h>    /* MUST be first */


template<typename T>struct TLDefaultOperators_Relational
{
    template<typename T2>static inline bool lt(T const &a,T2 const &b)  {  return(a<b);   }
    template<typename T2>static inline bool le(T const &a,T2 const &b)  {  return(a<=b);  }
    template<typename T2>static inline bool gt(T const &a,T2 const &b)  {  return(a>b);   }
    template<typename T2>static inline bool ge(T const &a,T2 const &b)  {  return(a>=b);  }
    template<typename T2>static inline bool eq(T const &a,T2 const &b)  {  return(a==b);  }
    template<typename T2>static inline bool ne(T const &a,T2 const &b)  {  return(a!=b);  }
};

template<typename T,typename T2>struct TLDefaultOperators_Relational2
{
    static inline bool lt(T const &a,T2 const &b)  {  return(a<b);   }
    static inline bool le(T const &a,T2 const &b)  {  return(a<=b);  }
    static inline bool gt(T const &a,T2 const &b)  {  return(a>b);   }
    static inline bool ge(T const &a,T2 const &b)  {  return(a>=b);  }
    static inline bool eq(T const &a,T2 const &b)  {  return(a==b);  }
    static inline bool ne(T const &a,T2 const &b)  {  return(a!=b);  }
};


template<typename T,typename ORD,typename T2,typename ORD2>
    struct TLDefaultOperators_OrdRel2
{
    static inline bool lt(T const &a,T2 const &b)
        {  return(ORD::ord(a)<ORD2::ord(b));   }
    static inline bool le(T const &a,T2 const &b)
        {  return(ORD::ord(a)<=ORD2::ord(b));  }
    static inline bool gt(T const &a,T2 const &b)
        {  return(ORD::ord(a)>ORD2::ord(b));   }
    static inline bool ge(T const &a,T2 const &b)
        {  return(ORD::ord(a)>=ORD2::ord(b));  }
    static inline bool eq(T const &a,T2 const &b)
        {  return(ORD::ord(a)==ORD2::ord(b));  }
    static inline bool ne(T const &a,T2 const &b)
        {  return(ORD::ord(a)!=ORD2::ord(b));  }
};

template<typename T,typename ORD,typename T2,typename ORD2>
    struct TLDefaultOperators_OrdRel2_Rev
{
    static inline bool lt(T const &a,T2 const &b)
        {  return(ORD::ord(a)>ORD2::ord(b));   }
    static inline bool le(T const &a,T2 const &b)
        {  return(ORD::ord(a)>=ORD2::ord(b));  }
    static inline bool gt(T const &a,T2 const &b)
        {  return(ORD::ord(a)<ORD2::ord(b));   }
    static inline bool ge(T const &a,T2 const &b)
        {  return(ORD::ord(a)<=ORD2::ord(b));  }
    static inline bool eq(T const &a,T2 const &b)
        {  return(ORD::ord(a)==ORD2::ord(b));  }
    static inline bool ne(T const &a,T2 const &b)
        {  return(ORD::ord(a)!=ORD2::ord(b));  }
};


template<typename T,typename ORD,typename T2>
    struct TLDefaultOperators_OrdRel2D
{
    static inline bool lt(T const &a,T2 const &b)  {  return(ORD::ord(a)<b);   }
    static inline bool le(T const &a,T2 const &b)  {  return(ORD::ord(a)<=b);  }
    static inline bool gt(T const &a,T2 const &b)  {  return(ORD::ord(a)>b);   }
    static inline bool ge(T const &a,T2 const &b)  {  return(ORD::ord(a)>=b);  }
    static inline bool eq(T const &a,T2 const &b)  {  return(ORD::ord(a)==b);  }
    static inline bool ne(T const &a,T2 const &b)  {  return(ORD::ord(a)!=b);  }
};


template<typename T>struct TLDefaultOperators_Construct_PDT
{
    static const bool pdt=1;
    
    static inline _constfn_ size_t size()
        {  return(sizeof(T));  }
    
    static inline T &ass(T &l,T const &r)  {  return(l=r);  }
    
    static inline _constfn_ void ini(T *) {}
    static inline void ini(T *p,T const &a)  {  *p=a;  }
    static inline _constfn_ void clr(T *) {}
};

template<typename T>struct TLDefaultOperators_Construct_CDT
{
    static const bool pdt=0;
    static inline _constfn_ size_t size()  {  return(sizeof(T));  }
    static inline T & ass(T &l,T const &r)  {  return(l=r);  }
    static inline void ini(T *p)  {  new(p) T();  }
    static inline void ini(T *p,T const &a)  {  new(p) T(a);  }
    static inline void clr(T *p)  {  p->~T();  }
};


template<typename T>struct TLDefaultOperators_Index
{
    template<typename I>static inline T &idx(T *array,I i)
        {  return(array[i]);  }
    template<typename I>static inline const T &idx(const T *array,I i)
        {  return(array[i]);  }
};


struct TLDefaultOperators_Allocation
{
    static inline void *alloc(size_t size)  {  return(ALLOC<char>(size));  }
    static inline void *free(void *ptr)  {  return(FREE(ptr));  }
    static inline void *realloc(void *ptr,size_t size)
        {  return(REALLOC((char*)ptr,size));  }
};


template<typename T>struct TLDefaultOperators_PDT : 
    TLDefaultOperators_Relational<T>,
    TLDefaultOperators_Construct_PDT<T>,
    TLDefaultOperators_Index<T>,
    TLDefaultOperators_Allocation
{
    // All provided in base classses. 
};

template<typename T>struct TLDefaultOperators_CDT : 
    TLDefaultOperators_Relational<T>,
    TLDefaultOperators_Construct_CDT<T>,
    TLDefaultOperators_Index<T>,
    TLDefaultOperators_Allocation
{
    // All provided in base classses. 
};

#endif  /* _TemplateLibrary_DefaultOperators_H_ */

---