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

/// 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.
ONIXS_CONFLATEDUDP_LTWT_CLASS 
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.
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:
    /// 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)
    {
        ItemIterator
        const 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_
        );
    }
};

ONIXS_CONFLATEDUDP_NAMESPACE_END