tim::hash Namespace Reference

Classes
struct	hasher
struct	static_string

Typedefs
using	hash_value_t = size_t
using	hash_map_t = std::unordered_map< hash_value_t, std::string >
using	hash_alias_map_t = std::unordered_map< hash_value_t, hash_value_t >
using	hash_map_ptr_t = std::shared_ptr< hash_map_t >
using	hash_map_ptr_pair_t = std::pair< hash_map_ptr_t, hash_map_ptr_t >
using	hash_alias_ptr_t = std::shared_ptr< hash_alias_map_t >
using	hash_resolver_t = std::function< bool(hash_value_t, std::string &)>
using	hash_resolver_vec_t = std::vector< hash_resolver_t >

Functions
	TIMEMORY_HASH_LINKAGE (hash_map_ptr_t &) get_hash_ids()
	TIMEMORY_HASH_LINKAGE (hash_alias_ptr_t &) get_hash_aliases()
	TIMEMORY_HASH_LINKAGE (std::shared_ptr< hash_resolver_vec_t > &) get_hash_resolvers()
	TIMEMORY_HASH_LINKAGE (hash_value_t) get_hash_id(const hash_alias_ptr_t &_hash_alias
	if (_alias_itr !=_hash_alias->end()) return _alias_itr -> second
	TIMEMORY_HASH_LINKAGE (void) add_hash_id(const hash_map_ptr_t &
	TIMEMORY_HASH_LINKAGE (void) add_hash_id(hash_value_t _hash_id
	if (_reported.count(_hash_id) > 0) return
_reported	insert (_hash_id)
	if (!_hash_map)
	for (const auto &aitr :*_hash_alias)
	for (auto &mitr :*_hash_map)
	if (_hash_id > 0)
	TIMEMORY_HASH_LINKAGE (typename hash_map_t::const_iterator) find_hash_identifier(const hash_map_ptr_t &_hash_map
	if (_map_itr !=_hash_map->end()) return _map_itr = &_map_itr->second
return _hash_map	end ()
	TIMEMORY_HASH_LINKAGE (typename hash_map_t::const_iterator) find_hash_identifier(hash_value_t _hash_id)
	TIMEMORY_HASH_LINKAGE (bool) get_hash_identifier(const hash_map_ptr_t &_hash_map
	if (static_string::is_registered(_hash_id)) = reinterpret_cast<const char*>(_hash_id)
	if (_hash_alias)
	TIMEMORY_HASH_LINKAGE (std::string) get_hash_identifier(hash_value_t _hash_id)
	TIMEMORY_HASH_LINKAGE (bool) get_hash_identifier(hash_value_t _hash_id
	TIMEMORY_HASH_LINKAGE (std::string) get_hash_identifier(const hash_map_ptr_t &_hash_map
	if (get_hash_identifier(_hash_map, _hash_alias, _hash_id, _ret)) return *_ret
	hash_identifier_error (_hash_map, _hash_alias, _hash_id)
hash_map_ptr_t &	get_hash_ids ()
hash_alias_ptr_t &	get_hash_aliases ()
std::shared_ptr< hash_resolver_vec_t > &	get_hash_resolvers ()
template<typename Tp , std::enable_if_t< concepts::is_string_type< std::decay_t< Tp > >::value, int > = 0>
hash_value_t	get_hash_id (Tp &&_prefix)
hash_value_t	get_combined_hash_id (hash_value_t _lhs, hash_value_t _rhs)
template<typename Tp , std::enable_if_t<!std::is_integral< std::decay_t< Tp > >::value, int > = 0>
hash_value_t	get_combined_hash_id (hash_value_t _lhs, Tp &&_rhs)
hash_value_t	get_hash_id (const hash_alias_ptr_t &_hash_alias, hash_value_t _hash_id)
hash_value_t	add_hash_id (hash_map_ptr_t &_hash_map, string_view_cref_t _prefix)
	add an string to the given hash-map (if it doesn't already exist) and return the hash More...
hash_value_t	add_hash_id (string_view_cref_t _prefix)
	add an string to the default hash-map (if it doesn't already exist) and return the hash More...
void	add_hash_id (const hash_map_ptr_t &_hash_map, const hash_alias_ptr_t &_hash_alias, hash_value_t _hash_id, hash_value_t _alias_hash_id)
void	add_hash_id (const hash_alias_ptr_t &_hash_alias, hash_value_t _hash_id, hash_value_t _alias_hash_id)
void	add_hash_id (hash_value_t _hash_id, hash_value_t _alias_hash_id)
void	hash_identifier_error (const hash_map_ptr_t &_hash_map, const hash_alias_ptr_t &_hash_alias, hash_value_t _hash_id)
string_view_t	get_hash_identifier_fast (hash_value_t _hash)
	this does not check other threads or aliases. Only call this function when you know that the hash exists on the thread and is not an alias More...
bool	get_hash_identifier_fast (hash_value_t _hash, std::string *&_v)
bool	get_hash_identifier_fast (hash_value_t _hash, const char *&_v)
hash_map_t::const_iterator	find_hash_identifier (const hash_map_ptr_t &_hash_map, const hash_alias_ptr_t &_hash_alias, hash_value_t _hash_id)
hash_map_t::const_iterator	find_hash_identifier (hash_value_t _hash_id)
bool	get_hash_identifier (const hash_map_ptr_t &_hash_map, const hash_alias_ptr_t &_hash_alias, hash_value_t _hash_id, std::string *&_ret)
bool	get_hash_identifier (const hash_map_ptr_t &_hash_map, const hash_alias_ptr_t &_hash_alias, hash_value_t _hash_id, const char *&_ret)
bool	get_hash_identifier (hash_value_t _hash_id, std::string *&_ret)
bool	get_hash_identifier (hash_value_t _hash_id, const char *&_ret)
std::string	get_hash_identifier (const hash_map_ptr_t &_hash_map, const hash_alias_ptr_t &_hash_alias, hash_value_t _hash_id)
std::string	get_hash_identifier (hash_value_t _hash_id)
template<typename FuncT >
size_t	add_hash_resolver (FuncT &&_func)
std::string	demangle_hash_identifier (std::string, char bdelim='[', char edelim=']')
template<typename... Args>
auto	get_demangled_hash_identifier (Args &&... _args)
template<typename T >
size_t	get_hash (T &&obj)
size_t	get_hash (string_view_cref_t str)
size_t	get_hash (const char *cstr)

Variables
hash_value_t	_hash_id
const hash_alias_ptr_t &	_hash_alias
const hash_alias_ptr_t hash_value_t hash_value_t	_alias_hash_id
auto	_alias_itr = _hash_alias->find(_hash_id)
const hash_alias_ptr_t hash_value_t std::string *&	_ret
auto	_map_itr = _hash_map->find(_hash_id)
	true
return	false

Typedef Documentation

hash_alias_map_t

using tim::hash::hash_alias_map_t = typedef std::unordered_map<hash_value_t, hash_value_t>

Definition at line 86 of file types.hpp.

hash_alias_ptr_t

using tim::hash::hash_alias_ptr_t = typedef std::shared_ptr<hash_alias_map_t>

Definition at line 89 of file types.hpp.

hash_map_ptr_pair_t

using tim::hash::hash_map_ptr_pair_t = typedef std::pair<hash_map_ptr_t, hash_map_ptr_t>

Definition at line 88 of file types.hpp.

hash_map_ptr_t

using tim::hash::hash_map_ptr_t = typedef std::shared_ptr<hash_map_t>

Definition at line 87 of file types.hpp.

hash_map_t

using tim::hash::hash_map_t = typedef std::unordered_map<hash_value_t, std::string>

Definition at line 85 of file types.hpp.

hash_resolver_t

using tim::hash::hash_resolver_t = typedef std::function<bool(hash_value_t, std::string&)>

Definition at line 90 of file types.hpp.

hash_resolver_vec_t

using tim::hash::hash_resolver_vec_t = typedef std::vector<hash_resolver_t>

Definition at line 91 of file types.hpp.

hash_value_t

using tim::hash::hash_value_t = typedef size_t

Definition at line 84 of file types.hpp.

Function Documentation

add_hash_id() [1/5]

void tim::hash::add_hash_id	(	const hash_alias_ptr_t &	_hash_alias,
		hash_value_t	_hash_id,
		hash_value_t	_alias_hash_id
	)

add_hash_id() [2/5]

void tim::hash::add_hash_id	(	const hash_map_ptr_t &	_hash_map,
		const hash_alias_ptr_t &	_hash_alias,
		hash_value_t	_hash_id,
		hash_value_t	_alias_hash_id
	)

add_hash_id() [3/5]

hash_value_t tim::hash::add_hash_id ( hash_map_ptr_t &  _hash_map, string_view_cref_t  _prefix  )

inline

add an string to the given hash-map (if it doesn't already exist) and return the hash

Definition at line 190 of file types.hpp.

{
    hash_value_t _hash_id = get_hash_id(_prefix);
    if(_hash_map && _hash_map->find(_hash_id) == _hash_map->end())
    {
        (*_hash_map)[_hash_id] = std::string{ _prefix };
    }
    return _hash_id;
}

add_hash_id() [4/5]

void tim::hash::add_hash_id	(	hash_value_t	_hash_id,
		hash_value_t	_alias_hash_id
	)

add_hash_id() [5/5]

hash_value_t tim::hash::add_hash_id ( string_view_cref_t  _prefix )

inline

add an string to the default hash-map (if it doesn't already exist) and return the hash

Definition at line 210 of file types.hpp.

{
    return add_hash_id(get_hash_ids(), _prefix);
}

add_hash_resolver()

template<typename FuncT >

size_t tim::hash::add_hash_resolver

(

FuncT &&

_func

)

Definition at line 315 of file types.hpp.

{
    auto _resolvers = get_hash_resolvers();
    if(!_resolvers)
        return 0;
    _resolvers->emplace_back(std::forward<FuncT>(_func));
    return _resolvers->size();
}

demangle_hash_identifier()

std::string tim::hash::demangle_hash_identifier	(	std::string	,
		char	bdelim = '[',
		char	edelim = ']'
	)

end()

return _hash_map tim::hash::end

(

)

find_hash_identifier() [1/2]

hash_map_t::const_iterator tim::hash::find_hash_identifier	(	const hash_map_ptr_t &	_hash_map,
		const hash_alias_ptr_t &	_hash_alias,
		hash_value_t	_hash_id
	)

Referenced by tim::bundle< Tag, BundleT, TupleT >::set_prefix().

find_hash_identifier() [2/2]

hash_map_t::const_iterator tim::hash::find_hash_identifier

(

hash_value_t

_hash_id

)

for() [1/2]

tim::hash::for

(

auto &mitr :*

_hash_map

)

Definition at line 199 of file definition.hpp.

                   : *_hash_map)
    {
        if(_hash_id == mitr.first)
        {
            fprintf(stderr,
                    "[%s@%s:%i]> found hash identifier %llu in hash map via iteration "
                    "after uomap->find failed! This might be an ABI or an integer "
                    "overflow problem\n",
                    __FUNCTION__, TIMEMORY_TRUNCATED_FILE_STRING(__FILE__).c_str(),
                    __LINE__, (unsigned long long) _hash_id);
        }
    }

for() [2/2]

tim::hash::for

(

const auto &aitr :*

_hash_alias

)

Definition at line 179 of file definition.hpp.

                         : *_hash_alias)
    {
        if(_hash_id == aitr.first)
        {
            for(const auto& mitr : *_hash_map)
            {
                if(mitr.first == aitr.second)
                {
                    fprintf(stderr,
                            "[%s@%s:%i]> found hash identifier %llu in alias map via "
                            "iteration after uomap->find failed! This might be an ABI or "
                            "an integer overflow problem\n",
                            __FUNCTION__,
                            TIMEMORY_TRUNCATED_FILE_STRING(__FILE__).c_str(), __LINE__,
                            (unsigned long long) _hash_id);
                }
            }
        }
    }

get_combined_hash_id() [1/2]

hash_value_t tim::hash::get_combined_hash_id	(	hash_value_t	_lhs,
		hash_value_t	_rhs
	)

Definition at line 161 of file types.hpp.

{
    return (_lhs ^= _rhs + 0x9e3779b9 + (_lhs << 6) + (_lhs >> 2));
}

get_combined_hash_id() [2/2]

template<typename Tp , std::enable_if_t<!std::is_integral< std::decay_t< Tp > >::value, int > = 0>

hash_value_t tim::hash::get_combined_hash_id	(	hash_value_t	_lhs,
		Tp &&	_rhs
	)

Definition at line 170 of file types.hpp.

{
    return get_combined_hash_id(_lhs, get_hash_id(std::forward<Tp>(_rhs)));
}

Referenced by tim::scope::config::compute_hash().

get_demangled_hash_identifier()

template<typename... Args>

auto tim::hash::get_demangled_hash_identifier

(

Args &&...

_args

)

Definition at line 337 of file types.hpp.

{
    return demangle_hash_identifier(get_hash_identifier(std::forward<Args>(_args)...));
}

get_hash() [1/3]

size_t tim::hash::get_hash

(

const char *

cstr

)

Definition at line 218 of file utility.hpp.

{
    return std::hash<string_view_t>{}(cstr);
}

get_hash() [2/3]

size_t tim::hash::get_hash

(

string_view_cref_t

str

)

Definition at line 212 of file utility.hpp.

{
    return std::hash<string_view_t>{}(str);
}

get_hash() [3/3]

template<typename T >

size_t tim::hash::get_hash

(

T &&

obj

)

Definition at line 206 of file utility.hpp.

{
    return std::hash<decay_t<T>>()(std::forward<T>(obj));
}

Referenced by tim::hash::hasher< T >::operator()().

get_hash_aliases()

hash_alias_ptr_t & tim::hash::get_hash_aliases

(

)

Referenced by tim::bundle< Tag, BundleT, TupleT >::set_prefix().

get_hash_id() [1/2]

hash_value_t tim::hash::get_hash_id	(	const hash_alias_ptr_t &	_hash_alias,
		hash_value_t	_hash_id
	)

get_hash_id() [2/2]

template<typename Tp , std::enable_if_t< concepts::is_string_type< std::decay_t< Tp > >::value, int > = 0>

hash_value_t tim::hash::get_hash_id

(

Tp &&

_prefix

)

Definition at line 143 of file types.hpp.

{
    return std::hash<string_view_t>{}(std::forward<Tp>(_prefix));
}

get_hash_identifier() [1/6]

std::string tim::hash::get_hash_identifier	(	const hash_map_ptr_t &	_hash_map,
		const hash_alias_ptr_t &	_hash_alias,
		hash_value_t	_hash_id
	)

get_hash_identifier() [2/6]

bool tim::hash::get_hash_identifier	(	const hash_map_ptr_t &	_hash_map,
		const hash_alias_ptr_t &	_hash_alias,
		hash_value_t	_hash_id,
		const char *&	_ret
	)

get_hash_identifier() [3/6]

bool tim::hash::get_hash_identifier	(	const hash_map_ptr_t &	_hash_map,
		const hash_alias_ptr_t &	_hash_alias,
		hash_value_t	_hash_id,
		std::string *&	_ret
	)

Referenced by tim::bundle< Tag, BundleT, TupleT >::set_prefix().

get_hash_identifier() [4/6]

std::string tim::hash::get_hash_identifier

(

hash_value_t

_hash_id

)

get_hash_identifier() [5/6]

bool tim::hash::get_hash_identifier	(	hash_value_t	_hash_id,
		const char *&	_ret
	)

get_hash_identifier() [6/6]

bool tim::hash::get_hash_identifier	(	hash_value_t	_hash_id,
		std::string *&	_ret
	)

get_hash_identifier_fast() [1/3]

string_view_t tim::hash::get_hash_identifier_fast ( hash_value_t  _hash )

inline

this does not check other threads or aliases. Only call this function when you know that the hash exists on the thread and is not an alias

Definition at line 252 of file types.hpp.

{
    auto& _hash_ids = get_hash_ids();
    auto  itr       = _hash_ids->find(_hash);
    if(itr != _hash_ids->end())
        return itr->second;
    return string_view_t{};
}

get_hash_identifier_fast() [2/3]

bool tim::hash::get_hash_identifier_fast ( hash_value_t  _hash, const char *&  _v  )

inline

Definition at line 272 of file types.hpp.

{
    auto& _hash_ids = get_hash_ids();
    auto  itr       = _hash_ids->find(_hash);
    if(itr != _hash_ids->end())
        return (_v = itr->second.c_str(), true);
    return false;
}

get_hash_identifier_fast() [3/3]

bool tim::hash::get_hash_identifier_fast ( hash_value_t  _hash, std::string *&  _v  )

inline

Definition at line 262 of file types.hpp.

{
    auto& _hash_ids = get_hash_ids();
    auto  itr       = _hash_ids->find(_hash);
    if(itr != _hash_ids->end())
        return (_v = &itr->second, true);
    return false;
}

get_hash_ids()

hash_map_ptr_t & tim::hash::get_hash_ids

(

)

Referenced by tim::bundle< Tag, BundleT, TupleT >::set_prefix().

get_hash_resolvers()

std::shared_ptr< hash_resolver_vec_t > & tim::hash::get_hash_resolvers

(

)

hash_identifier_error() [1/2]

tim::hash::hash_identifier_error	(	_hash_map	,
		_hash_alias	,
		_hash_id
	)

hash_identifier_error() [2/2]

void tim::hash::hash_identifier_error	(	const hash_map_ptr_t &	_hash_map,
		const hash_alias_ptr_t &	_hash_alias,
		hash_value_t	_hash_id
	)

if() [1/8]

tim::hash::if

(

!

_hash_map

)

Definition at line 159 of file definition.hpp.

    {
        fprintf(stderr,
                "[%s@%s:%i]> hash identifier %llu could not be found bc the pointer to "
                "the hash map is null\n",
                __FUNCTION__, TIMEMORY_TRUNCATED_FILE_STRING(__FILE__).c_str(), __LINE__,
                (unsigned long long) _hash_id);
        return;
    }

if() [2/8]

tim::hash::if

(

_alias_itr !

= _hash_alias->end()

)

-> second

Definition at line 279 of file definition.hpp.

    {
        return find_hash_identifier(_hash_map, _hash_alias, _alias_itr->second);
    }

if() [3/8]

tim::hash::if

(

_hash_alias

)

Definition at line 317 of file definition.hpp.

    {
        auto _alias_itr = _hash_alias->find(_hash_id);
        if(_alias_itr != _hash_alias->end())
        {
            return get_hash_identifier(_hash_map, _hash_alias, _alias_itr->second, _ret);
        }
    }

if() [4/8]

tim::hash::if	(	_hash_id	,
		0
	)

Definition at line 212 of file definition.hpp.

    {
        std::stringstream ss;
        ss << "Error! node with hash " << _hash_id
           << " does not have an associated string!\n";
        static std::set<hash_value_t> _reported{};
        if(_reported.count(_hash_id) == 0)
        {
            _reported.emplace(_hash_id);
            bool _found_direct = (_hash_map->find(_hash_id) != _hash_map->end());
            ss << "    Found in map       : " << std::boolalpha << _found_direct << '\n';
            bool _found_alias = (_hash_alias->find(_hash_id) != _hash_alias->end());
            ss << "    Found in alias map : " << std::boolalpha << _found_alias << '\n';
            if(_found_alias)
            {
                auto aitr = _hash_alias->find(_hash_id);
                ss << "    Found aliasing : " << aitr->first << " -> " << aitr->second
                   << '\n';
                auto mitr = _hash_map->find(aitr->second);
                if(mitr != _hash_map->end())
                    ss << "    Found mapping  : " << mitr->first << " -> " << mitr->second
                       << '\n';
                else
                    ss << "    Missing mapping\n";
            }
            else
            {
                ss << "    Missing aliasing\n";
            }
            ss << "    Hash map:\n";
            auto _w = 20;
            for(const auto& itr : *_hash_map)
                ss << "        " << std::setw(_w) << itr.first << " : " << (itr.second)
                   << "\n";
            if(!_hash_alias->empty())
            {
                ss << "    Alias hash map:\n";
                for(const auto& itr : *_hash_alias)
                    ss << "        " << std::setw(_w) << itr.first << " : " << itr.second
                       << "\n";
            }
            auto _registry = static_string::get_registry();
            if(!_registry.empty())
            {
                ss << "    Static strings:\n";
                for(const auto* itr : _registry)
                {
                    ss << "        " << std::setw(_w)
                       << reinterpret_cast<std::size_t>(itr) << " : " << itr << "\n";
                }
            }
            fprintf(stderr, "%s", ss.str().c_str());
        }
    }

if() [5/8]

tim::hash::if

(

_map_itr !

= _hash_map->end()

)

= &_map_itr->second

if() [6/8]

tim::hash::if	(	_reported.	count_hash_id,
		0
	)

if() [7/8]

tim::hash::if

(

get_hash_identifier(_hash_map, _hash_alias, _hash_id, _ret)

)

if() [8/8]

tim::hash::if

(

static_string::is_registered(_hash_id)

)

= reinterpret_cast<const char*>(_hash_id)

Definition at line 311 of file definition.hpp.

    {
        auto itr = _hash_map->emplace(_hash_id, reinterpret_cast<const char*>(_hash_id));
        return (_ret = &itr.first->second, true);
    }

insert()

_reported tim::hash::insert

(

_hash_id

)

TIMEMORY_HASH_LINKAGE() [1/12]

tim::hash::TIMEMORY_HASH_LINKAGE

(

bool

)

const &

TIMEMORY_HASH_LINKAGE() [2/12]

tim::hash::TIMEMORY_HASH_LINKAGE

(

bool

)

TIMEMORY_HASH_LINKAGE() [3/12]

tim::hash::TIMEMORY_HASH_LINKAGE

(

hash_alias_ptr_t &

)

Definition at line 74 of file definition.hpp.

{
    static thread_local auto _inst =
        get_shared_ptr_pair_instance<hash_alias_map_t, TIMEMORY_API>();
    static thread_local auto _dtor = scope::destructor{ []() {
        auto                 _main = get_shared_ptr_pair_main_instance<hash_alias_map_t, TIMEMORY_API>();
        if(!_inst || !_main || _inst == _main)
            return;
        auto_lock_t          _lk{ type_mutex<hash_alias_map_t>(), std::defer_lock };
        if(!_lk.owns_lock())
            _lk.lock();
        for(const auto& itr : *_inst)
        {
            if(_main->find(itr.first) == _main->end())
                _main->emplace(itr.first, itr.second);
        }
    } };
    return _inst;
    (void) _dtor;
}

TIMEMORY_HASH_LINKAGE() [4/12]

tim::hash::TIMEMORY_HASH_LINKAGE

(

hash_map_ptr_t &

)

Definition at line 50 of file definition.hpp.

{
    static thread_local auto _inst =
        get_shared_ptr_pair_instance<hash_map_t, TIMEMORY_API>();
    static thread_local auto _dtor = scope::destructor{ []() {
        auto                 _main = get_shared_ptr_pair_main_instance<hash_map_t, TIMEMORY_API>();
        if(!_inst || !_main || _inst == _main)
            return;
        auto_lock_t          _lk{ type_mutex<hash_map_t>(), std::defer_lock };
        if(!_lk.owns_lock())
            _lk.lock();
        for(const auto& itr : *_inst)
        {
            if(_main->find(itr.first) == _main->end())
                _main->emplace(itr.first, itr.second);
        }
    } };
    return _inst;
    (void) _dtor;
}

TIMEMORY_HASH_LINKAGE() [5/12]

tim::hash::TIMEMORY_HASH_LINKAGE

(

hash_value_t

)

const &

TIMEMORY_HASH_LINKAGE() [6/12]

tim::hash::TIMEMORY_HASH_LINKAGE

(

std::shared_ptr< hash_resolver_vec_t > &

)

Definition at line 98 of file definition.hpp.

{
    static auto _inst = []() {
        auto _subinst = get_shared_ptr_lone_instance<hash_resolver_vec_t, TIMEMORY_API>();
        if(_subinst && _subinst->empty())
            _subinst->reserve(10);
        return _subinst;
    }();
    return _inst;
}

TIMEMORY_HASH_LINKAGE() [7/12]

tim::hash::TIMEMORY_HASH_LINKAGE

(

std::string

)

const &

TIMEMORY_HASH_LINKAGE() [8/12]

tim::hash::TIMEMORY_HASH_LINKAGE

(

std::string

)

Definition at line 362 of file definition.hpp.

{
    std::string* _ret = nullptr;
    if(get_hash_identifier(get_hash_ids(), get_hash_aliases(), _hash_id, _ret))
        return *_ret;
    hash_identifier_error(get_hash_ids(), get_hash_aliases(), _hash_id);
    return std::string("unknown-hash=") + std::to_string(_hash_id);
}

TIMEMORY_HASH_LINKAGE() [9/12]

tim::hash::TIMEMORY_HASH_LINKAGE

(

typename hash_map_t::const_iterator

)

const &

TIMEMORY_HASH_LINKAGE() [10/12]

tim::hash::TIMEMORY_HASH_LINKAGE

(

typename hash_map_t::const_iterator

)

Definition at line 289 of file definition.hpp.

{
    return find_hash_identifier(get_hash_ids(), get_hash_aliases(), _hash_id);
}

TIMEMORY_HASH_LINKAGE() [11/12]

tim::hash::TIMEMORY_HASH_LINKAGE

(

void

)

const &

TIMEMORY_HASH_LINKAGE() [12/12]

tim::hash::TIMEMORY_HASH_LINKAGE

(

void

)

Variable Documentation

_alias_hash_id

hash_value_t tim::hash::_alias_hash_id

Initial value:

{
    _hash_alias->emplace(_alias_hash_id, _hash_id)

Definition at line 125 of file definition.hpp.

_alias_itr

auto tim::hash::_alias_itr = _hash_alias->find(_hash_id)

Definition at line 278 of file definition.hpp.

_hash_alias

const hash_alias_ptr_t & tim::hash::_hash_alias

Definition at line 124 of file definition.hpp.

_hash_id

const hash_alias_ptr_t hash_value_t tim::hash::_hash_id

Initial value:

{
    auto _alias_itr = _hash_alias->find(_hash_id)

Definition at line 113 of file definition.hpp.

_map_itr

auto tim::hash::_map_itr = _hash_map->find(_hash_id)

Definition at line 306 of file definition.hpp.

_ret

const char *& tim::hash::_ret

Initial value:

{
    
    
    if(!_hash_map)
        return false

Definition at line 299 of file definition.hpp.

false

return tim::hash::false

Definition at line 326 of file definition.hpp.

true

tim::hash::true

Definition at line 308 of file definition.hpp.