Group.h

Go to the documentation of this file.

#pragma once

#include <vector>
#include <boost/iterator/indirect_iterator.hpp>

namespace NuTo
{
template <typename T>
class Group
{
    class SortedUniqueVector
    {
    public:
        bool Add(const T& element)
        {
            auto it = std::lower_bound(mData.begin(), mData.end(), &element);
            if (it == mData.end() || *it != &element)
            {
                mData.insert(it, &element);
                return true;
            }
            return false;
        }

        bool Contains(const T& element) const
        {
            auto it = std::lower_bound(mData.begin(), mData.end(), &element);
            if (it == mData.end())
                return false;
            return *it == &element;
        }

    private:
        std::vector<const T*> mData;
    };

    typedef std::vector<T*> Data;

public:
    typedef boost::indirect_iterator<typename Data::iterator> GroupIterator;
    typedef boost::indirect_iterator<typename Data::const_iterator> ConstGroupIterator;

    Group() = default;

    Group(T& element)
    {
        Add(element);
    }

    Group(std::initializer_list<std::reference_wrapper<T>> elements)
    {
        for (auto element : elements)
            Add(element);
    }

    T& operator[](size_t index)
    {
        return *mData[index];
    }

    const T& operator[](size_t index) const
    {
        return *mData[index];
    }

    void Add(T& element)
    {
        if (mUniqueData.Add(element))
            mData.push_back(&element);
    }

    bool Contains(const T& element) const
    {
        return mUniqueData.Contains(element);
    }

    bool Empty() const
    {
        return Size() == 0;
    }

    auto Size() const
    {
        return mData.size();
    }

    ConstGroupIterator begin() const
    {
        return mData.begin();
    }

    ConstGroupIterator end() const
    {
        return mData.end();
    }

    GroupIterator begin()
    {
        return mData.begin();
    }

    GroupIterator end()
    {
        return mData.end();
    }

private:
    Data mData;

    SortedUniqueVector mUniqueData;
};

template <typename T>
Group<T> Unite(const Group<T>& one, const Group<T>& two)
{
    Group<T> newGroup = one;
    for (auto& t : two)
        newGroup.Add(t);
    return newGroup;
}

template <typename T, typename... TArgs>
Group<T> Unite(const Group<T>& one, const TArgs&... args)
{
    return Unite(one, Unite(args...));
}

template <typename T>
Group<T> Difference(const Group<T>& one, const Group<T>& two)
{
    Group<T> newGroup;
    for (auto& t : one)
        if (not two.Contains(t))
            newGroup.Add(t);
    return newGroup;
}

template <typename T>
Group<T> Intersection(const Group<T>& one, const Group<T>& two)
{
    Group<T> newGroup;
    for (auto& t : one)
        if (two.Contains(t))
            newGroup.Add(t);
    return newGroup;
}


template <typename T>
Group<T> SymmetricDifference(const Group<T>& one, const Group<T>& two)
{
    return Difference(Unite(one, two), Intersection(one, two));
}
} // namespace NuTo