TinySet.h

Go to the documentation of this file.

// Copyright Onix Solutions Limited [OnixS]. All rights reserved.
//
// This software owned by Onix Solutions Limited [OnixS] and is 
// protected by copyright law and international copyright treaties.
//
// Access to and use of the software is governed by the terms of the applicable 
// OnixS Software Services Agreement (the Agreement) and Customer end user license 
// agreements granting a non-assignable, non-transferable and non-exclusive license 
// to use the software for it's own data processing purposes under the terms defined 
// in the Agreement.
//
// Except as otherwise granted within the terms of the Agreement, copying or 
// reproduction of any part of this source code or associated reference material 
// to any other location for further reproduction or redistribution, and any 
// amendments to this copyright notice, are expressly prohibited.
//
// Any reproduction or redistribution for sale or hiring of the Software not in 
// accordance with the terms of the Agreement is a violation of copyright law.
//
 
#pragma once
 
#include <vector>
#include <iterator>
#include <algorithm>
 
#include <OnixS/CME/ConflatedUDP/String.h>
 
ONIXS_CONFLATEDUDP_NAMESPACE_BEGIN

template
<
    class Key
>
class TinySet
{
public:
    typedef Key Item;

    typedef 
    std::vector<Item> 
    Items;

    typedef 
    typename 
    Items::const_iterator 
    ConstIterator;

    TinySet()
    {
    }

    explicit 
    TinySet(
        size_t capacity)
    {
        reserve(capacity);
    }

    TinySet(
        const TinySet& other)
        : items_(other.items_)
    {
    }

    ~TinySet()
    {
    }

    bool empty() const
    {
        return items_.empty();
    }

    size_t size() const
    {
        return items_.size();
    }

    void
    reserve(
        size_t capacity)
    {
        items_.reserve(capacity);
    }

    ConstIterator 
    begin() const
    {
        return items_.begin();
    }

    ConstIterator 
    end() const
    {
        return items_.end();
    }

    ConstIterator 
    find(
        const Item& item) const
    {
        return 
            std::find(
                items_.begin(), 
                items_.end(), 
                item);
    }

    bool 
    insert(
        const Item& item)
    {
        if (end() == find(item))
        {
            items_.push_back(item);
 
            return true;
        }
 
        return false;
    }

    bool 
    erase(
        const Item& item)
    {
        typename 
        Items::iterator 
        const 
        found = 
            std::find(
                items_.begin(),
                items_.end(),
                item);
 
        if (items_.end() == found)
            return false;
 
        items_.erase(found);
 
        return true;
    }

    void
    clear()
    {
        items_.clear();
    }

    void
    swap(
        TinySet& other)
    {
        std::swap(
            items_, 
            other.items_);
    }

    TinySet&
    operator =(
        const TinySet& other)
    {
        if (&other != this)
        {
            TinySet copy(other);
 
            swap(copy);
        }
 
        return *this;
    }
 
private:
    Items items_;
};

ONIXS_CONFLATEDUDP_LTWT_CLASS 
TinyStrSetIterator
{
public:
    typedef 
    std::vector<std::string>
    Items;

    typedef 
    Items::const_iterator 
    ItemIterator;

    TinyStrSetIterator()
    {
    }

    TinyStrSetIterator(
        const TinyStrSetIterator& other)
        : iterator_(other.iterator_)
    {
    }

    explicit
    TinyStrSetIterator(
        const ItemIterator& iterator)
        : iterator_(iterator)
    {
    }

    ~TinyStrSetIterator()
    {
    }

    StrRef
    operator *() const
    {
        return toStrRef(*iterator_);
    }

    bool 
    operator ==(
        const 
        TinyStrSetIterator& other) const
    {
        return iterator_ == other.iterator_;
    }

    bool 
    operator !=(
        const 
        TinyStrSetIterator& other) const
    {
        return iterator_ != other.iterator_;
    }

    TinyStrSetIterator&
    operator =(
        const 
        TinyStrSetIterator& other)
    {
        iterator_ = other.iterator_;
 
        return *this;
    }

    TinyStrSetIterator&
    operator ++()
    {
        ++iterator_;
 
        return *this;
    }
 
private:
    ItemIterator iterator_;
};

ONIXS_CONFLATEDUDP_LTWT_CLASS
TinyStrSet
{
    typedef 
    std::vector<std::string>
    Items;
 
    typedef 
    Items::const_iterator
    ItemConstIterator;
 
    typedef 
    Items::iterator
    ItemIterator;
 
    class ItemLocator
    {
        StrRef sought_;
 
    public:
        ItemLocator(
            const StrRef& sought)
            : sought_(sought)
        {
        }
 
        bool 
        operator ()(
            const 
            std::string& other) const
        {
            return sought_ == other;
        }
    };
 
    Items items_;
 
public:
    typedef StrRef Item;

    typedef 
    TinyStrSetIterator
    ConstIterator;

    TinyStrSet()
    {
    }

    explicit
    TinyStrSet(
        size_t capacity)
    {
        reserve(capacity);
    }

    TinyStrSet(
        const TinyStrSet& other)
        : items_(other.items_)
    {
    }

    ~TinyStrSet()
    {
    }

    bool empty() const
    {
        return items_.empty();
    }

    size_t size() const
    {
        return items_.size();
    }

    void
    reserve(
        size_t capacity)
    {
        items_.reserve(capacity);
    }

    ConstIterator 
    begin() const
    {
        return 
            ConstIterator(
                items_.begin());
    }

    ConstIterator 
    end() const
    {
        return 
            ConstIterator(
                items_.end());
    }

    ConstIterator 
    find(
        const Item& item) const
    {
        return 
            ConstIterator(
                std::find_if(
                    items_.begin(), 
                    items_.end(), 
                    ItemLocator(item)));
    }

    bool 
    insert(
        const Item& item)
    {
        if (end() == find(item))
        {
            items_.push_back(toStr(item));
 
            return true;
        }
 
        return false;
    }

    bool 
    erase(
        const Item& item)
    {
        ItemIterator
        const found = 
            std::find_if(
                items_.begin(), 
                items_.end(), 
                ItemLocator(item));
 
        if (items_.end() == found)
            return false;
 
        items_.erase(found);
 
        return true;
    }

    void
    clear()
    {
        items_.clear();
    }

    void
    swap(
        TinyStrSet& other)
    {
        std::swap
        (
            items_, 
            other.items_
        );
    }
};
 
ONIXS_CONFLATEDUDP_NAMESPACE_END