ConsumerBase.h

Go to the documentation of this file.

/******************************************************************************
*
* Copyright Saab AB, 2006-2013 (http://safir.sourceforge.net)
*
* 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:
        virtual RevokedRegistrationBase * ToRevokedRegistrationBase() {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:
        virtual CompletedRegistrationBase * ToCompletedRegistrationBase() {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:
        virtual EntityRequestBase * ToEntityRequestBase() {return this;}
    };

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

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

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

         virtual void OnInitialInjectionsDone(const Safir::Dob::Typesystem::TypeId typeId,
                                              const Dob::Typesystem::HandlerId& handlerId)
         { //This is an empty implementation, but we have this little bit to avoid MSVC++ warnings
#ifdef _MSC_VER
             typeId;handlerId;
#endif
         }


    private:
        virtual EntityInjectionBase * ToEntityInjectionBase() {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:
        virtual ServiceRequestBase * ToServiceRequestBase() {return this;}
    };

}
}


#endif