meta.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_REFLECTION_META_H
#define H_OGF_GOM_REFLECTION_META_H
 
#include <OGF/gom/common/common.h>
#include <OGF/gom/reflection/meta_type.h>
#include <OGF/gom/reflection/meta_class.h>
 
#include <typeinfo>
#include <string>
#include <map>
#include <vector>
 
#include <sstream>
 
//___________________________________________________
 
namespace OGF {
 
    class GOM_API Meta {
    public:
        ~Meta() ;
 
        static Meta* instance() ;
 
        bool meta_type_is_bound(const std::string& name) const ;
 
        bool typeid_name_is_bound(const std::string& typeid_name) const ;
 
        bool bind_meta_type(MetaType* meta_type) ;
 
 
        void bind_meta_type_alias(MetaType* meta_type, const std::string& alias);
 
        bool bind_meta_type(
            MetaType* meta_type, const std::string& typeid_name
        ) ;
 
        MetaType* resolve_meta_type(const std::string& type_name) const ;
 
        MetaClass* resolve_meta_class(const std::string& type_name) const {
            return dynamic_cast<MetaClass*>(resolve_meta_type(type_name));
        }
 
        MetaType* resolve_meta_type_by_typeid_name(
            const std::string& typeid_name
        ) const ;
 
 
        bool unbind_meta_type(const std::string& name) ;
 
        void list_types(std::vector<MetaType*>& types) ;
 
        void list_type_names(std::vector<std::string>& type_names);
 
        static void initialize() ;
 
        static void terminate() ;
 
    private:
        Meta() ;
 
        typedef std::map<std::string, MetaType_var> MetaTypesTable ;
        typedef std::map<std::string, MetaType*> TypeidNamesTable ;
 
        static Meta* instance_ ;
        MetaTypesTable   type_name_to_meta_type_ ;
        TypeidNamesTable typeid_name_to_meta_type_ ;
    } ;
 
    //___________________________________________________________________
 
 
    template <class T> inline MetaType* ogf_dynamic_type(const T& x) {
        ogf_argused(x); // suppresses a warning of MSVC
        return Meta::instance()->resolve_meta_type_by_typeid_name(
            typeid(x).name()
        ) ;
    }
 
    template <class T> inline MetaType* ogf_static_type(const T& x) {
        ogf_argused(x); // suppresses a warning of MSVC
        return Meta::instance()->resolve_meta_type_by_typeid_name(
            typeid(T).name()
        ) ;
    }
 
    template <class T> inline bool ogf_is_a(const T& x, const MetaType* type) {
        return ogf_dynamic_type(x)->is_subtype_of(type) ;
    }
 
    //___________________________________________________________________
 
    template <class T> class ogf_meta {
    public:
 
        static MetaType* type() {
            static MetaType* result = nullptr ;
            if(result == nullptr) {
                result = Meta::instance()->resolve_meta_type_by_typeid_name(
                    typeid(T).name()
                ) ;
            }
            if(result == nullptr) {
                Logger::err("Meta") << "No MetaType for typeid "
                                    << typeid(T).name()
                                    << std::endl ;
            }
            ogf_assert(result != nullptr) ;
            return result ;
        }
 
        static MetaClass* meta_class() {
            static MetaClass* result = nullptr ;
            if(result == nullptr) {
                result = dynamic_cast<MetaClass*>(type()) ;
            }
            if(result == nullptr) {
                Logger::err("Meta") << "MetaType for typeid "
                                    << typeid(T).name()
                                    << " is not a MetaClass"
                                    << std::endl ;
            }
            ogf_assert(result != nullptr) ;
            return result ;
        }
 
        static Serializer* serializer() {
            static Serializer* result = type()->serializer() ;
            if(result == nullptr) {
                Logger::err("Meta") << "No Serializer for typeid "
                                    << typeid(T).name()
                                    << std::endl ;
                Logger::err("Meta") << "type name = " << type()->name()
                                    << std::endl ;
            }
            ogf_assert(result != nullptr) ;
            return result ;
        }
 
        static Factory* factory() {
            return meta_class()->factory() ;
        }
    } ;
 
    //___________________________________________________________________
 
    template <class T> inline bool ogf_convert_to_string(
        const T& value, std::string& string
    ) {
        std::ostringstream stream ;
        bool result = ogf_meta<T>::serializer()->serialize_write(
            stream, (void*)(&value)
        ) ;
        if(result) {
            string = stream.str() ;
        }
        return result ;
    }
 
    template <class T> inline bool ogf_convert_from_string(
        const std::string& string, T& value
    ) {
        if(string.length() == 0) {
            value = T() ;
            return true ;
        }
        std::istringstream stream(string) ;
        return ogf_meta<T>::serializer()->serialize_read(
            stream, (void*)(&value)
        ) ;
    }
 
    //___________________________________________________________________
 
}
 
#endif