util/qos/QueryQosData.cpp

Go to the documentation of this file.

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

#include <util/qos/QueryQosData.h>
# include <util/Constants.h>
# include <util/Global.h>

using namespace org::xmlBlaster::util;
using namespace org::xmlBlaster::util::cluster;

using namespace std;

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

void QueryQosData::init() 
{
//   QosData::init();
   subscriptionId_ = "";
   forceDestroy_   = false;
   meta_           = true;
   content_        = true;
   multiSubscribe_ = true;
   local_          = true;
   initialUpdate_  = true;
   updateOneway_   = false;
   notify_         = true;
   maxEntries_     = -10;
   consumable_     = false;
   timeout_        = 0;
}

void QueryQosData::copy(const QueryQosData& data) 
{
   QosData::copy(data);
   subscriptionId_ = data.subscriptionId_;
   forceDestroy_   = data.forceDestroy_;
   meta_           = data.meta_;
   content_        = data.content_;
   multiSubscribe_ = data.multiSubscribe_;
   local_          = data.local_;
   initialUpdate_  = data.initialUpdate_;
   updateOneway_   = data.updateOneway_;
   notify_         = data.notify_;
   maxEntries_     = data.maxEntries_;
   consumable_     = data.consumable_;
   timeout_        = data.timeout_;
}


QueryQosData::QueryQosData(Global& global)
   : QosData(global),
      forceDestroy_(false),
      meta_(true), 
      content_(true),
      multiSubscribe_(true),
      local_(true),
      initialUpdate_(true),
      updateOneway_(false),
      notify_(true),
      filters_(),
      historyQos_(global), 
      maxEntries_(-10),
      consumable_(false),
      timeout_(0L)
{
   ME = "QueryQosData";
}


void QueryQosData::setWantInitialUpdate(bool initialUpdate)
{
   initialUpdate_ = initialUpdate;
}

bool QueryQosData::getWantInitialUpdate() const
{
   return initialUpdate_;
}

void QueryQosData::setWantUpdateOneway(bool updateOneway)
{
   updateOneway_ = updateOneway;
}

bool QueryQosData::getWantUpdateOneway() const
{
   return updateOneway_;
}

void QueryQosData::setWantNotify(bool notify)
{
   notify_ = notify;
}

bool QueryQosData::getWantNotify() const
{
   return notify_;
}

void QueryQosData::setMultiSubscribe(bool multiSubscribe)
{
   multiSubscribe_ = multiSubscribe;
}

bool QueryQosData::getMultiSubscribe() const
{
   return multiSubscribe_;
}

void QueryQosData::setWantLocal(bool local)
{
   local_ = local;
}

bool QueryQosData::getWantLocal() const
{
   return local_;
}

void QueryQosData::setWantMeta(bool meta)
{
   meta_ = meta;
}

bool QueryQosData::getWantMeta() const
{
   return meta_;
}

void QueryQosData::setWantContent(bool content)
{
   content_ = content;
}

bool QueryQosData::getWantContent() const
{
   return content_;
}

void QueryQosData::setForceDestroy(bool forceDestroy)
{
   forceDestroy_ = forceDestroy;
}

bool QueryQosData::getForceDestroy() const
{
   return forceDestroy_;
}

void QueryQosData::addAccessFilter(const AccessFilterQos& filter)
{
   filters_.insert(filters_.begin(), filter);
}

AccessFilterVector QueryQosData::getAccessFilters() const
{
   return filters_;
}


void QueryQosData::setHistoryQos(const HistoryQos& historyQos)
{
   historyQos_ = historyQos;
}

HistoryQos QueryQosData::getHistoryQos() const
{
   return historyQos_;
}

void QueryQosData::setQueryQos(int maxEntries, long timeout, bool consumable) {
    maxEntries_ = maxEntries;
    timeout_ = timeout;
    consumable_ = consumable;
}

string QueryQosData::getSubscriptionId() const
{
   return subscriptionId_;
}

void QueryQosData::setSubscriptionId(const string& subscriptionId)
{
   subscriptionId_ = subscriptionId;
}


string QueryQosData::toXml(const string& extraOffset) const
{
   string ret;
   string offset = Constants::OFFSET + extraOffset;

   ret += offset + "<qos>"; // <!-- SubscribeRetQos -->");
   if (!subscriptionId_.empty())
      ret += offset + " <subscribe id='" + subscriptionId_ + "'/>";
   ret += offset + " <erase forceDestroy='" + Global::getBoolAsString(forceDestroy_) + "'/>";

   if (!meta_) ret += offset + " <meta>false</meta>";
   if (!content_) ret += offset + " <content>false</content>";
   if (!multiSubscribe_) ret += offset + " <multiSubscribe>false</multiSubscribe>";
   if (!local_) ret += offset + " <local>false</local>";
   if (!initialUpdate_) ret += offset + " <initialUpdate>false</initialUpdate>";
   if (updateOneway_) ret += offset + " <updateOneway/>";
   if (!notify_) ret += offset + " <notify>false</notify>";
   if (isPersistent())
      ret += offset + " <persistent/>";

   AccessFilterVector::const_iterator iter = filters_.begin();
   while (iter != filters_.end()) {
      ret += (*iter).toXml(extraOffset + Constants::INDENT);
      iter++;
   }
   
   if (maxEntries_ != -10) {
      ret += offset + 
             "<querySpec type='QueueQuery'>" +
                   "maxEntries="+
                   lexical_cast<std::string>(maxEntries_)+
                   "&amp;maxSize=-1&amp;consumable="+
                   lexical_cast<std::string>(consumable_)+
                   "&amp;waitingDelay="+
                   lexical_cast<std::string>(timeout_)+
             "</querySpec>";
   }
   
   ret += historyQos_.toXml(extraOffset + Constants::INDENT);
        bool clearText = false;
   ret += dumpClientProperties(extraOffset + Constants::INDENT, clearText);
   ret += offset + "</qos>";

   if (ret.length() < 16)
      return "<qos/>";  // minimal footprint

   return ret;
}

QueryQosData* QueryQosData::getClone() const
{
   return new QueryQosData(*this);
}

}}}} // namespace