#include <cdevServer.h>
 
// ******************************************************************
// * class ReflectorServer:
// *   This is the server class for the reflector. It simply
// *   receives messages from a client and immediately returns them.
// *
// *   The constructor passes the domain, server, port and rate to the
// *   underlying cdevServer class to be processed. The cdevServer
// *   constructor will add this server to the Name Server and will 
// *   begin processing messages when the cdevServer::runServer() 
// *   method is executed.
// *
// *   The processMessages method is the servers interface to the 
// *   world... Each time a complete message is received or the time 
// *   specified in rate expires, that method will be called.
// ******************************************************************
class ReflectorServer : public cdevServer
{
public:
   ReflectorServer ( char *domain, char *server, 
                  unsigned int port, double rate )
      : cdevServer(domain, server, port, rate)
      {
      }
 
   virtual void processMessages ( void )
      {
      cdevMessage * message;
      while(dequeue(message)==0)
         {
         enqueue(message);
         delete message;
         }
      }
};
 
void main()
{
ReflectorServer server("REFLECTOR", "TestServerX", 9120, 60);
cdevServer::runServer();
}
			

#include <cdevClientService.h>
 
// ******************************************************************
// * Function called to create initial instance of ReflectorService
// ******************************************************************
extern "C" cdevService *newReflectorService ( char *, cdevSystem *);
 
// ******************************************************************
// * class ReflectorService :
// *   This class simply inherits from the cdevClientService and must 
// *   define only a constructor and destructor.
// ******************************************************************
class ReflectorService : public cdevClientService
{
public:
   ReflectorService (   char * name, cdevSystem & system =
      cdevSystem::defaultSystem());   
protected:
   virtual ~ReflectorService ( void ) {};
};
			

#include <ReflectorService.h>
 
// ******************************************************************
// * newReflectorService:
// *   This function will be called by the cdevSystem object to create 
// *   an initial instance of the ReflectorService.
// ******************************************************************
extern "C" cdevService * newReflectorService 
   (char * name, cdevSystem * system)
   {
   return new ReflectorService(name, *system);
   }
 
// ******************************************************************
// * ReflectorService::ReflectorService :
// *   This is the constructor for the ReflectorService.  It 
// *   initializes the underlying cdevClientService by specifying 
// *   that it is in the domain of REFLECTOR.
// ******************************************************************
ReflectorService::ReflectorService 
   ( char * name, cdevSystem & system)
   : cdevClientService("REFLECTOR", name, system) 
   {
   system.reportError(CDEV_SEVERITY_INFO, "ReflectorService", NULL, 
            "Constructing a new ReflectorService"); 
   }
			

service Reflector 
   {
   tags {server}
   }
 
class Reflectors 
   {
       verbs {get}
   attributes 
      {
      attrib1     Reflector {server=TestServerX};
      }
   }
 
Reflectors :
   device1,
;