---

server.h

Go to the documentation of this file.

/* -*- c++ -*- */
/**************************************************************************
 Copyright (c) 2000-2001, Tony Garnock-Jones
 All rights reserved.

 Redistribution and use in source and binary forms, with or without
 modification, are permitted provided that the following conditions are
 met:

     * Redistributions of source code must retain the above copyright
       notice, this list of conditions and the following disclaimer.

     * Redistributions in binary form must reproduce the above
       copyright notice, this list of conditions and the following
       disclaimer in the documentation and/or other materials provided
       with the distribution.

     * Neither the names of the copyright holders nor the names of this
       software's contributors may be used to endorse or promote
       products derived from this software without specific prior
       written permission.

 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR
 CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
**************************************************************************/

/* -*- c++ -*- */
#ifndef MPS_Server_H
#define MPS_Server_H

namespace MPS {

class Server;
class   InterfaceServer;

/**
 * Generalised server for MPS objects, proxies, and gateways. Responds
 * to requests which come in over a connection. Subclasses implement
 * particular request dispatch strategies. */
class Server {
private:
  typedef map<string, string> boundNames_t;     ///< A transport-vs-address map.
  boundNames_t boundNames;      ///< All addresses this server is reachable at.

  string objectName;            ///< The human-readable name for this server object.

  friend class Transport;       ///< Allows access to bindName() and unbindName().

  /// Register an address that this server is available at.
  void bindName(Address const &addr) {
    boundNames[addr.getTransport()] = addr.getResolvedName();
  }

  /// Deregister an address that this server was available at.
  void unbindName(string const &transport) {
    boundNames.erase(transport);
  }

protected:
  /// Construct a Server with the given human-readable name.
  Server(string const &_o)
    : objectName(_o)
  {}

public:
  virtual ~Server() {}

  /// Retrieve the symbolic/human name for this object.
  string const &getObjectName() const { return objectName; }

  /**
   * Returns all addresses that this server has been bound to. */
  vector<string> getBoundNames() const;

  /**
   * Returns the address that this Interface has been bound to via a
   * particular Transport, or the empty-string if this Interface has
   * not been bound to the named transport. */
  string getBoundName(string const &transportName) const {
    boundNames_t::const_iterator i = boundNames.find(transportName);
    return (i == boundNames.end()) ? "" : (*i).second;
  }

  /// Dispatches an method request coming in over a connection.
  virtual void dispatch(InputStream &request, OutputStream &reply) = 0;
};

///////////////////////////////////////////////////////////////////////////

/**
 * Base class for MPS object servers. The dispatcher here reads a
 * message, takes the first int from it, and uses it to index into a
 * list of request-handler function pointers, which then further
 * deconstruct the incoming message, call their implementation object,
 * and fill in a reply message, which is sent along the Connection by
 * the InterfaceServer::dispatch() method. */
class InterfaceServer: public Server {
public:
  /**
   * This is the type that each method in the MPS
   * automatically-generated server-glue should have. The __impl
   * parameter is used to pass down a handle on the implementation
   * object; the __input and __output parameters are used for
   * communication with the client.
   *
   * Request handlers that do not wish to send a reply message
   * containing any data (ie. void-typed methods) should not fill in
   * any bytes in __output. The dispatch() method below takes this as
   * an indication of a void response.
   *
   * @param __impl the implementation object this method is operating on
   * @param __input the input message
   * @param __output the reply message
   */
  typedef void (*request_handler_t)(ref<Interface> const &__impl,
                                    InputStream &__input,
                                    OutputStream &__output);

private:
  friend class Transport;       // for special-casing locally-bound interfaces.

  typedef vector<request_handler_t> requesthandlervec_t;        ///< A list of method-handlers.

  ref<Interface> __impl;        ///< Our implementation object.
  requesthandlervec_t methods;  ///< All the methods we implement

public:
  /// Create an MPS object server called objectName, implemented by impl.
  InterfaceServer(string const &objectName, ref<Interface> const &impl)
    : Server(objectName),
      __impl(impl),
      methods()
  {
    __impl->_setInterfaceServer(this);
  }

protected:
  /// Called by (automatically-generated) subclasses to register method-handlers.
  void registerMethod(int methodIndex, string const &methodName, request_handler_t handler);

public:
  virtual void dispatch(InputStream &request, OutputStream &reply);
};

}

#endif

---