Object.hpp

Go to the documentation of this file.

#pragma once

#include <etk/types.hpp>
#include <vector>
#include <exml/exml.hpp>
#include <mutex>
#include <ememory/memory.hpp>
#include <unordered_map>

#include <ewol/debug.hpp>
#include <ememory/memory.hpp>
#include <eproperty/Interface.hpp>
#include <eproperty/Value.hpp>
#include <eproperty/Range.hpp>
#include <eproperty/List.hpp>
#include <esignal/Interface.hpp>


namespace ewol {
    // some class need to define element befor other ...
    class Object;
    namespace object {
        class Manager;
    }
    class Context;
}

template<class TYPE_OBJECT> static void baseInit(const ememory::SharedPtr<TYPE_OBJECT>& _object) {
    // end of recurtion
    return;
}

template<class TYPE_OBJECT, class TYPE_VAL, class ... TYPE> static void baseInit(const ememory::SharedPtr<TYPE_OBJECT>& _object, const std::string& _name, const TYPE_VAL& _val, TYPE&& ... _all ) {
    eproperty::Property* prop(nullptr);
    eproperty::PropertyType<TYPE_VAL>* propType(nullptr);
    if (_object == nullptr) {
        EWOL_ERROR("EMPTY pointer");
        return;
    }
    prop = _object->properties.getRaw(_name);
    if (prop == nullptr) {
        EWOL_ERROR("property does not exit ... '" << _name << "'");
        goto exit_on_error;
    }
    propType = dynamic_cast<eproperty::PropertyType<TYPE_VAL>*>(prop);
    if (propType == nullptr) {
        EWOL_ERROR("property does not cast in requested type ... '" << _name << "' require type : " << typeid(_val).name() << "' instead of '" << prop->getType() << "'");
        goto exit_on_error;
    }
    propType->setDirectCheck(_val);
exit_on_error:
    baseInit(_object, std::forward<TYPE>(_all)... );
    return;
}

#define UN_DECLARE_FACTORY(className) \
    template<class ... EWOL_FACTORY_CREATE_TYPE> static ememory::SharedPtr<className> create(const EWOL_FACTORY_CREATE_TYPE& ... _all) = delete;

#define DECLARE_FACTORY(className) \
    template<class ... EWOL_FACTORY_CREATE_TYPE> static ememory::SharedPtr<className> create(const EWOL_FACTORY_CREATE_TYPE& ... _all) { \
        ememory::SharedPtr<className> object(new className()); \
        if (object == nullptr) { \
            EWOL_ERROR("Factory error"); \
            return nullptr; \
        } \
        baseInit(object, _all... ); \
        object->init(); \
        if (object->objectHasBeenCorectlyInit() == false) { \
            EWOL_CRITICAL("Object Is not correctly init : " << #className ); \
        } \
        return object; \
    }

#define DECLARE_SINGLE_FACTORY(className, uniqueName) \
    template<class ... EWOL_FACTORY_CREATE_TYPE> static ememory::SharedPtr<className> create(const EWOL_FACTORY_CREATE_TYPE& ... _all) { \
        ememory::SharedPtr<className> object; \
        ememory::SharedPtr<ewol::Object> object2 = getObjectNamed(uniqueName); \
        if (object2 != nullptr) { \
            object = ememory::dynamicPointerCast<className>(object2); \
            if (object == nullptr) { \
                EWOL_CRITICAL("Request object element: '" << uniqueName << "' With the wrong type (dynamic cast error)"); \
                return nullptr; \
            } \
        } \
        if (object != nullptr) { \
            return object; \
        } \
        object = ememory::SharedPtr<className>(new className()); \
        if (object == nullptr) { \
            EWOL_ERROR("Factory error"); \
            return nullptr; \
        } \
        baseInit(object, "name", std::string(uniqueName), _all... ); \
        object->init(); \
        if (object->objectHasBeenCorectlyInit() == false) { \
            EWOL_CRITICAL("Object Is not correctly init : " << #className ); \
        } \
        return object; \
    }

namespace ewol {
    using ObjectShared = ememory::SharedPtr<ewol::Object>;
    using ObjectWeak = ememory::WeakPtr<ewol::Object>;
    class Object : public ememory::EnableSharedFromThis<Object>,
                   public eproperty::Interface,
                   public esignal::Interface {
        public: // Event list
            
        public: // propertie list
            eproperty::Value<std::string> propertyName; 
        private:
            static size_t m_valUID; 
        private:
            bool m_objectHasBeenInit; 
        protected:
            Object();
            virtual void init();
        public:
            DECLARE_FACTORY(Object);
            virtual ~Object();
            bool objectHasBeenCorectlyInit();
        protected:
            ewol::ObjectWeak m_parent; 
            bool m_destroy; 
        protected:
            virtual void autoDestroy();
        public:
            virtual void destroy();
            bool isDestroyed() const;
        protected:
            virtual void requestDestroyFromChild(const ewol::ObjectShared& _child);
        public:
            virtual void setParent(const ewol::ObjectShared& _newParent);
            virtual void removeParent();
        private:
            std::vector<const char*> m_listType;
        public:
            const char * const getObjectType() const;
            std::string getTypeDescription() const;
            bool isTypeCompatible(const std::string& _type) const;
        protected:
            void addObjectType(const char* _type);
        protected:
            bool m_static; 
        public:
            bool getStatic(){
                return m_static;
            };
        private:
            int32_t m_uniqueId; 
        public:
            int32_t getId(){
                return m_uniqueId;
            };
        public:
            // TODO : Rework the position on this function ... This is a convignent function ...
            bool propertySetOnWidgetNamed(const std::string& _objectName, const std::string& _config, const std::string& _value);
        public:
            virtual bool loadXML(const exml::Element& _node);
            virtual bool storeXML(exml::Element& _node) const;
        public:
            static ewol::object::Manager& getObjectManager();
            static ewol::Context& getContext();
        private:
            bool m_isResource; 
        public:
            void setStatusResource(bool _val) {
                m_isResource = _val;
            }
            bool getStatusResource() const {
                return m_isResource;
            }
            static ewol::ObjectShared getObjectNamed(const std::string& _objectName);
            virtual ewol::ObjectShared getSubObjectNamed(const std::string& _objectName);
        protected:
            // TODO : Create a template ...
            #define subBind(_type, _name, _event, _shared_ptr, _func, ...) do {\
                ememory::SharedPtr<_type> myObject = ememory::dynamicPointerCast<_type>(getSubObjectNamed(_name)); \
                if (myObject != nullptr) { \
                    myObject->_event.connect(_shared_ptr, _func, ##__VA_ARGS__); \
                } else { \
                    EWOL_ERROR("object named='" << _name << "' not exit or can not be cast in : " << #_type); \
                } \
            } while (false)
            /*
            template<class TYPE> void subBind(ememory::SharedPtr<ewol::Object> _obj, void (TYPE::*_func)()) {
                ememory::SharedPtr<TYPE> obj2 = ememory::dynamicPointerCast<TYPE>(_obj);
                if (obj2 == nullptr) {
                    EWOL_ERROR("Can not connect signal ...");
                    return;
                }
                m_callerList.push_back(std::make_pair(ewol::ObjectWeak(_obj), std::connect(_func, obj2.get())));
            }
            */
    };
    bool propertySetOnObjectNamed(const std::string& _objectName, const std::string& _config, const std::string& _value);
};

#define globalBind(_type, _name, _event, _obj, _func, ...) do {\
    ememory::SharedPtr<_type> myObject = ememory::dynamicPointerCast<_type>(ewol::getContext().getEObjectManager().getObjectNamed(_name)); \
    if (myObject != nullptr) { \
        myObject->_event.connect(_obj, _func, ##__VA_ARGS__); \
    } else { \
        EWOL_ERROR("object named='" << _name << "' not exit or can not be cast in : " << #_type); \
    } \
} while (false)

#define externSubBind(_object, _type, _name, _event, _obj, _func, ...) do {\
    ememory::SharedPtr<_type> myObject = ememory::dynamicPointerCast<_type>(_object->getObjectNamed(_name)); \
    if (myObject != nullptr) { \
        myObject->_event.connect(_obj, _func, ##__VA_ARGS__); \
    } else { \
        EWOL_ERROR("object named='" << _name << "' not exit or can not be cast in : " << #_type); \
    } \
} while (false)