Abstract.hpp

Go to the documentation of this file.

// ANNA - Anna is Not Nothingness Anymore                                                         //
//                                                                                                //
// (c) Copyright 2005-2015 Eduardo Ramos Testillano & Francisco Ruiz Rayo                         //
//                                                                                                //
// See project site at http://redmine.teslayout.com/projects/anna-suite                           //
// See accompanying file LICENSE or copy at http://www.teslayout.com/projects/public/anna.LICENSE //


#ifndef anna_http_wims20_Abstract_hpp
#define anna_http_wims20_Abstract_hpp

#include <vector>

#include <anna/core/RuntimeException.hpp>
#include <anna/core/util/Recycler.hpp>

namespace anna {

namespace http {

namespace wims20 {

class Abstract {
public:
  typedef std::vector <std::string*> other_level_container;
  typedef other_level_container::iterator other_level_iterator;
  typedef other_level_container::const_iterator const_other_level_iterator;

  typedef std::pair <std::string*, std::string*> parameter_pkv;
  typedef std::vector <parameter_pkv> parameter_container;
  typedef parameter_container::iterator parameter_iterator;
  typedef parameter_container::const_iterator const_parameter_iterator;

  virtual ~Abstract();

  const std::string& getDomain() const { return a_domain; }

  const std::string* getPath() const { return a_path; }

  const std::string& getServiceID() const { return a_serviceID; }

  const std::string& getGUID() const { return a_guid; }

  void setServiceID(const std::string& serviceID) { a_serviceID = serviceID; a_fixedPart.clear(); }

  void setGUID(const std::string& guid) { a_guid = guid; a_fixedPart.clear(); }

  bool hasParameters() const { return a_parameters != NULL && a_parameters->empty() == false; }

  bool hasOtherLevels() const { return a_otherLevels != NULL && a_otherLevels->empty() == false; }

  virtual void clearOtherLevels() ;

  virtual void clearParameters() ;

  void clear() {
    clearOtherLevels();
    clearParameters();
  }

  std::string asString() const ;

  other_level_iterator other_level_begin() { return a_otherLevels->begin(); }

  other_level_iterator other_level_end() { return a_otherLevels->end(); }

  static std::string* otherLevel(other_level_iterator ii) { return *ii; }

  const_other_level_iterator other_level_begin() const { return a_otherLevels->begin(); }

  const_other_level_iterator other_level_end() const { return a_otherLevels->end(); }

  static const std::string& otherLevel(const_other_level_iterator ii) { return **ii; }

  const_parameter_iterator parameter_begin() const { return a_parameters->begin(); }

  const_parameter_iterator parameter_end() const { return a_parameters->end(); }

  static const std::string& parameter_name(const_parameter_iterator ii) { return *(ii->first); }

  static const std::string& parameter_value(const_parameter_iterator ii) { return *(ii->second); }

protected:
  other_level_container* a_otherLevels;
  parameter_container* a_parameters;

  Abstract(const char* whatis, const std::string& domain, const std::string& path);

  explicit Abstract(const char* whatis, const std::string& domain);

  const std::string& calculeFixedPart() noexcept(false);

  const std::string& calculeShortFixedPart() noexcept(false);

  std::string* createString() noexcept(false) { return a_string_pool.create(); }

  std::string* createString(const char* value) noexcept(false) {
    std::string* result = a_string_pool.create();
    *result = value;
    return result;
  }

  std::string* createString(const std::string& value) noexcept(false) { return createString(value.c_str()); }

  void destroyString(std::string* str) { a_string_pool.release(str); }

  void other_level_add(const std::string& otherLevel) noexcept(false);

  void parameter_set(const std::string& name, const std::string& value) noexcept(false);

  parameter_iterator parameter_begin() { return a_parameters->begin(); }

  parameter_iterator parameter_end() { return a_parameters->end(); }

  static std::string* parameter_name(parameter_iterator ii) { return ii->first; }

  static std::string* parameter_value(parameter_iterator ii) { return ii->second; }

  static void appendWithSlash(std::string& target, const std::string& other) ;

private:
  const std::string a_whatis;
  const std::string a_domain;
  std::string* a_path;
  std::string a_serviceID;
  std::string a_guid;
  Recycler <std::string> a_string_pool;
  std::string a_fixedPart;
};


}
}
}

#endif