TransactionManager.h

Go to the documentation of this file.

#ifndef SZA_ARRAY_TRANSACTION_H
#define SZA_ARRAY_TRANSACTION_H

#include <string>
#include <list>

#include "gcp/control/code/unix/libunix_src/common/input.h"

namespace gcp {
  namespace control {
    
    class TransactionManager {
    public:
      
      static const unsigned DEV_NAME_MAX      = 100;
      static const unsigned SERIAL_NAME_MAX   = 20;
      static const unsigned LOCATION_NAME_MAX = 100;
      static const unsigned WHO_NAME_MAX      = 20;
      static const unsigned PREFIX_LEN        = 5;

      TransactionManager();
      
      virtual ~TransactionManager();
      
      void readCatalog(std::string dir, std::string file);

      void printDevices();

      void printLocations();

      void printSerialNumbers();

      void printAll();
      
      // A location specifier
      //------------------------------------------------------------

      struct Location {
    std::string name_;

    Location(std::string name) : name_(name) {};
      };

      class Location_eq : public std::unary_function<Location, bool> {
    std::string name_;
      public:
    explicit Location_eq(std::string name) : name_(name) {}
    bool operator() (const Location& location) const {
      return location.name_ == name_;
    }
      };

      //------------------------------------------------------------
      // A serial number specifier
      //------------------------------------------------------------

      struct SerialNumber {
    std::string name_;

    SerialNumber(std::string name) : name_(name) {};
      };

      class SerialNumber_eq : public std::unary_function<SerialNumber, bool> {
    std::string name_;
      public:
    explicit SerialNumber_eq(std::string name) : name_(name) {}
    bool operator() (const SerialNumber& sn) const {
      return sn.name_ == name_;
    }
      };

      //------------------------------------------------------------
      // A device specifier
      //------------------------------------------------------------

      struct Device {
    std::string name_;

    // A list of pointers to valid serial numbers for this device

    std::list<SerialNumber*> serialNumbers_;

    // A list of pointers to valid locations for this device

    std::list<Location*> locations_;

    Device(std::string name) : name_(name) {};
    void addLocation(Location* location);
    void addSerialNumber(SerialNumber* serialNumber);
    void printLocations();
    void printSerialNumbers();
    Location* findLocation(std::string name);
    SerialNumber* findSerialNumber(std::string name);
    bool isValidLocation(std::string name);
    bool isValidSerialNumber(std::string name);
      };

      class Device_eq : public std::unary_function<Device, bool> {
    std::string name_;
      public:
    explicit Device_eq(std::string name) : name_(name) {}
    bool operator() (const Device& device) const {
      return device.name_ == name_;
    }
      };

      void clearCatalog();

    private:

      // The known list of devices

      std::list<Device> devices_;
      std::list<Location> locations_;
      std::list<SerialNumber> serialNumbers_;

      // Read a location specifier from an input stream

      void readLocation(Device* device, InputStream* stream);

      // Read a serialNumber specifier from an input stream

      void readSerialNumber(Device* device, InputStream* stream);

      // Read a device specifier from an input stream

      Device* readDevice(InputStream* stream);

    public:

      // Find a device by name

      Device* findDevice(std::string name);

      // Return true if this is a valid device

      bool isValidDevice(std::string name);

      // Return true if this is a valid serial number/device pair

      bool isValidSerialNumber(std::string device, std::string serial);

      // Return true if this is a valid location/device pair

      bool isValidLocation(std::string device, std::string location);

    private:

      // Find a device by name

      Location* findLocation(std::string name);

      // Find a serial number by name

      SerialNumber* findSerialNumber(std::string name);

    public:

      /*
       * Return non-zero if a character isn't a separator character.
       */
      static int notSeparatorChar(int c);

      // Add a device by name

      Device* addDevice(std::string name);

      // Add a device by name

      Location* addLocation(std::string name);

      // Add a serial number by name

      SerialNumber* addSerialNumber(std::string name);

    }; // End class TransactionManager
    
  } // End namespace control
} // End namespace gcp



#endif // End #ifndef SZA_ARRAY_TRANSACTION_H