Response.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_ldap_Response_hpp
#define anna_ldap_Response_hpp

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

#include <anna/ldap/defines.hpp>
#include <anna/ldap/ClassCode.hpp>
#include <anna/ldap/ResultCode.hpp>

namespace anna {

namespace ldap {

class Session;
class Attribute;
class Timer;
class Request;

class Response {
public:
  typedef Recycler<Attribute> attribute_container;
  typedef attribute_container::iterator attribute_iterator;
  typedef attribute_container::const_iterator const_attribute_iterator;

  typedef Recycler<std::string> referral_container;
  typedef referral_container::const_iterator const_referral_iterator;

  ClassCode::_v getClassCode() const { return a_classCode; }

  IdMessage getIdMessage() const { return a_idMessage; }

  const Session* getSession() const { return a_session; }

  const ResultCode& getResultCode() const { return a_resultCode; }

  const std::string& getName() const { return a_name; }

  const Request* getRequest()const  { return a_request; }

  Session* getSession() { return a_session; }

  int attribute_size() const { return a_attributes.size(); }

  const_attribute_iterator attribute_begin() const { return a_attributes.begin(); }

  const_attribute_iterator attribute_end() const { return a_attributes.end(); }

  int referral_size() const { return a_referrals.size(); }

  const_referral_iterator referral_begin() const { return a_referrals.begin(); }

  const_referral_iterator referral_end() const { return a_referrals.end(); }

  static const Attribute* attribute(const_attribute_iterator ii) { return attribute_container::data(ii); }

  static const std::string& referral(const_referral_iterator ii) { return *referral_container::data(ii); }

  std::string asString() const ;

private:
  ClassCode::_v a_classCode;
  IdMessage a_idMessage;
  Session* a_session;
  ResultCode a_resultCode;
  std::string a_name;
  attribute_container a_attributes;
  referral_container a_referrals;
  Timer* a_timer;
  const Request* a_request;

  typedef Recycler<Response> response_pool;
  static response_pool st_responses;

  Response();

  static Response* instance(const ClassCode::_v, const IdMessage) noexcept(false);
  static void release(Response* response) ;

  void clear() ;

  void setName(const std::string& name) { a_name = name; }
  void setSession(Session* session) { a_session = session; }
  void setRequest(const Request* request) { a_request = request; }
  void activateTimer() noexcept(false);
  void cancelTimer() ;
  void setResultCode(const ResultCode& resultCode) { a_resultCode = resultCode; }

  Attribute* createAttribute(const std::string& name) noexcept(false);

  void createReferral(const char* value) noexcept(false) {
    std::string* newReferral = a_referrals.create();
    *newReferral = value;
  }


  attribute_iterator attribute_begin() { return a_attributes.begin(); }
  attribute_iterator attribute_end() { return a_attributes.end(); }
  static Attribute* attribute(attribute_iterator ii) { return attribute_container::data(ii); }

  friend class Session;
  friend class Allocator<Response>;
};

}
}

#endif