JROOT::JRootComparator Class Reference

ROOT comparator. More...

#include <JRootComparator.hh>

Inheritance diagram for JROOT::JRootComparator:

Public Member Functions
	JRootComparator ()
	Default constructor.
template<class T >
bool	operator() (const T &first, const T &second) const
	Compare objects.
template<class T >
void	operator() (const JType< T > &type)
	Addition of class.

Public Attributes
int	debug = 0
	debug level

Protected Member Functions
bool	compare (const JRootWritableClass &first, const JRootWritableClass &second) const
	Compare objects.

Detailed Description

ROOT comparator.

Definition at line 80 of file JRootComparator.hh.

Constructor & Destructor Documentation

JRootComparator()

JROOT::JRootComparator::JRootComparator ( )

inline

Default constructor.

Definition at line 87 of file JRootComparator.hh.

    {
      using namespace JPP;
      
      for_each<JRemove<JPrimitiveTypes_t, long double>::typelist>(*this);
 
      (*this)(JType<std::string>());
      (*this)(JType<std::size_t>());
 
#define VALUE_TYPE(__TYPE__) value_type(#__TYPE__, new JObjectComparator<__TYPE__>())
 
      this->insert(VALUE_TYPE(Char_t));
      this->insert(VALUE_TYPE(UChar_t));
      this->insert(VALUE_TYPE(Short_t));
      this->insert(VALUE_TYPE(UShort_t));
      this->insert(VALUE_TYPE(Int_t));
      this->insert(VALUE_TYPE(UInt_t));
      this->insert(VALUE_TYPE(Long_t));
      this->insert(VALUE_TYPE(ULong_t));
      this->insert(VALUE_TYPE(Long64_t));
      this->insert(VALUE_TYPE(ULong64_t));
      this->insert(VALUE_TYPE(Float_t));
      this->insert(VALUE_TYPE(Double_t));
      this->insert(VALUE_TYPE(TString));
 
#undef VALUE_TYPE
    }

Member Function Documentation

operator()() [1/2]

template<class T >

bool JROOT::JRootComparator::operator() ( const T & first, const T & second ) const

inline

Compare objects.

Parameters

first	first object
second	second object

Returns

true if objects are equal; else false

Definition at line 124 of file JRootComparator.hh.

    {
      using namespace std;
 
      DEBUG("compare: " << JRootWritableClass(first).getTypename() << ' ' << JRootWritableClass(second).getTypename() << endl << endl);
 
      return this->compare(JRootWritableClass(first), JRootWritableClass(second));
    }

operator()() [2/2]

template<class T >

void JROOT::JRootComparator::operator() ( const JType< T > & type )

inline

Addition of class.

Parameters

type

data type

Definition at line 140 of file JRootComparator.hh.

    {
      this->insert(value_type(JRoot::getTypename<T>(), new JObjectComparator<T>()));
    }

compare()

bool JROOT::JRootComparator::compare ( const JRootWritableClass & first, const JRootWritableClass & second ) const

inlineprotected

Compare objects.

Parameters

first	first object
second	second object

Returns

true if objects are equal; else false

Definition at line 156 of file JRootComparator.hh.

    {     
      using namespace std;
 
      if (first .is_valid() &&
          second.is_valid()) {
 
        const_iterator i1 = this->find(first .getTypename());
        const_iterator i2 = this->find(second.getTypename());
 
        if (i1 != this->end() &&
            i2 != this->end() &&
            i1 == i2) {
 
          if (!i1->second->equals(first.getAddress(), second.getAddress())) {
            return false;
          }
 
        } else if (first .getClass() != NULL &&
                   second.getClass() != NULL) {
 
          if (first .getClass()->GetCollectionType() != ROOT::ESTLType::kNotSTL && first .getClass()->GetCollectionProxy() != NULL &&
              second.getClass()->GetCollectionType() != ROOT::ESTLType::kNotSTL && second.getClass()->GetCollectionProxy() != NULL) {
 
            std::unique_ptr<TVirtualCollectionProxy> p1(first .getClass()->GetCollectionProxy()->Generate());
            std::unique_ptr<TVirtualCollectionProxy> p2(second.getClass()->GetCollectionProxy()->Generate());
 
            p1->PushProxy(const_cast<char*>(first .getAddress()));
            p2->PushProxy(const_cast<char*>(second.getAddress()));
 
            TDictionary* d1 = TDictionary::GetDictionary(p1->GetType() == EDataType::kNoType_t ? p1->GetValueClass()->GetName() : TDataType::GetTypeName(p1->GetType()));
            TDictionary* d2 = TDictionary::GetDictionary(p2->GetType() == EDataType::kNoType_t ? p2->GetValueClass()->GetName() : TDataType::GetTypeName(p2->GetType()));
 
            DEBUG("proxy:  " << p1->GetCollectionClass()->GetName() << " " << d1->GetName() << "(" << p1->Size() << ");" << endl);
            DEBUG("proxy:  " << p2->GetCollectionClass()->GetName() << " " << d2->GetName() << "(" << p2->Size() << ");" << endl);
 
            if (p1->Size() != p2->Size()) {
              return false;
            }
 
            for (UInt_t i = 0; (i != p1->Size() &&
                                i != p2->Size()); ++i) {
 
              DEBUG("index:  " << d1->GetName() << "[" << i << "] " << endl);
              //DEBUG("index:  " << d2->GetName() << "[" << i << "] " << endl);
 
              const JRootWritableClass w1(d1, (char*) p1->At(i));
              const JRootWritableClass w2(d2, (char*) p2->At(i));
 
              if (!this->compare(w1, w2)) {
                return false;
              }
            }
 
          } else {
 
            if (first .getClass()->GetListOfBases() != NULL &&
                second.getClass()->GetListOfBases() != NULL) {
 
              std::unique_ptr<TIterator> i1(first .getClass()->GetListOfBases()->MakeIterator());
              std::unique_ptr<TIterator> i2(second.getClass()->GetListOfBases()->MakeIterator());
 
              for (const TBaseClass *p1, *p2; ((p1 = (const TBaseClass*) i1->Next()) != NULL &&
                                               (p2 = (const TBaseClass*) i2->Next()) != NULL); ) {
 
                if (JRoot::is_class(p1->GetName()) &&
                    JRoot::is_class(p2->GetName())) {
 
                  DEBUG("base:   " << p1->GetName() << endl);
                  //DEBUG("base:   " << p2->GetName() << endl);
 
                  if (!this->compare(first.get(*p1), second.get(*p2))) {
                    return false;
                  }
                }
              }
            }
 
            if (first .getClass()->GetListOfDataMembers() != NULL &&
                second.getClass()->GetListOfDataMembers() != NULL) {
 
              std::unique_ptr<TIterator> i1(first .getClass()->GetListOfDataMembers()->MakeIterator());
              std::unique_ptr<TIterator> i2(second.getClass()->GetListOfDataMembers()->MakeIterator());
 
              for (const TDataMember *p1, *p2; ((p1 = (const TDataMember*) i1->Next()) != NULL &&
                                                (p2 = (const TDataMember*) i2->Next()) != NULL); ) {
 
 
                if (JRoot::is_class(p1->GetName()) &&
                    JRoot::is_class(p2->GetName())) {
 
                  DEBUG("member: " << p1->GetTrueTypeName() << " " << p1->GetName() << ";" << endl);
                  //DEBUG("member: " << p2->GetTrueTypeName() << " " << p2->GetName() << ";" << endl);
 
                  if (!this->compare(first.get(*p1), second.get(*p2))) {
                    return false;
                  }
                }
              }
            }
          }
        }
      }
 
      return true;
    }

Member Data Documentation

debug

int JROOT::JRootComparator::debug = 0

debug level

Definition at line 146 of file JRootComparator.hh.

---

The documentation for this class was generated from the following file:

• JRootComparator.hh