meta_type.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_META_TYPES_META_TYPE_H
#define H_OGF_META_TYPES_META_TYPE_H
 
#include <OGF/gom/common/common.h>
#include <OGF/gom/services/life_cycle.h>
#include <OGF/gom/services/serializer.h>
#include <OGF/gom/types/arg_list.h>
#include <OGF/gom/types/object.h>
#include <string>
 
namespace OGF {
 
    class GOM_API CustomAttributes {
    public:
 
        size_t nb_custom_attributes() const {
            return custom_attributes_.nb_args() ;
        }
 
        std::string ith_custom_attribute_name(index_t i) const {
            return (i < nb_custom_attributes())
                ? custom_attributes_.ith_arg_name(i)
                : std::string();
        }
 
        std::string ith_custom_attribute_value(index_t i) const {
            return (i < nb_custom_attributes())
                ? custom_attributes_.ith_arg_value(i).as_string()
                : std::string();
        }
 
        bool has_custom_attribute(const std::string& name) const {
            return custom_attributes_.has_arg(name) ;
        }
 
        void create_custom_attribute(
            const std::string& name, const std::string& value
        ) {
            custom_attributes_.create_arg(name, value) ;
        }
 
        void set_custom_attribute(
            const std::string& name, const std::string& value
        ) {
            custom_attributes_.set_arg(name, value) ;
        }
 
        std::string custom_attribute_value(const std::string& name) const {
            return
                has_custom_attribute(name) ?
                custom_attributes_.get_arg(name) : std::string();
        }
 
        void clear_custom_attributes() {
            custom_attributes_.clear();
        }
 
    private:
        ArgList custom_attributes_ ;
    } ;
 
 
    gom_attribute(abstract,"true")
    gom_class GOM_API MetaInformation : public Object, public CustomAttributes {
    public:
        MetaInformation() {
        }
 
        ~MetaInformation() override;
 
 
        void search(
            const std::string& needle, const std::string& path = ""
        ) override;
 
    gom_slots:
 
        size_t nb_custom_attributes() const;
 
        bool has_custom_attribute(const std::string& name) const;
 
        std::string ith_custom_attribute_name(index_t i) const;
 
        std::string ith_custom_attribute_value(index_t i) const;
 
        std::string custom_attribute_value(const std::string& name) const;
 
        void create_custom_attribute(
            const std::string& name, const std::string& value
        );
 
        void set_custom_attribute(
            const std::string& name, const std::string& value
        );
 
    } ;
 
    gom_attribute(abstract,"true")
    gom_class GOM_API MetaType : public MetaInformation {
    public:
 
        explicit MetaType(const std::string& name) ;
 
        ~MetaType() override;
 
 
        const std::string& name() const {
            return name_ ;
        }
 
        void set_typeid_name(const std::string& typeid_name ) {
            typeid_name_ = typeid_name ;
        }
 
        const std::string& typeid_name() const {
            return typeid_name_ ;
        }
 
        LifeCycle* life_cycle() const {
            return life_cycle_;
        }
 
        void set_life_cycle(LifeCycle* life_cycle) {
            life_cycle_ = life_cycle;
            // life_cycle_->ref();
        }
 
        Serializer* serializer() const {
            return serializer_ ;
        }
 
        void set_serializer(Serializer* ser) {
            serializer_ = ser ;
        }
 
        virtual void pre_delete();
 
    gom_slots:
 
        virtual bool is_subtype_of(const MetaType* other) const;
 
    gom_properties:
        const std::string& get_name() const {
            return name();
        }
 
 
    private:
        std::string name_;
        std::string typeid_name_;
        LifeCycle_var life_cycle_;
        Serializer_var serializer_;
    } ;
 
    typedef SmartPointer<MetaType> MetaType_var ;
}
 
#endif