ShapeService.h

#pragma once

#include "ShapesModule.h"
#include "Types.h"

namespace Eegeo
{
    namespace Shapes
    {
        template <typename TModel, typename TCreateParams, typename TFactory, typename TRepository>
        class TShapeServiceBase
        {
        public:
            typedef TModel ModelType;
            typedef TCreateParams CreateParamsType;
            typedef TFactory ModelFactoryType;
            typedef TRepository ModelRepositoryType;
            
            virtual ~TShapeServiceBase() {}
            
            virtual typename ModelType::IdType Create(const CreateParamsType& polygonCreateParams) = 0;
            
            virtual void Destroy(typename ModelType::IdType modelId) = 0;
            
            virtual bool Exists(typename ModelType::IdType modelId) const = 0;
            
            virtual ModelType& Get(typename ModelType::IdType modelId) const = 0;
        };
        
        
        template <typename TBase>
        class TShapeService : public TBase, private Eegeo::NonCopyable
        {
        public:
            typedef typename TBase::ModelType ModelType;
            typedef typename TBase::CreateParamsType CreateParamsType;
            typedef typename TBase::ModelFactoryType ModelFactoryType;
            typedef typename TBase::ModelRepositoryType ModelRepositoryType;
            
            
            
            
            TShapeService(ModelFactoryType& modelFactory,
                          ModelRepositoryType& modelRepository)
            : m_modelFactory(modelFactory)
            , m_modelRepository(modelRepository)
            {
                
            }
            
            virtual ~TShapeService() {}
            
            virtual typename ModelType::IdType Create(const CreateParamsType& createParams)
            {
                ModelType* pShapeModel = m_modelFactory.Create(createParams);
                
                m_modelRepository.Add(pShapeModel->GetId(), pShapeModel);
                
                return pShapeModel->GetId();
            }
            
            virtual void Destroy(typename ModelType::IdType shapeModelId)
            {
                Eegeo_ASSERT(Exists(shapeModelId), "Shape id %d does not exist", shapeModelId);
                
                ModelType* pShapeModel = m_modelRepository.Get(shapeModelId);
                
                m_modelRepository.Remove(shapeModelId);
                
                Eegeo_DELETE pShapeModel;
            }
            
            virtual bool Exists(typename ModelType::IdType shapeModelId) const
            {
                return m_modelRepository.Contains(shapeModelId);
            }
            
            virtual ModelType& Get(typename ModelType::IdType shapeModelId) const
            {
                Eegeo_ASSERT(Exists(shapeModelId), "Shape model id %d does not exist", shapeModelId);
                return *m_modelRepository.Get(shapeModelId);
            }
            
            
            
        private:
            ModelFactoryType& m_modelFactory;
            ModelRepositoryType& m_modelRepository;
        };
        
    }
}