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/MDH/String.h>
 
ONIXS_CMEMDH_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_;
};

class ONIXS_CMEMDH_LTWT 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_;
};

class ONIXS_CMEMDH_LTWT TinyStrSet
{
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)
    {
        const ItemIterator 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_);
    }
 
private:
    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_;
};
 
ONIXS_CMEMDH_NAMESPACE_END