Defining a caller

NOTE MRemoteCaller is not multithread safe. Only one thread can operate on a single caller instance at a time.

To define a caller, you:

1. Write the caller class interface as described on page 81.
   
2. Define a caller constructor as described on page 83.
   
3. Write the caller stubs as described on page 83.
   
4. Call MRemoteCallerDefinitionsMacro using the name of the dispatcher class that corresponds to this caller, as shown on page 84.
   

Writing the caller class interface

  class TAdditionCaller : public MRemoteCaller, public MAdditionProtocol {
    public:
      TaligentTypeExtensionDeclarationsMacro(TAdditionCaller)
    public:
                  
TAdditionCaller(const TServiceReference& serviceReference);
                  TAdditionCaller(const TAdditionCaller& source);
      virtual     ~TAdditionCaller();
      
      virtual TStream&    operator>>=(TStream& toStream) const;
      virtual TStream&    operator<<=(TStream& fromStream);
                                  
      
virtual long        Add(long num1, long num2);
      virtual void        AddOne(long& num);
  
      
MRemoteCallerDeclarationsMacro(TAdditionDispatcher);
  
  private:
                  TAdditionCaller();
      TAdditionCaller&operator=(const TAdditionCaller& source);
  
    private:
      enum {kOriginalVersion};
      TServiceReference* fServiceReference;
      TMessageStreamsTransport*fTransport;
  };

Defining the caller class constructor

1. Call the empty constructor of the abstract base class from which the caller is derived (for example, TAdditionProtocol).
   
2. Accept the service reference as a parameter.
   
3. Call the MRemoteCaller constructor, passing the transport as a parameter.
   
4. Call the macro MRemoteCallerEnable to build the dispatcher ID. You can use this macro anywhere in the constructor.
   
5. Construct a TMessageStreamsTransport object using a TRequestSenderStream.
   Use the service reference passed into the constructor to create the TRequestSenderStream object. This opens a communications channel to the dispatcher.
   

  TAdditionCaller::TAdditionCaller(const TServiceReference& serviceReference)
      : MRemoteCaller(),
      MAdditionProtocol(),
      fServiceReference(NIL),
      fTransport(NIL)
  {
      
MRemoteCallerEnable();
      
      
fServiceReference = ::Copy(serviceReference);
      fTransport = 
          new TMessageStreamsTransport (new TRequestSenderStream(*fServiceReference));
      SetTransport(fTransport);
  }

Writing the caller stubs

1. Call MRemoteCaller::BeginRequest, passing the member function identifier as the only argument.
   BeginRequest returns the stream as a parameter. Because this storage is owned by the base class, do not delete the pointer that this function returns.
   
2. Stream each argument into the argument stream.
   
3. Call MRemoteCaller::SendRequest to transmit the request to the dispatcher and receive the reply back.
   SendRequest catches any exceptions thrown in this process. If you catch an exception from SendRequest, you must re-throw it. You cannot stream out the results at this point.
   
4. Stream the results out of the result stream.
   
5. Call MRemoteCaller::EndRequest.
   
6. Return the result.
   

  long
  TAdditionCaller::Add(long num1, long num2)
  {
      long result = 0;
      
      try {
          
TStream& argumentStream = *BeginRequest(TAdditionDispatcher::kAdd);
          
          num1 >>= argumentStream;
          num2 >>= argumentStream;
          
          TStream& resultStream = *SendRequest();
          
          result <<= resultStream;
          
          EndRequest();
      }
      
catch (TRemoteCallException& exception) {
          cout << endl << "*** Remote call failed. ***" << endl;
      }
      catch (TMathException& exception) {
          cout << endl << "*** Received Math Exception ***" << endl;
          throw;
      }
      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;
      }
      
      
return result;
  }

Using the caller definitions macro