object.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_OBJECT_H
#define H_OGF_GOM_TYPES_OBJECT_H
 
#include <OGF/gom/common/common.h>
#include <OGF/gom/types/gom_defs.h>
#include <OGF/gom/types/arg_list.h>
 
#include <string>
#include <vector>
 
namespace OGF {
 
    class MetaType;
    class MetaClass;
    class Object;
    class Connection;
    class ConnectionTable;
    class Interpreter;
 
    gom_attribute(abstract,"true")
    gom_class GOM_API Object : public Counted {
    public:
        explicit Object(bool transient = false);
 
        ~Object() override;
 
        // Run-time type information
 
        virtual MetaClass* meta_class() const;
 
        virtual void set_meta_class(MetaClass* mclass);
 
        unsigned int id() const {
            return id_;
        }
 
        std::string string_id() const;
 
        // Properties and Dynamic invokation interface
 
        bool has_method(const std::string& method_name) const;
 
        virtual bool invoke_method(
            const std::string& method_name,
            const ArgList& args, Any& ret_val
        );
 
        bool invoke_method(
            const std::string& method_name, const ArgList& args
        ) {
            Any ret_val;
            return invoke_method(method_name, args, ret_val);
        }
 
        bool invoke_method(const std::string& method_name) {
            ArgList args;
            Any ret_val;
            return invoke_method(method_name, args, ret_val);
        }
 
        bool has_property(const std::string& prop_name) const;
 
        virtual bool get_property(
            const std::string& prop_name, std::string& prop_value
        ) const;
 
        // ************** Signals and slots *************************
 
        virtual Connection* connect_signal_to_slot(
            const std::string& signal_name,
            Object* to, const std::string& slot_name
        );
 
        virtual void add_connection(Connection* connection);
 
        virtual void remove_connection(Connection* connection);
 
        static Object* id_to_object(unsigned int id) {
            if(id_to_object_ == nullptr) {
                return nullptr;
            }
            auto it = id_to_object_->find(id);
            if(it == id_to_object_->end()) {
                return nullptr;
            }
            return it->second;
        }
 
        virtual void get_element(index_t i, Any& value) const;
 
        virtual void set_element(index_t i, const Any& value);
 
        void get_element(
            index_t item, index_t component, Any& value
        ) const {
            get_element(item * get_dimension() + component, value);
        }
 
        void set_element(
            index_t item, index_t component, const Any& value
        ) {
            set_element(item * get_dimension() + component, value);
        }
 
        virtual void search(
            const std::string& needle, const std::string& path=""
        );
 
    gom_properties:
 
        virtual index_t get_nb_elements() const;
 
 
        virtual index_t get_dimension() const;
 
        bool get_signals_enabled() const {
            return signals_enabled_;
        }
 
        void set_signals_enabled(bool value) {
            signals_enabled_ = value;
        }
 
        bool get_slots_enabled() const {
            return slots_enabled_;
        }
 
        void set_slots_enabled(bool value) {
            slots_enabled_ = value;
        }
 
        MetaClass* get_meta_class() const {
            return meta_class();
        }
 
        std::string get_string_id() const {
            return string_id();
        }
 
        virtual std::string get_doc() const;
 
 
    gom_slots:
 
        bool equals(const Object* other) const;
 
        virtual Sign compare(const Object* other) const;
 
 
 
        virtual bool is_a(const MetaType* type) const;
 
        void disconnect();
 
        void enable_signals() {
            signals_enabled_ = true;
        }
 
        void disable_signals() {
            signals_enabled_ = false;
        }
 
        void enable_slots() {
            slots_enabled_ = true;
        }
 
        void disable_slots() {
            slots_enabled_ = false;
        }
 
        void set_properties(const ArgList& args);
 
        virtual bool set_property(
            const std::string& name, const std::string& value
        );
 
        void help() const;
 
      public:
        // Note: set_property() variants that are not slots
        // need to be declared *after* the set_property() slot
        // else gomgen does not see the set_property slot.
 
        virtual bool set_property(
            const std::string& name, const Any& value
        );
 
        virtual bool get_property(
            const std::string& prop_name, Any& prop_value
        ) const;
 
    protected:
 
        virtual bool emit_signal(
            const std::string& signal_name, const ArgList& args,
            bool called_from_slot = false
        );
 
    private:
        MetaClass* meta_class_;
        ConnectionTable* connections_;
        bool signals_enabled_;
        bool slots_enabled_;
        unsigned int id_;
 
        // Signal method adapter needs to call
        // emit_signal() which is protected.
        friend class MetaMethod;
        static std::map<index_t, Object*>* id_to_object_;
    };
 
    /**************************************************************/
 
    typedef SmartPointer<Object> Object_var;
 
    /**************************************************************/
 
}
 
#endif