void main () 
   {
   // *************************************************************
   // * Get references to the 2 devices
   // *************************************************************
   cdevDevice& mag1 = cdevDevice::attachRef ("Magnet1");
   cdevDevice& mag2 = cdevDevice::attachRef ("Magnet2");
   cdevData result;
 
   // *************************************************************
   // * Get the current from the first magnet and use it to set 
   // * the current on the second.
   // *************************************************************   
   mag1.send("get current", NULL, result);
   mag2.send("set current", result, NULL);
   }
			

cdevData d1, d2;
int valtag;
float x, x2;
int status;
...
d1.tagC2I("value",&valtag);     // get the integer tag for "value"
...
d1.insert("value",37.9);        // insert using a character tag
device.send("message",d1,d2);   // send d1, get back d2
d2.get(valtag,&x);              // get "value" from d2 into x
d2.get("status",&status);       // extract the "status"
x2 = d2;                        // get "value" into x2 (= overload)
			

class cdevDevice: 
{
public:
   int send (char* msg, cdevData& out, cdevData& result);
   int sendNoBlock (char* msg, cdevData& out, cdevData& result);
   int sendCallback (char* msg, cdevData& out, cdevCallback cb);
};
			

// declare the callback func
cdevCallbackFunction gotit;
 
// create callback object                                    
cdevCallback callbk(gotit, myarg);                                    
...
mag1.sendCallback("monitorOn current",NULL,callbk);
...
 
void gotit(int status, void* userarg, cdevRequestObject& reqobj,
         cdevData& result)
   {
   float f = result;
   printf("new value is %f\\n",f);
   }
 
			

typedef void (*cdevCallbackFunction)(int status, void* userarg,
                               cdevRequestObject& reqobj,
                               cdevData& result);
class cdevCallback 
{
public:
   cdevCallback (cdevCallbackFunction func, void* userarg);
   cdevCallbackFunction function;
   void* userarg;
}
			

// get default system
cdevSystem& sys = cdevSystem::defaultSystem();   
...
mag1.sendNoBlock("on",...);  // async op(s)
mag2.sendNoBlock("on",...);  // async op(s)
...
sys.pend();                  // wait for all I/O to complete   
			

class cdevSystem 
{
public:
   intflush();
   int   poll();
   intpend();
}
			

cdevGroup g1, g2;
...
g1.start();
mag1.sendCallback(...);
mag2.sendCallback(...);
g2.start();
bpm1.sendNoBlock(...);
bpm2.sendNoBlock(...);
g1.end();
mag3.sendCallback(...);
bpm3.sendNoBlock(...);
g2.end();
g1.pend(4.0);
// at this point operations on mag1, mag2, bpm1, & bpm2 are done
// or have timed out (error handling discussed later).
...
// mag3 and bpm3 may not be finished yet, pend on the second
// group to wait for their completion
g2.pend();
			

cdevRequestObject& mag1BDL =
   cdevRequestObject::attachRef("mag1","set BDL");
cdevData mydata;
...
   {
   mydata = i*10;               // 10 amp steps
   mag1BDL.send(mydata,NULL);   // ignore errors for now
   sleep(1);
   }
			

class cdevRequestObject 
{
public:
   char* message();           // returns the message string
   cdevDevice& device();      // returns the device object
   int state();               // connected/disconnected/   
   int access();              // read/write/none
   int send(cdevData& out, cdevData& result);
   int sendNoBlock(cdevData& out, cdevData& result);
   int sendCallback(cdevData& out, cdevCallback callback);
}
			

typedef void (*cdevFdChangedCallback)(int fd, int opened, 
             void* userarg)
class cdevSystem 
{
public:
   ...
   int getFd(int fd[], int &numFD);
   int addFdChangedCallback(cdevFdChangedCallback cbk, void* arg);
}
			

int myFD[5];
 
void mySelectLoop ( cdevSystem & system )
   {
   int fd[20];
   int numFD = 15, nfds;
   fd_set rfds; // Ready file descriptors
   fd_set afds; // Active file descriptors
 
   // Copy the file descriptors I am already using to the list
   memcpy(fd, myFD, sizeof(myFD));
 
   // Get the file descriptors in use by the cdevSystem object
   system.getFd(&fd[5], numFD);
   
   // Add in the 5 previously defined file descriptors
   numFD += 5;
 
   // Zero the active file descriptors
   FD_ZERO(&afds);
   
   // Setup the active file descriptors
 
   // Get the maximum number of file descriptors
   nfds = FD_SETSIZE;
   
   while(1) {
      // Copy the active descriptors to the ready descriptors
      memcpy((void *)&rfds, (void *)&afds, sizeof(rfds));
 
      // Use select to detect activity on the file descriptors
   
      // Iterate through the list of file descriptors 
         {
         if (FD_ISSET(fd[i], &rfds) 
            {
            // Respond to active file descriptor here
            }
         }
      }
   }
			

typedef void (*cdevErrorHandler)(int severity, char* text, 
                                 cdevRequestObject& request);
class cdevSystem 
{
public:
   ...
   int autoErrorOn();
   int autoErrorOff();
   cdevErrorHandler setErrorHandler(cdevErrorHandler handler = 0);
   int reportError(int severity, char *name, 
                   cdevRequestObject* request, char* format, ...);
   void setThreshold ( int errorThreshold );
}
			

CDEV_SEVERITY_INFO    Informative message
 
CDEV_SEVERITY_WARN    Warning message - operation encountered a
                      problem during processing.
 
CDEV_SEVERITY_ERROR   Error message - operation cannot be completed
 
CDEV_SEVERITY_SEVERE  Severe/Fatal Error - cdev cannot continue 
                      execution
			

CDEV_WARNING        = -2  Failure of function is non-consequential
CDEV_ERROR          = -1  Errors that are not in any categories
CDEV_SUCCESS        = 0   Success
CDEV_INVALIDOBJ     = 1   Invalid cdev objects
CDEV_INVALIDARG     = 2   Invalid argument passed to cdev calls
CDEV_INVALIDSVC     = 3   Wrong service during dynamic loading
CDEV_INVALIDOP      = 4   Operation is unsupported (collection)
CDEV_NOTCONNECTED   = 5   Not connected to low network service
CDEV_IOFAILED       = 6   Low level network service IO failed
CDEV_CONFLICT       = 7   Conflicts of data types or tags
CDEV_NOTFOUND       = 8   Cannot find user request (cdevData)
CDEV_TIMEOUT        = 9   Time out
CDEV_CONVERT        = 10  cdevData Conversion error
CDEV_OUTOFRANGE     = 11  Value out of range for device attribute
CDEV_NOACCESS       = 12  Insufficient access to perform request
CDEV_ACCESSCHANGED  = 13  Change in access permission of device
CDEV_DISCONNECTED   = 60  Application has lost server connection
CDEV_RECONNECTED    = 61  Application has regained server connection
			

cdevDevice & device = cdevDevice::attachRef("cdevDirectory");
			

dev-class dev-namemessageserviceservice-data
   magnet   mag1   on   ca   {pv=M1CSR.VAL default=1}
			

service myservice 
   {
   tags {abc, def, ghi}
   }
			

service ca
   {
   tags {pv, default}
   }
			

magnet : m1 m2 m3;
			

alias myname m1