Archiver.h

#ifndef ARCHIVER_H
#define ARCHIVER_H

#include <is/info.h>
#include <is/inforeceiver.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 "ArchivingServiceInterface.hh"
#include "ArchiverArguments.h"
#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 IPCNamedObject<POA_ArchivingServiceI::ArchivingServiceInterface, ipc::multi_thread>, private boost::noncopyable{
  private:
    Archiver(ArchiverArguments args);
  protected:
    ~Archiver() throw();
  private:
    static Archiver* archiver; 
    
  public:
    void shutdown() {};
    static Archiver& instance();
    
    static Archiver& initialize(ArchiverArguments args);
    void go(unsigned nWorker) throw(IsException);
    const char* getStatus() const throw();
    virtual char* status();
    virtual CORBA::Short busy();
    virtual CORBA::Short queueLength();
    void setFifo(bool);
    bool isFifo();
    virtual void suspendCallbacks (CORBA::Boolean doSuspend);
    static void archive_callback(ISCallbackInfo * isc);
    
    IPCServer& getArchiverServer() throw();
    
    virtual void archiveISName (const char* ioNameIS);
    virtual void retrieveISName (const char* ioNameIS);
    virtual void retrieveArchName (const char* archivingName);
    virtual void retrieve(const char* runNumber, const char* scanNumber, const char* className, const char* specifier); 
    virtual CORBA::Short getCompressionLevel ();
    virtual void setCompressionLevel (CORBA::Short level);
    virtual void setRetrieveIsServer (const char* 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 internal_getRetrieveIsServer() const throw();

    virtual void setPersistentDirectory(const char* newDirectory);

    char * getRetrieveIsServer() throw();
    /* 
       save any unsaved data - may be time consuming! 
    */
    void recover();
  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;
    mutable boost::recursive_mutex counterMutex; 
    double getAverageTime(double time) const throw();
    Sct::Archive::IOManagerArchive* m_archive_manager;
    std::string m_retrieval_is_server;
    bool m_suspend_callback;
    ArchiverArguments m_args;
}; // end of definition of class Archiver;
 
}// end of namespace SctArchiving
#endif // #ifndef ARCHIVER_H

---