map.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_map_h
#define INCL_evo_map_h

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

namespace evo {


template<class TKey, class TValue, class TSize=SizeT>
class Map {
public:
    EVO_CONTAINER_TYPE;
    typedef Map<TKey,TValue,TSize> ThisType;                
    typedef Map<TKey,TValue,TSize> MapBaseType;             
    typedef TSize           Size;                           
    typedef TKey            Key;                            
    typedef TValue          Value;                          
    typedef Pair<Key,Value> 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)); }
        IterKey& operator=(const IterKey& src)
            { memcpy(this, &src, sizeof(src)); return *this; }
    };
    typedef Pair<const Key,Value> IterItem;
    typedef typename IteratorBi<ThisType>::Const Iter;      
    typedef IteratorBi<ThisType>                 IterM;     

#if defined(EVO_CPP11)
    using KeyPass = typename DataCopy<TKey>::PassType;      
    using ValuePass = typename DataCopy<TValue>::PassType;  

    struct InitPair {
        KeyPass   key;     
        ValuePass value;   

        InitPair(KeyPass key, ValuePass value) : key(key), value(value) {
        }

        InitPair() = delete;
        InitPair(const InitPair&) = delete;
        InitPair& operator=(const InitPair&) = delete;
    };
#endif

protected:
    Size       size_;           
    bool       ordered_;        

    Map() : size_(0), ordered_(true)
        { }

    Map(bool ordered) : size_(0), ordered_(ordered)
        { }

    Map(const Map&) EVO_ONCPP11(= delete);

    virtual const Item* getiter(IterKey& iterkey, const Key& key) const = 0;

public:
    virtual ~Map()
        { }

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

    // SET

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

    virtual MapBaseType& set() = 0;

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

    virtual MapBaseType& setempty() = 0;

    virtual MapBaseType& clear() = 0;

    // INFO

    bool ordered() const
        { return ordered_; }

    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 MapBaseType& map) const {
        bool result = false;
        if (this == &map)
            result = true;
        else if (this->null())
            result = map.null();
        else if (map.null())
            result = false;
        else if (size_ == map.size_) {
            result = true;
            if (size_ > 0) {
                const Value* val;
                for (Iter iter(*this); iter; ++iter) {
                    val = map.find(iter->first);
                    if (val == NULL || !(*val == iter->second)) {
                        result = false;
                        break;
                    }
                }
            }
        }
        return result;
    }

    bool operator!=(const MapBaseType& map) const
        { return !this->operator==(map); }

    // 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(); }

    virtual bool contains(const Key& key) const = 0;

    virtual const Value* find(const Key& key) const = 0;

    virtual Value* findM(const Key& key) = 0;

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

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

    virtual Item& getitem(const Key& key, bool* created=NULL) = 0;

    Value& get(const Key& key, bool* created=NULL)
        { return this->getitem(key, created).second; }

    // INFO_SET

    Value& operator[](const Key& key)
        { return this->getitem(key, NULL).second; }

    virtual MapBaseType& unshare() = 0;

    virtual MapBaseType& capacity(Size size) = 0;

    virtual MapBaseType& capacitymin(Size min) = 0;

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

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

    // ADD

    virtual Item& add(const Key& key, const Value& value, bool update=true) = 0;

    virtual Item& add(const Item& item, bool update=true) = 0;

    virtual MapBaseType& add(const MapBaseType& map, bool update=true) = 0;

    template<class T>
    Size addsplit(const T& str, char delim=',', char kvdelim='=') {
        char delims_buf[2];
        delims_buf[0] = delim;
        delims_buf[1] = kvdelim;
        const SubString delims(delims_buf, 2);
        const SubString EMPTY;

        Size count = 0;
        bool created;
        StrTok tok(str);
        for (; tok.nextany(delims); ++count) {
            Value& val = get(tok.value().convert<Key>(), &created);
            if (tok.delim().null() || *tok.delim() == delim) {
                if (!created)
                    DataCopy<Value>::set_default(val);
            } else {
                tok.next(delim);
                val = tok.value().convert<Value>();
            }
        }
        return count;
    }

    // REMOVE

    virtual bool remove(const Key& key) = 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;
};


template<class T> inline bool map_contains(const T& map, const typename T::Key& key, const typename T::Value& value) {
    const typename T::Value* p = map.find(key);
    return (p != NULL && *p == value);
}

template<class TMap>
inline SubString lookupsub(const TMap& map, const typename TMap::Key& key) {
    const typename TMap::Value* val = map.find(key);
    return (val != NULL ? SubString(*val) : SubString());
}

// STD/STL container helpers

template<class TMap>
inline SubString stdlookupsub(const TMap& map, const typename TMap::key_type& key) {
    typename TMap::const_iterator i = map.find(key);
    return (i != map.end() ? SubString(i->second) : SubString());
}

template<class TMap>
inline const typename TMap::mapped_type* stdlookup(const TMap& map, const typename TMap::key_type& key) {
    typename TMap::const_iterator i = map.find(key);
    return (i != map.end() ? &i->second : NULL);
}

template<class TMap>
inline typename TMap::mapped_type* stdlookupM(TMap& map, const typename TMap::key_type& key) {
    typename TMap::iterator i = map.find(key);
    return (i != map.end() ? &i->second : NULL);
}


}
#endif