TestMatrixInterface.cpp

/* 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 */

/** @file MatrixInterfaceCheck.cpp
 *  @ingroup g_tests
    @brief Class capsulating the checks for interfaces of Matrix* classes
    without using inheritance and thus avoiding the overhead induced by the
    vtable.
    @relates Matrix, Matrix2x2, Matrix3x3, Matrix3x4, Matrix4x4, ...
    @author woelk 05/2008 (c) www.vision-n.de */

#include <Base/Math/Matrix.hh>
#include <Base/Math/Matrix2x2.hh>
#include <Base/Math/Matrix3x3.hh>
#include <Base/Math/SymmetricMatrix3x3.hh>
#include <Base/Math/Matrix3x4.hh>
#include <Base/Math/Matrix4x4.hh>

using namespace BIAS;

/// macro for checking the existence of a specific function with signature
/// RESULT FUNCTION(__VA_ARGS__) CONST. The check is conducted by trying to
/// assign a pointer to the member-function in question to the
/// variable 'p'
#define MATRIX_INTERFACE(RESULT, FUNCTION, CONST, ARG)\
  { RESULT (MATRIX_CLASS<T>::* p)(ARG) CONST = &MATRIX_CLASS<T>::FUNCTION; \
    p=0; }

#define MATRIX_INTERFACE2(RESULT, FUNCTION, CONST, ARG1, ARG2)\
  { RESULT (MATRIX_CLASS<T>::* p)(ARG1, ARG2) CONST = &MATRIX_CLASS<T>::FUNCTION; \
    p=0; }

#define MATRIX_INTERFACE3(RESULT, FUNCTION, CONST)\
  { RESULT (MATRIX_CLASS<T>::* p)() CONST = &MATRIX_CLASS<T>::FUNCTION; \
    p=0; }

#define MATRIX_INTERFACE4(RESULT, FUNCTION)\
  { RESULT (MATRIX_CLASS<T>::* p)() = &MATRIX_CLASS<T>::FUNCTION; \
    p=0; }


#define MATRIX_INTERFACE5(RESULT, FUNCTION, ARG)\
  { RESULT (MATRIX_CLASS<T>::* p)(ARG) = &MATRIX_CLASS<T>::FUNCTION; \
    p=0; } 

template <template <typename> class MATRIX_CLASS,
          template <typename> class VECTOR_CLASS, class T>
class MatrixInterfaceCheck
{
public:
  static void Constraints()
  {
    MATRIX_CLASS<T> m;

    // T* operator[](const unsigned)
#if  __GNUC_PREREQ(4,6)
  #pragma GCC diagnostic ignored "-Wunused-but-set-variable"
#endif
    MATRIX_INTERFACE5(T* , operator[], const unsigned);

    // const T* operator[](const unsigned) const
#if  __GNUC_PREREQ(4,6)
  #pragma GCC diagnostic ignored "-Wunused-but-set-variable"
#endif
    MATRIX_INTERFACE(const T* , operator[], const, const unsigned);

    // T* GetData()
#if  __GNUC_PREREQ(4,6)
  #pragma GCC diagnostic ignored "-Wunused-but-set-variable"
#endif
    MATRIX_INTERFACE4(T* , GetData);

    // const T* GetData() const
#if  __GNUC_PREREQ(4,6)
  #pragma GCC diagnostic ignored "-Wunused-but-set-variable"
#endif
    MATRIX_INTERFACE3(const T* , GetData, const);

    // unsigned GetNumElements() const
#if  __GNUC_PREREQ(4,6)
  #pragma GCC diagnostic ignored "-Wunused-but-set-variable"
#endif
    MATRIX_INTERFACE3(unsigned , GetNumElements, const);

    // void SetZero()
#if  __GNUC_PREREQ(4,6)
  #pragma GCC diagnostic ignored "-Wunused-but-set-variable"
#endif
    MATRIX_INTERFACE4(void, SetZero);

    // void SetIdentity()
#if  __GNUC_PREREQ(4,6)
  #pragma GCC diagnostic ignored "-Wunused-but-set-variable"
#endif
    MATRIX_INTERFACE4(void, SetIdentity);

    // void Mult(const VECTOR_CLASS &, VECTOR_CLASS &) const
#if  __GNUC_PREREQ(4,6)
  #pragma GCC diagnostic ignored "-Wunused-but-set-variable"
#endif
    MATRIX_INTERFACE2(void, Mult, const, const VECTOR_CLASS<T> &, VECTOR_CLASS<T> &);

    // void TransposedMult(const VECTOR_CLASS &, VECTOR_CLASS &) const
#if  __GNUC_PREREQ(4,6)
  #pragma GCC diagnostic ignored "-Wunused-but-set-variable"
#endif
    MATRIX_INTERFACE2(void, TransposedMult, const, const VECTOR_CLASS<T> &, VECTOR_CLASS<T> &);

    // void Mult(const MATRIX_CLASS &, MATRIX_CLASS &) const
#if  __GNUC_PREREQ(4,6)
  #pragma GCC diagnostic ignored "-Wunused-but-set-variable"
#endif
    MATRIX_INTERFACE2(void, Mult, const, const MATRIX_CLASS<T> &, MATRIX_CLASS<T> &);

    // MATRIX_CLASS& operator*=(const MATRIX_CLASS &)
#if  __GNUC_PREREQ(4,6)
  #pragma GCC diagnostic ignored "-Wunused-but-set-variable"
#endif
    MATRIX_INTERFACE5(MATRIX_CLASS<T>&, operator*= , const MATRIX_CLASS<T> &);

    // void Scale(const T &, MATRIX_CLASS &) const
#if  __GNUC_PREREQ(4,6)
  #pragma GCC diagnostic ignored "-Wunused-but-set-variable"
#endif
    MATRIX_INTERFACE2(void, Scale, const, const T &, MATRIX_CLASS<T> &);

    // bool Load(const std::string &)
#if  __GNUC_PREREQ(4,6)
  #pragma GCC diagnostic ignored "-Wunused-but-set-variable"
#endif
    MATRIX_INTERFACE5(bool, Load , const std::string &);

    // bool Save(const std::string &) const
#if  __GNUC_PREREQ(4,6)
    #pragma GCC diagnostic ignored "-Wunused-but-set-variable"
#endif
    MATRIX_INTERFACE(bool, Save, const , const std::string &);

    // bool Save2(const std::string &) const does not exist
    // MATRIX_INTERFACE(bool, Save2, const, const std::string &);

    // ....... unfinished
  }

  MatrixInterfaceCheck()
  {
    void(*p)() = Constraints;  p=0;
  }


};

int main(int argc, char *argv[])
{
  // if one of the lines below does not compile, the interface of the
  // matrix class in question is not conformal with this check. Either the
  //

  //MatrixInterfaceCheck<Matrix, Vector, double> m;
  //MatrixInterfaceCheck<Matrix2x2, Vector2, double > m2x2;
  MatrixInterfaceCheck<Matrix3x3, Vector3, double > m3x3;
  //MatrixInterfaceCheck<Matrix3x4, Vector4, double> m3x4;
  //MatrixInterfaceCheck<Matrix4x4, Vector4, double> m4x4;
  //MatrixInterfaceCheck<SymmetricMatrix3x3, Vector3, double> m4x4;
  return 0;
}