util/qos/ClientProperty.h

Go to the documentation of this file.

/*------------------------------------------------------------------------------
Name:      ClientProperty.h
Project:   xmlBlaster.org
Copyright: xmlBlaster.org, see xmlBlaster-LICENSE file
Comment:   Handling one client property of QosData
------------------------------------------------------------------------------*/
#ifndef _UTIL_QOS_CLIENTPROPERTY_H
#define _UTIL_QOS_CLIENTPROPERTY_H

#include <util/xmlBlasterDef.h>
#include <util/Constants.h>
#include <util/Base64.h>
#include <util/lexical_cast.h>
#include <typeinfo>
#include <vector>
#include <string>
#include <iostream> // temporary for cerr

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

class Dll_Export ClientProperty
{
private:
   std::string name_;  // Can't be const because of: operator=() error: non-static const member `const std::string name_', can't use default assignment operator
   std::string value_;
   std::string encoding_;
   mutable std::string type_;
   mutable std::string charset_;

   template <typename T_VALUE> void guessType(const T_VALUE& value) const;
   bool needsEncoding() const;

public:

   template <typename T_VALUE> ClientProperty(
                  const std::string& name,
                  const T_VALUE& value,
                  const std::string& type="",
                  const std::string& encoding="",
                  const std::string& charset=""
                  );

   ClientProperty(bool dummy,
                  const std::string& name,
                  const std::string& type,
                  const std::string& encoding,
                  const std::string& charset
                  );

   ClientProperty(const std::string& name,
                  const char *value,
                  const std::string& type="");

   ClientProperty(const std::string& name,
                  const std::vector<unsigned char>& value,
                  const std::string& type="");

   //virtual ~ClientProperty();

   const std::string& getName() const;

   std::string getType() const;

   std::string getEncoding() const;

   std::string getCharset() const;

   void setCharset(const std::string& charset);

   bool isBase64() const;

   std::string getValueRaw() const;
   
   std::string getStringValue() const;
   
   std::vector<unsigned char> getValue() const;
   
   template <typename T_VALUE> void getValue(T_VALUE& value) const;
   
   void setValue(const std::string& value);

   void setValueRaw(const std::string& value);

   std::string toXml(std::string extraOffset="", bool clearText=false, std::string tagName="clientProperty") const;
};


// All template based function definitions follow here
// to be available outside the shared library
template <typename T_VALUE> ClientProperty::ClientProperty(
                     const std::string& name,
                     const T_VALUE& value,
                     const std::string& type,
                     const std::string& encoding,
                     const std::string& charset
                     )
   : name_(name),
     value_(""),
     encoding_(encoding),
     type_(type),
     charset_(charset)
{
   if (type_ == "") {
      guessType(value);  // guess type from T_VALUE
   }

   // Convert the given value type to a std::string value_
   
   value_ = lexical_cast<std::string>(value);

   if (needsEncoding()) {
      std::vector<unsigned char> vec;
      vec.reserve(value_.size());
      encoding_ = org::xmlBlaster::util::Constants::ENCODING_BASE64;
      copy(value_.begin(), value_.end(), back_inserter(vec));
      value_ = org::xmlBlaster::util::Base64::Encode(vec);
   }
}

template <typename T_VALUE> void ClientProperty::guessType(const T_VALUE& value) const {
   const char *cPC=0;
   char *cP=0;
   unsigned char *cUP=0;
   const unsigned char *cUPC=0;
   int64_t ll=0L; // Assumed to be 'long long int' (C99) == _int64 (Windows), Windows does not like double LL like 0LL;
   std::vector<char> vc;
   std::vector<unsigned char> vuc;

   if (typeid(value) == typeid(std::string("")))
      type_ = std::string(""); // "String"
   else if (typeid(value) == typeid(true))
      type_ = org::xmlBlaster::util::Constants::TYPE_BOOLEAN;
   else if (typeid(value) == typeid(char(0)))
      type_ = org::xmlBlaster::util::Constants::TYPE_BYTE;
   else if (typeid(value) == typeid(cP) || typeid(value) == typeid(cPC) ||
            typeid(value) == typeid("A") || typeid(value).name() == std::string("A13_c"))
      type_ = std::string(""); // "String"
   else if (typeid(value) == typeid(cUP) || typeid(value) == typeid(cUPC))
      type_ = org::xmlBlaster::util::Constants::TYPE_BLOB;
   else if (typeid(value) == typeid(vc) || typeid(value) == typeid(vuc))
      type_ = org::xmlBlaster::util::Constants::TYPE_BLOB;
   else if (typeid(value) == typeid(short(0)))
      type_ = org::xmlBlaster::util::Constants::TYPE_SHORT;
   else if (typeid(value) == typeid(int(0)))
      type_ = org::xmlBlaster::util::Constants::TYPE_INT;
   else if (typeid(value) == typeid(long(0L)))
      type_ = org::xmlBlaster::util::Constants::TYPE_LONG;
   else if (typeid(value) == typeid(ll))
      type_ = org::xmlBlaster::util::Constants::TYPE_LONG;
   else if (typeid(value) == typeid(float(1.10)))
      type_ = org::xmlBlaster::util::Constants::TYPE_FLOAT;
   else if (typeid(value) == typeid(double(1.7L)))
      type_ = org::xmlBlaster::util::Constants::TYPE_DOUBLE;
   else {
      type_ = org::xmlBlaster::util::Constants::TYPE_BLOB;
      std::cerr << "Warning: ClientProperty typeid=" << typeid(value).name() << " is unknown, we handle it as a blob" << std::endl;
   }
}

template <typename T_VALUE> void ClientProperty::getValue(T_VALUE& value) const {
   if (isBase64()) {
      if (type_ == org::xmlBlaster::util::Constants::TYPE_BLOB) {
         // TODO: detect it on compile time
         std::cerr << "Sorry, binary data type '" << typeid(value).name()
                   << "' is not supported using getValue(value), please use 'std::vector<unsigned char> getValue()' instead"
                   << std::endl;
         value = lexical_cast<T_VALUE>(getStringValue());
      }
      else {
         value = lexical_cast<T_VALUE>(getStringValue());
      }
   }
   else {
      value = lexical_cast<T_VALUE>(value_);
   }
}

}}}}

#endif