NAME

       FBB::Hash - Various mapping template classes using hashing

SYNOPSIS

       #include <bobcat/hash>

DESCRIPTION

       The  FBB:Hash  group of template classes offer hashing-based mapping. Various variants are
       available, all based on the facilities offered by the unordered_map.

       The hash-map offered in the unordered_map container  has  a  fairly  complex  construction
       interface,  and  Hash  is  an attempt to simplify this part of its interface. In practice,
       hashing uses a textual key, which may be std::string or char * based, and the keys may  be
       used  either  case  sensitively  or  case insensitively. Hash merely requires its users to
       specify the map’s value type, while the key may be a char const  *  or  std::string,  used
       case sensitively or case insensitively.

NAMESPACE

       FBB
       All  constructors,  members,  operators  and manipulators, mentioned in this man-page, are
       defined in the namespace FBB.

INHERITS FROM

       std::unordered_map, using various instantiations.

TYPE

       All variants define value_type as the corresponding unordered_map value_type. In  practice
       a value_type defines a std::pair<Key, Value>, where Key represents the hash’s key-type and
       Value represents the hash’s value type.

CONSTRUCTORS

       Variants of the FBB::Hash container are available for char const *  or  std::string  keys,
       used case sensitively or case insensitively.

       All  variants  support default and move construction (as well as move assignment), support
       construction from initializer lists. and support construction from  iterators  defining  a
       half-open range of value_type values.

       The following variants are available (showing their default constructors). Value refers to
       the value type stored in the hash table.

       o      HashCharPtr<Value>():
              this hash table uses case sensitive char const * keys;

       o      HashCharCasePtr<Value>():
              this hash table uses case insensitive char const * keys;

       o      HashString<Value>():
              this hash table uses case sensitive std::string keys;

       o      HashStringCase<Value>():
              this hash table uses case insensitive std::string keys;

OVERLOADED OPERATOR

       In addition to the index operator inherited from unordered_map  the  overloaded  copy  and
       move assignment operators are available for all Hash containers.

MEMBER FUNCTIONS

       All  members  of  the  unordered_map  container  are available, as Hash inherits from this
       template class.

EXAMPLE

           #include <iostream>
           #include <bobcat/hash>

           using namespace std;
           using namespace FBB;

           pair<char const *, size_t> ap[] =
           {
               pair<char const *, size_t>("one", 1),
               pair<char const *, size_t>("two", 2),
           };

           int main()
           {
               HashCharPtr<size_t> hcp;
               HashCharPtr<size_t> hcp2(ap, ap + 2);
               HashCharPtr<size_t> hcp3(hcp2);

               hcp = hcp2;

               cout << hcp2["one"] << endl;
           }

FILES

       bobcat/hash - defines the class interface

SEE ALSO

       bobcat(7)

BUGS

       None Reported.

BOBCAT PROJECT FILES

       o      https://fbb-git.gitlab.io/bobcat/: gitlab project page;

       o      bobcat_6.02.02-x.dsc: detached signature;

       o      bobcat_6.02.02-x.tar.gz: source archive;

       o      bobcat_6.02.02-x_i386.changes: change log;

       o      libbobcat1_6.02.02-x_*.deb: debian package containing the libraries;

       o      libbobcat1-dev_6.02.02-x_*.deb: debian package containing  the  libraries,  headers
              and manual pages;

BOBCAT

       Bobcat is an acronym of `Brokken’s Own Base Classes And Templates’.

COPYRIGHT

       This  is  free  software,  distributed  under  the terms of the GNU General Public License
       (GPL).

AUTHOR

       Frank B. Brokken (f.b.brokken@rug.nl).