include/anna/ldap/Search.hpp

   1 // ANNA - Anna is Not Nothingness Anymore                                                         //
   2 //                                                                                                //
   3 // (c) Copyright 2005-2015 Eduardo Ramos Testillano & Francisco Ruiz Rayo                         //
   4 //                                                                                                //
   5 // See project site at http://redmine.teslayout.com/projects/anna-suite                           //
   6 // See accompanying file LICENSE or copy at http://www.teslayout.com/projects/public/anna.LICENSE //
   7
   8
   9 #ifndef anna_ldap_Search_hpp
  10 #define anna_ldap_Search_hpp
  11
  12 #include <vector>
  13
  14 #include <anna/core/util/Recycler.hpp>
  15
  16 #include <anna/ldap/defines.hpp>
  17 #include <anna/ldap/Request.hpp>
  18 #include <anna/ldap/Scope.hpp>
  19
  20 namespace anna {
  21
  22 namespace ldap {
  23
  24 class Session;
  25
  26 /**
  27    Modela las peticiones de busqueda realizadas contra un servidor LDAP.
  28 */
  29 class Search : public Request {
  30   typedef Recycler<std::string> attribute_pool;
  31   typedef std::vector<std::string*> attribute_container;
  32   typedef attribute_container::iterator attribute_iterator;
  33
  34 public:
  35   typedef attribute_container::const_iterator const_attribute_iterator;
  36
  37   /**
  38      Constructor.
  39      \param onExpiry Indica la acción a realizar si el temporizador de esta transación expira.
  40   */
  41   Search(const Request::OnExpiry::_v onExpiry = Request::OnExpiry::Abandon) : Request(ClassCode::Search, onExpiry) { clear(); }
  42
  43   /**
  44      Devuelve el DN de la entrada en la que se comienza la busqueda.
  45      \return El DN de la entrada en la que se comienza la busqueda.
  46   */
  47   const std::string& getBase() const { return a_base; }
  48
  49   /**
  50      Devuelve el ambito de la busqueda.
  51      \return El ambito de la busqueda.
  52   */
  53   Scope::_v getScope() const { return a_scope; }
  54
  55   /**
  56      Devuelve el filtro aplicado a la busqueda.
  57      \return El filtro aplicado a la busqueda.
  58   */
  59   const std::string& getFilter() const { return a_filter; }
  60
  61   /**
  62      Devuelve el indicador de tratamiento de busquedas.
  63      \return El indicador de tratamiento de busquedas.
  64   */
  65   bool getOnlyType() const { return a_onlyType; }
  66
  67   /**
  68      Devuelve el numero maximo de elementos devueltos como resultado de la consulta.
  69      \return El numero maximo de elementos devueltos como resultado de la consulta.
  70      \see clearSizeLimit.
  71   */
  72   int getSizeLimit() const { return a_sizeLimit; }
  73
  74   /**
  75      Establece el DN de la entrada en la que comenzar la busqueda.
  76      \param base DN de la entrada en la que comenzar la busqueda.
  77   */
  78   void setBase(const std::string& base) { a_base = base; }
  79
  80   /**
  81      Establece el ambito de la busqueda.
  82      \param scope Ambito de la busqueda.
  83   */
  84   void setScope(const Scope::_v scope) { a_scope = scope; }
  85
  86   /**
  87      Establece el ambito de la busqueda.
  88      \param scope Texto que identifica el ambito de la busqueda. Si no se trata de un texto
  89      reconocido se devolvera una excepcion.
  90   */
  91   void setScope(const char* scope) noexcept(false) { a_scope = Scope::asEnumEx(scope); }
  92
  93   /**
  94      Establece el filtro aplicado a la busqueda.
  95      \param filter Filtro aplicado a la busqueda.
  96      \see clearFilter
  97   */
  98   void setFilter(const std::string& filter) { a_filter = filter; }
  99
 100   /**
 101      Determina como se van a tratar los atributos.
 102      \param onlyType Un valor \em true indica que solo se requieren los tipos de atributos, un valor
 103      \em false indica que se requieren tipos y valores asociados a los atributos.
 104   */
 105   void setOnlyType(const bool onlyType) { a_onlyType = onlyType; }
 106
 107   /**
 108      Establece el numero maximo de elementos devueltos como resultado de la consulta.
 109      \param sizeLimit Numero de entradas retornadas por la busqueda.
 110      \see clearSizeLimit.
 111   */
 112   void setSizeLimit(const int sizeLimit) { a_sizeLimit = sizeLimit; }
 113
 114   /**
 115      Elimina el filtro asociado a esta consulta.
 116   */
 117   void clearFilter() { a_filter.clear(); }
 118
 119   /**
 120      Elimina el limite en cuanto al numero de elementos indicados en la consulta.
 121   */
 122   void clearSizeLimit() { a_sizeLimit = 0; }
 123
 124   /**
 125    * Elimina los atributos asociados a esta consulta.
 126    */
 127   void clearAttributes() ;
 128
 129   /**
 130      Incorpora un elemento a la lista de atributos que deseamos obtener de cada una de las entradas
 131      que cumplen el filtro establecido.
 132      Si esta lista esta vacia se devolvera la informacion de todos los atributos implicados.
 133   */
 134   void addAttribute(const std::string& attribute) {
 135     std::string* newString = st_attributes.create();
 136     *newString = attribute;
 137     a_attributes.push_back(newString);
 138   }
 139
 140   /**
 141      Inicializa el contenido de esta clase.
 142   */
 143   void clear() ;
 144
 145   /**
 146      Devuelve un iterador que apunta el primer atributo contenido en la consulta.
 147      \return un iterador que apunta el primer atributo contenido en la consulta.
 148   */
 149   const_attribute_iterator attribute_begin() const { return a_attributes.begin(); }
 150
 151   /**
 152      Devuelve un iterador que apunta el ultimo atributo contenido en la consulta.
 153      \return un iterador que apunta el ultimo atributo contenido en la consulta.
 154   */
 155   const_attribute_iterator attribute_end() const { return a_attributes.end(); }
 156
 157   /**
 158      Devuelve el numero de atributos contenidos en la consulta.
 159      \return El numero de atributos contenidos en la consulta.
 160   */
 161   int attribute_size() const { return a_attributes.size(); }
 162
 163   /**
 164      Devuelve el atributo apuntado por el iterador recibido.
 165      \param ii Iterador con el que estamos recorriendo los atributos.
 166      \return El atributo apuntado por el iterador recibido.
 167   */
 168   static const std::string& attribute(const_attribute_iterator ii) { return **ii; }
 169
 170   /**
 171      Devuelve una cadena con la informacion referente a este objeto.
 172      \return Una cadena con la informacion referente a este objeto.
 173   */
 174   virtual std::string asString() const ;
 175
 176   /**
 177      Devuelve un nodo XML con la informacion referente a este objeto.
 178      \param parent Nodo XML a partir del cual introducir la informacion.
 179      \return Un nodo XML con la informacion referente a este objeto.
 180   */
 181   virtual xml::Node* asXML(xml::Node* parent) const ;
 182
 183 private:
 184   std::string a_base;
 185   Scope::_v a_scope;
 186   std::string a_filter;
 187   bool a_onlyType;
 188   int a_sizeLimit;
 189   attribute_container a_attributes;
 190
 191   static attribute_pool st_attributes;
 192
 193   attribute_iterator attribute_begin() { return a_attributes.begin(); }
 194   attribute_iterator attribute_end() { return a_attributes.end(); }
 195   int attribute_size() { return a_attributes.size(); }
 196   static std::string& attribute(attribute_iterator ii) { return **ii; }
 197
 198   IdMessage send(Session&) const ;
 199 };
 200
 201 }
 202 }
 203
 204 #endif
 205