TLDAPEntry.cxx

Go to the documentation of this file.

// @(#)root/ldap:$Id$
// Author: Evgenia Smirnova   21/09/2001

/*************************************************************************
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/

#include "TLDAPEntry.h"
#include "TLDAPAttribute.h"
#include "Riostream.h"


ClassImp(TLDAPEntry);

////////////////////////////////////////////////////////////////////////////////
/// Creates the new TLDAPEntry object with the specified DN (distinguished
/// name) and the empty list of attributes.
/// const char *dn: The DN of the entry. You can change it later by calling
///                 the SetDn() member function

TLDAPEntry::TLDAPEntry(const char *dn) : fNCount(0)
{
   SetDn(dn);
   fAttr = new TList;
   fAttr->SetOwner();
}

////////////////////////////////////////////////////////////////////////////////
/// Copy ctor.

TLDAPEntry::TLDAPEntry(const TLDAPEntry &e) : TObject(e), fNCount(e.fNCount)
{
   SetDn(e.GetDn());
   fAttr = new TList;
   fAttr->SetOwner();

   TIter next(e.fAttr);
   while (TLDAPAttribute *att = (TLDAPAttribute *)next()) {
      fAttr->AddLast(new TLDAPAttribute(*att));
   }
}

////////////////////////////////////////////////////////////////////////////////
/// Equal operator

TLDAPEntry& TLDAPEntry::operator=(const TLDAPEntry& lde)
{
   if(this!=&lde) {
      TObject::operator=(lde);
      fDn=lde.fDn;
      fAttr=lde.fAttr;
      fNCount=lde.fNCount;
   } return *this;
}

////////////////////////////////////////////////////////////////////////////////
/// Deletes all the attributes of the entry.

TLDAPEntry::~TLDAPEntry()
{
   delete fAttr;
}

////////////////////////////////////////////////////////////////////////////////
/// Add an attribute to the entry.
/// TLDAPAtrribute attr: attribute to be added.

void TLDAPEntry::AddAttribute(const TLDAPAttribute &attr)
{
   fAttr->AddLast(new TLDAPAttribute(attr));
}

////////////////////////////////////////////////////////////////////////////////
/// Print entry in LDIF format.

void TLDAPEntry::Print(Option_t *) const
{
   std::cout << "dn: "<< fDn << std::endl;
   TLDAPAttribute *attr = GetAttribute("objectClass");
   if (attr != 0)
      attr->Print();
   Int_t n = GetCount();
   for (Int_t i = 0; i < n; i++) {
      attr = (TLDAPAttribute*) fAttr->At(i);
      if (TString(attr->GetName()).CompareTo("objectClass", TString::kIgnoreCase) != 0)
         attr->Print();
   }
   std::cout << std::endl;
}

////////////////////////////////////////////////////////////////////////////////
/// Get next attribute of the entry. Returns zero after the last attribute,
/// then returns the first attribute again.

TLDAPAttribute *TLDAPEntry::GetAttribute() const
{
   Int_t n = GetCount();
   if (n > fNCount) {
      return (TLDAPAttribute*)fAttr->At(fNCount++);
   } else {
      fNCount = 0;
      return 0;
   }
}

////////////////////////////////////////////////////////////////////////////////
/// Get attribute by name.
/// Doesn't affect the order of attributes to be returned from the
/// next GetAttribute() call. Attribute name is case insensitive.

TLDAPAttribute *TLDAPEntry::GetAttribute(const char *name) const
{
   Int_t n = GetCount();
   for (Int_t i = 0; i < n; i++) {
      if (TString(((TLDAPAttribute*)fAttr->At(i))->GetName()).CompareTo(name, TString::kIgnoreCase) == 0) {
         return (TLDAPAttribute*)fAttr->At(i);
      }
   }
   return 0;
}

////////////////////////////////////////////////////////////////////////////////
/// Delete attribute by name.
/// Attribute name is case insensitive.

void TLDAPEntry::DeleteAttribute(const char *name)
{
   Int_t n = GetCount();
   for (Int_t i = 0; i < n; i++) {
      if (TString(((TLDAPAttribute*)fAttr->At(i))->GetName()).CompareTo(name, TString::kIgnoreCase) == 0) {
         delete fAttr->Remove(fAttr->At(i));
         if (fNCount > i) fNCount--;
         return;
      }
   }
}

////////////////////////////////////////////////////////////////////////////////
/// Check if entry is referal.

Bool_t TLDAPEntry::IsReferral() const
{
   Bool_t att = kFALSE;
   Bool_t obj = kFALSE;
   Int_t n = GetCount();
   TString name;
   for (Int_t i = 0; (i < n) && (!att || !obj); i++) {
      name = TString(((TLDAPAttribute*) fAttr->At(i))->GetName());
      if (name.CompareTo("ref", TString::kIgnoreCase) == 0) {
         att = kTRUE;
      } else {
         if (name.CompareTo("objectclass", TString::kIgnoreCase) == 0) {
            TLDAPAttribute *attr = (TLDAPAttribute*)fAttr->At(i);
            Int_t valcnt = attr->GetCount() + 1;
            for (Int_t j = 0; (j < valcnt) && (!obj); j++)
               obj |= (Bool_t)TString(attr->GetValue()).CompareTo("referral", TString::kIgnoreCase);
         }
      }
   }
   return (att && obj);
}

////////////////////////////////////////////////////////////////////////////////
/// Get the TList of referrals.
/// Returns an empty list if entry is not referral.
/// User is responsible for deleting returned TList.

TList *TLDAPEntry::GetReferrals() const
{
   TList *list = new TList;
   TLDAPAttribute *ref = GetAttribute("ref");
   if (ref != 0) {
      Int_t n = ref->GetCount();
      for (Int_t i = 0; i < n; i++) {
         list->Add(ref->fValues->At(i));
      }
   }
   return list;
}

////////////////////////////////////////////////////////////////////////////////
/// Get array of "LDAPMod" structures for entry.

LDAPMod **TLDAPEntry::GetMods(Int_t op)
{
   Int_t n = GetCount();
   LDAPMod **mods = new LDAPMod* [n + 1];
   for (Int_t i = 0; i < n; i++)
      mods[i] = ((TLDAPAttribute*)(fAttr->At(i)))->GetMod(op);
   mods[n] = 0;
   return mods;
}