list_t.hpp

Go to the documentation of this file.

/*
 * Title:        bits/list_t.hpp
 * Description:  C++ header-only wrapper for C-ABI data_t type
 * $Copyright (c) 2015-2017 Software AG, Darmstadt, Germany and/or Software AG USA Inc., Reston, VA, USA, and/or its subsidiaries and/or its affiliates and/or their licensors.$
 * Use, reproduction, transfer, publication or disclosure is prohibited except as specifically provided for in your License Agreement with Software AG
 * @Version:     $Id: list_t.hpp 309474 2017-06-13 10:13:34Z mben $
 */

#ifndef _DATAT_BITS_INCLUDE_TAG
#error Must only be included from sag_connectivity_cpp.hpp, use that instead
#endif

class list_t: protected sag_underlying_vector_t
{
        friend class data_t;
        friend class map_t;
        friend class Message;
        static size_t MIN_CAPACITY() { return 10; }
public:
        template<typename DATA, typename UNDERLYING>
        struct _iterator: public std::iterator<std::random_access_iterator_tag, DATA>
        {
                typedef _iterator<DATA, UNDERLYING> iterator;
                _iterator() : ptr(nullptr), direction(1) {}
                explicit _iterator(UNDERLYING ptr, bool forward=true)
                        : ptr(ptr), direction(forward?1:-1)
                {}
                iterator &operator+=(size_t n) { ptr += direction*n; return *this; }
                iterator &operator-=(size_t n) { ptr -= direction*n; return *this; }
                iterator operator+(size_t n) const { return iterator(ptr+(direction*n), direction>0); }
                iterator operator-(size_t n) const { return iterator(ptr+(direction*-n), direction > 0); }
                ptrdiff_t operator-(const iterator &other) const { return direction*(ptr-other.ptr); }
                DATA &operator[](size_t n) const { return static_cast<DATA&>(ptr[n*direction]); }
                bool operator<(const iterator &other) const { return direction>0 ? ptr < other.ptr : ptr > other.ptr; }
                bool operator>(const iterator &other) const { return direction>0 ? ptr > other.ptr : ptr < other.ptr; }
                bool operator>=(const iterator &other) const { return direction>0 ? ptr >= other.ptr : ptr <= other.ptr; }
                bool operator<=(const iterator &other) const { return direction>0 ? ptr <= other.ptr : ptr >= other.ptr; }
                bool operator==(const iterator &other) const { return ptr == other.ptr; }
                bool operator!=(const iterator &other) const { return !operator==(other); }
                iterator &operator++() { return operator+=(1); }
                iterator operator++(int)
                {
                        iterator tmp(*this);
                        operator++();
                        return tmp;
                }
                iterator &operator--() { return operator-=(1); }
                iterator operator--(int)
                {
                        iterator tmp(*this);
                        operator--();
                        return tmp;
                }
                DATA &operator*() const { return static_cast<DATA&>(*ptr); }
                DATA *operator->() const { return static_cast<DATA*>(ptr); }
                UNDERLYING ptr;
                int64_t direction;
        };
        typedef _iterator<data_t, sag_underlying_data_t *> iterator;
        typedef _iterator<const data_t, const sag_underlying_data_t *> const_iterator;

        list_t()
        {
                table = nullptr;
        }
        explicit list_t(size_t n);

        ~list_t()
        {
                clear();
        }

        list_t &operator=(list_t &&other)
        {
                list_t tmp;
                // put us in tmp
                swap(std::move(tmp));
                // put other in us (and by extension the null tmp in other)
                swap(std::move(other));
                return *this;
        }
        list_t(list_t &&other)
        {
                table = nullptr;
                swap(std::move(other));
        }

        list_t(std::initializer_list<data_t> l)
        {
                table = nullptr;
                for(auto it = l.begin(); it != l.end(); ++it) {
                        push_back(it->copy());
                }
        }

        void swap(list_t &&other)
        {
                std::swap(table, other.table);
        }
        list_t copy() const
        {
                list_t newlist(size());
                for (const_iterator it = begin(); it != end(); ++it) {
                        newlist.push_back(it->copy());
                }
                return newlist;
        }

private:
        list_t &operator=(const list_t &other) { abort(); }
        list_t(const list_t &other) { abort(); }
public:

        bool operator==(const list_t &other) const;

        bool operator!=(const list_t &other) const { return !operator==(other); }

        /* Iteration: 
         * begin() and end() methods, both const and non-const, forward and backward.
         */
        iterator begin() { return iterator(table?table->data:0); }
        iterator end() { return iterator(table?table->data+table->count:0); }
        const_iterator begin() const { return const_iterator(table?table->data:0); } 
        const_iterator end() const { return const_iterator(table?table->data+table->count:0); } 
        const_iterator cbegin() const { return const_iterator(table?table->data:0); } 
        const_iterator cend() const { return const_iterator(table?table->data+table->count:0); } 
        iterator rbegin() { return iterator(table?table->data+table->count-1:0, false); } 
        iterator rend() { return iterator(table?table->data-1:0, false); } 
        const_iterator rbegin() const { return const_iterator(table?table->data+table->count-1:0, false); } 
        const_iterator rend() const { return const_iterator(table?table->data-1:0, false); } 

        size_t size() const { return table?table->count:0; }
        bool empty() const { return 0 == size(); }

        const data_t &operator[](size_t n) const;
        data_t &operator[](size_t n);
        const data_t &front() const { return operator[](0); }
        const data_t &back() const { return operator[](table?table->count-1:0); }
        data_t &front() { return operator[](0); }
        data_t &back() { return operator[](table?table->count-1:0); }

        void reserve(size_t n)
        {
                if (!table) resize(n);
                if (n > table->capacity) resize(n);
        }
        void clear();

        void push_back(data_t &&d);

        void pop_back();

private:
        void resize(size_t newsize);
};