diff -r 8f65914e7046 -r 5def6ff8b466 src/containers.h --- a/src/containers.h Sun Feb 02 01:50:23 2014 +0200 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,346 +0,0 @@ -/* - Copyright 2012-2014 Santeri Piippo - All rights reserved. - - Redistribution and use in source and binary forms, with or without - modification, are permitted provided that the following conditions - are met: - - 1. Redistributions of source code must retain the above copyright - notice, this list of conditions and the following disclaimer. - 2. Redistributions in binary form must reproduce the above copyright - notice, this list of conditions and the following disclaimer in the - documentation and/or other materials provided with the distribution. - 3. The name of the author may not be used to endorse or promote products - derived from this software without specific prior written permission. - - THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR - IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES - OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. - IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, - INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT - NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, - DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY - THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT - (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF - THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -*/ - -#ifndef BOTC_CONTAINERS_H -#define BOTC_CONTAINERS_H - -#include -#include -#include -#include - -template class list -{ - public: - using list_type = typename ::std::deque; - using iterator = typename list_type::iterator; - using const_iterator = typename list_type::const_iterator; - using reverse_iterator = typename list_type::reverse_iterator; - using const_reverse_iterator = typename list_type::const_reverse_iterator; - using element_type = T; - using self_type = list; - - // ===================================================================== - // - list() {} - - // ===================================================================== - // - list (std::initializer_list vals) - { - m_data = vals; - } - - // ===================================================================== - // - list (const list_type& a) : - m_data (a) {} - - // ===================================================================== - // - iterator begin() - { - return m_data.begin(); - } - - // ===================================================================== - // - const_iterator begin() const - { - return m_data.cbegin(); - } - - // ===================================================================== - // - iterator end() - { - return m_data.end(); - } - - // ===================================================================== - // - const_iterator end() const - { - return m_data.cend(); - } - - // ===================================================================== - // - reverse_iterator rbegin() - { - return m_data.rbegin(); - } - - // ===================================================================== - // - const_reverse_iterator crbegin() const - { - return m_data.crbegin(); - } - - // ===================================================================== - // - reverse_iterator rend() - { - return m_data.rend(); - } - - // ===================================================================== - // - const_reverse_iterator crend() const - { - return m_data.crend(); - } - - // ===================================================================== - // - inline void erase (int pos) - { - assert (pos < size()); - m_data.erase (m_data.begin() + pos); - } - - // ===================================================================== - // - element_type& push_front (const element_type& value) - { - m_data.push_front (value); - return m_data[0]; - } - - // ===================================================================== - // - element_type& push_back (const element_type& value) - { - m_data.push_back (value); - return m_data[m_data.size() - 1]; - } - - // ===================================================================== - // - void push_back (const self_type& vals) - { - for (const T & val : vals) - push_back (val); - } - - // ===================================================================== - // - bool pop (T& val) - { - if (is_empty()) - return false; - - val = m_data[size() - 1]; - m_data.erase (m_data.end() - 1); - return true; - } - - // ===================================================================== - // - T& operator<< (const T& value) - { - return push_back (value); - } - - // ===================================================================== - // - void operator<< (const self_type& vals) - { - push_back (vals); - } - - // ===================================================================== - // - bool operator>> (T& value) - { - return pop (value); - } - - // ===================================================================== - // - self_type reverse() const - { - self_type rev; - - for (const T & val : *this) - val >> rev; - - return rev; - } - - // ===================================================================== - // - void clear() - { - m_data.clear(); - } - - // ===================================================================== - // - void insert (int pos, const element_type& value) - { - m_data.insert (m_data.begin() + pos, value); - } - - // ===================================================================== - // - void makeUnique() - { - // Remove duplicate entries. For this to be effective, the vector must be - // sorted first. - sort(); - iterator pos = std::unique (begin(), end()); - resize (std::distance (begin(), pos)); - } - - // ===================================================================== - // - int size() const - { - return m_data.size(); - } - - // ===================================================================== - // - element_type& operator[] (int n) - { - assert (n < size()); - return m_data[n]; - } - - // ===================================================================== - // - const element_type& operator[] (int n) const - { - assert (n < size()); - return m_data[n]; - } - - // ===================================================================== - // - void resize (int size) - { - m_data.resize (size); - } - - // ===================================================================== - // - void sort() - { - std::sort (begin(), end()); - } - - // ===================================================================== - // - int find (const element_type& needle) const - { - int i = 0; - - for (const element_type& hay : *this) - { - if (&hay == &needle) - return i; - - i++; - } - - return -1; - } - - // ===================================================================== - // - void remove (const element_type& it) - { - int idx; - - if ((idx = find (it)) != -1) - erase (idx); - } - - // ===================================================================== - // - inline bool is_empty() const - { - return size() == 0; - } - - // ===================================================================== - // - self_type mid (int a, int b) const - { - assert (a >= 0 && b >= 0 && a < size() && b < size() && a <= b); - self_type result; - - for (int i = a; i <= b; ++i) - result << operator[] (i); - - return result; - } - - // ===================================================================== - // - inline const list_type& std_deque() const - { - return m_data; - } - - // ===================================================================== - // - const element_type& first() const - { - return *(m_data.begin()); - } - - // ===================================================================== - // - const element_type& last() const - { - return *(m_data.end() - 1); - } - - // ===================================================================== - // - bool contains (const element_type& a) const - { - return find (a) != -1; - } - - private: - list_type m_data; -}; - -// ============================================================================= -// -template list& operator>> (const T& value, list& haystack) -{ - haystack.push_front (value); - return haystack; -} - -#endif // BOTC_CONTAINERS_H