StringPool.cxx

Go to the documentation of this file.

/*
  Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
*/
#include "SGTools/StringPool.h"
#include "SGTools/transientKey.h"
#include "SGTools/exceptions.h"
#include "CxxUtils/crc64.h"
#include <map>
#include <unordered_map>
#include <vector>
#include <algorithm>
#include <cstdlib>
#include <iostream>
#include <iomanip>
 
 
namespace SG {
 
 
//***************************************************************************
// Implementation class.
//
 
 
class StringPoolImpl
{
public:
  bool registerKey (StringPool::sgkey_t key,
                    const std::string& str,
                    StringPool::sgaux_t aux);
 
  const std::string* keyToString (StringPool::sgkey_t key,
                                  StringPool::sgaux_t& aux) const;
 
  size_t size() const;
 
  void clear();
 
  void dump() const;
 
  bool merge (const StringPoolImpl& other);
 
private:
  // The key hash table.
  typedef std::pair<StringPool::sgaux_t, std::string> pair_t;
  typedef SG::SGKeyMap<pair_t> keymap_t;
  keymap_t m_keymap;
};
 
 
bool StringPoolImpl::registerKey (StringPool::sgkey_t key,
                                  const std::string& str,
                                  StringPool::sgaux_t aux)
{
  StringPoolImpl::keymap_t::iterator i = m_keymap.find (key);
  if (i == m_keymap.end()) {
    pair_t& p = m_keymap[key];
    p.first = aux;
    p.second = str;
  }
  else if (i->second.first != aux || i->second.second != str) {
    return false;
  }
  return true;
}
 
 
const std::string*
StringPoolImpl::keyToString (StringPool::sgkey_t key,
                             StringPool::sgaux_t& aux) const
{
  StringPoolImpl::keymap_t::const_iterator i = m_keymap.find (key);
  if (i != m_keymap.end()) {
    aux = i->second.first;
    return &i->second.second;
  }
  return 0;
}
 
 
size_t StringPoolImpl::size() const
{
  return m_keymap.size();
}
 
 
void StringPoolImpl::clear()
{
  keymap_t().swap (m_keymap);
}
 
 
void StringPoolImpl::dump() const
{
  std::vector<StringPool::sgkey_t> keys;
  keys.reserve (m_keymap.size());
  for (const keymap_t::value_type& p : m_keymap)
    keys.push_back (p.first);
  std::sort (keys.begin(), keys.end());
  for (StringPool::sgkey_t k : keys) {
    keymap_t::const_iterator it = m_keymap.find (k);
    std::cout << std::hex << std::setw(18) << k << " "
              << std::dec << std::setw(9) << it->second.first << " "
              << it->second.second << "\n";
  }
}
 
 
bool StringPoolImpl::merge (const StringPoolImpl& other)
{
  bool allgood = true;
  for (const keymap_t::value_type& p : other.m_keymap) {
    if (!registerKey (p.first, p.second.second, p.second.first)) {
      allgood = false;
    }
  }
  return allgood;
}
 
 
//***************************************************************************
// StringPool class.
//
 
StringPool::StringPool()
  : m_impl (std::make_unique<StringPoolImpl>())
{
}
 
 
StringPool::StringPool (const StringPool& other)
  : m_impl (std::make_unique<StringPoolImpl> (*other.m_impl))
{
}
 
 
StringPool::StringPool (StringPool&& other)
  : m_impl (std::move (other.m_impl))
{
  // False positive:
  // cppcheck-suppress useInitializationList
  other.m_impl = std::make_unique<StringPoolImpl>();
}
 
 
StringPool& StringPool::operator= (const StringPool& other)
{
  if (this != &other) {
    *m_impl = *other.m_impl;
  }
  return *this;
}
 
 
StringPool& StringPool::operator= (StringPool&& other)
{
  if (this != &other) {
    StringPoolImpl& other_impl = *other.m_impl;
    *m_impl = std::move (other_impl);
  }
  return *this;
}
 
 
StringPool::~StringPool()
{
  clear();
}
 
 
StringPool::sgkey_t StringPool::stringToKey (const std::string& str,
                                             sgaux_t aux /*= 0*/)
{
  uint64_t crc = CxxUtils::crc64 (str);
  if (aux) crc = CxxUtils::crc64addint (crc, aux);
  sgkey_t key = (crc & sgkey_t_max);
  if (m_impl->registerKey (key, str, aux)) {
    return key;
  }
 
  // Hash collision...
  // If we have a transient key, then adjust the hash to avoid a collision.
  if (SG::isTransientKey (str)) {
    sgkey_t new_key = ( (key+1) & sgkey_t_max);
    while (!m_impl->registerKey (new_key, str, aux)) {
      new_key = ( (new_key+1) & sgkey_t_max);
      if (key == new_key) std::abort();
    }
    return new_key;
  }
 
  // Otherwise raise an exception.
  sgaux_t old_aux = 0;
  const std::string* old_str = keyToString (key, old_aux);
  if (!old_str) std::abort(); // Shouldn't happen.
  throw ExcSgkeyCollision (str, aux,
                           *old_str, old_aux,
                           key);
}
 
 
const std::string* StringPool::keyToString (sgkey_t key) const
{
  sgaux_t aux;
  return m_impl->keyToString (key, aux);
}
 
 
const std::string* StringPool::keyToString (sgkey_t key,
                                            sgaux_t& aux) const
{
  return m_impl->keyToString (key, aux);
}
 
 
bool StringPool::registerKey (sgkey_t key,
                              const std::string& str,
                              sgaux_t aux /*= 0*/)
{
  // Make sure the primary mapping is registered first.
  stringToKey (str, aux);
  return m_impl->registerKey (key, str, aux);
}
 
 
size_t StringPool::size() const
{
  return m_impl->size();
}
 
 
void StringPool::dump () const
{
  m_impl->dump();
}
 
 
void StringPool::clear()
{
  m_impl->clear();
}
 
 
bool StringPool::merge (const StringPool& other)
{
  return m_impl->merge (*other.m_impl);
}
 
 
} // namespace SG