art::Hash< I > Class Template Reference

#include <Hash.h>

Public Types
using	value_type = std::string

Public Member Functions
	Hash ()
	Hash (std::string const &)
	Hash (Hash< I > const &)
	Hash (Hash< I > &&)
Hash< I > &	operator= (Hash< I > const &)
Hash< I > &	operator= (Hash< I > &&)
bool	isValid () const
bool	isCompactForm () const noexcept
std::string	compactForm () const
bool	operator< (Hash< I > const &) const
bool	operator> (Hash< I > const &) const
bool	operator== (Hash< I > const &) const
bool	operator!= (Hash< I > const &) const
std::ostream &	print (std::ostream &) const
void	swap (Hash< I > &)

Static Public Member Functions
static short	Class_Version () noexcept

Private Member Functions
void	fixup ()

Private Attributes
std::string	hash_ {}

Detailed Description

template<int I>
class art::Hash< I >

Definition at line 32 of file Hash.h.

Member Typedef Documentation

template<int I>

using art::Hash< I >::value_type = std::string

Definition at line 34 of file Hash.h.

Constructor & Destructor Documentation

template<int I>

art::Hash< I >::Hash

(

)

Definition at line 78 of file Hash.h.

  {
    fixup();
  }

template<int I>

art::Hash< I >::Hash ( std::string const &  s )

explicit

Definition at line 84 of file Hash.h.

                                  : hash_{s}
  {
    fixup();
  }

template<int I>

art::Hash< I >::Hash

(

Hash< I > const &

rhs

)

Definition at line 90 of file Hash.h.

                                  : hash_{rhs.hash_}
  {
    fixup();
  }

template<int I>

art::Hash< I >::Hash

(

Hash< I > &&

rhs

)

Definition at line 96 of file Hash.h.

                             : hash_{std::move(rhs.hash_)}
  {
    fixup();
  }

Member Function Documentation

template<int I>

short art::Hash< I >::Class_Version ( )

staticnoexcept

Definition at line 72 of file Hash.h.

  {
    return 10;
  }

template<int I>

std::string art::Hash< I >::compactForm

(

)

const

Definition at line 197 of file Hash.h.

  {
    if (isCompactForm()) {
      return hash_;
    }
    Hash<I> tMe(*this);
    return tMe.compactForm();
  }

template<int I>

void art::Hash< I >::fixup ( )

private

Definition at line 208 of file Hash.h.

  {
    if (hash_.size() == 16) {
      // Already in compact form.
      return;
    }
    if (hash_.size() == 0) {
      hash_ = art::detail::InvalidHash();
      return;
    }
    if (hash_.size() == 32) {
      cet::MD5Result md5;
      md5.fromHexifiedString(hash_);
      hash_ = md5.compactForm();
      return;
    }
    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>

bool art::Hash< I >::isCompactForm ( ) const

noexcept

Definition at line 231 of file Hash.h.

  {
    return hash_.size() == 16;
  }

template<int I>

bool art::Hash< I >::isValid

(

)

const

Definition at line 123 of file Hash.h.

  {
    if (isCompactForm()) {
      return hash_ != art::detail::InvalidHash();
    }
    return !hash_.empty();
  }

template<int I>

bool art::Hash< I >::operator!=

(

Hash< I > const &

rhs

)

const

Definition at line 166 of file Hash.h.

  {
    if (isCompactForm() == rhs.isCompactForm()) {
      return hash_ != rhs.hash_;
    }
    // Force both into compact form.
    return Hash<I>{*this} != Hash<I>{rhs};
  }

template<int I>

bool art::Hash< I >::operator<

(

Hash< I > const &

rhs

)

const

Definition at line 133 of file Hash.h.

  {
    if (isCompactForm() == rhs.isCompactForm()) {
      return hash_ < rhs.hash_;
    }
    // Force both into compact form.
    return Hash<I>{*this} < Hash<I>{rhs};
  }

template<int I>

Hash< I > & art::Hash< I >::operator=

(

Hash< I > const &

rhs

)

Definition at line 103 of file Hash.h.

  {
    if (this != &rhs) {
      hash_ = rhs.hash_;
      fixup();
    }
    return *this;
  }

template<int I>

Hash< I > & art::Hash< I >::operator=

(

Hash< I > &&

rhs

)

Definition at line 114 of file Hash.h.

  {
    hash_ = std::move(rhs.hash_);
    fixup();
    return *this;
  }

template<int I>

bool art::Hash< I >::operator==

(

Hash< I > const &

rhs

)

const

Definition at line 155 of file Hash.h.

  {
    if (isCompactForm() == rhs.isCompactForm()) {
      return hash_ == rhs.hash_;
    }
    // Force both into compact form.
    return Hash<I>{*this} == Hash<I>{rhs};
  }

template<int I>

bool art::Hash< I >::operator>

(

Hash< I > const &

rhs

)

const

Definition at line 144 of file Hash.h.

  {
    if (isCompactForm() == rhs.isCompactForm()) {
      return hash_ > rhs.hash_;
    }
    // Force both into compact form.
    return Hash<I>{*this} > Hash<I>{rhs};
  }

template<int I>

std::ostream & art::Hash< I >::print

(

std::ostream &

os

)

const

Definition at line 177 of file Hash.h.

  {
    Hash<I> tMe{*this};
    cet::MD5Result temp;
    cet::copy_all(tMe.hash_, temp.bytes);
    os << temp.toString();
    return os;
  }

template<int I>

void art::Hash< I >::swap

(

Hash< I > &

rhs

)

Definition at line 188 of file Hash.h.

  {
    fixup();
    hash_.swap(rhs.hash_);
    fixup();
  }

Member Data Documentation

template<int I>

std::string art::Hash< I >::hash_ {}

private

Definition at line 66 of file Hash.h.

---

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

• canvas/canvas/Persistency/Provenance/Hash.h