selection.hpp

Go to the documentation of this file.

/*
    Copyright 2013 Adobe
    Distributed under the Boost Software License, Version 1.0.
    (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
*/
/**************************************************************************************************/
 
#ifndef ADOBE_SELECTION_HPP
#define ADOBE_SELECTION_HPP
 
#include <adobe/config.hpp>
 
#include <cassert>
#include <vector>
 
#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::const_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(store_m.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
 
/**************************************************************************************************/