Hash.h

Go to the documentation of this file.

#ifndef canvas_Persistency_Provenance_Hash_h
#define canvas_Persistency_Provenance_Hash_h

// ======================================================================
//
// Hash:
//
// Note: The call to 'fixup' in every member function is a temporary
// measure for backwards compatibility. It is necessary in every function
// because Root creates instances of the class *without* using the
// interface of the class, thus making it insufficient to assure that all
// constructors make corrected instances.
//
// ======================================================================

#include "canvas/Utilities/Exception.h"
#include "cetlib/MD5Digest.h"
#include "cetlib/container_algorithms.h"
#include <ostream>
#include <string>

// ----------------------------------------------------------------------

namespace art {

  namespace detail {
    // This string is the 16-byte, non-printable version.
    std::string const& InvalidHash();
  }

  template <int I>
  class Hash {
  public:
    typedef std::string value_type;

    Hash();
    explicit Hash(value_type const& v);

    Hash(Hash<I> const&);
    // We can't ref-qualify assignment because of GCC_XML
    Hash<I> const& operator=(Hash<I> const& iRHS);

    // For now, just check the most basic: a default constructed
    // ParameterSetID is not valid. This is very crude: we are
    // assuming that nobody created a ParameterSetID from an empty
    // string, nor from any string that is not a valid string
    // representation of an MD5 checksum.
    bool isValid() const;

    bool operator<(Hash<I> const& other) const;
    bool operator>(Hash<I> const& other) const;
    bool operator==(Hash<I> const& other) const;
    bool operator!=(Hash<I> const& other) const;
    std::ostream& print(std::ostream& os) const;
    void swap(Hash<I>& other);

    // Return the 16-byte (non-printable) string form.
    value_type compactForm() const;

    bool isCompactForm() const;

    // MUST UPDATE WHEN CLASS IS CHANGED!
    static short
    Class_Version()
    {
      return 10;
    }

  private:
    // Hexified version of data *must* contain a multiple of 2
    // bytes. If it does not, throw an exception.
    void throwIfIllFormed() const;

    // 'Fix' the string data member of this Hash, i.e., if it is in
    // the hexified (32 byte) representation, make it be in the
    // 16-byte (unhexified) representation.
    void fixup();

    template <typename Op>
    bool
    compareUsing(Hash<I> const& iOther, Op op) const
    {
      if (this->isCompactForm() == iOther.isCompactForm()) {
        return op(this->hash_, iOther.hash_);
      }
      Hash<I> tMe(*this);
      Hash<I> tOther(iOther);
      return op(tMe.hash_, tOther.hash_);
    }

    value_type hash_;
  };

  //--------------------------------------------------------------------
  //
  // Implementation details follow...
  //--------------------------------------------------------------------

  template <int I>
  inline Hash<I>::Hash() : hash_()
  {
    fixup();
  }

  template <int I>
  inline Hash<I>::Hash(typename Hash<I>::value_type const& v) : hash_(v)
  {
    fixup();
  }

  template <int I>
  inline Hash<I>::Hash(Hash<I> const& iOther) : hash_(iOther.hash_)
  {
    fixup();
  }

  template <int I>
  inline Hash<I> const&
  Hash<I>::operator=(Hash<I> const& iRHS)
  {
    hash_ = iRHS.hash_;
    fixup();
    return *this;
  }

  template <int I>
  inline bool
  Hash<I>::isValid() const
  {
    return isCompactForm() ? (hash_ != art::detail::InvalidHash()) :
                             (hash_.size() != 0);
  }

  template <int I>
  inline bool
  Hash<I>::operator<(Hash<I> const& other) const
  {
    return this->compareUsing(other, std::less<std::string>());
  }

  template <int I>
  inline bool
  Hash<I>::operator>(Hash<I> const& other) const
  {
    return this->compareUsing(other, std::greater<std::string>());
  }

  template <int I>
  inline bool
  Hash<I>::operator==(Hash<I> const& other) const
  {
    return this->compareUsing(other, std::equal_to<std::string>());
  }

  template <int I>
  inline bool
  Hash<I>::operator!=(Hash<I> const& other) const
  {
    return this->compareUsing(other, std::not_equal_to<std::string>());
  }

  template <int I>
  inline std::ostream&
  Hash<I>::print(std::ostream& os) const
  {
    Hash<I> tMe(*this);
    cet::MD5Result temp;
    cet::copy_all(tMe.hash_, temp.bytes);
    os << temp.toString();
    return os;
  }

  template <int I>
  inline void
  Hash<I>::swap(Hash<I>& other)
  {
    fixup();
    hash_.swap(other.hash_);
    fixup();
  }

  template <int I>
  inline typename Hash<I>::value_type
  Hash<I>::compactForm() const
  {
    if (this->isCompactForm()) {
      return hash_;
    }
    Hash<I> tMe(*this);
    return tMe.compactForm();
  }

  template <int I>
  inline void
  Hash<I>::throwIfIllFormed() const
  {
    // Fixup not needed here.
    if (hash_.size() % 2 == 1) {
      throw art::Exception(art::errors::LogicError)
        << "Ill-formed Hash instance. "
        << "Please report this to the core framework developers";
    }
  }

  // Note: this template is not declared 'inline' because of the
  // switch statement.

  template <int I>
  void
  Hash<I>::fixup()
  {
    switch (hash_.size()) {
      case 0: {
        hash_ = art::detail::InvalidHash();
      }
      case 16: {
        break;
      }
      case 32: {
        cet::MD5Result temp;
        temp.fromHexifiedString(hash_);
        hash_ = temp.compactForm();
        break;
      }
      default: {
        throw art::Exception(art::errors::LogicError)
          << "art::Hash<> instance with data in illegal state:\n"
          << hash_ << "\nPlease report this to the core framework developers";
      }
    }
  }

  template <int I>
  inline bool
  Hash<I>::isCompactForm() const
  {
    return 16 == hash_.size();
  }

  // Free swap function
  template <int I>
  inline void
  swap(Hash<I>& a, Hash<I>& b)
  {
    a.swap(b);
  }

  template <int I>
  inline std::ostream&
  operator<<(std::ostream& os, Hash<I> const& h)
  {
    return h.print(os);
  }

} // art

  // ======================================================================

#endif /* canvas_Persistency_Provenance_Hash_h */

// Local Variables:
// mode: c++
// End: