SG::StringPool Class Reference

#include <StringPool.h>

Collaboration diagram for SG::StringPool:

Public Types
typedef uint32_t	sgkey_t
	Type of the integer keys. More...
typedef unsigned int	sgaux_t
	Type of auxiliary data. More...

Public Member Functions
	StringPool ()
	Constructor. More...
	~StringPool ()
	Destructor. More...
	StringPool (const StringPool &other)
	Copy/move constructors. More...
	StringPool (StringPool &&other)
	Move constructor. More...
StringPool &	operator= (const StringPool &other)
	Assignment/move operators. More...
StringPool &	operator= (StringPool &&other)
	Move operator. More...
sgkey_t	stringToKey (const std::string &str, sgaux_t aux=0)
	Find the key for a string. More...
const std::string *	keyToString (sgkey_t key) const
	Find the string corresponding to a given key. More...
const std::string *	keyToString (sgkey_t key, sgaux_t &aux) const
	Find the string corresponding to a given key. More...
bool	registerKey (sgkey_t key, const std::string &str, sgaux_t aux=0)
	Remember an additional mapping from key to string. More...
size_t	size () const
	Number of registered mappings. More...
void	dump () const
	Debugging dump. More...
void	clear ()
	Empty the pool. More...
bool	merge (const StringPool &other)
	Merge another pool into this one. More...

Static Public Attributes
static const int	sgkey_t_nbits = 30
	Number of bits we'll use in the keys. More...
static const sgkey_t	sgkey_t_max

Private Attributes
std::unique_ptr< StringPoolImpl >	m_impl

Detailed Description

Definition at line 34 of file StringPool.h.

Member Typedef Documentation

sgaux_t

typedef unsigned int SG::StringPool::sgaux_t

Type of auxiliary data.

Definition at line 41 of file StringPool.h.

sgkey_t

typedef uint32_t SG::StringPool::sgkey_t

Type of the integer keys.

Definition at line 38 of file StringPool.h.

Constructor & Destructor Documentation

StringPool() [1/3]

SG::StringPool::StringPool

(

)

Constructor.

Definition at line 174 of file StringPool.cxx.

  : m_impl (std::make_unique<StringPoolImpl>())
{
}

~StringPool()

SG::StringPool::~StringPool

(

)

Destructor.

Definition at line 233 of file StringPool.cxx.

{
  clear();
}

StringPool() [2/3]

SG::StringPool::StringPool

(

const StringPool &

other

)

Copy/move constructors.

Copy constructor.

other Object from which to copy.

Definition at line 184 of file StringPool.cxx.

  : m_impl (std::make_unique<StringPoolImpl> (*other.m_impl))
{
}

StringPool() [3/3]

SG::StringPool::StringPool

(

StringPool &&

other

)

Move constructor.

other Object from which to move.

Definition at line 194 of file StringPool.cxx.

  : m_impl (std::move (other.m_impl))
{
  // False positive:
  // cppcheck-suppress useInitializationList
  other.m_impl = std::make_unique<StringPoolImpl>();
}

Member Function Documentation

clear()

void SG::StringPool::clear

(

)

Empty the pool.

Definition at line 350 of file StringPool.cxx.

{
  m_impl->clear();
}

dump()

void SG::StringPool::dump

(

)

const

Debugging dump.

Write to cout.

Definition at line 341 of file StringPool.cxx.

{
  m_impl->dump();
}

keyToString() [1/2]

const std::string * SG::StringPool::keyToString

(

sgkey_t

key

)

const

Find the string corresponding to a given key.

Parameters

key	The key to look up.

Returns

Pointer to the string found, or null. We can find keys as long as the corresponding string was given to either stringToKey() or registerKey().

Definition at line 286 of file StringPool.cxx.

{
  sgaux_t aux;
  return m_impl->keyToString (key, aux);
}

keyToString() [2/2]

const std::string * SG::StringPool::keyToString	(	sgkey_t	key,
		sgaux_t &	aux
	)		const

Find the string corresponding to a given key.

Parameters

key	The key to look up.
aux[out]	Auxiliary data associated with the key.

Returns

Pointer to the string found, or null. We can find keys as long as the corresponding string was given to either stringToKey() or registerKey().

Definition at line 301 of file StringPool.cxx.

{
  return m_impl->keyToString (key, aux);
}

merge()

bool SG::StringPool::merge

(

const StringPool &

other

)

Merge another pool into this one.

Parameters

other

The other pool to merge into this one.

In case of collisions, the colliding entries are skipped, and false is returned. If no collisions, then true is returned.

Definition at line 363 of file StringPool.cxx.

{
  return m_impl->merge (*other.m_impl);
}

operator=() [1/2]

StringPool & SG::StringPool::operator=

(

const StringPool &

other

)

Assignment/move operators.

Assignment operator.

other Object from which to copy.

Definition at line 207 of file StringPool.cxx.

{
  if (this != &other) {
    *m_impl = *other.m_impl;
  }
  return *this;
}

operator=() [2/2]

StringPool & SG::StringPool::operator=

(

StringPool &&

other

)

Move operator.

other Object from which to move.

Definition at line 220 of file StringPool.cxx.

{
  if (this != &other) {
    StringPoolImpl& other_impl = *other.m_impl;
    *m_impl = std::move (other_impl);
  }
  return *this;
}

registerKey()

bool SG::StringPool::registerKey	(	sgkey_t	key,
		const std::string &	str,
		sgaux_t	aux = 0
	)

Remember an additional mapping from key to string.

Parameters

key	The key to enter.
str	The string to enter.
aux	Auxiliary data to include along with the string.

Returns

True if successful; false if the key already corresponds to a different string.

This registers an additional mapping from a key to a string; it can be found later through lookup() on the string.

Definition at line 319 of file StringPool.cxx.

{
  // Make sure the primary mapping is registered first.
  stringToKey (str, aux);
  return m_impl->registerKey (key, str, aux);
}

size()

size_t SG::StringPool::size

(

)

const

Number of registered mappings.

Definition at line 332 of file StringPool.cxx.

{
  return m_impl->size();
}

stringToKey()

StringPool::sgkey_t SG::StringPool::stringToKey	(	const std::string &	str,
		sgaux_t	aux = 0
	)

Find the key for a string.

Parameters

str	The string to look up.
aux	Auxiliary data to include along with the string.

Returns

A key identifying the string. A given string will always return the same key. Will throw ExcSgkeyCollision in case of a hash collision (for a non-transient string)!

Definition at line 248 of file StringPool.cxx.

{
  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);
}

Member Data Documentation

m_impl

std::unique_ptr<StringPoolImpl> SG::StringPool::m_impl

private

Definition at line 137 of file StringPool.h.

sgkey_t_max

const sgkey_t SG::StringPool::sgkey_t_max

static

Initial value:

=
    (static_cast<sgkey_t>(1) << sgkey_t_nbits) - 1

Definition at line 46 of file StringPool.h.

sgkey_t_nbits

const int SG::StringPool::sgkey_t_nbits = 30

static

Number of bits we'll use in the keys.

Leave a few spare bits in case we want to overload them for flags later.

Definition at line 45 of file StringPool.h.

---

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

• StringPool.h
• StringPool.cxx