sublist.h

Go to the documentation of this file.

// Evo C++ Library
/* Copyright 2019 Justin Crowell
Distributed under the BSD 2-Clause License -- see included file LICENSE.txt for details.
*/

#pragma once
#ifndef INCL_evo_sublist_h
#define INCL_evo_sublist_h

#include "impl/container.h"
#include "impl/iter.h"

namespace evo {


template<class T,class TSize=SizeT>
struct SubList : public ListBase<T,TSize> {
    using ListBase<T,TSize>::data_;
    using ListBase<T,TSize>::size_;

    EVO_CONTAINER_TYPE;                             
    typedef TSize               Size;               
    typedef Size                Key;                
    typedef T                   Value;              
    typedef T                   Item;               
    typedef typename DataCopy<T>::PassType ItemVal; 

    typedef SubList<T,Size>     ThisType;           
    typedef SubList<T,Size>     SubListType;        
    typedef ListBase<T,Size>    ListBaseType;       

    // Iterator support types
    typedef Key IterKey;
    typedef T   IterItem;
    typedef typename IteratorRa<ThisType>::Const Iter;  

    SubList() {
        data_ = NULL;
        size_ = 0;
    }

    SubList(const ThisType& data) {
        data_ = data.data_;
        size_ = data.size_;
    }

    SubList(const ListBaseType& data) {
        data_ = data.data_;
        size_ = data.size_;
    }

    SubList(const ListBaseType& data, Key index, Size size=ALL) {
        if (data.data_ == NULL) {
            data_ = NULL;
            size_ = 0;
        } else {
            if (index > data.size_)
                index = data.size_;
            const Size max_size = data.size_ - index;
            data_ = (Item*)data.data_ + index;
            size_ = (size > max_size ? max_size : size);
        }
    }

    SubList(const ListBaseType* data) {
        if (data == NULL) {
            data_ = NULL;
            size_ = 0;
        } else {
            data_ = data->data_;
            size_ = data->size_;
        }
    }

    SubList(const Item* data, Size size) {
        data_ = (Item*)data;
        size_ = size;
    }

    SubList(const Item* data, ValNull v, ItemVal term=0) {
        EVO_PARAM_UNUSED(v);
        data_ = (Item*)data;
        size_ = 0;
        if (data != NULL)
            while (!(data[size_] == term))
                ++size_;
    }

#if defined(EVO_CPP11)

    SubList(ThisType&& src) {
        ::memcpy(this, &src, sizeof(ThisType));
    }

    ThisType& operator=(ThisType&& src) {
        ::memcpy(this, &src, sizeof(ThisType));
        return *this;
    }
#endif

    const ThisType& asconst() const {
        return *this;
    }

    // SET

    ThisType& operator=(const ThisType& src) {
        ::memcpy(this, &src, sizeof(ThisType));
        return *this;
    }

    ThisType& operator=(const ValNull& val) {
        EVO_PARAM_UNUSED(val);
        data_ = NULL;
        size_ = 0;
        return *this;
    }

    ThisType& operator=(const ValEmpty& val) {
        EVO_PARAM_UNUSED(val);
        data_ = NULL;
        size_ = 0;
        return *this;
    }

    ThisType& operator=(const ListBaseType& data) {
        data_ = data.data_;
        size_ = data.size_;
        return *this;
    }

    ThisType& operator=(const ListBaseType* data) {
        if (data == NULL) {
            data_ = NULL;
            size_ = 0;
        } else {
            data_ = data->data_;
            size_ = data->size_;
        }
        return *this;
    }

    ThisType& clear() {
        if (size_ > 0) {
            data_ = EVO_PEMPTY;
            size_ = 0;
        }
        return *this;
    }

    ThisType& set() {
        data_ = NULL;
        size_ = 0;
        return *this;
    }

    ThisType& set(const ListBaseType& data) {
        data_ = data.data_;
        size_ = data.size_;
        return *this;
    }

    ThisType& set(const ListBaseType& data, Key index, Key size=ALL) {
        if (data.data_ == NULL) {
            data_ = NULL;
            size_ = 0;
        } else {
            if (index > data.size_)
                index = data.size_;
            const Size max_size = data.size_ - index;
            data_ = (Item*)data.data_ + index;
            size_ = (size > max_size ? max_size : size);
        }
        return *this;
    }

    ThisType& set(const ListBaseType* data) {
        if (data == NULL)
            set();
        else
            set(*data);
        return *this;
    }

    ThisType& set(const Item* data, Size size) {
        data_ = (Item*)data;
        size_ = size;
        return *this;
    }

    ThisType& set2(const ListBaseType& data, Key index1, Key index2) {
        if (data.data_ == NULL) {
            data_ = NULL;
            size_ = 0;
        } else {
            if (index1 > data.size_)
                index1 = data.size_;
            data_ = (Item*)data.data_ + index1;
            if (index2 > data.size_)
                size_ = data.size_ - index1;
            else if (index2 <= index1)
                size_ = 0;
            else
                size_ = index2 - index1;
        }
        return *this;
    }

    ThisType& setempty()
        { data_ = EVO_PEMPTY; size_ = 0; return *this; }

    // INFO

    bool null() const
        { return (data_ == NULL); }

    bool empty() const
        { return (size_ == 0); }

    Size size() const
        { return size_; }

    bool shared() const
        { return false; }

    const Item* data() const
        { return data_; }

    const Item& operator[](Key index) const {
        assert( index < size_ );
        return data_[index];
    }

    const Item& item(Key index) const {
        assert( index < size_ );
        return data_[index];
    }

    const Item* first() const
        { return (size_ > 0 ? data_ : NULL); }

    const Item* last() const
        { return (size_ > 0 ? data_+size_-1 : NULL); }

    Key iend(Size offset=0) const
        { return (offset >= size_ ? END : size_ - 1 - offset); }

    ulong hash(ulong seed=0) const
        { return DataHash<Item>::hash(data_, size_, seed); }

    // COMPARE

    int compare(const ListBaseType& data) const {
        int result;
        if (data_ == NULL)
            result = (data.data_ != NULL ? -1 : 0);
        else if (data.data_ == NULL)
            result = 1;
        else
            result = DataCompare<Item>::compare(data_, size_, data.data_, data.size_);
        return result;
    }

    bool operator==(const ListBaseType& data) const {
        bool result;
        if (data_ == NULL)
            result = (data.data_ == NULL);
        else if (data.data_ == NULL)
            result = false;
        else
            result = (DataCompare<Item>::compare(data_, size_, data.data_, data.size_) == 0);
        return result;
    }

    bool operator!=(const ListBaseType& data) const {
        bool result;
        if (data_ == NULL)
            result = (data.data_ != NULL);
        else if (data.data_ == NULL)
            result = true;
        else
            result = (DataCompare<Item>::compare(data_, size_, data.data_, data.size_) != 0);
        return result;
    }

    bool starts(ItemVal item) const
        { return (size_ > 0 && *data_ == item); }

    bool starts(const Item* items, Size size) const
        { return (size > 0 && size_ >= size && DataEqual<Item>::equal(data_, items, size)); }

    bool starts(const ListBaseType& items) const
        { return (items.size_ > 0 && size_ >= items.size_ && DataEqual<Item>::equal(data_, items.data_, items.size_)); }

    bool ends(ItemVal item) const
        { return (size_ > 0 && data_[size_-1] == item); }

    bool ends(const Item* items, Size size) const
        { return (size > 0 && size_ >= size && DataEqual<Item>::equal(data_+size_-size, items, size)); }

    bool ends(const ListBaseType& items) const
        { return (items.size_ > 0 && size_ >= items.size_ && DataEqual<Item>::equal(data_+size_-items.size_, items.data_, items.size_)); }

    // FIND

    Iter cbegin() const
        { return Iter(*this); }

    Iter cend() const
        { return Iter(); }

    Iter begin() const
        { return Iter(*this); }

    Iter end() const
        { return Iter(); }

    Key find(ItemVal item, Key start=0, Key end=END) const {
        if (end > size_)
            end = size_;
        for (; start<end; ++start)
            if (data_[start] == item)
                return start;
        return (Key)NONE;
    }

    Key findr(ItemVal item, Key start=0, Key end=END) const {
        if (end > size_)
            end = size_;
        while (end>start)
            if (data_[--end] == item)
                return end;
        return (Key)NONE;
    }

    Key findany(const Item* items, Size count, Key start=0, Key end=END) const {
        Size j;
        if (end > size_)
            end = size_;
        for (; start<end; ++start)
            for (j=0; j<count; ++j)
                if (data_[start] == items[j])
                    return start;
        return (Key)NONE;
    }

    Key findanyr(const Item* items, Size count, Key start=0, Key end=END) const {
        Size j;
        if (end > size_)
            end = size_;
        while (end>start) {
            --end;
            for (j=0; j<count; ++j)
                if (data_[end] == items[j])
                    return end;
        }
        return (Key)NONE;
    }

    bool contains(ItemVal item) const {
        bool result = false;
        for (Key i=0; i<size_; ++i)
            if (data_[i] == item)
                { result = true; break; }
        return result;
    }

    bool contains(const Item* data, Size size) const {
        bool result = false;
        if (size > 0 && size_ >= size) {
            const Size end = size_ - size;
            for (Key i=0; i<=end; ++i)
                if (DataEqual<Item>::equal(data_+i, data, size))
                    { result = true; break; }
        }
        return result;
    }

    bool contains(const ListBaseType& data) const {
        bool result = false;
        if (data.size_ > 0 && size_ >= data.size_) {
            const Size end = size_ - data.size_;
            for (Key i=0; i<=end; ++i)
                if (DataEqual<Item>::equal(data_+i, data.data_, data.size_))
                    { result = true; break; }
        }
        return result;
    }

    // SPLIT

    template<class T1,class T2>
    bool splitat(Key index, T1& left, T2& right) const {
        bool result = false;
        if (index >= size_) {
            left.set(*this);
            right.set();
        } else {
            left.set(*this, 0, index);
            right.set(*this, index+1, size_-index-1);
            result = true;
        }
        return result;
    }

    template<class T1>
    bool splitat(Key index, T1& left) const {
        bool result = false;
        if (index >= size_)
            left.set(*this);
        else {
            left.set(*this, 0, index);
            result = true;
        }
        return result;
    }

    template<class T2>
    bool splitat(Key index, ValNull left, T2& right) const {
        EVO_PARAM_UNUSED(left);
        bool result = false;
        if (index >= size_)
            right.set();
        else {
            right.set(*this, index+1, size_-index-1);
            result = true;
        }
        return result;
    }

    bool splitat_setl(Key index) {
        bool result = false;
        if (index < size_) {
            set(data_, index);
            result = true;
        }
        return result;
    }

    template<class T2>
    bool splitat_setl(Key index, T2& right) {
        bool result = false;
        if (index >= size_) {
            right.set();
        } else {
            right.set(*this, index+1, size_-index-1);
            set(data_, index);
            result = true;
        }
        return result;
    }

    bool splitat_setr(Key index) {
        bool result = false;
        if (index >= size_)
            set();
        else {
            set(data_+index+1, size_-index-1);
            result = true;
        }
        return result;
    }
    
    template<class T1>
    bool splitat_setr(Key index, T1& left) {
        bool result = false;
        if (index >= size_) {
            left.set(*this);
            set();
        } else {
            left.set(*this, 0, index);
            set(data_+index+1, size_-index-1);
            result = true;
        }
        return result;
    }

    // TRIM

    ThisType& triml(Size size) {
        if (size < size_) {
            size_ -= size;
            data_ += size;
        } else if (size_ > 0) {
            data_ = EVO_PEMPTY;
            size_ = 0;
        }
        return *this;
    }

    ThisType& trimr(Size size) {
        if (size < size_) {
            size_ -= size;
        } else if (size_ > 0) {
            data_ = EVO_PEMPTY;
            size_ = 0;
        }
        return *this;
    }

    ThisType& truncate(Size size) {
        if (size < size_) {
            if (size == 0)
                data_ = EVO_PEMPTY;
            size_ = size;
        }
        return *this;
    }

    // SLICE

    ThisType& slice(Key index) {
        if (index < size_) {
            data_ += index;
            size_ -= index;
        } else if (size_ > 0) {
            data_ = EVO_PEMPTY;
            size_ = 0;
        }
        return *this;
    }

    ThisType& slice(Key index, Size size) {
        if (index < size_) {
            data_ += index;
            const Size maxsize = size_ - index;
            if (size > maxsize)
                size_ = maxsize;
            else
                size_ = size;
        } else if (size_ > 0) {
            data_ = EVO_PEMPTY;
            size_ = 0;
        }
        return *this;
    }

    ThisType& slice2(Key index1, Key index2)
        { return slice(index1, (index1 < index2 ? index2-index1 : 0)); }

    // UNSHARE

    ThisType& unshare()
        { return *this; }

    // SWAP

    void swap(ThisType& list)
        { EVO_IMPL_CONTAINER_SWAP(this, &list, ThisType); }

    // INTERNAL

    // Iterator support methods
    void iterInitMutable()
        { }
    const IterItem* iterFirst(IterKey& key) const
        { key = 0; return data_; }
    const IterItem* iterNext(IterKey& key) const {
        const IterItem* result = NULL;
        if (key != END) {
            if (++key < size_)
                result = data_ + key;
            else
                key = END;
        }
        return result;
    }
    const IterItem* iterNext(Size count, IterKey& key) const {
        const IterItem* result = NULL;
        if (key != END) {
            if ( (key+=count) < size_ )
                result = data_ + key;
            else
                key = END;
        }
        return result;
    }
    const IterItem* iterLast(IterKey& key) const {
        const IterItem* result = NULL;
        if (size_ > 0) {
            key    = size_ - 1;
            result = data_ + key;
        }
        return result;
    }
    const IterItem* iterPrev(IterKey& key) const {
        const IterItem* result = NULL;
        if (key != END) {
            if (key > 0)
                result = data_ + --key;
            else
                key = END;
        }
        return result;
    }
    const IterItem* iterPrev(Size count, IterKey& key) const {
        const IterItem* result = NULL;
        if (key != END) {
            if (key > 0 && count <= key)
                result = data_ + (key-=count);
            else
                key = END;
        }
        return result;
    }
    Size iterCount() const
        { return size_; }
    const IterItem* iterSet(IterKey key) const {
        const IterItem* result = NULL;
        if (key < size_)
            result = data_ + key;
        return result;
    }
};


}
#endif