Selection.hh

Go to the documentation of this file.

#ifndef __DIADES__UTILS__SELECTION__HH
#define __DIADES__UTILS__SELECTION__HH

#include<cstddef>
#include<vector>
#include<string>
#include<iostream>
#include<sstream>



namespace Diades
{
        namespace Utils
        {
                using std::vector;
                using std::string;
                using std::cout;
                using std::endl;
                using std::stringstream;

                template<typename Item>
                class Selection
                {
                public:
                        typedef vector<Item> ItemVector;

                private:

                        const ItemVector & _items;
                        vector<unsigned> _unselectedItemPool;
                        vector<unsigned> _position;
                        unsigned _selectedIndexStart;


                public:

                        class IndexIterator
                        {
                        public:
                                typedef IndexIterator self;
                                typedef std::ptrdiff_t difference_type;
                                typedef std::forward_iterator_tag iterator_category;
                                typedef unsigned value_type;
                                typedef unsigned* pointer;
                                typedef const unsigned& reference;


                        private:
                                const vector<unsigned> & _unselectedItemPool;
                                unsigned _index;
                        public:

                                IndexIterator(const vector<unsigned> & unselectedItemPool,
                                                          unsigned index) : _unselectedItemPool(unselectedItemPool),
                                _index(index)
                                {
                                }

                                reference operator*() const
                                {
                                        return _unselectedItemPool[_index];
                                }

                                pointer operator->() const
                                {
                                        return &_unselectedItemPool[_index];
                                }

                                self & operator++()
                                {
                                        ++_index;
                                        return *this;
                                }

                                self operator++(int)
                                {
                                        self tmp = *this;
                                        ++_index;
                                        return tmp;
                                }

                                bool operator==(const self & it) const
                                {
                                        return(_unselectedItemPool == it._unselectedItemPool) && (_index == it._index);
                                }

                                bool operator!=(const self & it) const
                                {
                                        return !(*this == it);
                                }
                        };

                        Selection(const vector<Item> & items) : _items(items),
                        _unselectedItemPool(items.size()),
                        _position(items.size()),
                        _selectedIndexStart(items.size())
                        {
                                for(unsigned index = 0; index < _items.size(); ++index)
                                {
                                        _unselectedItemPool[index] = index;
                                        _position[index] = index;
                                }
                        }

                        IndexIterator
                        indexBegin() const
                        {
                                return IndexIterator(_unselectedItemPool, 0);
                        }

                        IndexIterator
                        indexEnd() const
                        {
                                return IndexIterator(_unselectedItemPool, _unselectedItemPool.size());
                        }

                        unsigned
                        numberOfNonSelectedItems() const
                        {
                                return _selectedIndexStart;
                        }

                        unsigned
                        numberOfSelectedItems() const
                        {
                                return numberOfItems() - numberOfNonSelectedItems();
                        }

                        unsigned
                        numberOfItems() const
                        {
                                return _items.size();
                        }

                        IndexIterator
                        selectedIndexBegin() const
                        {
                                return IndexIterator(_unselectedItemPool, _selectedIndexStart);
                        }

                        IndexIterator
                        selectedIndexEnd() const
                        {
                                return IndexIterator(_unselectedItemPool, _unselectedItemPool.size());
                        }

                        IndexIterator
                        nonSelectedIndexBegin() const
                        {
                                return IndexIterator(_unselectedItemPool, 0);
                        }

                        IndexIterator
                        nonSelectedIndexEnd() const
                        {
                                return IndexIterator(_unselectedItemPool, _selectedIndexStart);
                        }

                        typename ItemVector::const_iterator
                        selectedBegin() const
                        {
                                return _items.begin() + _selectedIndexStart;
                        }

                        typename ItemVector::const_iterator
                        selectedEnd() const
                        {
                                return _items.end();
                        }

                        typename ItemVector::const_iterator
                        nonSelectedBegin() const
                        {
                                return _items.begin();
                        }

                        typename ItemVector::const_iterator
                        nonSelectedEnd() const
                        {
                                return _items.begin() + _selectedIndexStart;
                        }

                        bool
                        hasBeenAlreadySelectedOnce(unsigned index) const
                        {
                                return index >= _selectedIndexStart;
                        }

                        bool
                        allSelected() const
                        {
                                return _selectedIndexStart == 0;
                        }

                        unsigned
                        newSelection()
                        {
                                unsigned result = _unselectedItemPool[0];
                                select(_unselectedItemPool[0]);
                                return result;
                        }

                        const Item &
                        getItem(unsigned index) const
                        {
                                return _items[index];
                        }

                        void
                        select(unsigned index)
                        {
                                --_selectedIndexStart;
                                unsigned theSelectedToSwap = _unselectedItemPool[_position[index]];
                                unsigned oldPositionOfTheSelectedToSwap = _position[index];
                                unsigned theNonSelectedToSwap = _unselectedItemPool[_selectedIndexStart];
                                _unselectedItemPool[oldPositionOfTheSelectedToSwap] = theNonSelectedToSwap;
                                _unselectedItemPool[_selectedIndexStart] = theSelectedToSwap;
                                _position[theSelectedToSwap] = _selectedIndexStart;
                                _position[theNonSelectedToSwap] = oldPositionOfTheSelectedToSwap;
                        }

                        void
                        print()
                        {
                                cout << "*******************************************************************************" << endl;
                                cout << "CURRENT TABLES:" << endl;
                                cout << "\t";
                                for(unsigned i = 0; i < _items.size(); ++i)
                                {
                                        cout << _items[i] << "\t";
                                }
                                cout << endl;
                                cout << "\t";
                                for(unsigned i = 0; i < _items.size(); ++i)
                                {
                                        cout << _unselectedItemPool[i] << "\t";
                                }
                                cout << endl;
                                cout << "\t";
                                for(unsigned i = 0; i < _items.size(); ++i)
                                {
                                        cout << _position[i] << "\t";
                                }
                                cout << endl;

                                cout << "SELECTED ITEMS:" << endl;
                                cout << "\t";
                                for(unsigned i = _selectedIndexStart; i < _items.size(); ++i)
                                {
                                        cout << _items[_unselectedItemPool[i]] << "\t";
                                }
                                cout << endl;
                                cout << "UNSELECTED ITEMS:" << endl;
                                cout << "\t";
                                for(unsigned i = 0; i < _selectedIndexStart; ++i)
                                {
                                        cout << _items[_unselectedItemPool[i]] << "\t";
                                }

                                cout << endl;
                                cout << "POSITIONS (should be exactly the same as the first table:" << endl;
                                cout << "\t";
                                for(unsigned i = 0; i < _items.size(); ++i)
                                {
                                        cout << _items[_unselectedItemPool[_position[i]]] << "\t";
                                }
                                cout << endl;
                                cout << "*******************************************************************************" << endl;
                        }
                };
        };
};

#endif