set.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_set_h
#define INCL_evo_set_h

#include "type.h"
#include "strtok.h"

namespace evo {


template<class TKey, class TSize=SizeT>
class Set {
public:
    EVO_CONTAINER_TYPE;
    typedef Set<TKey,TSize> ThisType;                   
    typedef Set<TKey,TSize> SetBaseType;                
    typedef TSize Size;                                 
    typedef TKey  Key;                                  
    typedef TKey  Value;                                
    typedef TKey  Item;                                 

    // Iterator support types
    struct IterKey {
        Size a, b;

        IterKey(Size a=0, Size b=0) : a(a), b(b)
            { }
        IterKey(const IterKey& src)
            { memcpy(this, &src, sizeof(src)); }
    };
    typedef Item IterItem;
    typedef typename IteratorBi<ThisType>::Const Iter;  
    typedef IteratorBi<ThisType>                 IterM; 

protected:
    Size size_;             

    Set() : size_(0)
        { }

    Set(const ThisType&) EVO_ONCPP11(= delete);

    virtual const Value* getiter(IterKey& iterkey, const Value& value) const = 0;

public:
    virtual ~Set()
        { }

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

    // SET

    SetBaseType& operator=(const SetBaseType& src) {
        set(src);
        return *this;
    }

    virtual SetBaseType& set() = 0;

    virtual SetBaseType& set(const SetBaseType& src) = 0;

    virtual SetBaseType& setempty() = 0;

    virtual SetBaseType& clear() = 0;

    // INFO

    virtual bool ordered() const = 0;

    virtual bool null() const = 0;

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

    Size size() const
        { return size_; }

    virtual bool shared() const = 0;

    virtual Size capacity() const = 0;

    // COMPARE

    bool operator==(const SetBaseType& set) const {
        bool result = false;
        if (this == &set)
            result = true;
        else if (this->null())
            result = set.null();
        else if (set.null())
            result = false;
        else if (size_ == set.size_) {
            result = true;
            for (Iter iter(*this); iter; ++iter) {
                if (!set.contains(*iter)) { // lookup rather than rely on ordering
                    result = false;
                    break;
                }
            }
        }
        return result;
    }

    bool operator!=(const SetBaseType& set) const
        { return !this->operator==(set); }

    // CONTAINS

    virtual bool contains(const Value& value) const = 0;

    // FIND

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

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

    IterM begin()
        { return IterM(*this); }

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

    IterM end()
        { return IterM(); }

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

    Iter iter(const Value& value) const {
        IterKey iterkey;
        const Item* item = this->getiter(iterkey, value);
        return (item != NULL ? Iter(*this, iterkey, (IterItem*)item) : Iter(*this, iterEND));
    }

    IterM iterM(const Value& value) {
        IterKey iterkey;
        Item* item = (Item*)this->getiter(iterkey, value);
        return (item != NULL ? IterM(*this, iterkey, (IterItem*)item) : IterM(*this, iterEND));
    }

    virtual Value& get(const Value& value, bool* created=NULL) = 0;

    // INFO_SET

    virtual SetBaseType& unshare() = 0;

    virtual SetBaseType& capacity(Size size) = 0;

    virtual SetBaseType& capacitymin(Size min) = 0;

    virtual SetBaseType& compact()
        { return *this; }

    SetBaseType& reserve(Size size) {
        this->capacitymin(size_ + size);
        return *this;
    }

    // ADD

    virtual Value& add(const Value& value, bool update=false) = 0;

    template<class T>
    Size addfrom(const T& items, bool update=false) {
        if (this != &items) {
            const Size start_size = size_;
            reserve(items.size());
            for (typename T::Iter iter(items); iter; ++iter)
                this->add(*iter, update);
            return (size_ - start_size);
        }
        return 0;
    }

    template<class T>
    Size addsplit(const T& str, char delim=',') {
        Size count = 0;
        StrTok tok(str);
        for (; tok.next(delim); ++count)
            this->add(tok.value().convert<Value>());
        return count;
    }

    // REMOVE

    virtual bool remove(const Value& value) = 0;

    virtual bool remove(IterM& iter, IteratorDir dir=iterNONE) = 0;

    // INTERNAL

    // Iterator support methods (used internally)
    virtual void iterInitMutable() = 0;
    virtual const IterItem* iterFirst(IterKey& key) const = 0;
    virtual const IterItem* iterNext(IterKey& key) const = 0;
    virtual const IterItem* iterLast(IterKey& key) const = 0;
    virtual const IterItem* iterPrev(IterKey& key) const = 0;
};


}
#endif