client/qos/PublishQos.cpp

Go to the documentation of this file.

/*------------------------------------------------------------------------------
Name:      PublishQos.cpp
Project:   xmlBlaster.org
Copyright: xmlBlaster.org, see xmlBlaster-LICENSE file
------------------------------------------------------------------------------*/

#include <client/qos/PublishQos.h>
#include <util/Global.h>

using namespace org::xmlBlaster::util;
using namespace org::xmlBlaster::util::qos;
using namespace std;

namespace org { namespace xmlBlaster { namespace client { namespace qos {

   PublishQos::PublishQos(Global& global)
      : ME("PublishQos"), global_(global), msgQosData_(global, "")
   {
      // deprecated
      //setLifeTime(global_.getProperty().getLongProperty("message.lifeTime", -1));
   }

   PublishQos::PublishQos(Global& global, const Destination& destination)
      : ME("PublishQos"), global_(global), msgQosData_(global, "")
   {
      addDestination(destination);
   }

   PublishQos::PublishQos(Global& global, bool persistent)
      : ME("PublishQos"), global_(global), msgQosData_(global, "")
   {
      setPersistent(persistent);
   }

   const MsgQosData& PublishQos::getData()
   {
      return msgQosData_;
   }

   PriorityEnum PublishQos::getPriority() const
   {
      return msgQosData_.getPriority();
   }

   void PublishQos::setPriority(PriorityEnum priority)
   {
      msgQosData_.setPriority(priority);
   }

   void PublishQos::setForceUpdate(bool force)
   {
      msgQosData_.setForceUpdate(force);
   }

   void PublishQos::setForceDestroy(bool forceDestroy)
   {
      msgQosData_.setForceDestroy(forceDestroy);
   }

   void PublishQos::setSubscribable(bool isSubcribeable)
   {
      msgQosData_.setSubscribable(isSubcribeable);
   }

   void PublishQos::setReadonly(bool readonly)
   {
      msgQosData_.setReadonly(readonly);
   }

   void PublishQos::setVolatile(bool volatileFlag)
   {
      msgQosData_.setVolatile(volatileFlag);
   }

   bool PublishQos::isVolatile()
   {
      return msgQosData_.isVolatile();
   }

   void PublishQos::setPersistent(bool persistent)
   {
      msgQosData_.setPersistent(persistent);
   }

   void PublishQos::setLifeTime(long lifeTime)
   {
      msgQosData_.setLifeTime(lifeTime);
   }

   void PublishQos::addDestination(const Destination& destination)
   {
      msgQosData_.addDestination(destination);
   }

   SessionNameRef PublishQos::getSender()
   {
      return msgQosData_.getSender();
   }

   /*
   void PublishQos::setSender(const SessionName& sender)
   {
      msgQosData_.setSender(sender);
   }
   */

   void PublishQos::setState(const string& state)
   {
      msgQosData_.setState(state);
   }

   string PublishQos::getState()
   {
      return msgQosData_.getState();
   }

   void PublishQos::setStateInfo(const string& stateInfo)
   {
      msgQosData_.setStateInfo(stateInfo);
   }

   string PublishQos::getStateInfo()
   {
      return msgQosData_.getStateInfo();
   }

   void PublishQos::setTopicProperty(const TopicProperty& topicProperty)
   {
      msgQosData_.setTopicProperty(topicProperty);
   }

   void PublishQos::setClientProperties(const QosData::ClientPropertyMap& cm)
   {
      msgQosData_.setClientProperties(cm);
   }

   const QosData::ClientPropertyMap& PublishQos::getClientProperties() const
   {
      return msgQosData_.getClientProperties();
   }

   string PublishQos::toString()
   {
      return toXml();
   }

   string PublishQos::toXml()
   {
      return msgQosData_.toXml();
   }

}}}}