util/qos/storage/QueuePropertyBase.h

Go to the documentation of this file.

/*------------------------------------------------------------------------------
Name:      QueuePropertyBase.h
Project:   xmlBlaster.org
Copyright: xmlBlaster.org, see xmlBlaster-LICENSE file
Comment:   Holding callback queue properties
Version:   $Id: QueuePropertyBase.h 13445 2005-07-15 01:54:35Z ruff $
------------------------------------------------------------------------------*/

#ifndef _UTIL_QUEUE_QUEUEPROPERTYBASE_H
#define _UTIL_QUEUE_QUEUEPROPERTYBASE_H

#include <util/xmlBlasterDef.h>
#include <util/Constants.h>
#include <util/qos/address/AddressBase.h>

#include <string>
#include <vector>

namespace org { namespace xmlBlaster { namespace util { namespace qos { namespace storage {

extern Dll_Export  const long DEFAULT_maxEntriesDefault;
extern Dll_Export  const long DEFAULT_maxEntriesCacheDefault;
extern Dll_Export  const long DEFAULT_bytesDefault;
extern Dll_Export  const long DEFAULT_bytesCacheDefault;
extern Dll_Export  const double DEFAULT_storeSwapLevelRatio;
extern Dll_Export  const double DEFAULT_storeSwapBytesRatio;
extern Dll_Export  const double DEFAULT_reloadSwapLevelRatio;
extern Dll_Export  const double DEFAULT_reloadSwapBytesRatio;
extern Dll_Export  const Timestamp DEFAULT_minExpires;
extern Dll_Export  const Timestamp DEFAULT_maxExpires;
extern Dll_Export  const std::string DEFAULT_onOverflow;
extern Dll_Export  const std::string DEFAULT_onFailure;

// static variables
extern Dll_Export  std::string DEFAULT_type;
extern Dll_Export  std::string DEFAULT_version;
extern Dll_Export  long DEFAULT_expires;

typedef std::vector<org::xmlBlaster::util::qos::address::AddressBaseRef> AddressVector;

class Dll_Export QueuePropertyBase
{
   friend class QueuePropertyFactory;
protected:
   std::string  ME; //  = "QueuePropertyBase";
   org::xmlBlaster::util::Global& global_;
   org::xmlBlaster::util::I_Log&    log_;

   std::string type_;

   std::string version_;

   long maxEntriesDefault_;

   long maxEntriesCacheDefault_;

   long maxBytesDefault_;

   long maxBytesCacheDefault_;

   Timestamp minExpires_;

   Timestamp maxExpires_;


   std::string relating_; //  = Constants.RELATING_CALLBACK;
   Timestamp expires_; // = DEFAULT_expires;
   long maxEntries_;
   long maxBytes_;
   long maxEntriesCache_;

   long storeSwapLevel_;

   long storeSwapBytes_;

   long reloadSwapLevel_;

   long reloadSwapBytes_;

   long maxBytesCache_;

   std::string onOverflow_;

   std::string onFailure_;

   AddressVector addressArr_; // = new org::xmlBlaster::util::qos::address::AddressBase[0];

   std::string nodeId_; // = null;

   std::string propertyPrefix_;

   std::string rootTagName_;

   void copy(const QueuePropertyBase& prop)
   {
      type_                 = prop.type_;
      version_              = prop.version_;
      maxEntriesDefault_    = prop.maxEntriesDefault_;
      maxEntriesCacheDefault_= prop.maxEntriesCacheDefault_;
      maxBytesDefault_      = prop.maxBytesDefault_;
      maxBytesCacheDefault_ = prop.maxBytesCacheDefault_;
      minExpires_           = prop.maxExpires_;
      relating_             = prop.relating_;
      expires_              = prop.expires_;
      maxEntries_           = prop.maxEntries_;
      maxBytes_             = prop.maxBytes_;
      maxEntriesCache_      = prop.maxEntriesCache_;
      storeSwapLevel_       = prop.storeSwapLevel_;
      storeSwapBytes_       = prop.storeSwapBytes_;
      reloadSwapLevel_      = prop.reloadSwapLevel_;
      reloadSwapBytes_      = prop.reloadSwapBytes_;
      maxBytesCache_        = prop.maxBytesCache_;
      onOverflow_           = prop.onOverflow_;
      onFailure_            = prop.onFailure_;
      addressArr_           = prop.addressArr_;
      nodeId_               = prop.nodeId_;
      propertyPrefix_       = prop.propertyPrefix_;
      rootTagName_          = prop.rootTagName_;
   }

   /*inline*/ void initialize(const std::string& propertyPrefix);

   void setMaxExpires(Timestamp maxExpires)
   {
      maxExpires_ = maxExpires;
   }

   Timestamp getMaxExpires() const
   {
      return maxExpires_;
   }

   void setMinExpires(Timestamp minExpires)
   {
      minExpires_ = minExpires;
   }

   Timestamp getMinExpires()
   {
      return minExpires_;
   }

public:

   QueuePropertyBase(org::xmlBlaster::util::Global& global, const std::string& nodeId);

   QueuePropertyBase(const QueuePropertyBase& prop);

   QueuePropertyBase& operator =(const QueuePropertyBase& prop);

   virtual ~QueuePropertyBase();

   void setRelating(const std::string& relating);

   std::string getRelating() const;

   Timestamp getExpires() const;

   void setExpires(Timestamp expires);

   long getMaxEntries() const;

   void setMaxEntries(long maxEntries);

   std::string getType() const;

   void setType(const std::string& type);

   std::string getVersion() const;

   void setVersion(const std::string& version);

   long getMaxEntriesCache() const;

   void setMaxEntriesCache(long maxEntriesCache);

   long getMaxBytes() const;

   void setMaxBytes(long maxBytes);

   long getMaxBytesCache() const;

   long getStoreSwapLevel() const;

   void setStoreSwapLevel(long storeSwapLevel);

   long getStoreSwapBytes() const;

   void setStoreSwapBytes(long storeSwapBytes);

   long getReloadSwapLevel() const;

   void setReloadSwapLevel(long reloadSwapLevel);

   long getReloadSwapBytes() const;

   void setReloadSwapBytes(long reloadSwapBytes);

   void setMaxBytesCache(long maxBytesCache);

   void setOnOverflow(const std::string& onOverflow);

   std::string getOnOverflow() const;

   /*
    * The default mode, when queue is full the publisher blocks until
    * there is space again.
   public final boolean onOverflowBlock() {
      if (Constants.ONOVERFLOW_BLOCK.equalsIgnoreCase(getOnOverflow()))
         return true;
      return false;
   }
    */

   void setOnFailure(const std::string& onFailure);

   std::string getOnFailure() const;

   bool onFailureDeadMessage();

   AddressVector getAddresses() const;

   std::string toXml(const std::string& extraOffset="") const;

   org::xmlBlaster::util::Global& getGlobal();

//   void cleanupAddresses();

   std::string getPropertyPrefix() const;
   void setpropertyPrefix(const std::string& prefix);

   std::string getPrefix();

   std::string getPropName(const std::string& token);

   std::string getRootTagName() const;

};

}}}}} // namespaces

#endif