Object.hpp

#pragma once
#ifndef __H__OCULAR_OBJECT__H__
#define __H__OCULAR_OBJECT__H__

#include "ObjectIO/ObjectIO.hpp"
#include "UUID.hpp"

#include <string>

//------------------------------------------------------------------------------------------

namespace Ocular
{
    namespace Core
    {
        class Object : public ObjectIO
        {
        public:
        
            Object(std::string name, std::string className);

            Object(std::string name);
        
            Object();
        
            virtual ~Object();
        
            std::string const& getName() const;
        
            void setName(std::string name);

            std::string const& getClass() const;

            void setUUID(std::string const& uuid);

            UUID const& getUUID() const;

            int64_t getCreationTime() const;
        
            virtual std::string toString() const;

            template<class T> bool isType() 
            { 
                /* Unfortunately, this dynamic_cast seems to be the best solution.
                 * Using std::is_base_of, std::is_convertible, typeid() ==, etc. just aren't sufficient.
                 *
                 * The issue is that a common use-case for this method is checking if an event is a
                 * certain type. For example, we get an Ocular::Core::AEvent* and we want to see if it
                 * is an instance of Ocular::Core::MouseScrollInputEvent.
                 *
                 * The other approaches such as:
                 *
                 *      std::is_base_of<T, std::remove_pointer<decltype(this)>::type>::value
                 *      typeid(T*) == typeid(*this)
                 *
                 * Work fine if checking making this comparison in a vaccuum. Ie:
                 *
                 *     std::is_convertible<AEvent*, MouseScrollInputEvent*>  -> true
                 *     std::is_convertible<MouseScrollInputEvent*, AEvent*>  -> true
                 *
                 * But since this a method of Object, when we call `this`, all of the types return
                 * the type of `Object` and not whatever the actual derived caller may be (in this
                 * example MouseScrollInputEvent).
                 */

                return (dynamic_cast<T*>(this) ? true : false); 
            }
        
        protected:
        
            std::string m_Name;   
            std::string m_Class;  
            UUID m_UUID;
            const int64_t m_CreationTime;
        
        private:
        };
    }
}
//------------------------------------------------------------------------------------------

#endif