FBB:...rMap(3bobcat)

📦

version 6.15.01 · 7 versions

6.15.01 · ubuntu stonking (latest)
5.11.01 · nixos 26.05, nixpkgs unstable
5.09.01 · ubuntu jammy
6.04.00 · ubuntu noble
6.02.02 · debian bookworm
6.11.00 · ubuntu resolute
6.07.01 · debian trixie, ubuntu questing

💖 FBB:...rMap — the `3bobcat` era 💖

okay bestie, buckle up, we're doing a whole manual page and it's literally about a little mapping container called FBB::LinearMap ✨

🌸 NAME 🌸

FBB::LinearMap — a mapping container that uses linear searching. yes. it just... walks the line, one element at a time, and find you 💅

✨ SYNOPSIS ✨

#include <bobcat/linearmap>

🦋 DESCRIPTION 🦋

The class template LinearMap implements a mapping container using a linear searching algorithm. ngl, a mapping container that linear-searches is less complex than either the sorted std::map or the unsorted std::unordered_map container. and lowkey? for a relatively small number of elements, linear search is also faster than binary search or hashing-based searching algorithms. it's giving "small but mighty" 🔥

LinearMap implements all of the members which are also found in the standard std::map, except for the key_comp and value_comp members. those two are simply not available, because ordering the keys is not an issue with the unordered, linear searching method that LinearMap uses. no ordering, no drama, no comparator 🎀

💜 NAMESPACE 💜

FBB

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

🫶 INHERITS (PRIVATELY) FROM 🫶

std::vector<Key, Value>

yes, bestie, it's inheriting privately — remember that, it matters later 🙈

🌈 TEMPLATE TYPES 🌈

The full template type definition of LinearMap is:

template < typename Key, typename Value >

The Key type must offer bool operator==. Furthermore, the Key and Value types must support default and copy constructors and overloaded (copy) assignment operators. no cap, it's a whole vibe check on your types 👑

🎀 USING SPECIFICATIONS 🎀

using value_type = std::pair<Key, Value>;
iterator — an iterator to a LinearMap object's elements;
const_iterator — a const_iterator to a LinearMap object's elements;
reverse_iterator — a reverse_iterator to a LinearMap object's elements;
const_reverse_iterator — a const_reverse_iterator to a LinearMap object's elements.

🍓 CONSTRUCTORS 🍓

LinearMap(Iterator begin, Iterator end) — the constructor is initialized using the iterator range [begin, end), where Iterator is any iterator type pointing to value_type objects. If identical keys K are used then only the first occurrence of the value_type object using key K is inserted.
LinearMap(std:initializer_list<value_type> initial) — the constructor is initialized with the values stored in the std::initializer_list of value_type objects. If identical keys K are used then only the first occurrence of the value_type object using key K is inserted.

Default, copy and move constructors (and copy and move assignment operators) are available. so many options, so slay 💖

💅 OVERLOADED OPERATORS 💅

Value &operator[](Key const &key) — a reference to the Value associated with key is returned. If key was not available prior to the call of the index operator, a value_map(key, Value()) object is inserted. (yes, the index operator inserts things. it's the main character of side effects 🙈)

👑 MEMBER FUNCTIONS 👑

Note that the members of std::vector are not automatically available, as LinearMap is privately inherited from std::vector. that private inheritance is doing its little gatekeeping thing, exactly as promised 😭

LinearMap offers the following member functions:

Value &at(int idx) — returns a reference to the LinearMap's Value that is associated with key. If the key is not stored in the LinearMap then an std::out_of_range exception is thrown. 🚨
iterator begin() — returns an iterator pointing to the LinearMap's first element.
size_t capacity() — returns the number of elements that can be stored in the LinearMap before its capacity is enlarged.
const_iterator cbegin() const — returns a const_iterator pointing to the LinearMap's first element.
const_iterator cend() const — returns a const_iterator pointing beyond the LinearMap's last element.
void clear() — erases all elements from the LinearMap.
size_t count(key) — returns 1 if the provided key is available in the LinearMap, otherwise 0 is returned.
const_reverse_iterator crbegin() const — returns a const_reverse_iterator pointing to a LinearMap object's last element.
const_reverse_iterator crend() const — returns a const_reverse_iterator pointing before a LinearMap object's first element.
std::pair<iterator, bool> emplace(Args &&...args) — a value_type object is constructed from emplace's arguments. A std::pair is returned containing an iterator pointing to the object using that key. If the LinearMap already contains an object having the provided Key value then the returned std::pair's bool value is false. If the provided key was not found, then the newly constructed object is inserted into the LinearMap, and the returned std::pair's bool value is true.
bool empty() — returns true if the LinearMap contains no elements.
iterator end() — returns an iterator pointing beyond the LinearMap's last element.
std::pair<iterator, iterator> equal_range(key) — returns a pair of iterators, being respectively the return values of the member functions lower_bound and upper_bound.
bool erase(Key const &key) — erases the element having the given key from the LinearMap. True is returned if the value was removed, false if the LinearMap did not contain an element using the given key.
void erase(iterator pos) — erases the element at iterator position pos.
void erase(iterator begin, iterator end) — erases all elements indicated by the iterator range [first, beyond).
iterator find(Key const &key) — returns an iterator to the element having the given key. If the element isn't available, end is returned.
const_iterator find(Key const &key) const — returns a const_iterator to the element having the given key. If the element isn't available, end is returned.
allocator_type get_allocator() const — returns a copy of the allocator object used by the LinearMap object.
std::pair<iterator, bool> insert(value_type const &keyValue) — tries to inserts a new value_type object into the LinearMap, returning a std::pair<iterator, bool>. If the returned ti(bool) field is true, keyValue was inserted into the LinearMap. The value false indicates that the specified key was already available, and keyvalue was not inserted into the LinearMap. In both cases the iterator field points to the data element having the specified key.
iterator insert(iterator pos, value_type const &keyValue) — tries to insert keyValue into the LinearMap. Pos is ignored, and an iterator to the element having keyValue's key value is returned. If the specified key was already present, keyValue is not inserted into the LinearMap. (yes bestie, pos gets ghosted 💀)
void insert(Iterator begin, Iterator end) — tries to insert the value_type elements pointed at by the iterator range [begin, end) objects into the LinearMap. Iterator is any iterator type pointing to value_type objects. Already existing value_type elements having keys equal to the keys of the elements pointed at by the iterator range are not replaced.
iterator lower_bound(Key const &key) — returns an iterator pointing to the keyvalue element having the specified key. If no such element exists, end is returned.
const_iterator lower_bound(Key const &key) const — returns a const_iterator pointing to the keyvalue element having the specified key. If no such element exists, end is returned.
size_t max_size() const — returns the maximum number of elements this LinearMap may contain.
reverse_iterator rbegin() — returns a reverse_iterator pointing to the LinearMap object's last element.
const_reverse_iterator rbegin() const — returns a const_reverse_iterator pointing to the LinearMap object's last element.
reverse_iterator rend() — returns a reverse_iterator pointing before the LinearMap object's first element.
const_reverse_iterator rbegin() const — returns a const_reverse_iterator pointing before the LinearMap object's first element.
size_t size() const — returns the number of elements in the LinearMap.
void swap(LinearMap &other) — swaps two LinearMaps using identical Key and Value types.
iterator upper_bound(Key const &key) — returns an iterator pointing to the keyvalue element having the specified key. If no such element exists, end is returned.
const_iterator upper_bound(Key const &key) const — returns a const_iterator pointing to the keyvalue element having the specified key. If no such element exists, end is returned.

⭐ EXAMPLE ⭐

here's the whole example, verbatim, no notes, just vibes:

#include <iostream>
#include <string>
#include <iostream>

#include <bobcat/linearmap>

using namespace std;
using namespace FBB;

int main()
{
    typedef LinearMap<string, string> LM;

    // constructors:
    LM lm;
    LM lm2 =
    {
        {"one", "value 1"},
        {"two", "value 2"}
    };
    LM lm3(lm2);

    LM lm4(lm3.begin(), lm3.end());

    // assignment:
    lm = lm2;

    // some members:
    lm["key"] = "value";
    cout << lm["key"] << ’\n’;
    cout << lm.find("key")->second << ’\n’;

    for (auto value: lm)
        cout << "For loop: " << value.first << ", " <<
                                                value.second << ’\n’;

    cerr << "# times ’key’ is stored: " << lm.count("key") << "\n"
            "# times ’value is stored: " << lm.count("value") << ’\n’;

    lm4 = lm2;
    cout << "lm4’s size after assignment: " << lm4.size() << ’\n’;

    lm4.clear();
    cout << "lm4’s size after clear: " << lm4.size() << ’\n’;
};

🧚 FILES 🧚

bobcat/linearmap — defines the class interface

🔥 SEE ALSO 🔥

bobcat(7)

🙈 BUGS 🙈

None Reported. iconic behaviour, honestly 💅

🌸 BOBCAT PROJECT FILES 🌸

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

Debian Bobcat project files:

libbobcat6: debian package containing the shared library, changelog and copyright note;
libbobcat-dev: debian package containing the static library, headers, manual pages, and developer info;

💖 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).

and that's the whole page bestie 🎀 this manual came to you from libbobcat-dev_6.15.01, dated 2005-2026, living under the name FBB:...rMap(3bobcat) — go forth and linear search, you ate 💅✨

📦 where this page comes from

ubuntu stonking: libbobcat-dev 6.15.01-1 · GPL-3.0-or-later WITH OpenSSL exception
💖 girlified by deepseek-ai/DeepSeek-V4.1-Flash on 2026-11-03: a language model's rewrite of the original, under its terms