ConsumerBase.h

Go to the documentation of this file.

/******************************************************************************
*
* Copyright Saab AB, 2006-2013 (http://safirsdkcore.com)
*
* Created by: Anders Widén / stawi
*
*******************************************************************************
*
* This file is part of Safir SDK Core.
*
* Safir SDK Core is free software: you can redistribute it and/or modify
* it under the terms of version 3 of the GNU General Public License as
* published by the Free Software Foundation.
*
* Safir SDK Core 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with Safir SDK Core.  If not, see <http://www.gnu.org/licenses/>.
*
******************************************************************************/
 
#ifndef _SAFIR_DOB_CONSUMER_BASE_H
#define _SAFIR_DOB_CONSUMER_BASE_H
 
#include <Safir/Dob/DoseCppExportDefs.h>
#include <Safir/Dob/Defs.h>
#include <Safir/Dob/ResponseSender.h>
#include <Safir/Dob/EntityProxy.h>
#include <Safir/Dob/InjectedEntityProxy.h>
#include <Safir/Dob/EntityRequestProxy.h>
#include <Safir/Dob/ServiceRequestProxy.h>
#include <Safir/Dob/Typesystem/Defs.h>
#include <Safir/Dob/Typesystem/HandlerId.h>
#include <Safir/Dob/Typesystem/Exceptions.h>
 
#ifdef _MSC_VER
//we need to disable the warning about inheriting by dominance, it is intended to be this way,
//and there is no way to produce code that does not give this warning, unfortunately.
//see also the comment on ConsumerBase
#pragma warning (disable: 4250)
#endif
 
namespace Safir
{
namespace Dob
{
    //Forward declarations:
    class RevokedRegistrationBase;
    class CompletedRegistrationBase;
    class EntityRequestBase;
    class EntityInjectionBase;
    class ServiceRequestBase;
    class StopHandler;
    class Dispatcher;
    class EntityHandler;
    class EntityHandlerInjection;
    class EntityHandlerPending;
    class ServiceHandler;
    class ServiceHandlerPending;
    class Requestor;
    class MessageSender;
    class RegistrationSubscriber;
    class MessageSubscriber;
    class EntitySubscriber;
 
    namespace Internal
    {
        //forward declaration
        class Callbacks;

        class DOSE_CPP_API ConsumerBase
        {
        public:
            virtual ~ConsumerBase() {}
 
        private:
            friend class Safir::Dob::Internal::Callbacks;
 
            virtual RevokedRegistrationBase * ToRevokedRegistrationBase()
            {throw Dob::Typesystem::SoftwareViolationException
                    (L"Call to ConsumerBase::ToRevokedRegistrationBase is illegal. Method must be overridden!",
                     __WFILE__,__LINE__);}
            virtual CompletedRegistrationBase * ToCompletedRegistrationBase()
            {throw Dob::Typesystem::SoftwareViolationException
                    (L"Call to ConsumerBase::ToCompletedRegistrationBase is illegal. Method must be overridden!",
                     __WFILE__,__LINE__);}
            virtual EntityRequestBase * ToEntityRequestBase()
            {throw Dob::Typesystem::SoftwareViolationException
                    (L"Call to ConsumerBase::ToEntityRequestBase is illegal. Method must be overridden!",
                     __WFILE__,__LINE__);}
            virtual EntityInjectionBase * ToEntityInjectionBase()
            {throw Dob::Typesystem::SoftwareViolationException
                    (L"Call to ConsumerBase::ToEntityInjectionBase is illegal. Method must be overridden!",
                     __WFILE__,__LINE__);}
            virtual ServiceRequestBase * ToServiceRequestBase()
            {throw Dob::Typesystem::SoftwareViolationException
                    (L"Call to ConsumerBase::ToServiceRequestBase is illegal. Method must be overridden!",
                     __WFILE__,__LINE__);}
            virtual StopHandler * ToStopHandler()
            {throw Dob::Typesystem::SoftwareViolationException
                    (L"Call to ConsumerBase::ToStopHandler is illegal. Method must be overridden!",
                     __WFILE__,__LINE__);}
            virtual Dispatcher * ToDispatcher()
            {throw Dob::Typesystem::SoftwareViolationException
                    (L"Call to ConsumerBase::ToDispatcher is illegal. Method must be overridden!",
                     __WFILE__,__LINE__);}
            virtual EntityHandler * ToEntityHandler()
            {throw Dob::Typesystem::SoftwareViolationException
                    (L"Call to ConsumerBase::ToEntityHandler is illegal. Method must be overridden!",
                     __WFILE__,__LINE__);}
            virtual EntityHandlerInjection * ToEntityHandlerInjection()
            {throw Dob::Typesystem::SoftwareViolationException
                    (L"Call to ConsumerBase::ToEntityHandlerInjection is illegal. Method must be overridden!",
                     __WFILE__,__LINE__);}
            virtual EntityHandlerPending * ToEntityHandlerPending()
            {throw Dob::Typesystem::SoftwareViolationException
                    (L"Call to ConsumerBase::ToEntityHandlerPending is illegal. Method must be overridden!",
                     __WFILE__,__LINE__);}
            virtual ServiceHandler * ToServiceHandler()
            {throw Dob::Typesystem::SoftwareViolationException
                    (L"Call to ConsumerBase::ToServiceHandler is illegal. Method must be overridden!",
                     __WFILE__,__LINE__);}
            virtual ServiceHandlerPending * ToServiceHandlerPending()
            {throw Dob::Typesystem::SoftwareViolationException
                    (L"Call to ConsumerBase::ToServiceHandlerPending is illegal. Method must be overridden!",
                     __WFILE__,__LINE__);}
            virtual Requestor * ToRequestor()
            {throw Dob::Typesystem::SoftwareViolationException
                    (L"Call to ConsumerBase::ToRequestor is illegal. Method must be overridden!",
                     __WFILE__,__LINE__);}
            virtual MessageSender * ToMessageSender()
            {throw Dob::Typesystem::SoftwareViolationException
                    (L"Call to ConsumerBase::ToMessageSender is illegal. Method must be overridden!",
                     __WFILE__,__LINE__);}
            virtual RegistrationSubscriber * ToRegistrationSubscriber()
            {throw Dob::Typesystem::SoftwareViolationException
                    (L"Call to ConsumerBase::ToRegistrationSubscriber is illegal. Method must be overridden!",
                     __WFILE__,__LINE__);}
            virtual MessageSubscriber * ToMessageSubscriber()
            {throw Dob::Typesystem::SoftwareViolationException
                    (L"Call to ConsumerBase::ToMessageSubscriber is illegal. Method must be overridden!",
                     __WFILE__,__LINE__);}
            virtual EntitySubscriber * ToEntitySubscriber()
            {throw Dob::Typesystem::SoftwareViolationException
                    (L"Call to ConsumerBase::ToEntitySubscriber is illegal. Method must be overridden!",
                     __WFILE__,__LINE__);}
 
 
            //These functions take a void ptr and call the desired version of the above methods
            static RevokedRegistrationBase * ToRevokedRegistrationBase(void * consumerBase)
            {return static_cast<ConsumerBase*>(consumerBase)->ToRevokedRegistrationBase();}
            static CompletedRegistrationBase * ToCompletedRegistrationBase(void * consumerBase)
            {return static_cast<ConsumerBase*>(consumerBase)->ToCompletedRegistrationBase();}
            static EntityRequestBase * ToEntityRequestBase(void * consumerBase)
            {return static_cast<ConsumerBase*>(consumerBase)->ToEntityRequestBase();}
            static EntityInjectionBase * ToEntityInjectionBase(void * consumerBase)
            {return static_cast<ConsumerBase*>(consumerBase)->ToEntityInjectionBase();}
            static ServiceRequestBase * ToServiceRequestBase(void * consumerBase)
            {return static_cast<ConsumerBase*>(consumerBase)->ToServiceRequestBase();}
            static StopHandler * ToStopHandler(void * consumerBase)
            {return static_cast<ConsumerBase*>(consumerBase)->ToStopHandler();}
            static Dispatcher * ToDispatcher(void * consumerBase)
            {return static_cast<ConsumerBase*>(consumerBase)->ToDispatcher();}
            static EntityHandler * ToEntityHandler(void * consumerBase)
            {return static_cast<ConsumerBase*>(consumerBase)->ToEntityHandler();}
            static EntityHandlerInjection * ToEntityHandlerInjection(void * consumerBase)
            {return static_cast<ConsumerBase*>(consumerBase)->ToEntityHandlerInjection();}
            static EntityHandlerPending * ToEntityHandlerPending(void * consumerBase)
            {return static_cast<ConsumerBase*>(consumerBase)->ToEntityHandlerPending();}
            static ServiceHandler * ToServiceHandler(void * consumerBase)
            {return static_cast<ConsumerBase*>(consumerBase)->ToServiceHandler();}
            static ServiceHandlerPending * ToServiceHandlerPending(void * consumerBase)
            {return static_cast<ConsumerBase*>(consumerBase)->ToServiceHandlerPending();}
            static Requestor * ToRequestor(void * consumerBase)
            {return static_cast<ConsumerBase*>(consumerBase)->ToRequestor();}
            static MessageSender * ToMessageSender(void * consumerBase)
            {return static_cast<ConsumerBase*>(consumerBase)->ToMessageSender();}
            static RegistrationSubscriber * ToRegistrationSubscriber(void * consumerBase)
            {return static_cast<ConsumerBase*>(consumerBase)->ToRegistrationSubscriber();}
            static MessageSubscriber * ToMessageSubscriber(void * consumerBase)
            {return static_cast<ConsumerBase*>(consumerBase)->ToMessageSubscriber();}
            static EntitySubscriber * ToEntitySubscriber(void * consumerBase)
            {return static_cast<ConsumerBase*>(consumerBase)->ToEntitySubscriber();}
        };
    }

    class DOSE_CPP_API RevokedRegistrationBase:
        public virtual Internal::ConsumerBase
    {
    public:
        virtual ~RevokedRegistrationBase() {}

        virtual void OnRevokedRegistration(const Safir::Dob::Typesystem::TypeId     typeId,
                                           const Safir::Dob::Typesystem::HandlerId& handlerId) = 0;
 
    private:
        RevokedRegistrationBase * ToRevokedRegistrationBase() override {return this;}
    };

    class DOSE_CPP_API CompletedRegistrationBase : public virtual RevokedRegistrationBase
    {
    public:
        virtual void OnCompletedRegistration(const Safir::Dob::Typesystem::TypeId     typeId,
                                             const Safir::Dob::Typesystem::HandlerId& handlerId) = 0;
 
    private:
        CompletedRegistrationBase * ToCompletedRegistrationBase() override {return this;}
    };

    class DOSE_CPP_API EntityRequestBase:
        public virtual Internal::ConsumerBase
    {
    public:
        virtual ~EntityRequestBase() {}

        virtual void OnCreateRequest(const Safir::Dob::EntityRequestProxy entityRequestProxy,
                                     Safir::Dob::ResponseSenderPtr        responseSender) = 0;

        virtual void OnUpdateRequest(const Safir::Dob::EntityRequestProxy entityRequestProxy,
                                     Safir::Dob::ResponseSenderPtr        responseSender) = 0;

        virtual void OnDeleteRequest(const Safir::Dob::EntityRequestProxy entityRequestProxy,
                                     Safir::Dob::ResponseSenderPtr        responseSender) = 0;
 
    private:
        EntityRequestBase * ToEntityRequestBase() override {return this;}
    };

    class DOSE_CPP_API EntityInjectionBase : public virtual EntityRequestBase
    {
    public:
        virtual void OnInjectedNewEntity(const Safir::Dob::InjectedEntityProxy injectedEntityProxy)
        {
            (void)injectedEntityProxy; //unused
        }

        virtual void OnInjectedUpdatedEntity(const Safir::Dob::InjectedEntityProxy injectedEntityProxy)
        {
            (void)injectedEntityProxy; //unused
        }

        virtual void OnInjectedDeletedEntity(const Safir::Dob::InjectedEntityProxy injectedEntityProxy)
        {
            (void)injectedEntityProxy; //unused
        }

         virtual void OnInitialInjectionsDone(const Safir::Dob::Typesystem::TypeId typeId,
                                              const Safir::Dob::Typesystem::HandlerId& handlerId)
         {
             //unused parameters
             (void)typeId;
             (void)handlerId;
         }
 
 
    private:
         EntityInjectionBase * ToEntityInjectionBase() override {return this;}
    };

    class DOSE_CPP_API ServiceRequestBase:
        public virtual Internal::ConsumerBase
    {
    public:
        virtual ~ServiceRequestBase() {}

        virtual void OnServiceRequest(const Safir::Dob::ServiceRequestProxy serviceRequestProxy,
                                      Safir::Dob::ResponseSenderPtr         responseSender ) = 0;
 
    private:
        ServiceRequestBase * ToServiceRequestBase() override {return this;}
    };
 
}
}
 
 
#endif