// $Revision: 1.4 $

    // Copyright (C) 1994-1995 Taligent, Inc. All rights reserved.

#ifndef TaligentSamples_DISPATCHERON
#define TaligentSamples_DISPATCHERON

#ifndef TaligentSamples_PROTOCOLON
#include "ProtocolOn.h"
#endif

#ifndef Taligent_REMOTEDISPATCHER
#include <Taligent/RemoteDispatcher.h>          // Included for MRemoteDispatcher.
#endif

#ifndef TaligentSamples_IMPLEMENTATIONON
#include "ImplementationOn.h"
#endif

#ifndef TaligentSamples_STANDARDFUNCTORON
#include "StandardFunctorOn.h"
#endif

#ifndef IOSTREAMH
#include <iostream.h>   // Included for cout
#endif


//---- TDispatcherOn -----------------------------------------------------------

template<class AType>
class TDispatcherOn : public MRemoteDispatcher {
  public:
    TaligentTypeExtensionTemplateDeclarationsMacro(TDispatcherOn,AType)
  public:
                            TDispatcherOn(TImplementationOn<AType>* adoptedImplementation);
    virtual                 ~TDispatcherOn();
                    
    
    enum EAdditionRequest {
            kDo,
            kLastRequest = kDo };
                            
  protected:
                            TDispatcherOn();
    void                    DoStub(TStream& argStream, TStream& resultStream);
                    
  private:
        // The following member functions are privatized because MRemoteDispatcher requires that
        // they won't be called.
                                TDispatcherOn(const TDispatcherOn<AType>& source) {}
    TDispatcherOn<AType>&   operator=(const TDispatcherOn<AType>& source) {return *this;}
    virtual TStream&            operator>>=(TStream& toStream) const {return toStream;}
    virtual TStream&            operator<<=(TStream& fromStream) {return fromStream;}

    enum {kOriginalVersion};
    TImplementationOn<AType>*   fImplementation;
};

//---- TDispatcherOn ---------------------------------------------------------

TaligentTypeExtensionTemplateMacro(TDispatcherOn,AType)

template<class AType>
TDispatcherOn<AType>::TDispatcherOn()
    : MRemoteDispatcher(),
    fImplementation(NIL)
{
}

template<class AType>
TDispatcherOn<AType>::TDispatcherOn(TImplementationOn<AType>* adoptedImplementation)
    : MRemoteDispatcher(),
    fImplementation(adoptedImplementation)
{
    static RequestEntry requests[] = {
        {kDo, (RemoteFnPtr)&TDispatcherOn<AType>::DoStub},
        // The following constant is very important to include in the request entry.
        {MRemoteCaller::kUnknownRequest}
    };

    RegisterRequests(TStandardText(typeid(*this).name()), kLastRequest, requests);
}

template<class AType>
TDispatcherOn<AType>::~TDispatcherOn()
{
    delete fImplementation;
}

template<class AType>
void
TDispatcherOn<AType>::DoStub(TStream& argStream, TStream& resultStream)
{
    ::Assertion(fImplementation != NIL, "\nCannot have a NIL implementation!\n");
    TStandardFunctorOn<AType>* functor;
    
    ::Resurrect(functor, argStream);
    
    fImplementation->Do(*functor);
    
    ReturnSuccess(resultStream);
    
    *functor >>= resultStream;
}

#endif