// $Revision: 1.4 $

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

#ifndef TaligentSamples_TCALLERON
#define TaligentSamples_TCALLERON

#ifndef Taligent_REMOTECALLER
#include <Taligent/RemoteCaller.h>
#endif

#ifndef Taligent_SERVICEACCESS
#include <Taligent/ServiceAccess.h>
#endif

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

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

#ifndef TaligentSamples_DISPATCHERON
#include "DispatcherOn.h"
#endif

#ifndef Taligent_ASSERTIONS
#include <Taligent/Assertions.h>
#endif

#ifndef TaligentSamples_TEMPLATECALLERMACROS
#include "TemplateCallerMacros.h"
#endif

class TMessageStreamsTransport;

//---- TCallerOn -----------------------------------------------------------

template<class AType>
class TCallerOn : public MRemoteCaller, public MProtocolOn<AType> {
  public:
    TaligentTypeExtensionTemplateDeclarationsMacro(TCallerOn,AType)
  public:
                            TCallerOn();
                            TCallerOn(const TServiceReference& serviceReference);
                            TCallerOn(const TCallerOn<AType>& source);
    virtual                 ~TCallerOn();
    
    virtual TStream&        operator>>=(TStream& toStream) const;
    virtual TStream&        operator<<=(TStream& fromStream);
                                
    virtual void            Do(TStandardFunctorOn<AType>& functor);

    MRemoteCallerTemplateDeclarationsMacro()
  
  private:
    TCallerOn<AType>&   operator=(const TCallerOn<AType>& source);

  private:
    enum {kOriginalVersion};
    TServiceReference* fServiceReference;
    TMessageStreamsTransport*   fTransport;
};

//---- TCallerOn ---------------------------------------------------------

MRemoteCallerTemplateCallerAndTemplateDispatcherDefinitionsMacro(TCallerOn,TDispatcherOn,AType)
TaligentTypeExtensionTemplateMacro(TCallerOn,AType)

template<class AType>
TCallerOn<AType>::TCallerOn()
    : MRemoteCaller(),
    MProtocolOn<AType>(),
    fServiceReference(NIL),
    fTransport(NIL)
{
    MRemoteCallerEnable();
}

template<class AType>
TCallerOn<AType>::TCallerOn(const TServiceReference& serviceReference)
    : MRemoteCaller(),
    MProtocolOn<AType>(),
    fServiceReference(NIL),
    fTransport(NIL)
{
    MRemoteCallerEnable();
    
    fServiceReference = ::Copy(serviceReference);
    fTransport = new TMessageStreamsTransport(new TRequestSenderStream(*fServiceReference));
    SetTransport(fTransport);
}

template<class AType>
TCallerOn<AType>::TCallerOn(const TCallerOn<AType>& source)
    : MRemoteCaller(),
    fServiceReference(NIL),
    fTransport(NIL)
{
    fServiceReference = ::CopyPointer(source.fServiceReference);
    fTransport = new TMessageStreamsTransport(new TRequestSenderStream(*fServiceReference));
    SetTransport(fTransport);
}

template<class AType>
TCallerOn<AType>::~TCallerOn()
{
    delete fTransport;
}

template<class AType>
TCallerOn<AType>&
TCallerOn<AType>::operator=(const TCallerOn<AType>& source)
{
    // Can't be done because you can't change the transport you are using.
    // This member function has been privatized due to this.
    return *this;
}

template<class AType>
TStream&
TCallerOn<AType>::operator>>=(TStream& toStream) const
{
    ::WriteVersion(toStream, kOriginalVersion);
    ::Flatten(fServiceReference, toStream);
    return toStream;
}

template<class AType>
TStream&
TCallerOn<AType>::operator<<=(TStream& fromStream)
{
    ::ReadVersion(fromStream, kOriginalVersion, kOriginalVersion);
    delete fServiceReference;
    ::Resurrect(fServiceReference, fromStream);
    delete fTransport;
    fTransport = new TMessageStreamsTransport(new TRequestSenderStream(*fServiceReference));
    SetTransport(fTransport);
    return fromStream;
}

template<class AType>
void
TCallerOn<AType>::Do(TStandardFunctorOn<AType>& functor)
{
    try {
        TStream& argumentStream = *BeginRequest(TDispatcherOn<AType>::kDo);
        ::Flatten(&functor, argumentStream);
        TStream& resultStream = *SendRequest();
        functor <<= resultStream;
        EndRequest();
   }
    catch (TRemoteCallException& exception) {
        cout << endl << "*** Remote call failed. ***" << endl;
    }
    catch (TStandardException& exception) {
        cout << endl << "*** Encountered an error while making remote call. ***" << endl;
    }
    catch (...) {
        cout << endl << "*** Encountered a completely unknown error while making remote call. ***" << endl;
    }
}


#endif