class_factory.h

Go to the documentation of this file.

 
#pragma once
 
#include <stdexcept>
 
namespace adtf
{
namespace ucom
{
namespace ant
{
 
template <typename ...Classes>
class class_factory : public catwo::object<IClassFactory>
{
    private:
        template<typename ...InnerClasses>
        struct dispatch
        {
            static tResult CreateInstance(const char* /* strCID */,
                                          iobject_ptr<IObject>& /* oObject */,
                                          const char* /* strNameOfObject */)
            {
                RETURN_ERROR(ERR_NO_CLASS);
            }
 
            static void AddClassInfo(iobject_enum<const IClassInfo>& /* lstOfClasses */)
            {
            }
        };
 
        template<typename Class, typename ...InnerClasses>
        struct dispatch<Class, InnerClasses...>
        {
            static tResult CreateInstance(const char* strCID,
                                          iobject_ptr<IObject>& oObject,
                                          const tChar* strNameOfObject = "")
            {
                if (adtf_util::cString(strCID).IsEqual(get_class_id<Class>()))
                {
                    try
                    {
                        object_ptr<IObject> pCreatedObject(make_object_ptr<Class>());
                        if (!pCreatedObject)
                        {
                            RETURN_ERROR(ERR_MEMORY);
                        }
                        oObject.Reset(pCreatedObject);
                        if (oObject.Get() == nullptr)
                        {
                            RETURN_ERROR(ERR_INVALID_INTERFACE);
                        }
 
                        RETURN_NOERROR;
                    }
                    catch (const tResult& oError)
                    {
                        return oError;
                    }
                    catch (const std::exception& oError)
                    {
                        RETURN_ERROR_DESC(ERR_FAILED, "%s", oError.what());
                    }
                    catch (...)
                    {
                        RETURN_ERROR(ERR_UNKNOWN);
                    }
                }
                return dispatch<InnerClasses...>::CreateInstance(strCID, oObject, strNameOfObject);
            }
 
            static void AddClassInfo(iobject_enum<const IClassInfo>& lstOfClasses)
            {
                //use copy constructor
                object_ptr<const IClassInfo> pInfo = get_class_info<Class>();
                lstOfClasses.PushObject(pInfo);
                dispatch<InnerClasses...>::AddClassInfo(lstOfClasses);
            }
        };
 
    private:
        class_factory(const class_factory&) = delete;
        class_factory(class_factory&&) = delete;
        class_factory& operator=(const class_factory&) = delete;
        class_factory& operator=(class_factory&&) = delete;
 
    public:
        class_factory()
        {
        }
 
        virtual ~class_factory()
        {
        }
 
 
    public: // implements IClassFactory
        virtual tResult CreateInstance(const char* strCID,
                                       iobject_ptr<IObject>& oObject,
                                       const tChar* strNameOfObject = "") const
        {
            RETURN_IF_POINTER_NULL(strCID);
 
            object_ptr<IObject> pCreatedObject = nullptr;
 
            adtf_util::cString strClassToCreate(strCID);
 
            if (strClassToCreate.IsEmpty())
            {
                RETURN_ERROR_DESC(ERR_INVALID_ARG, "CID is empty");
            }
 
            return dispatch<Classes...>::CreateInstance(strCID, oObject, strNameOfObject);
        }
 
        tResult GetClasses(iobject_enum<const IClassInfo>& lstOfClasses) const
        {
            dispatch<Classes...>::AddClassInfo(lstOfClasses);
            RETURN_NOERROR;
        }
};
 
}//ns ant
 
using ant::class_factory;
 
}//ns ucom
}//ns adtf