JRootComparator.hh

Go to the documentation of this file.

#ifndef __JROOT_COMPARATOR__
#define __JROOT_COMPARATOR__
 
#include <string>
#include <memory>
#include <map>
 
#include "TString.h"
#include "TDictionary.h"
#include "TVirtualCollectionProxy.h"
#include "TBaseClass.h"
#include "TDataMember.h"
 
#include "JLang/JTypeList.hh"
#include "JLang/JPrimitiveTypes.hh"
 
#include "JROOT/JRootClass.hh"
 
#include "Jeep/JMessage.hh"
 
 
namespace JROOT {}
namespace JPP { using namespace JROOT; }
 
namespace JROOT {
 
  using JLANG::JType;
 
 
  /**
   * Interface for comparison of a template class.
   */
  class JAbstractComparator {
  public:
    /**
     * Virtual destructor.
     */
    virtual ~JAbstractComparator()
    {}
 
    
    /**
     * Compare objects.
     *
     * \param  first         pointer to first  object
     * \param  second        pointer to second object
     * \return               true if objects are equal; else false
     */
    virtual bool equals(const void* first, const void* second) const = 0;
  };
  
 
  /**
   * Implementation for comparison of a template class.
   *
   * This class implements the JROOT::JAstractComparator interface for the given template class using the operator <tt>==</tt>.
   */
  template<class T>
  class JObjectComparator :
    public JAbstractComparator
  {
  public:
    /**
     * Compare objects.
     *
     * \param  first         pointer to first  object
     * \param  second        pointer to second object
     * \return               true if objects are equal; else false
     */
    virtual bool equals(const void* first, const void* second) const override
    {
      return (* ((const T*) first) == * ((const T*) second));
    }
  };
 
 
  /**
   * ROOT comparator.
   */
  class JRootComparator :
    public std::map<std::string, std::shared_ptr<JAbstractComparator> >
  {
  public:
    /**
     * Default constructor.
     */
    JRootComparator()
    {
      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
    }
 
 
    /**
     * Compare objects.
     *
     * \param  first         first  object
     * \param  second        second object
     * \return               true if objects are equal; else false
     */
    template<class T>
    bool operator()(const T& first, const T& second) const
    {
      using namespace std;
 
      DEBUG("compare: " << JRootWritableClass(first).getTypename() << ' ' << JRootWritableClass(second).getTypename() << endl << endl);
 
      return this->compare(JRootWritableClass(first), JRootWritableClass(second));
    }
 
 
    /**
     * Addition of class.
     *
     * \param  type          data type
     */
    template<class T>
    void operator()(const JType<T>& type)
    {
      this->insert(value_type(JRoot::getTypename<T>(), new JObjectComparator<T>()));
    }
 
 
    int debug = 0;                      //!< debug level
    
  protected:
    /**
     * Compare objects.
     *
     * \param  first         first  object
     * \param  second        second object
     * \return               true if objects are equal; else false
     */
    bool compare(const JRootWritableClass& first, const JRootWritableClass& second) const
    {     
      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;
    }
  };
}
  
#endif