coffee/etl
1
0
Fork 0
mirror of https://github.com/ETLCPP/etl.git synced 2026-11-09 14:49:53 +08:00
Code Issues Packages Projects Releases Wiki Activity

Combined flat_map.h, iflat_map.h & flat_map_base.h

Browse Source 
Deleted iflat_map.h & flat_map_base.h
This commit is contained in:
John Wellbelove 2017-04-17 13:33:57 +01:00
parent 47156229f8
commit f0e82157a3
1 changed files with 892 additions and 10 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

902
src/flat_map.h
View File

@ -34,10 +34,22 @@ SOFTWARE.
#include <stddef.h>
#include <iterator>
#include <functional>
#include <algorithm>
#include <functional>
#include <utility>
#include "iflat_map.h"
#include "platform.h"
#include "vector.h"
#include "pool.h"
#include "exception.h"
#include "vector.h"
#include "error_handler.h"
#include "debug_count.h"
#include "type_traits.h"
#include "parameter_type.h"
#undef ETL_FILE
#define ETL_FILE "2"
//*****************************************************************************
///\defgroup flat_map flat_map
@ -49,6 +61,874 @@ SOFTWARE.
namespace etl
{
//***************************************************************************
///\ingroup flat_map
/// Exception base for flat_maps
//***************************************************************************
class flat_map_exception : public etl::exception
{
public:
flat_map_exception(string_type what, string_type file_name, numeric_type line_number)
: etl::exception(what, file_name, line_number)
{
}
};
//***************************************************************************
///\ingroup flat_map
/// Vector full exception.
//***************************************************************************
class flat_map_full : public etl::flat_map_exception
{
public:
flat_map_full(string_type file_name, numeric_type line_number)
: etl::flat_map_exception(ETL_ERROR_TEXT("flat_map: full", ETL_FILE"A"), file_name, line_number)
{
}
};
//***************************************************************************
///\ingroup flat_map
/// Vector out of bounds exception.
//***************************************************************************
class flat_map_out_of_bounds : public etl::flat_map_exception
{
public:
flat_map_out_of_bounds(string_type file_name, numeric_type line_number)
: etl::flat_map_exception(ETL_ERROR_TEXT("flat_map:bounds", ETL_FILE"B"), file_name, line_number)
{
}
};
//***************************************************************************
///\ingroup flat_map
/// The base class for all templated flat_map types.
//***************************************************************************
class flat_map_base
{
public:
typedef size_t size_type;
protected:
etl::debug_count construct_count; ///< Internal debugging.
};
//***************************************************************************
/// The base class for specifically sized flat_maps.
/// Can be used as a reference type for all flat_maps containing a specific type.
///\ingroup flat_map
//***************************************************************************
template <typename TKey, typename TMapped, typename TKeyCompare = std::less<TKey> >
class iflat_map : public flat_map_base
{
public:
typedef std::pair<const TKey, TMapped> value_type;
private:
typedef etl::ivector<value_type*> lookup_t;
typedef etl::ipool storage_t;
public:
typedef TKey key_type;
typedef TMapped mapped_type;
typedef TKeyCompare key_compare;
typedef value_type& reference;
typedef const value_type& const_reference;
typedef value_type* pointer;
typedef const value_type* const_pointer;
typedef size_t size_type;
//*************************************************************************
class iterator : public std::iterator<std::bidirectional_iterator_tag, value_type>
{
public:
friend class iflat_map;
iterator()
{
}
iterator(typename lookup_t::iterator ilookup)
: ilookup(ilookup)
{
}
iterator(const iterator& other)
: ilookup(other.ilookup)
{
}
iterator& operator =(const iterator& other)
{
ilookup = other.ilookup;
return *this;
}
iterator& operator ++()
{
++ilookup;
return *this;
}
iterator operator ++(int)
{
iterator temp(*this);
++ilookup;
return temp;
}
iterator& operator --()
{
--ilookup;
return *this;
}
iterator operator --(int)
{
iterator temp(*this);
--ilookup;
return temp;
}
reference operator *()
{
return *(*ilookup);
}
const_reference operator *() const
{
return *(*ilookup);
}
pointer operator &()
{
return etl::addressof(*(*ilookup));
}
const_pointer operator &() const
{
return &(*(*ilookup));
}
pointer operator ->()
{
return etl::addressof(*(*ilookup));
}
const_pointer operator ->() const
{
return etl::addressof(*(*ilookup));
}
friend bool operator == (const iterator& lhs, const iterator& rhs)
{
return lhs.ilookup == rhs.ilookup;
}
friend bool operator != (const iterator& lhs, const iterator& rhs)
{
return !(lhs == rhs);
}
private:
typename lookup_t::iterator ilookup;
};
//*************************************************************************
class const_iterator : public std::iterator<std::bidirectional_iterator_tag, const value_type>
{
public:
friend class iflat_map;
const_iterator()
{
}
const_iterator(typename lookup_t::const_iterator ilookup)
: ilookup(ilookup)
{
}
const_iterator(const iterator& other)
: ilookup(other.ilookup)
{
}
const_iterator(const const_iterator& other)
: ilookup(other.ilookup)
{
}
const_iterator& operator =(const iterator& other)
{
ilookup = other.ilookup;
return *this;
}
const_iterator& operator =(const const_iterator& other)
{
ilookup = other.ilookup;
return *this;
}
const_iterator& operator ++()
{
++ilookup;
return *this;
}
const_iterator operator ++(int)
{
const_iterator temp(*this);
++ilookup;
return temp;
}
const_iterator& operator --()
{
--ilookup;
return *this;
}
const_iterator operator --(int)
{
const_iterator temp(*this);
--ilookup;
return temp;
}
const_reference operator *() const
{
return *(*ilookup);
}
const_pointer operator &() const
{
return etl::addressof(*(*ilookup));
}
const_pointer operator ->() const
{
return etl::addressof(*(*ilookup));
}
friend bool operator == (const const_iterator& lhs, const const_iterator& rhs)
{
return lhs.ilookup == rhs.ilookup;
}
friend bool operator != (const const_iterator& lhs, const const_iterator& rhs)
{
return !(lhs == rhs);
}
private:
typename lookup_t::const_iterator ilookup;
};
typedef std::reverse_iterator<iterator> reverse_iterator;
typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
typedef typename std::iterator_traits<iterator>::difference_type difference_type;
protected:
typedef typename parameter_type<TKey>::type key_value_parameter_t;
private:
//*********************************************************************
/// How to compare elements and keys.
//*********************************************************************
class compare
{
public:
bool operator ()(const value_type& element, key_type key) const
{
return key_compare()(element.first, key);
}
bool operator ()(key_type key, const value_type& element) const
{
return key_compare()(key, element.first);
}
};
public:
//*********************************************************************
/// Returns an iterator to the beginning of the flat_map.
///\return An iterator to the beginning of the flat_map.
//*********************************************************************
iterator begin()
{
return iterator(lookup.begin());
}
//*********************************************************************
/// Returns a const_iterator to the beginning of the flat_map.
///\return A const iterator to the beginning of the flat_map.
//*********************************************************************
const_iterator begin() const
{
return const_iterator(lookup.begin());
}
//*********************************************************************
/// Returns an iterator to the end of the flat_map.
///\return An iterator to the end of the flat_map.
//*********************************************************************
iterator end()
{
return iterator(lookup.end());
}
//*********************************************************************
/// Returns a const_iterator to the end of the flat_map.
///\return A const iterator to the end of the flat_map.
//*********************************************************************
const_iterator end() const
{
return const_iterator(lookup.end());
}
//*********************************************************************
/// Returns a const_iterator to the beginning of the flat_map.
///\return A const iterator to the beginning of the flat_map.
//*********************************************************************
const_iterator cbegin() const
{
return const_iterator(lookup.cbegin());
}
//*********************************************************************
/// Returns a const_iterator to the end of the flat_map.
///\return A const iterator to the end of the flat_map.
//*********************************************************************
const_iterator cend() const
{
return const_iterator(lookup.cend());
}
//*********************************************************************
/// Returns an reverse iterator to the reverse beginning of the flat_map.
///\return Iterator to the reverse beginning of the flat_map.
//*********************************************************************
reverse_iterator rbegin()
{
return reverse_iterator(lookup.rbegin());
}
//*********************************************************************
/// Returns a const reverse iterator to the reverse beginning of the flat_map.
///\return Const iterator to the reverse beginning of the flat_map.
//*********************************************************************
const_reverse_iterator rbegin() const
{
return reverse_iterator(lookup.rbegin());
}
//*********************************************************************
/// Returns a reverse iterator to the end + 1 of the flat_map.
///\return Reverse iterator to the end + 1 of the flat_map.
//*********************************************************************
reverse_iterator rend()
{
return reverse_iterator(lookup.rend());
}
//*********************************************************************
/// Returns a const reverse iterator to the end + 1 of the flat_map.
///\return Const reverse iterator to the end + 1 of the flat_map.
//*********************************************************************
const_reverse_iterator rend() const
{
return const_reverse_iterator(lookup.rend());
}
//*********************************************************************
/// Returns a const reverse iterator to the reverse beginning of the flat_map.
///\return Const reverse iterator to the reverse beginning of the flat_map.
//*********************************************************************
const_reverse_iterator crbegin() const
{
return const_reverse_iterator(lookup.crbegin());
}
//*********************************************************************
/// Returns a const reverse iterator to the end + 1 of the flat_map.
///\return Const reverse iterator to the end + 1 of the flat_map.
//*********************************************************************
const_reverse_iterator crend() const
{
return const_reverse_iterator(lookup.crend());
}
//*********************************************************************
/// Returns a reference to the value at index 'key'
///\param i The index.
///\return A reference to the value at index 'key'
//*********************************************************************
mapped_type& operator [](key_value_parameter_t key)
{
iterator i_element = lower_bound(key);
if (i_element == end())
{
std::pair<iterator, bool> result = insert_at(i_element, value_type(key, mapped_type()));
i_element = result.first;
}
return i_element->second;
}
//*********************************************************************
/// Returns a reference to the value at index 'key'
/// If asserts or exceptions are enabled, emits an etl::flat_map_out_of_bounds if the key is not in the range.
///\param i The index.
///\return A reference to the value at index 'key'
//*********************************************************************
mapped_type& at(key_value_parameter_t key)
{
iterator i_element = lower_bound(key);
ETL_ASSERT(i_element != end(), ETL_ERROR(flat_map_out_of_bounds));
return i_element->second;
}
//*********************************************************************
/// Returns a const reference to the value at index 'key'
/// If asserts or exceptions are enabled, emits an etl::flat_map_out_of_bounds if the key is not in the range.
///\param i The index.
///\return A const reference to the value at index 'key'
//*********************************************************************
const mapped_type& at(key_value_parameter_t key) const
{
const_iterator i_element = lower_bound(key);
ETL_ASSERT(i_element != end(), ETL_ERROR(flat_map_out_of_bounds));
return i_element->second;
}
//*********************************************************************
/// Assigns values to the flat_map.
/// If ETL_THROW_EXCEPTIONS & _DEBUG are defined, emits flat_map_full if the flat_map does not have enough free space.
/// If ETL_THROW_EXCEPTIONS & _DEBUG are defined, emits flat_map_iterator if the iterators are reversed.
///\param first The iterator to the first element.
///\param last The iterator to the last element + 1.
//*********************************************************************
template <typename TIterator>
void assign(TIterator first, TIterator last)
{
#if defined(ETL_DEBUG)
difference_type count = std::distance(first, last);
ETL_ASSERT(count <= difference_type(capacity()), ETL_ERROR(flat_map_full));
#endif
clear();
while (first != last)
{
insert(*first++);
}
}
//*********************************************************************
/// Inserts a value to the flat_map.
/// If asserts or exceptions are enabled, emits flat_map_full if the flat_map is already full.
///\param value The value to insert.
//*********************************************************************
std::pair<iterator, bool> insert(const value_type& value)
{
iterator i_element = lower_bound(value.first);
return insert_at(i_element, value);
}
//*********************************************************************
/// Inserts a value to the flat_map.
/// If asserts or exceptions are enabled, emits flat_map_full if the flat_map is already full.
///\param position The position to insert at.
///\param value The value to insert.
//*********************************************************************
iterator insert(iterator position, const value_type& value)
{
return insert(value).first;
}
//*********************************************************************
/// Inserts a range of values to the flat_map.
/// If asserts or exceptions are enabled, emits flat_map_full if the flat_map does not have enough free space.
///\param position The position to insert at.
///\param first The first element to add.
///\param last The last + 1 element to add.
//*********************************************************************
template <class TIterator>
void insert(TIterator first, TIterator last)
{
while (first != last)
{
insert(*first++);
}
}
//*********************************************************************
/// Erases an element.
///\param key The key to erase.
///\return The number of elements erased. 0 or 1.
//*********************************************************************
size_t erase(key_value_parameter_t key)
{
iterator i_element = find(key);
if (i_element == end())
{
return 0;
}
else
{
i_element->~value_type();
storage.release(etl::addressof(*i_element));
lookup.erase(i_element.ilookup);
--construct_count;
return 1;
}
}
//*********************************************************************
/// Erases an element.
///\param i_element Iterator to the element.
//*********************************************************************
void erase(iterator i_element)
{
i_element->~value_type();
storage.release(etl::addressof(*i_element));
lookup.erase(i_element.ilookup);
--construct_count;
}
//*********************************************************************
/// Erases a range of elements.
/// The range includes all the elements between first and last, including the
/// element pointed by first, but not the one pointed by last.
///\param first Iterator to the first element.
///\param last Iterator to the last element.
//*********************************************************************
void erase(iterator first, iterator last)
{
iterator itr = first;
while (itr != last)
{
itr->~value_type();
storage.release(etl::addressof(*itr));
++itr;
--construct_count;
}
lookup.erase(first.ilookup, last.ilookup);
}
//*************************************************************************
/// Clears the flat_map.
//*************************************************************************
void clear()
{
erase(begin(), end());
}
//*********************************************************************
/// Finds an element.
///\param key The key to search for.
///\return An iterator pointing to the element or end() if not found.
//*********************************************************************
iterator find(key_value_parameter_t key)
{
iterator itr = lower_bound(key);
if (itr != end())
{
if (!key_compare()(itr->first, key) && !key_compare()(key, itr->first))
{
return itr;
}
else
{
return end();
}
}
return end();
}
//*********************************************************************
/// Finds an element.
///\param key The key to search for.
///\return An iterator pointing to the element or end() if not found.
//*********************************************************************
const_iterator find(key_value_parameter_t key) const
{
const_iterator itr = lower_bound(key);
if (itr != end())
{
if (!key_compare()(itr->first, key) && !key_compare()(key, itr->first))
{
return itr;
}
else
{
return end();
}
}
return end();
}
//*********************************************************************
/// Counts an element.
///\param key The key to search for.
///\return 1 if the key exists, otherwise 0.
//*********************************************************************
size_t count(key_value_parameter_t key) const
{
return (find(key) == end()) ? 0 : 1;
}
//*********************************************************************
/// Finds the lower bound of a key
///\param key The key to search for.
///\return An iterator.
//*********************************************************************
iterator lower_bound(key_value_parameter_t key)
{
return std::lower_bound(begin(), end(), key, compare());
}
//*********************************************************************
/// Finds the lower bound of a key
///\param key The key to search for.
///\return An iterator.
//*********************************************************************
const_iterator lower_bound(key_value_parameter_t key) const
{
return std::lower_bound(cbegin(), cend(), key, compare());
}
//*********************************************************************
/// Finds the upper bound of a key
///\param key The key to search for.
///\return An iterator.
//*********************************************************************
iterator upper_bound(key_value_parameter_t key)
{
return std::upper_bound(begin(), end(), key, compare());
}
//*********************************************************************
/// Finds the upper bound of a key
///\param key The key to search for.
///\return An iterator.
//*********************************************************************
const_iterator upper_bound(key_value_parameter_t key) const
{
return std::upper_bound(begin(), end(), key, compare());
}
//*********************************************************************
/// Finds the range of equal elements of a key
///\param key The key to search for.
///\return An iterator pair.
//*********************************************************************
std::pair<iterator, iterator> equal_range(key_value_parameter_t key)
{
iterator i_lower = std::lower_bound(begin(), end(), key, compare());
return std::make_pair(i_lower, std::upper_bound(i_lower, end(), key, compare()));
}
//*********************************************************************
/// Finds the range of equal elements of a key
///\param key The key to search for.
///\return An iterator pair.
//*********************************************************************
std::pair<const_iterator, const_iterator> equal_range(key_value_parameter_t key) const
{
const_iterator i_lower = std::lower_bound(cbegin(), cend(), key, compare());
return std::make_pair(i_lower, std::upper_bound(i_lower, cend(), key, compare()));
}
//*************************************************************************
/// Assignment operator.
//*************************************************************************
iflat_map& operator = (const iflat_map& rhs)
{
if (&rhs != this)
{
assign(rhs.cbegin(), rhs.cend());
}
return *this;
}
//*************************************************************************
/// Gets the current size of the flat_map.
///\return The current size of the flat_map.
//*************************************************************************
size_type size() const
{
return lookup.size();
}
//*************************************************************************
/// Checks the 'empty' state of the flat_map.
///\return <b>true</b> if empty.
//*************************************************************************
bool empty() const
{
return lookup.empty();
}
//*************************************************************************
/// Checks the 'full' state of the flat_map.
///\return <b>true</b> if full.
//*************************************************************************
bool full() const
{
return lookup.full();
}
//*************************************************************************
/// Returns the capacity of the flat_map.
///\return The capacity of the flat_map.
//*************************************************************************
size_type capacity() const
{
return lookup.capacity();
}
//*************************************************************************
/// Returns the maximum possible size of the flat_map.
///\return The maximum size of the flat_map.
//*************************************************************************
size_type max_size() const
{
return lookup.max_size();
}
//*************************************************************************
/// Returns the remaining capacity.
///\return The remaining capacity.
//*************************************************************************
size_t available() const
{
return lookup.available();
}
protected:
//*********************************************************************
/// Constructor.
//*********************************************************************
iflat_map(lookup_t& lookup_, storage_t& storage_)
: lookup(lookup_),
storage(storage_)
{
}
private:
//*********************************************************************
/// Inserts a value to the flat_map.
///\param i_element The place to insert.
///\param value The value to insert.
//*********************************************************************
std::pair<iterator, bool> insert_at(iterator i_element, const value_type& value)
{
std::pair<iterator, bool> result(end(), false);
if (i_element == end())
{
// At the end.
ETL_ASSERT(!lookup.full(), ETL_ERROR(flat_map_full));
value_type* pvalue = storage.allocate<value_type>();
::new (pvalue) value_type(value);
lookup.push_back(pvalue);
result.first = --end();
result.second = true;
++construct_count;
}
else
{
// Not at the end.
result.first = i_element;
// Existing element?
if (value.first != i_element->first)
{
// A new one.
ETL_ASSERT(!lookup.full(), ETL_ERROR(flat_map_full));
value_type* pvalue = storage.allocate<value_type>();
::new (pvalue) value_type(value);
lookup.insert(i_element.ilookup, pvalue);
result.second = true;
++construct_count;
}
}
return result;
}
// Disable copy construction.
iflat_map(const iflat_map&);
lookup_t& lookup;
storage_t& storage;
};
//***************************************************************************
/// Equal operator.
///\param lhs Reference to the first flat_map.
///\param rhs Reference to the second flat_map.
///\return <b>true</b> if the arrays are equal, otherwise <b>false</b>
///\ingroup flat_map
//***************************************************************************
template <typename TKey, typename TMapped, typename TKeyCompare>
bool operator ==(const etl::iflat_map<TKey, TMapped, TKeyCompare>& lhs, const etl::iflat_map<TKey, TMapped, TKeyCompare>& rhs)
{
return (lhs.size() == rhs.size()) && std::equal(lhs.begin(), lhs.end(), rhs.begin());
}
//***************************************************************************
/// Not equal operator.
///\param lhs Reference to the first flat_map.
///\param rhs Reference to the second flat_map.
///\return <b>true</b> if the arrays are not equal, otherwise <b>false</b>
///\ingroup flat_map
//***************************************************************************
template <typename TKey, typename TMapped, typename TKeyCompare>
bool operator !=(const etl::iflat_map<TKey, TMapped, TKeyCompare>& lhs, const etl::iflat_map<TKey, TMapped, TKeyCompare>& rhs)
{
return !(lhs == rhs);
}
//***************************************************************************
/// A flat_map implementation that uses a fixed size buffer.
///\tparam TKey The key type.
@ -58,7 +938,7 @@ namespace etl
///\ingroup flat_map
//***************************************************************************
template <typename TKey, typename TValue, const size_t MAX_SIZE_, typename TCompare = std::less<TKey> >
class flat_map : public iflat_map<TKey, TValue, TCompare>
class flat_map : public etl::iflat_map<TKey, TValue, TCompare>
{
public:
@ -68,7 +948,7 @@ namespace etl
/// Constructor.
//*************************************************************************
flat_map()
: iflat_map<TKey, TValue, TCompare>(lookup, storage)
: etl::iflat_map<TKey, TValue, TCompare>(lookup, storage)
{
}
@ -76,9 +956,9 @@ namespace etl
/// Copy constructor.
//*************************************************************************
flat_map(const flat_map& other)
: iflat_map<TKey, TValue, TCompare>(lookup, storage)
: etl::iflat_map<TKey, TValue, TCompare>(lookup, storage)
{
iflat_map<TKey, TValue, TCompare>::assign(other.cbegin(), other.cend());
etl::iflat_map<TKey, TValue, TCompare>::assign(other.cbegin(), other.cend());
}
//*************************************************************************
@ -89,9 +969,9 @@ namespace etl
//*************************************************************************
template <typename TIterator>
flat_map(TIterator first, TIterator last)
: iflat_map<TKey, TValue, TCompare>(lookup, storage)
: etl::iflat_map<TKey, TValue, TCompare>(lookup, storage)
{
iflat_map<TKey, TValue, TCompare>::assign(first, last);
etl::iflat_map<TKey, TValue, TCompare>::assign(first, last);
}
//*************************************************************************
@ -99,7 +979,7 @@ namespace etl
//*************************************************************************
~flat_map()
{
iflat_map<TKey, TValue, TCompare>::clear();
etl::iflat_map<TKey, TValue, TCompare>::clear();
}
//*************************************************************************
@ -109,7 +989,7 @@ namespace etl
{
if (&rhs != this)
{
iflat_map<TKey, TValue, TCompare>::assign(rhs.cbegin(), rhs.cend());
etl::iflat_map<TKey, TValue, TCompare>::assign(rhs.cbegin(), rhs.cend());
}
return *this;
@ -117,7 +997,7 @@ namespace etl
private:
typedef typename iflat_map<TKey, TValue, TCompare>::value_type node_t;
typedef typename etl::iflat_map<TKey, TValue, TCompare>::value_type node_t;
// The pool of nodes.
etl::pool<node_t, MAX_SIZE> storage;
@ -127,4 +1007,6 @@ namespace etl
};
}
#undef ETL_FILE
#endif