main/include/TypeDescriptor.h

/*
This file is part of Caelum.
See http://www.ogre3d.org/wiki/index.php/Caelum 

Copyright (c) 2008 Caelum team. See Contributors.txt for details.

Caelum is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published
by the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

Caelum 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 Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License
along with Caelum. If not, see <http://www.gnu.org/licenses/>.
*/

#ifndef CAELUM__TYPE_DESCRIPTOR_H
#define CAELUM__TYPE_DESCRIPTOR_H

#include "CaelumPrerequisites.h"

#if CAELUM_TYPE_DESCRIPTORS

#include <typeinfo>

namespace Caelum
{
    class ValuePropertyDescriptor;

    class CAELUM_EXPORT TypeDescriptor
    {
    public:
        virtual ~TypeDescriptor() {};

        typedef std::map<String, const ValuePropertyDescriptor*> PropertyMap;

        virtual const ValuePropertyDescriptor* getPropertyDescriptor (const Ogre::String& name) const = 0;

        virtual const std::vector<String> getPropertyNames () const = 0;

        virtual const PropertyMap getFullPropertyMap () const = 0;
    };

    class CAELUM_EXPORT ValuePropertyDescriptor
    {
    public:
        virtual ~ValuePropertyDescriptor() {};

        virtual bool canGetValue () const = 0;

        virtual bool canSetValue () const = 0;

        virtual const Ogre::Any getValue (const void* target) const = 0;

        virtual void setValue (void* target, const Ogre::Any& value) const = 0;

        virtual const std::type_info& getValueTypeId () const = 0;

        virtual bool implementsTypedValuePropertyDescriptor () const {
            return false;
        }
    };

    template<typename ValueT>
    class CAELUM_EXPORT TypedValuePropertyDescriptor: public ValuePropertyDescriptor
    {
    public:
        virtual const ValueT getValueTyped (const void* target) const = 0;
        virtual void setValueTyped (void* target, const ValueT& value) const = 0;

    private:
        virtual const Ogre::Any getValue (const void* target) const {
            return Ogre::Any(this->getValueTyped (target));
        }

        virtual void setValue (void* target, const Ogre::Any& value) const {
            this->setValueTyped (target, Ogre::any_cast<ValueT>(value));
        }

        virtual const std::type_info& getValueTypeId () const {
            return typeid(ValueT);
        }

        virtual bool implementsTypedValuePropertyDescriptor () const {
            return true;
        }
    };

    template <class TargetT, typename ParamT, typename InParamT = const ParamT&, typename OutParamT = const ParamT>
    class AccesorPropertyDescriptor: public TypedValuePropertyDescriptor<ParamT>
    {
    public:
        typedef void(TargetT::*SetFunc)(InParamT);
        typedef OutParamT(TargetT::*GetFunc)(void) const;

    private:
        GetFunc mGetFunc;
        SetFunc mSetFunc;

    public:
        AccesorPropertyDescriptor (GetFunc getFunc, SetFunc setFunc)
        {
            mGetFunc = getFunc;
            mSetFunc = setFunc;
        }

        virtual bool canGetValue () const {
            return mGetFunc != 0;
        }

        virtual bool canSetValue () const {
            return mSetFunc != 0;
        }

        virtual const ParamT getValueTyped(const void* target) const
        {
            const TargetT* typedTarget = reinterpret_cast<const TargetT*>(target);
            return (typedTarget->*mGetFunc)();
        }

        virtual void setValueTyped(void* target, const ParamT& value) const
        {
            TargetT* typedTarget = reinterpret_cast<TargetT*>(target);
            (typedTarget->*mSetFunc)(value);
        }
    };

    class DefaultTypeDescriptor: public TypeDescriptor 
    {
    public:
        DefaultTypeDescriptor ();
        virtual ~DefaultTypeDescriptor ();

        inline PropertyMap& getPropertyMap () { return mPropertyMap; }

        void add (const Ogre::String& name, const ValuePropertyDescriptor* descriptor);

        void clear ();

        virtual const ValuePropertyDescriptor* getPropertyDescriptor (const Ogre::String& name) const;

        virtual const std::vector<String> getPropertyNames () const;

        virtual const PropertyMap getFullPropertyMap () const;

    private:
        void deleteAllPropertyDescriptors ();

        PropertyMap mPropertyMap;
    };

    class CAELUM_EXPORT CaelumDefaultTypeDescriptorData
    {
    private:
        void load();
        void unload();

    public:
        CaelumDefaultTypeDescriptorData();
        ~CaelumDefaultTypeDescriptorData();

        DefaultTypeDescriptor* CaelumSystemTypeDescriptor;
        DefaultTypeDescriptor* PointStarfieldTypeDescriptor;
        DefaultTypeDescriptor* BaseSkyLightTypeDescriptor;
        DefaultTypeDescriptor* GroundFogTypeDescriptor;
        DefaultTypeDescriptor* PrecipitationTypeDescriptor;
        DefaultTypeDescriptor* DepthComposerTypeDescriptor;
        DefaultTypeDescriptor* FlatCloudLayerTypeDescriptor;
        DefaultTypeDescriptor* SkyDomeTypeDescriptor;
    };
}

#endif // CAELUM_TYPE_DESCRIPTORS

#endif // CAELUM__TYPE_DESCRIPTOR_H

---