Search.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_Search_hpp
#define anna_ldap_Search_hpp

#include <vector>

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

#include <anna/ldap/defines.hpp>
#include <anna/ldap/Request.hpp>
#include <anna/ldap/Scope.hpp>

namespace anna {

namespace ldap {

class Session;

class Search : public Request {
  typedef Recycler<std::string> attribute_pool;
  typedef std::vector<std::string*> attribute_container;
  typedef attribute_container::iterator attribute_iterator;

public:
  typedef attribute_container::const_iterator const_attribute_iterator;

  Search(const Request::OnExpiry::_v onExpiry = Request::OnExpiry::Abandon) : Request(ClassCode::Search, onExpiry) { clear(); }

  const std::string& getBase() const { return a_base; }

  Scope::_v getScope() const { return a_scope; }

  const std::string& getFilter() const { return a_filter; }

  bool getOnlyType() const { return a_onlyType; }

  int getSizeLimit() const { return a_sizeLimit; }

  void setBase(const std::string& base) { a_base = base; }

  void setScope(const Scope::_v scope) { a_scope = scope; }

  void setScope(const char* scope) noexcept(false) { a_scope = Scope::asEnumEx(scope); }

  void setFilter(const std::string& filter) { a_filter = filter; }

  void setOnlyType(const bool onlyType) { a_onlyType = onlyType; }

  void setSizeLimit(const int sizeLimit) { a_sizeLimit = sizeLimit; }

  void clearFilter() { a_filter.clear(); }

  void clearSizeLimit() { a_sizeLimit = 0; }

  void clearAttributes() ;

  void addAttribute(const std::string& attribute) {
    std::string* newString = st_attributes.create();
    *newString = attribute;
    a_attributes.push_back(newString);
  }

  void clear() ;

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

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

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

  static const std::string& attribute(const_attribute_iterator ii) { return **ii; }

  virtual std::string asString() const ;

  virtual xml::Node* asXML(xml::Node* parent) const ;

private:
  std::string a_base;
  Scope::_v a_scope;
  std::string a_filter;
  bool a_onlyType;
  int a_sizeLimit;
  attribute_container a_attributes;

  static attribute_pool st_attributes;

  attribute_iterator attribute_begin() { return a_attributes.begin(); }
  attribute_iterator attribute_end() { return a_attributes.end(); }
  int attribute_size() { return a_attributes.size(); }
  static std::string& attribute(attribute_iterator ii) { return **ii; }

  IdMessage send(Session&) const ;
};

}
}

#endif