SSDI is a simple, lightweight, reusable IP-socket protocol to permit remote procedure calls across an IP transport
SSDI supports procedure calls across multiple interfaces to a single server. All the interfaces are collected into a container derived from GenericContainer.
Each interface must be identified by a unique string. The interface contains a list of virtual methods, as usual, but implements the base class methods as stub calls into the RPC system - this supports client calls. It also must register these methods with the base class and provide gateway methods to call the server implementation - this supports the server.
Each method is assigned an ordinal value, based on the order of the registration, and this must be matched in the stub method to ensure the correct method is called
The mechanism adoped means that all the messy interface-specific implementation is confined to the interface header file. Once written, the implementation class is totally isolated from the details of the mechanism and can be treated as though it were being called directly.
The client simply calls the methods in the interface base class, definied in the header. This calls the stub RPC methods which are responsible for packing the parameters, using GTLAdd, and transmitting them via the Container.
The server must implement the implementation class, derived from the interface base class. This provides the method implementations as usual.
When the RPC is invoked, the client class will result in the generic container dispatching the call to the appropriate interface. The interface then uses the registration list to call the appropriate gateway method in the interface header, passing the packed parameter list. The gateway method unpacks the parameters and calls the actual implementation method.