gom_implementation.h

Go to the documentation of this file.

/*
 *  GXML/Graphite: Geometry and Graphics Programming Library + Utilities
 *  Copyright (C) 2000 Bruno Levy
 *
 *  This program 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.
 *
 *  This program 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 this program; if not, write to the Free Software
 *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 *
 *  If you modify this software, you should include a notice giving the
 *  name of the person performing the modification, the date of modification,
 *  and the reason for such modification.
 *
 *  Contact: Bruno Levy
 *
 *     levy@loria.fr
 *
 *     ISA Project
 *     LORIA, INRIA Lorraine,
 *     Campus Scientifique, BP 239
 *     54506 VANDOEUVRE LES NANCY CEDEX
 *     FRANCE
 *
 *  Note that the GNU General Public License does not permit incorporating
 *  the Software into proprietary programs.
 */
 
#ifndef H_OGF_GOM_TYPES_GOM_IMPL_H
#define H_OGF_GOM_TYPES_GOM_IMPL_H
 
#include <OGF/gom/common/common.h>
#include <OGF/gom/types/gom.h>
#include <OGF/gom/types/arg_list.h>
#include <OGF/gom/reflection/meta_type.h>
#include <OGF/gom/reflection/meta_builtin.h>
#include <OGF/gom/reflection/meta_enum.h>
#include <OGF/gom/reflection/meta_class.h>
#include <OGF/gom/reflection/meta_struct.h>
#include <OGF/gom/services/serializer.h>
 
namespace OGF {
 
//_________________________________________________________________________
 
    template <class T> class ogf_declare_builtin_type {
    public:
        explicit ogf_declare_builtin_type(const std::string& type_name) {
            //   We create the MetaType using a SmartPointer, because
            // it may be already registered in the Meta repository. If
            // it is the case, then the SmartPointer will deallocate it.
            //   We need though to call Meta::bind_meta_type() since the
            // type may be an alias. The result is finally retreived in
            // the Meta instance (if there was a previous MetaType declared
            // with the same name, it will use this one).
            MetaBuiltinType_var meta_type = new MetaBuiltinType(type_name);
            meta_type->set_serializer(new GenericSerializer<T>);
            meta_type->set_life_cycle(new GenericLifeCycle<T>);
            Meta::instance()->bind_meta_type(
                meta_type, typeid(T).name()
            );
            result_ = dynamic_cast<MetaBuiltinType*>(
                Meta::instance()->resolve_meta_type(type_name)
            );
        }
        operator MetaBuiltinType*() {
            return result_;
        }
    private:
        MetaBuiltinType* result_;
    };
 
    template<> class ogf_declare_builtin_type<bool> {
    public:
        explicit ogf_declare_builtin_type(const std::string& type_name) {
            //   We create the MetaType using a SmartPointer, because
            // it may be already registered in the Meta repository. If
            // it is the case, then the SmartPointer will deallocate it.
            //   We need though to call Meta::bind_meta_type() since the
            // type may be an alias. The result is finally retreived in
            // the Meta instance (if there was a previous MetaType declared
            // with the same name, it will use this one).
            MetaBuiltinType_var meta_type = new MetaBuiltinType(type_name);
            meta_type->set_serializer(new BoolSerializer);
            meta_type->set_life_cycle(new GenericLifeCycle<bool>);
 
            Meta::instance()->bind_meta_type(
                meta_type, typeid(bool).name()
            );
            result_ = dynamic_cast<MetaBuiltinType*>(
                Meta::instance()->resolve_meta_type(type_name)
            );
        }
        operator MetaBuiltinType*() {
            return result_;
        }
    private:
        MetaBuiltinType* result_;
    };
 
    template<> class ogf_declare_builtin_type<void> {
    public:
        explicit ogf_declare_builtin_type(const std::string& type_name) {
            //   We create the MetaType using a SmartPointer, because
            // it may be already registered in the Meta repository. If
            // it is the case, then the SmartPointer will deallocate it.
            //   We need though to call Meta::bind_meta_type() since the
            // type may be an alias. The result is finally retreived in
            // the Meta instance (if there was a previous MetaType declared
            // with the same name, it will use this one).
            MetaBuiltinType_var meta_type = new MetaBuiltinType(type_name);
            Meta::instance()->bind_meta_type(
                meta_type, typeid(void).name()
            );
            result_ = dynamic_cast<MetaBuiltinType*>(
                Meta::instance()->resolve_meta_type(type_name)
            );
        }
        operator MetaBuiltinType*() {
            return result_;
        }
    private:
        MetaBuiltinType* result_;
    };
 
    template<> class ogf_declare_builtin_type<std::string> {
    public:
        explicit ogf_declare_builtin_type(const std::string& type_name) {
            //   We create the MetaType using a SmartPointer, because
            // it may be already registered in the Meta repository. If
            // it is the case, then the SmartPointer will deallocate it.
            //   We need though to call Meta::bind_meta_type() since the
            // type may be an alias. The result is finally retreived in
            // the Meta instance (if there was a previous MetaType declared
            // with the same name, it will use this one).
            MetaBuiltinType_var meta_type = new MetaBuiltinType(type_name);
            meta_type->set_serializer(new StringSerializer);
            meta_type->set_life_cycle(new GenericLifeCycle<std::string>);
            Meta::instance()->bind_meta_type(
                meta_type, typeid(std::string).name()
            );
            result_ = dynamic_cast<MetaBuiltinType*>(
                Meta::instance()->resolve_meta_type(type_name)
            );
        }
        operator MetaBuiltinType*() {
            return result_;
        }
    private:
        MetaBuiltinType* result_;
    };
 
    template <class T> class ogf_declare_pointer_type {
    public:
        explicit ogf_declare_pointer_type(const std::string& type_name) {
            //   We create the MetaType using a SmartPointer, because
            // it may be already registered in the Meta repository. If
            // it is the case, then the SmartPointer will deallocate it.
            //   We need though to call Meta::bind_meta_type() since the
            // type may be an alias. The result is finally retreived in
            // the Meta instance (if there was a previous MetaType declared
            // with the same name, it will use this one).
            MetaBuiltinType_var meta_type = new MetaBuiltinType(type_name);
            meta_type->set_serializer(new PointerSerializer);
            meta_type->set_life_cycle(new GenericLifeCycle<T>);
            Meta::instance()->bind_meta_type(
                meta_type, typeid(T).name()
            );
            result_ = dynamic_cast<MetaBuiltinType*>(
                Meta::instance()->resolve_meta_type(type_name)
            );
        }
        operator MetaBuiltinType*() {
            return result_;
        }
    private:
        MetaBuiltinType* result_;
    };
 
    template <class T> class ogf_declare_enum {
    public:
        explicit ogf_declare_enum(const std::string& type_name) {
            MetaEnum* meta_type = new MetaEnum(type_name);
            Meta::instance()->bind_meta_type(
                meta_type, typeid(T).name()
            );
            meta_type->set_life_cycle(new GenericLifeCycle<T>);
            result_ = meta_type;
        }
 
        operator MetaEnum*() {
            return result_;
        }
    private:
        MetaEnum* result_;
    };
 
    /***************************************************************************/
 
#define ogf_offset(structtype,field) \
        &(reinterpret_cast<structtype*>(0)->field)
 
#define ogf_add_field(structtype, field) \
    add_field(#field, ogf_offset(structtype, field))
 
    template <class T> class ogf_declare_struct {
    public:
        explicit ogf_declare_struct(const std::string& type_name) {
            MetaBuiltinStruct* meta_type = new MetaBuiltinStruct(type_name);
            Meta::instance()->bind_meta_type(
                meta_type, typeid(T).name()
            );
            //meta_type->set_serializer(new GenericSerializer<T>);
            meta_type->set_life_cycle(new GenericLifeCycle<T>);
            result_ = meta_type;
        }
 
        operator MetaBuiltinStruct*() {
            return result_;
        }
 
        MetaBuiltinStruct* operator->() {
            return result_;
        }
 
    private:
        MetaBuiltinStruct* result_;
    };
 
    /***************************************************************************/
 
    template <class T> class ogf_declare_class {
    public:
        ogf_declare_class(
            const std::string& class_name, MetaClass* super_class
        ) {
            MetaClass* meta_type = new MetaClass(class_name, super_class);
            Meta::instance()->bind_meta_type(
                meta_type, typeid(T).name()
            );
            result_ = meta_type;
        }
 
        ogf_declare_class(
            const std::string& class_name, const std::string& super_class_name
        ) {
            MetaClass* meta_type = new MetaClass(class_name, super_class_name);
            Meta::instance()->bind_meta_type(
                meta_type, typeid(T).name()
            );
            result_ = meta_type;
        }
 
        explicit ogf_declare_class(const std::string& class_name) {
            MetaClass* meta_type = new MetaClass(class_name);
            Meta::instance()->bind_meta_type(
                meta_type, typeid(T).name()
            );
            result_ = meta_type;
        }
 
        operator MetaClass*() {
            return result_;
        }
    private:
        MetaClass* result_;
    };
 
 
    template <class T> class ogf_declare_abstract_class {
    public:
 
        ogf_declare_abstract_class(
            const std::string& class_name, MetaClass* super_class
        ) {
            MetaClass* meta_type = new MetaClass(class_name, super_class);
            meta_type->set_abstract(true);
            Meta::instance()->bind_meta_type(
                meta_type, typeid(T).name()
            );
            result_ = meta_type;
        }
 
        ogf_declare_abstract_class(
            const std::string& class_name, const std::string& super_class_name
        ) {
            MetaClass* meta_type = new MetaClass(class_name, super_class_name);
            meta_type->set_abstract(true);
            Meta::instance()->bind_meta_type(
                meta_type, typeid(T).name()
            );
            result_ = meta_type;
        }
 
        explicit ogf_declare_abstract_class(const std::string& class_name) {
            MetaClass* meta_type = new MetaClass(class_name);
            meta_type->set_abstract(true);
            Meta::instance()->bind_meta_type(
                meta_type, typeid(T).name()
            );
            result_ = meta_type;
        }
 
        operator MetaClass*() {
            return result_;
        }
    private:
        MetaClass* result_;
    };
 
//_________________________________________________________________________
 
}
 
#endif