TypedFieldCheck.h

Go to the documentation of this file.

//    Copyright 2004-2019, SenseGraphics AB
//
//    This file is part of H3D API.
//
//    H3D API is free software; you can redistribute it and/or modify
//    it under the terms of the GNU General Public License as published by
//    the Free Software Foundation; either version 2 of the License, or
//    (at your option) any later version.
//
//    H3D API 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 General Public License for more details.
//
//    You should have received a copy of the GNU General Public License
//    along with H3D API; if not, write to the Free Software
//    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
//
//    A commercial license is also available. Please contact us at 
//    www.sensegraphics.com for more information.
//
//
//
#ifndef __TYPEDFIELDCHECK_H__
#define __TYPEDFIELDCHECK_H__
 
#include <string>
#include <H3D/Field.h>
#include <H3DUtil/Exception.h>
#include <H3D/TypedFieldTypesTmpl.h>
#include <H3D/TypedFieldAnyTmpl.h>
 
namespace H3D {
  H3D_API_EXCEPTION( TypedFieldError );
    
  namespace TypedFieldTypeCheck {
 
    H3D_API_EXCEPTION( InvalidTemplateArguments );
 
    template< class Type >
    struct AnyNumber {
      static void checkTemplateArguments() {
        TypesType< Type >::checkTemplateArguments();
      }
 
H3D_PUSH_WARNINGS()
H3D_DISABLE_UNUSED_PARAMETER_WARNING()
      static void checkType( Field *f, int index ) {
        TypesType< Type >::checkType( f );
      }
    };
H3D_POP_WARNINGS()
 
    
    template<H3D_TYPES_TEMPLATE_LIST>
    struct AnyNumber< H3D_TYPES_CLASS > {
      static void checkTemplateArguments() {
        H3D_TYPES_CLASS::checkTemplateArguments();
      }
 
      static void checkType( Field *f, int index ) {
        int nr_types =  H3D_TYPES_CLASS::numberTypes();
        H3D_TYPES_CLASS::checkType( f, index % nr_types );
      }
    };
 
    template< class Type >
    struct AnyNumber< AnyNumber< Type > > {
      static void checkTemplateArguments() {
        string s="No AnyNumber statements allowed in AnyNumber statement.";
        throw InvalidTemplateArguments( s ); 
      }
      static void checkType( Field *f, int index ) {
        string s="No AnyNumber statements allowed in AnyNumber statement.";
        throw InvalidTemplateArguments( s ); 
      }
    };
 
    template< class Type >
    struct AnyType {
      //  It is correct in this case since it is a normal type
      //  (all illegal types are handled as template specialisations ).
      static void checkTemplateArguments() {}
 
      static bool checkType( Field *f ) {
        return dynamic_cast< Type * >( f ) != NULL;
      }
    };
 
    template<H3D_ANY_TEMPLATE_LIST>
    struct AnyType< H3D_ANY_CLASS > {
      static void checkTemplateArguments() {
        string s = "No Any statements allowed in Any statement.";
        throw InvalidTemplateArguments( s );
      }
 
      static bool checkType( Field *f ) {
        string s = "No Any statements allowed in Any statement.";
        throw InvalidTemplateArguments( s );
      }
    };
 
    template<H3D_TYPES_TEMPLATE_LIST>
    struct AnyType< H3D_TYPES_CLASS > {
 
      static void checkTemplateArguments() {
        string s = "No Types statements allowed in Any statement.";
        throw InvalidTemplateArguments( s );
      }
 
      static bool checkType( Field *f ) {
        string s = "No Types statements allowed in Any statement.";
        throw InvalidTemplateArguments( s );
      }
    };
 
    template< class Type >
    struct AnyType< AnyNumber< Type > > {
 
      static void checkTemplateArguments() {
        string s = "No AnyNumber statements allowed in Any statement.";
        throw InvalidTemplateArguments( s );
      }
 
      static bool checkType( Field *f ) {
        string s = "No AnyNumber statements allowed in Any statement.";
        throw InvalidTemplateArguments( s );
      }
    };
 
    template< class Type >
    struct TypesType {
      //  It is correct in this case since it is a normal types 
      //  (all illegal types are handled as template specialisations ).
      static void checkTemplateArguments() {}
 
      static void checkType( Field *f ) {
        if( !dynamic_cast< Type * >( f ) ) {
          throw InvalidType( f->getTypeName(),
                             Type::classTypeName() );
        }
      }
    };
 
    template< H3D_ANY_TEMPLATE_LIST >
    struct TypesType< H3D_ANY_CLASS > {
      static void checkTemplateArguments() {
        H3D_ANY_CLASS::checkTemplateArguments();
      }
 
      static void checkType( Field *f ) {
        H3D_ANY_CLASS::checkType( f );
      }
    };
 
    template< H3D_TYPES_TEMPLATE_LIST >
    struct TypesType< H3D_TYPES_CLASS > {
      static void checkTemplateArguments() {
        string s = "No Types statements allowed in another Types statement.";
        throw InvalidTemplateArguments( s );
      }
 
      static void checkType( Field *f ) {
        string s = "No Types statements allowed in another Types statement.";
        throw InvalidTemplateArguments( s );
      }
    };
 
    template< class Type >
    struct TypesType< AnyNumber< Type > > {
 
      static void checkTemplateArguments() {
        string s ="No AnyNumber statements allowed in Types statement.";
        throw InvalidTemplateArguments( s );
      }
 
      static bool checkType( Field *f ) {
        string s ="No AnyNumber statements allowed in Types statement.";
        throw InvalidTemplateArguments( s );
      }
    };
 
    template< class RequiredArgType,
              class OptionalArgTypes >
    struct TypedFieldCheck {
      static void checkTemplateArguments() {
        TypesType<RequiredArgType>::checkTemplateArguments();
        TypedFieldCheck< void,  
          OptionalArgTypes >::checkTemplateArguments();
      }
        
      static void checkFieldType( Field *f, 
                                  int field_index, 
                                  int type_index ) {
        if( field_index == type_index ) {
          try {
            TypesType<RequiredArgType>::checkType( f );
          } catch( ... ) {
            stringstream s;
            s << "Route " << field_index << " has type " 
              << f->getTypeName() <<". Expecting "
              << RequiredArgType::classTypeName() << ".";
            throw H3D::TypedFieldError( s.str() );
          }
        } else {
          TypedFieldCheck< void,
            OptionalArgTypes >::checkFieldType( f, 
                                                field_index, 
                                                type_index + 1 );
        }
      }
    };
 
    template< H3D_TYPES_TEMPLATE_LIST, class OptionalArgTypes >
    struct TypedFieldCheck< H3D_TYPES_CLASS, OptionalArgTypes >{
      static void checkTemplateArguments() {
        H3D_TYPES_CLASS::checkTemplateArguments();
        TypedFieldCheck< void, 
          OptionalArgTypes >::checkTemplateArguments();
      }
 
      static void checkFieldType( Field *f, 
                                  int field_index, 
                                  int type_index ) {
        int nr_types = H3D_TYPES_CLASS::numberTypes();
        if( field_index < type_index + nr_types ) { 
          try {
            H3D_TYPES_CLASS::checkType( f, 
                                        field_index - type_index );
          } catch( const InvalidType &e ) {
            stringstream s;
            s << "Route " << field_index << " has type " 
              << e.value <<". Expecting "
              << e.message;
            throw H3D::TypedFieldError( s.str() );
          }
        } else {
          TypedFieldCheck< void, 
            OptionalArgTypes >::checkFieldType( f,
                                                field_index,
                                                type_index + 
                                                nr_types );
        }
      }
    };
 
    template< class Type, class OptionalArgTypes >
    struct TypedFieldCheck< AnyNumber< Type >, OptionalArgTypes >{
      static void checkTemplateArguments() {
        string s = "AnyNumber statements not allowed as RequiredArgTypes";
        throw InvalidTemplateArguments( s );
      }
 
      static void checkFieldType( Field *f, 
                                  int field_index, 
                                  int type_index ) {
        string s = "AnyNumber statements not allowed as RequiredArgTypes";
        throw InvalidTemplateArguments( s );
      }
    };
    
    template<>
    struct TypedFieldCheck< void, void > {
      static void checkTemplateArguments() {}
 
H3D_PUSH_WARNINGS()
H3D_DISABLE_UNUSED_PARAMETER_WARNING()
      static void checkFieldType( Field *f, 
                                  int field_index, 
                                  int type_index ) {
        stringstream s;
        s << "Too many routes. Expecing a maximum of " 
          << type_index  << " routes.";
        throw TypedFieldError( s.str() );
      }
    };
H3D_POP_WARNINGS()
 
    
    template< class OptionalArgType >
    struct TypedFieldCheck< void, OptionalArgType > {
      static void checkTemplateArguments() {
        TypesType< OptionalArgType >::checkTemplateArguments();
      }
 
      static void checkFieldType( Field *f, 
                                  int field_index, 
                                  int type_index ) {
        if( field_index == type_index ) {
          try {
            TypesType<OptionalArgType>::checkType( f );
          } catch( ... ) {
            stringstream s;
            s << "Route " << field_index << " has type " 
              << f->getTypeName() <<". Expecting "
              << OptionalArgType::classTypeName() 
              << ".";
            throw H3D::TypedFieldError( s.str() );
          }
        } else {
          stringstream s;
          s << "Too many routes. Expecing a maximum of " 
            << type_index << " routes.";
          throw H3D::TypedFieldError( s.str() );
        }
      }
    };
 
    template< H3D_TYPES_TEMPLATE_LIST >
    struct TypedFieldCheck< void, H3D_TYPES_CLASS >{
      static void checkTemplateArguments() {
        H3D_TYPES_CLASS::checkTemplateArguments();
      }
 
      static void checkFieldType( Field *f, 
                                  int field_index, 
                                  int type_index ) {
        int nr_types = H3D_TYPES_CLASS::numberTypes();
        if( field_index < type_index + nr_types ) { 
          H3D_TYPES_CLASS::checkType( f, 
                                      field_index - type_index );
        } else {
          stringstream s;
          s << "Too many routes. Expecting a maximum of " 
            << type_index << " routes.";
          throw H3D::TypedFieldError( s.str() );
        }
      }
    };
 
    template< class Type >
    struct TypedFieldCheck< void, AnyNumber< Type > >{
      static void checkTemplateArguments() {
        AnyNumber<Type>::checkTemplateArguments();
      }
        
      static void checkFieldType( Field *f, 
                                  int field_index, 
                                  int type_index ) {
        try {
          AnyNumber< Type >::checkType( f, field_index - type_index );
        } catch( const InvalidType &e ) {
          stringstream s;
          s << "Route " << field_index << " has type " 
            << e.value <<". Expecting "
            << e.message << ".";
          throw H3D::TypedFieldError( s.str() );
        }
      }
    };
  }
 
}
 
#endif