Archiver.h

#ifndef ARCHIVER_H
#define ARCHIVER_H

#include <is/isinfo.h>
#include <ipc/object.h>
#include <ipc/server.h>

#include <string>
#include <memory>
#include <sys/types.h>
#include <unistd.h>

#include <boost/thread.hpp>
#include "ArchivingServiceI.hh"
#include "Sct/Exception.h"
#include "Sct/ConfigurationException.h"
#include "Sct/LogicErrors.h"
#include "Sct/IoExceptions.h"
#include "Sct/Archive/IOManagerArchive.h"

using namespace Sct;
namespace SctArchiving {
  class ArchivingCommand;
  class ArchivingWorkerGroup;
  class Archiver: public IPCObject, public virtual ArchivingServiceI_T_ArchivingServiceInterface, private boost::noncopyable{
  private:
    Archiver() throw(ConfigurationException);
    ~Archiver() throw();
    static Archiver* archiver; 
    
  public:
    static Archiver& instance();
    
    static Archiver& initialize() throw(ConfigurationException);
    
    void go(unsigned nWorker) throw(IsException);
    const char* getStatus() const throw();
    virtual char* status(ArchivingServiceIStatus* status);
    virtual ilu_ShortInteger busy(ArchivingServiceIStatus *_status);
    virtual ilu_ShortInteger queueLength(ArchivingServiceIStatus *_status);
    virtual void suspendCallbacks (ArchivingServiceIStatus *_status, ilu_Boolean doSuspend);
    static void archive_callback(ISCallbackInfo * isc);
    
    IPCServer& getArchiverServer() throw();
    
    virtual void archiveISName (ArchivingServiceIStatus *status, char* ioNameIS);
    virtual void retrieveISName (ArchivingServiceIStatus *status, char* ioNameIS);
    virtual void retrieveArchName (ArchivingServiceIStatus *status, char* archivingName);
    virtual void retrieve(ArchivingServiceIStatus *_status, char* runNumber, char* scanNumber, char* className, char* specifier); 
    virtual ilu_ShortInteger getCompressionLevel (ArchivingServiceIStatus *_status);
    virtual void setCompressionLevel (ArchivingServiceIStatus *_status, ilu_ShortInteger level);
    virtual void setRetrieveIsServer (ArchivingServiceIStatus *_status, ilu_T_CString serverName);
    /*
      Add an ArchivingCommand to the workergroup.
    */
    virtual void addCommand(boost::shared_ptr<ArchivingCommand> command) const;
    void incrimentNArchived() throw();
    void incrimentNRetrieved() throw();
    void incrimentNValidated() throw();
    void addISTime(double time) throw();
    void addFileTime(double time) throw();
    Sct::Archive::IOManagerArchive& Archiver::getIOManagerArchive() const;
    string getRetrieveIsServer() const throw();
  private:
    ArchivingWorkerGroup* workergroup;
    void subscribe(const string& servername, const string& regexp, ISCallbackInfo::Callback callback);
    std::auto_ptr<ISInfoReceiver> infoReceiver;
    /* counters */
    long nArchived;
    long nRetrieved;
    long nValidated;
    double isTimeTaken;
    double fileTimeTaken;
    boost::mutex counterMutex; 
    double getAverageTime(double time) const throw();
    Sct::Archive::IOManagerArchive* m_archive_manager;

    std::string m_retrieval_is_server;
    bool m_suspend_callback;
}; // end of definition of class Archiver;
 
}// end of namespace SctArchiving
#endif // #ifndef ARCHIVER_H

---