selection.hpp

Go to the documentation of this file.

/*
    Copyright 2005-2007 Adobe Systems Incorporated
    Distributed under the MIT License (see accompanying file LICENSE_1_0_0.txt
    or a copy at http://stlab.adobe.com/licenses.html)
*/

/*************************************************************************************************/

#ifndef ADOBE_SELECTION_HPP
#define ADOBE_SELECTION_HPP

#include <adobe/config.hpp>

#include <vector>
#include <cassert>

#include <boost/operators.hpp>

/*************************************************************************************************/

namespace adobe {

/****************************************************************************************************/
/****************************************************************************************************/
class selection_t : boost::equality_comparable<selection_t>
{
public:
    typedef std::size_t                   value_type;
    typedef std::vector<value_type>       store_type;
    typedef store_type::iterator          iterator;
    typedef store_type::const_iterator    const_iterator;
    typedef store_type::size_type         size_type;
    typedef store_type::difference_type   difference_type;
    typedef value_type&                   reference;
    typedef const value_type&             const_reference;
    typedef value_type*                   pointer;
    typedef const value_type*             const_pointer;

    explicit selection_t(bool start_selected = false) :
        start_selected_m(start_selected)
    { }

    template <typename I> // value_type(I) == value_type
    selection_t(I first, I last, bool start_selected = false) :
        start_selected_m(start_selected),
        store_m(first, last)
    { }

    size_type size() const
    { return store_m.size(); }

    bool empty() const
    { return store_m.empty() && start_selected_m == false; }

    void push_back(const value_type& x)
    {
        assert(empty() || store_m.back() < x);

        store_m.push_back(x);
    }

    const_iterator begin() const { return store_m.begin(); }

    const_iterator end() const { return store_m.end(); }

    const value_type& operator[](const size_type& i) const
    { return store_m[i]; }

    void invert()
    { start_selected_m = !start_selected_m; }

    bool start_selected() const
    { return start_selected_m; }

    friend inline bool operator==(const selection_t& x, const selection_t& y)
    {
        return x.size() == y.size() &&
               std::equal(x.begin(), x.end(), y.begin());
    }

private:
#ifndef ADOBE_NO_DOCUMENTATION
    // This *can* be public because modifying it will not
    // violate any invariants.
    bool start_selected_m;

    // The requirement on the index store is that it be sorted.
    // Thus, we need to provide mechanisms where it stays so.
    store_type store_m;
#endif
};

/*************************************************************************************************/

} // namespace adobe

/*************************************************************************************************/

#endif

/*************************************************************************************************/