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

/// Class implementing set optimized
/// for storing small number of items.
template <class Key>
class TinySet
{
public:
    /// Aliases set item type.
    typedef Key Item;

    /// Aliases internal representation.
    typedef std::vector<Item> Items;

    /// Aliases iterator over set items.
    typedef typename Items::const_iterator ConstIterator;

    /// Initializes the empty set.
    TinySet() {}

    /// Initializes the empty set and configures
    /// the internal storage to be enough capacious
    /// to store the given number of items.
    explicit TinySet(size_t capacity)
    {
        reserve(capacity);
    }

    /// Initializes the set as a copy of the other one.
    TinySet(const TinySet& other)
        : items_(other.items_)
    {
    }

    /// Cleans everything up.
    ~TinySet() {}

    /// Indicates whether the set is empty.
    bool empty() const
    {
        return items_.empty();
    }

    /// Returns the number of items in the set.
    size_t size() const
    {
        return items_.size();
    }

    /// Makes the internal storage capacious
    /// enough to store the given number of items.
    void reserve(size_t capacity)
    {
        items_.reserve(capacity);
    }

    /// Provides iterating facilities.
    ConstIterator begin() const
    {
        return items_.begin();
    }

    /// Provides iterating facilities.
    ConstIterator end() const
    {
        return items_.end();
    }

    /// Tells whether the set contains given item.
    ConstIterator find(const Item& item) const
    {
        return std::find(items_.begin(), items_.end(), item);
    }

    /// Inserts the given item into the set.
    ///
    /// Returned value indicates whether the
    /// item was inserted (true) or the set
    /// already contained the given item (false).
    bool insert(const Item& item)
    {
        if (end() == find(item))
        {
            items_.push_back(item);

            return true;
        }

        return false;
    }

    /// Removes the given item from the set.
    ///
    /// Returned value indicates whether
    /// the item was actually removed.
    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;
    }

    /// Brings the set to the blank state.
    void clear()
    {
        items_.clear();
    }

    /// Swaps content with the other instance.
    void swap(TinySet& other)
    {
        std::swap(items_, other.items_);
    }

    /// Re-initializes the instance
    /// as a copy of the other one.
    TinySet& operator=(const TinySet& other)
    {
        if (&other != this)
        {
            TinySet copy(other);

            swap(copy);
        }

        return *this;
    }

private:
    Items items_;
};

/// Implements iterator for the TinyStrSet class.
class ONIXS_CMEMDH_LTWT TinyStrSetIterator
{
public:
    /// Aliases for internal representation.
    typedef std::vector<std::string> Items;

    /// Aliases iterator over the internal store.
    typedef Items::const_iterator ItemIterator;

    /// Initializes the iterator pointing to nowhere.
    TinyStrSetIterator() {}

    /// Initializes the instance as a copy of the other one.
    TinyStrSetIterator(const TinyStrSetIterator& other)
        : iterator_(other.iterator_)
    {
    }

    /// Initializes from iterator over the internal storage.
    explicit TinyStrSetIterator(const ItemIterator& iterator)
        : iterator_(iterator)
    {
    }

    /// Cleans everything up.
    ~TinyStrSetIterator() {}

    /// Provides access to the underlying object.
    StrRef operator*() const
    {
        return toStrRef(*iterator_);
    }

    /// Compares with the other instance.
    bool operator==(const TinyStrSetIterator& other) const
    {
        return iterator_ == other.iterator_;
    }

    /// Compares with the other instance.
    bool operator!=(const TinyStrSetIterator& other) const
    {
        return iterator_ != other.iterator_;
    }

    /// Re-initializes as a copy of the other instance.
    TinyStrSetIterator& operator=(const TinyStrSetIterator& other)
    {
        iterator_ = other.iterator_;

        return *this;
    }

    /// Advances the instance to the
    /// next item in the collection.
    TinyStrSetIterator& operator++()
    {
        ++iterator_;

        return *this;
    }

private:
    ItemIterator iterator_;
};

/// Implements TinySet for StrRef class.
///
/// In contrast to TinySet<StrRef> instantiation,
/// given class allocates space for content being
/// referenced by StrRef instances inserted into
/// the given set thus making content safe for
/// referencing.
class ONIXS_CMEMDH_LTWT TinyStrSet
{
public:
    /// Items of collection.
    typedef StrRef Item;

    /// Aliases iterator type.
    typedef TinyStrSetIterator ConstIterator;

    /// Initializes the empty set.
    TinyStrSet() {}

    /// Initializes the empty set capacious
    /// enough to store the given number of items.
    explicit TinyStrSet(size_t capacity)
    {
        reserve(capacity);
    }

    /// Initializes as a copy of the other instance.
    TinyStrSet(const TinyStrSet& other)
        : items_(other.items_)
    {
    }

    /// Destructs the internal storage.
    ~TinyStrSet() {}

    /// Indicates whether the set is empty.
    bool empty() const
    {
        return items_.empty();
    }

    /// Returns the number of items in the set.
    size_t size() const
    {
        return items_.size();
    }

    /// Makes the internal storage capacious
    /// enough to store the given number of items.
    void reserve(size_t capacity)
    {
        items_.reserve(capacity);
    }

    /// Provides iterating facilities.
    ConstIterator begin() const
    {
        return ConstIterator(items_.begin());
    }

    /// Provides iterating facilities.
    ConstIterator end() const
    {
        return ConstIterator(items_.end());
    }

    /// Looks for the given item and returns iterator
    /// pointing to the found entry or to nowhere.
    ConstIterator find(const Item& item) const
    {
        return ConstIterator(std::find_if(items_.begin(), items_.end(), ItemLocator(item)));
    }

    /// Inserts the given item into the set.
    ///
    /// Content referenced by the item being
    /// inserted is copied into the internal
    /// storage.
    ///
    /// Returned value indicates whether
    /// the item was actually inserted.
    bool insert(const Item& item)
    {
        if (end() == find(item))
        {
            items_.push_back(toStr(item));

            return true;
        }

        return false;
    }

    /// Removes the given item from the set.
    ///
    /// Returned value indicates whether
    /// item was actually erased.
    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;
    }

    /// Brings the set to the blank (empty) state.
    void clear()
    {
        items_.clear();
    }

    /// Exchanges content with the other instance.
    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