plucky (3) hash.3bobcat.gz

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.06.02-x.dsc: detached signature;

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

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

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

       o      libbobcat1-dev_6.06.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).