souffle::SymbolTable Class Reference

#include <SymbolTable.h>

Collaboration diagram for souffle::SymbolTable:

Public Member Functions
Lock::Lease	acquireLock () const
bool	contains (const RamDomain index) const
	Check if the symbol table contains an index. More...
bool	contains (const std::string &symbol) const
	Check if the symbol table contains a string. More...
void	insert (const std::string &symbol)
	Insert a single symbol into the table, not that this operation should not be used if inserting symbols in bulk. More...
void	insert (const std::vector< std::string > &symbols)
	Bulk insert symbols into the table, note that this operation is more efficient than repeated inserts of single symbols. More...
RamDomain	lookup (const std::string &symbol)
	Find the index of a symbol in the table, inserting a new symbol if it does not exist there already. More...
RamDomain	lookupExisting (const std::string &symbol) const
	Finds the index of a symbol in the table, giving an error if it's not found. More...
SymbolTable &	operator= (const SymbolTable &other)
	Assignment operator, performs a deep copy and frees memory allocated for all strings. More...
SymbolTable &	operator= (SymbolTable &&other) noexcept
	Assignment operator for r-value references. More...
void	print (std::ostream &out) const
	Print the symbol table to the given stream. More...
const std::string &	resolve (const RamDomain index) const
	Find a symbol in the table by its index, note that this gives an error if the index is out of bounds. More...
size_t	size () const
	SymbolTable ()=default
	Empty constructor. More...
	SymbolTable (const SymbolTable &other)
	Copy constructor, performs a deep copy. More...
	SymbolTable (std::initializer_list< std::string > symbols)
	SymbolTable (SymbolTable &&other) noexcept
	Copy constructor for r-value reference. More...
RamDomain	unsafeLookup (const std::string &symbol)
	Find the index of a symbol in the table, inserting a new symbol if it does not exist there already. More...
const std::string &	unsafeResolve (const RamDomain index) const
virtual	~SymbolTable ()=default
	Destructor, frees memory allocated for all strings. More...

Private Member Functions
void	newSymbol (const std::string &symbol)
	Convenience method to place a new symbol in the table, if it does not exist. More...
size_t	newSymbolOfIndex (const std::string &symbol)
	Convenience method to place a new symbol in the table, if it does not exist, and return the index of it. More...

Private Attributes
Lock	access
	A lock to synchronize parallel accesses. More...
std::deque< std::string >	numToStr
	Map indices to strings. More...
std::unordered_map< std::string, size_t >	strToNum
	Map strings to indices. More...

Friends
std::ostream &	operator<< (std::ostream &out, const SymbolTable &table)
	Stream operator, used as a convenience for print. More...

Detailed Description

Global pool of re-usable strings

SymbolTable stores Datalog symbols and converts them to numbers and vice versa.

Definition at line 48 of file SymbolTable.h.

Constructor & Destructor Documentation

SymbolTable() [1/4]

souffle::SymbolTable::SymbolTable ( )

default

Empty constructor.

SymbolTable() [2/4]

souffle::SymbolTable::SymbolTable ( const SymbolTable &  other )

inline

Copy constructor, performs a deep copy.

Definition at line 87 of file SymbolTable.h.

SymbolTable() [3/4]

souffle::SymbolTable::SymbolTable ( SymbolTable &&  other )

inlinenoexcept

Copy constructor for r-value reference.

Definition at line 90 of file SymbolTable.h.

                                : symbols) {
            newSymbol(symbol);
        }

References newSymbol().

Here is the call graph for this function:

SymbolTable() [4/4]

souffle::SymbolTable::SymbolTable ( std::initializer_list< std::string >  symbols )

inline

Definition at line 95 of file SymbolTable.h.

                                                     {

References numToStr, and strToNum.

~SymbolTable()

virtual souffle::SymbolTable::~SymbolTable ( )

virtualdefault

Destructor, frees memory allocated for all strings.

Member Function Documentation

acquireLock()

Lock::Lease souffle::SymbolTable::acquireLock ( ) const

inline

Definition at line 238 of file SymbolTable.h.

contains() [1/2]

bool souffle::SymbolTable::contains ( const RamDomain  index ) const

inline

Check if the symbol table contains an index.

Definition at line 227 of file SymbolTable.h.

               {
            return true;
        }
    }
 
    Lock::Lease acquireLock() const {
        return access.acquire();
    }
 
    /** Stream operator, used as a convenience for print. */

contains() [2/2]

bool souffle::SymbolTable::contains ( const std::string &  symbol ) const

inline

Check if the symbol table contains a string.

Definition at line 215 of file SymbolTable.h.

               {
            return true;
        }
    }
 
    /** Check if the symbol table contains an index */
    bool contains(const RamDomain index) const {
        auto lease = access.acquire();
        (void)lease;  // avoid warning;
        auto pos = static_cast<size_t>(index);

insert() [1/2]

void souffle::SymbolTable::insert ( const std::string &  symbol )

inline

Insert a single symbol into the table, not that this operation should not be used if inserting symbols in bulk.

Definition at line 193 of file SymbolTable.h.

                                      {
        {
            out << "SymbolTable: {\n\t";
            out << join(strToNum, "\n\t",

insert() [2/2]

void souffle::SymbolTable::insert ( const std::vector< std::string > &  symbols )

inline

Bulk insert symbols into the table, note that this operation is more efficient than repeated inserts of single symbols.

Definition at line 179 of file SymbolTable.h.

                                         {
        {

lookup()

RamDomain souffle::SymbolTable::lookup ( const std::string &  symbol )

inline

Find the index of a symbol in the table, inserting a new symbol if it does not exist there already.

Definition at line 124 of file SymbolTable.h.

                                                            {
        {
            auto lease = access.acquire();
            (void)lease;  // avoid warning;

Referenced by souffle::tuple::rewind(), and souffle::interpreter::test::TEST().

lookupExisting()

RamDomain souffle::SymbolTable::lookupExisting ( const std::string &  symbol ) const

inline

Finds the index of a symbol in the table, giving an error if it's not found.

Definition at line 133 of file SymbolTable.h.

                                                                                    : `%s`", symbol);
            }
            return static_cast<RamDomain>(result->second);
        }
    }
 
    /** Find the index of a symbol in the table, inserting a new symbol if it does not exist there
     * already. */
    RamDomain unsafeLookup(const std::string& symbol) {
        return static_cast<RamDomain>(newSymbolOfIndex(symbol));
    }

newSymbol()

void souffle::SymbolTable::newSymbol ( const std::string &  symbol )

inlineprivate

Convenience method to place a new symbol in the table, if it does not exist.

Definition at line 75 of file SymbolTable.h.

      :
    /** Empty constructor. */
    SymbolTable() = default;
 
    /** Copy constructor, performs a deep copy. */

Referenced by SymbolTable().

newSymbolOfIndex()

size_t souffle::SymbolTable::newSymbolOfIndex ( const std::string &  symbol )

inlineprivate

Convenience method to place a new symbol in the table, if it does not exist, and return the index of it.

Definition at line 61 of file SymbolTable.h.

               {
            index = it->second;
        }
        return index;
    }
 
    /** Convenience method to place a new symbol in the table, if it does not exist. */
    inline void newSymbol(const std::string& symbol) {
        if (strToNum.find(symbol) == strToNum.end()) {
            strToNum[symbol] = numToStr.size();
            numToStr.push_back(symbol);

Referenced by operator=().

operator=() [1/2]

SymbolTable& souffle::SymbolTable::operator= ( const SymbolTable &  other )

inline

Assignment operator, performs a deep copy and frees memory allocated for all strings.

Definition at line 106 of file SymbolTable.h.

                                                         {
        numToStr.swap(other.numToStr);
        strToNum.swap(other.strToNum);
        return *this;

operator=() [2/2]

SymbolTable& souffle::SymbolTable::operator= ( SymbolTable &&  other )

inlinenoexcept

Assignment operator for r-value references.

Definition at line 116 of file SymbolTable.h.

                                              {
        {
            auto lease = access.acquire();

References access, souffle::Lock::acquire(), and newSymbolOfIndex().

Here is the call graph for this function:

print()

void souffle::SymbolTable::print ( std::ostream &  out ) const

inline

Print the symbol table to the given stream.

Definition at line 202 of file SymbolTable.h.

                                                 {
        auto lease = access.acquire();
        (void)lease;  // avoid warning;
        auto result = strToNum.find(symbol);

resolve()

const std::string& souffle::SymbolTable::resolve ( const RamDomain  index ) const

inline

Find a symbol in the table by its index, note that this gives an error if the index is out of bounds.

Definition at line 154 of file SymbolTable.h.

                                                                {
        return numToStr[static_cast<size_t>(index)];
    }
 
    /* Return the size of the symbol table, being the number of symbols it currently holds. */

Referenced by souffle::interpreter::RelInterface::iterator_base::operator++(), and souffle::tuple::operator<<().

size()

size_t souffle::SymbolTable::size ( ) const

inline

Definition at line 172 of file SymbolTable.h.

                                                     {
        {

References access, souffle::Lock::acquire(), and strToNum.

Referenced by unsafeLookup().

Here is the call graph for this function:

unsafeLookup()

RamDomain souffle::SymbolTable::unsafeLookup ( const std::string &  symbol )

inline

Find the index of a symbol in the table, inserting a new symbol if it does not exist there already.

Definition at line 147 of file SymbolTable.h.

                                                          {
        {

References access, souffle::Lock::acquire(), and size().

Here is the call graph for this function:

unsafeResolve()

const std::string& souffle::SymbolTable::unsafeResolve ( const RamDomain  index ) const

inline

Definition at line 167 of file SymbolTable.h.

Friends And Related Function Documentation

operator<<

std::ostream& operator<< ( std::ostream &  out, const SymbolTable &  table  )

friend

Stream operator, used as a convenience for print.

Definition at line 243 of file SymbolTable.h.

Field Documentation

access

Lock souffle::SymbolTable::access

mutableprivate

A lock to synchronize parallel accesses.

Definition at line 51 of file SymbolTable.h.

Referenced by operator=(), size(), and unsafeLookup().

numToStr

std::deque<std::string> souffle::SymbolTable::numToStr

private

Map indices to strings.

Definition at line 54 of file SymbolTable.h.

Referenced by SymbolTable().

strToNum

std::unordered_map<std::string, size_t> souffle::SymbolTable::strToNum

private

Map strings to indices.

Definition at line 57 of file SymbolTable.h.

Referenced by size(), and SymbolTable().

---

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

• include/souffle/SymbolTable.h