From 0d88a4f0046f65a8cacb2a7d85828ae940f7c3fe Mon Sep 17 00:00:00 2001 From: jwellbelove Date: Wed, 18 Feb 2015 22:43:06 +0000 Subject: [PATCH] Renamed files to flat_map --- ilookup.h | 471 -------------------------------------------------- lookup.h | 105 ----------- lookup_base.h | 181 ------------------- 3 files changed, 757 deletions(-) delete mode 100644 ilookup.h delete mode 100644 lookup.h delete mode 100644 lookup_base.h diff --git a/ilookup.h b/ilookup.h deleted file mode 100644 index 213bf53d..00000000 --- a/ilookup.h +++ /dev/null @@ -1,471 +0,0 @@ -///\file - -/****************************************************************************** -The MIT License(MIT) - -Embedded Template Library. - -Copyright(c) 2014 jwellbelove - -Permission is hereby granted, free of charge, to any person obtaining a copy -of this software and associated documentation files(the "Software"), to deal -in the Software without restriction, including without limitation the rights -to use, copy, modify, merge, publish, distribute, sublicense, and / or sell -copies of the Software, and to permit persons to whom the Software is -furnished to do so, subject to the following conditions : - -The above copyright notice and this permission notice shall be included in all -copies or substantial portions of the Software. - -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE -AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -SOFTWARE. -******************************************************************************/ - -#ifndef __ETL_ILOOKUP__ -#define __ETL_ILOOKUP__ -#define __ETL_IN_ILOOKUP_H__ - -#include -#include -#include -#include -#include - -#include "lookup_base.h" -#include "type_traits.h" -#include "parameter_type.h" -#include "ivector.h" - -#ifndef ETL_THROW_EXCEPTIONS -#include "error_handler.h" -#endif - -namespace etl -{ - //*************************************************************************** - /// The base class for specifically sized lookups. - /// Can be used as a reference type for all lookups containing a specific type. - ///\ingroup lookup - //*************************************************************************** - template - class ilookup : public lookup_base - { - public: - - typedef std::pair value_type; - - private: - - typedef etl::ivector buffer_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 typename buffer_t::iterator iterator; - typedef typename buffer_t::const_iterator const_iterator; - typedef typename buffer_t::reverse_iterator reverse_iterator; - typedef typename buffer_t::const_reverse_iterator const_reverse_iterator; - typedef size_t size_type; - typedef typename std::iterator_traits::difference_type difference_type; - - protected: - - typedef typename parameter_type::type key_value_parameter_t; - - //************************************************************************* - /// How to compare elements. - //************************************************************************* - struct compare_element - { - bool operator ()(const value_type& value1, const value_type& value2) const - { - return key_compare()(value1.first, value2.first); - } - }; - - public: - - //********************************************************************* - /// Assignment operator. - /// The source lookup can be larger than the destination, but - /// only the elements that will fit in the destination will be copied. - ///\param other The other lookup. - //********************************************************************* - ilookup& operator = (ilookup& other) - { - buffer.operator=(other.buffer); - - return *this; - } - - //********************************************************************* - /// Returns an iterator to the beginning of the lookup. - ///\return An iterator to the beginning of the lookup. - //********************************************************************* - iterator begin() - { - return buffer.begin(); - } - - //********************************************************************* - /// Returns a const_iterator to the beginning of the lookup. - ///\return A const iterator to the beginning of the lookup. - //********************************************************************* - const_iterator begin() const - { - return buffer.begin(); - } - - //********************************************************************* - /// Returns an iterator to the end of the lookup. - ///\return An iterator to the end of the lookup. - //********************************************************************* - iterator end() - { - return buffer.end(); - } - - //********************************************************************* - /// Returns a const_iterator to the end of the lookup. - ///\return A const iterator to the end of the lookup. - //********************************************************************* - const_iterator end() const - { - return buffer.end(); - } - - //********************************************************************* - /// Returns a const_iterator to the beginning of the lookup. - ///\return A const iterator to the beginning of the lookup. - //********************************************************************* - const_iterator cbegin() const - { - return buffer.cbegin(); - } - - //********************************************************************* - /// Returns a const_iterator to the end of the lookup. - ///\return A const iterator to the end of the lookup. - //********************************************************************* - const_iterator cend() const - { - return buffer.cend(); - } - - //********************************************************************* - /// Returns an reverse iterator to the reverse beginning of the lookup. - ///\return Iterator to the reverse beginning of the lookup. - //********************************************************************* - reverse_iterator rbegin() - { - return buffer.rbegin(); - } - - //********************************************************************* - /// Returns a const reverse iterator to the reverse beginning of the lookup. - ///\return Const iterator to the reverse beginning of the lookup. - //********************************************************************* - const_reverse_iterator rbegin() const - { - return buffer.rbegin(); - } - - //********************************************************************* - /// Returns a reverse iterator to the end + 1 of the lookup. - ///\return Reverse iterator to the end + 1 of the lookup. - //********************************************************************* - reverse_iterator rend() - { - return buffer.rend(); - } - - //********************************************************************* - /// Returns a const reverse iterator to the end + 1 of the lookup. - ///\return Const reverse iterator to the end + 1 of the lookup. - //********************************************************************* - const_reverse_iterator rend() const - { - return buffer.rend(); - } - - //********************************************************************* - /// Returns a const reverse iterator to the reverse beginning of the lookup. - ///\return Const reverse iterator to the reverse beginning of the lookup. - //********************************************************************* - const_reverse_iterator crbegin() const - { - return buffer.crbegin(); - } - - //********************************************************************* - /// Returns a const reverse iterator to the end + 1 of the lookup. - ///\return Const reverse iterator to the end + 1 of the lookup. - //********************************************************************* - const_reverse_iterator crend() const - { - return buffer.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 = std::lower_bound(begin(), end(), value_type(key, TMapped()), compare_element()); - - if (i_element->first != key) - { - // Doesn't exist, so create a new one. - i_element = insert(std::make_pair(key, mapped_type())); - } - - return i_element->second; - } - - //********************************************************************* - /// Returns a reference to the value at index 'key' - /// If ETL_THROW_EXCEPTIONS is defined, emits an etl::lookup_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 = std::lower_bound(begin(), end(), value_type(key, TMapped()), compare_element()); - - if (i_element == end()) - { - // Doesn't exist. -#if ETL_THROW_EXCEPTIONS - throw lookup_out_of_bounds(); -#else - error_handler::error(lookup_out_of_bounds()); - -#endif - } - - return i_element->second; - } - - //********************************************************************* - /// Returns a const reference to the value at index 'key' - /// If ETL_THROW_EXCEPTIONS is defined, emits an etl::lookup_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 - { - typename buffer_t::const_iterator i_element = std::lower_bound(begin(), end(), value_type(key, TMapped()), compare_element()); - - if (i_element == end()) - { - // Doesn't exist. -#if ETL_THROW_EXCEPTIONS - throw lookup_out_of_bounds(); -#else - error_handler::error(lookup_out_of_bounds()); - -#endif - } - - return i_element->second; - } - - //********************************************************************* - /// Assigns values to the lookup. - /// If ETL_THROW_EXCEPTIONS is defined, emits lookup_full if the lookup does not have enough free space. - /// If ETL_THROW_EXCEPTIONS is defined, emits lookup_iterator if the iterators are reversed. - ///\param first The iterator to the first element. - ///\param last The iterator to the last element + 1. - //********************************************************************* - template - void assign(TIterator first, TIterator last) - { - clear(); - - while (first != last) - { - insert(*first++); - } - } - - //********************************************************************* - /// Inserts a value to the lookup. - /// If ETL_THROW_EXCEPTIONS is defined, emits lookup_full if the lookup is already full. - ///\param position The position to insert at. - ///\param value The value to insert. - //********************************************************************* - iterator insert(const value_type& value) - { - iterator i_element = std::lower_bound(begin(), end(), value, compare_element()); - - if (i_element == end()) - { - // At the end. - if (buffer.full()) - { -#ifdef ETL_THROW_EXCEPTIONS - throw lookup_full(); -#else - error_handler::error(lookup_full()); -#endif - } - else - { - buffer.push_back(value); - } - } - else - { - // Not at the end. - // Existing element? - if (value.first == i_element->first) - { - // Yes. - i_element->second = value.second; - } - else - { - // A new one. - if (buffer.full()) - { -#ifdef ETL_THROW_EXCEPTIONS - throw lookup_full(); -#else - error_handler::error(lookup_full()); -#endif - } - else - { - buffer.insert(i_element, value); - } - } - } - - return i_element; - } - - //********************************************************************* - /// Inserts a range of values to the lookup. - /// If ETL_THROW_EXCEPTIONS is defined, emits lookup_full if the lookup 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 - void insert(TIterator first, TIterator last) - { - while (first != last) - { - insert(*first++); - } - } - - //********************************************************************* - /// Erases an element. - ///\param i_element Iterator to the element. - ///\return An iterator pointing to the element that followed the erased element. - //********************************************************************* - iterator erase(iterator i_element) - { - return buffer.erase(i_element); - } - - //********************************************************************* - /// 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. - ///\return An iterator pointing to the element that followed the erased element. - //********************************************************************* - iterator erase(iterator first, iterator last) - { - return buffer.erase(first, last); - } - - //************************************************************************* - /// Clears the lookup. - //************************************************************************* - void clear() - { - buffer.clear(); - } - - //********************************************************************* - /// 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) - { - return std::lower_bound(begin(), end(), value_type(key, TMapped()), compare_element()); - } - - //********************************************************************* - /// 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 - { - return std::lower_bound(begin(), end(), value_type(key, TMapped()), compare_element()); - } - - protected: - - //********************************************************************* - /// Constructor. - //********************************************************************* - ilookup(buffer_t& buffer) - : lookup_base(buffer), - buffer(buffer) - { - } - - private: - - buffer_t& buffer; - }; - - //*************************************************************************** - /// Equal operator. - ///\param lhs Reference to the first lookup. - ///\param rhs Reference to the second lookup. - ///\return true if the arrays are equal, otherwise false - ///\ingroup lookup - //*************************************************************************** - template - bool operator ==(const etl::ilookup& lhs, const etl::ilookup& rhs) - { - return (lhs.size() == rhs.size()) && std::equal(lhs.begin(), lhs.end(), rhs.begin()); - } - - //*************************************************************************** - /// Not equal operator. - ///\param lhs Reference to the first lookup. - ///\param rhs Reference to the second lookup. - ///\return true if the arrays are not equal, otherwise false - ///\ingroup lookup - //*************************************************************************** - template - bool operator !=(const etl::ilookup& lhs, const etl::ilookup& rhs) - { - return !(lhs == rhs); - } -} - -#undef __ETL_IN_ILOOKUP_H__ -#endif diff --git a/lookup.h b/lookup.h deleted file mode 100644 index b2cdbc02..00000000 --- a/lookup.h +++ /dev/null @@ -1,105 +0,0 @@ -///\file - -/****************************************************************************** -The MIT License(MIT) - -Embedded Template Library. - -Copyright(c) 2014 jwellbelove - -Permission is hereby granted, free of charge, to any person obtaining a copy -of this software and associated documentation files(the "Software"), to deal -in the Software without restriction, including without limitation the rights -to use, copy, modify, merge, publish, distribute, sublicense, and / or sell -copies of the Software, and to permit persons to whom the Software is -furnished to do so, subject to the following conditions : - -The above copyright notice and this permission notice shall be included in all -copies or substantial portions of the Software. - -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE -AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -SOFTWARE. -******************************************************************************/ - -#ifndef __ETL_LOOKUP__ -#define __ETL_LOOKUP__ - -#include -#include -#include - -#include "ilookup.h" -#include "vector.h" - -//***************************************************************************** -///\defgroup lookup lookup -/// A lookup table with the capacity defined at compile time. -/// Has insertion of O(N) and lookup of O(logN) -/// Duplicate entries and not allowed. -///\note Uses a predefined array, so MAX_SIZE_ elements will be always be constructed. -///\ingroup containers -//***************************************************************************** - -namespace etl -{ - template > - //*************************************************************************** - /// A lookup implementation that uses a fixed size buffer. - ///\note Uses a predefined array, so MAX_SIZE_ elements will be always be constructed. - ///\tparam T The element type. - ///\tparam MAX_SIZE_ The maximum number of elements that can be stored. - ///\ingroup lookup - //*************************************************************************** - class lookup : public ilookup - { - public: - - static const size_t MAX_SIZE = MAX_SIZE_; - - //************************************************************************* - /// Constructor. - //************************************************************************* - lookup() - : ilookup(buffer) - { - } - - //************************************************************************* - /// Constructor, from an iterator range. - ///\tparam TIterator The iterator type. - ///\param first The iterator to the first element. - ///\param last The iterator to the last element + 1. - //************************************************************************* - template - lookup(TIterator first, TIterator last) - : ilookup(buffer) - { - ilookup::insert(first, last); - } - - //************************************************************************* - /// Assignment operator. - //************************************************************************* - lookup& operator = (const lookup& rhs) - { - if (&rhs != this) - { - ilookup::clear(); - ilookup::insert(rhs.cbegin(), rhs.cend()); - } - - return *this; - } - - private: - - etl::vector::value_type, MAX_SIZE> buffer; /// - -#include "exception.h" -#include "ivector.h" - -#ifndef ETL_THROW_EXCEPTIONS -#include "error_handler.h" -#endif - -namespace etl -{ - //*************************************************************************** - ///\ingroup lookup - /// Exception base for lookups - //*************************************************************************** - class lookup_exception : public exception - { - public: - - lookup_exception(const char* what) - : exception(what) - { - } - }; - - //*************************************************************************** - ///\ingroup lookup - /// Vector full exception. - //*************************************************************************** - class lookup_full : public lookup_exception - { - public: - - lookup_full() - : lookup_exception("lookup: full") - { - } - }; - - //*************************************************************************** - ///\ingroup lookup - /// Vector out of bounds exception. - //*************************************************************************** - class lookup_out_of_bounds : public lookup_exception - { - public: - - lookup_out_of_bounds() - : lookup_exception("lookup: out of bounds") - { - } - }; - - //*************************************************************************** - ///\ingroup lookup - /// Vector iterator exception. - //*************************************************************************** - class lookup_iterator : public lookup_exception - { - public: - - lookup_iterator() - : lookup_exception("lookup: iterator error") - { - } - }; - - //*************************************************************************** - ///\ingroup lookup - /// The base class for all templated lookup types. - //*************************************************************************** - class lookup_base - { - public: - - typedef size_t size_type; - - //************************************************************************* - /// Gets the current size of the lookup. - ///\return The current size of the lookup. - //************************************************************************* - size_type size() const - { - return vbase.size(); - } - - //************************************************************************* - /// Checks the 'empty' state of the lookup. - ///\return true if empty. - //************************************************************************* - bool empty() const - { - return vbase.empty(); - } - - //************************************************************************* - /// Checks the 'full' state of the lookup. - ///\return true if full. - //************************************************************************* - bool full() const - { - return vbase.full(); - } - - //************************************************************************* - /// Returns the capacity of the lookup. - ///\return The capacity of the lookup. - //************************************************************************* - size_type capacity() const - { - return vbase.capacity(); - } - - //************************************************************************* - /// Returns the maximum possible size of the lookup. - ///\return The maximum size of the lookup. - //************************************************************************* - size_type max_size() const - { - return vbase.max_size(); - } - - //************************************************************************* - /// Returns the remaining capacity. - ///\return The remaining capacity. - //************************************************************************* - size_t available() const - { - return vbase.available(); - } - - protected: - - //************************************************************************* - /// Constructor. - //************************************************************************* - lookup_base(vector_base& vbase) - : vbase(vbase) - { - } - - vector_base& vbase; - }; -} - -#endif