Constraints.hh

/* This file is part of the BIAS library (Basic ImageAlgorithmS).

   Copyright (C) 2003-2009    (see file CONTACT for details)
   Multimediale Systeme der Informationsverarbeitung
   Institut fuer Informatik
   Christian-Albrechts-Universitaet Kiel
   
   
   BIAS is free software; you can redistribute it and/or modify
   it under the terms of the GNU Lesser General Public License as published by
   the Free Software Foundation; either version 2.1 of the License, or
   (at your option) any later version.
   
   BIAS is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU Lesser General Public License for more details.
   
   You should have received a copy of the GNU Lesser General Public License
   along with BIAS; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/
#ifndef __Contraints_hh__
#define __Contraints_hh__

namespace BIAS {

  /** @class DerivedFrom
      @brief compile time check if B is (grand)father of T
      Found it in Bjarne Stroustrup's FAQ:
      http://public.research.att.com/~bs/bs_faq2.html
      "Actually, Derived_from doesn't check derivation, but conversion, but 
      that's often a better constraint. Finding good names for constraints
      can be hard."
      @author woelk 02/2006 */

  template<class T, class B>
  class DerivedFrom
  {
  public:
    DerivedFrom() {
      T* p = 0;
      B* pb = p;
      pb++; // avoid warn
    }
  };


  /** @class CanCopy 
      @brief compile time check for copy compatibilty between T1 and T2
      Found it in Bjarne Stroustrup's FAQ:
      http://public.research.att.com/~bs/bs_faq2.html
      @author woelk 02/2006 */
  template<class T1, class T2> 
  class CanCopy 
  {
  public:
    static void Constraints(T1 a, T2 b) { T2 c = a; b = a; }
    CanCopy() { 
      void(*p)(T1,T2) = Constraints; 
      p=0 /*NULL*/; 
    }
  };


  /** @class CanCompare
      @brief compile time check for comparabilty of T1 and T2
      Found it in Bjarne Stroustrup's FAQ:
      http://public.research.att.com/~bs/bs_faq2.html
      @author woelk 02/2006 */
  template<class T1, class T2 = T1> 
  class CanCompare 
  {
  public:
    static void Constraints(T1 a, T2 b) { a==b; a!=b; a<b; }
    CanCompare() { 
      void(*p)(T1,T2) = Constraints; 
      p=0 /*NULL*/; 
    }
  };


  /** @class CanMultiply
      @brief compile time check if T1 can be multiplied by T2
      Found it in Bjarne Stroustrup's FAQ:
      http://public.research.att.com/~bs/bs_faq2.html
      @author woelk 02/2006 */
  template<class T1, class T2, class T3 = T1> 
  class CanMultiply 
  {
  public:
    static void Constraints(T1 a, T2 b, T3 c) { c = a*b; }
    CanMultiply() { 
      void(*p)(T1,T2,T3) = Constraints; 
      p=0 /*NULL*/; 
    }
  };


  /** @class SameButConst
      @brief compile time check if the ConstType differs from 
      EditableType merely by a const qualifier, i.e. 
      const EditableType == ConstType
      @author woelk 02/2008 (c) www.vision-n.de*/
  template<class EditableType, class ConstType>
  class SameButConst
  { 
  public:
    static void Constraints(EditableType *a, ConstType *b, 
                            const EditableType *c) {
      c = const_cast<ConstType *>(a);
      *a = *c;
    } 
    SameButConst() { 
      void(*p)(EditableType *, ConstType *, const EditableType *) = 
        Constraints; 
      p = p; //avoid warning
      p=0 /*NULL*/; 
    }
  };




}

#endif // __Contraints_hh__