This class implements the ISocketObservable interface. It is a portable socket wrapper around the select call. This implementation is useful for daemons, command-line clients, etc.

     #include <yazpp/socket-manager.h>

     class SocketManager : public ISocketObservable {
       public:
         // Add an observer
         virtual void addObserver(int fd, ISocketObserver *observer);
         // Delete an observer
         virtual void deleteObserver(ISocketObserver *observer);
         // Delete all observers
         virtual void deleteObservers();
         // Set event mask for observer
         virtual void maskObserver(ISocketObserver *observer, int mask);
         // Set timeout
         virtual void timeoutObserver(ISocketObserver *observer,
                                  unsigned timeout);
         // Process one event. return > 0 if event could be processed;
         int processEvent();
         SocketManager();
         virtual ~SocketManager();
     };
    

This class implements the interfaces IPDU_Observable and ISocketObserver. This object implements a non-blocking client/server channel that transmits BER encoded PDUs (or those offered by YAZ COMSTACK).

     #include <yazpp/pdu-assoc.h>

     class PDU_Assoc : public IPDU_Observable,
                                 ISocketObserver {
       public:
         COMSTACK comstack(const char *type_and_host, void **vp);
         // Create object using specified socketObservable
         PDU_Assoc(ISocketObservable *socketObservable);
         // Create Object using existing comstack
         PDU_Assoc(ISocketObservable *socketObservable,
                  COMSTACK cs);
         // Close socket and destroy object.
         virtual ~PDU_Assoc();
         // Clone the object
         IPDU_Observable *clone();
         // Send PDU
         int send_PDU(const char *buf, int len);
         // connect to server (client role)
         void connect(IPDU_Observer *observer, const char *addr);
         // listen for clients (server role)
         void listen(IPDU_Observer *observer, const char *addr);
         // Socket notification
         void socketNotify(int event);
         // Close socket
         void close();
         // Close and destroy
         void destroy();
         // Set Idle Time
         void idleTime (int timeout);
         // Child start...
         virtual void childNotify(COMSTACK cs);
     };
    

This class implements the interface IPDU_Obserer. This object implements a Z39.50 client/server channel, aka Z-Association.

     #include <yazpp/z-assoc.h>

     class Z_Assoc : public IPDU_Observer {
       public:
         // Create object using the PDU Observer specified
         Z_Assoc(IPDU_Observable *the_PDU_Observable);
         // Destroy association and close PDU Observer
         virtual ~Z_Assoc();
         // Receive PDU
         void recv_PDU(const char *buf, int len);
         // Connect notification
         virtual void connectNotify() = 0;
         // Failure notification
         virtual void failNotify() = 0;
         // Timeout notification
         virtual void timeoutNotify() = 0;
         // Timeout specify
         void timeout(int timeout);
         // Begin Z39.50 client role
         void client(const char *addr);
         // Begin Z39.50 server role
         void server(const char *addr);
         // Close connection
         void close();

         // Decode Z39.50 PDU.
         Z_APDU *decode_Z_PDU(const char *buf, int len);
         // Encode Z39.50 PDU.
         int encode_Z_PDU(Z_APDU *apdu, char **buf, int *len);
         // Send Z39.50 PDU
         int send_Z_PDU(Z_APDU *apdu);
         // Receive Z39.50 PDU
         virtual void recv_Z_PDU(Z_APDU *apdu) = 0;
         // Create Z39.50 PDU with reasonable defaults
         Z_APDU *create_Z_PDU(int type);
         // Request Alloc
         ODR odr_encode ();
         ODR odr_decode ();
         ODR odr_print ();
         void set_APDU_log(const char *fname);
         const char *get_APDU_log();

         // OtherInformation
         void get_otherInfoAPDU(Z_APDU *apdu, Z_OtherInformation ***oip);
         Z_OtherInformationUnit *update_otherInformation (
               Z_OtherInformation **otherInformationP, int createFlag,
               int *oid, int categoryValue, int deleteFlag);
         void set_otherInformationString (
               Z_OtherInformation **otherInformationP,
               int *oid, int categoryValue,
               const char *str);
         void set_otherInformationString (
               Z_OtherInformation **otherInformation,
               int oidval, int categoryValue,
               const char *str);
         void set_otherInformationString (
               Z_APDU *apdu,
               int oidval, int categoryValue,
               const char *str);

         Z_ReferenceId *getRefID(char* str);
         Z_ReferenceId **get_referenceIdP(Z_APDU *apdu);
         void transfer_referenceId(Z_APDU *from, Z_APDU *to);

         const char *get_hostname();
     };
    

This object is just a specialization of Z_Assoc. It provides more facilities for the Z39.50 client role.

     #include <yazpp/ir-assoc.h>

     class IR_Assoc : public Z_Assoc {
       ...
     };
    

The example client, yaz-my-client.cpp, uses this class.

This object is just a specialization of Z_Assoc. It provides more facilities for the Z39.50 server role.

     #include <yazpp/z-server.h>

     class My_Server : public Z_Server {
       ...
     };
    

The example server, yaz-my-server.cpp, uses this class.