StateBlock.h

Go to the documentation of this file.

#ifndef STORM_STORAGE_BLOCK_H_
#define STORM_STORAGE_BLOCK_H_
 
#include <ostream>
 
#include <boost/container/container_fwd.hpp>
 
#include "storm/storage/BoostTypes.h"
#include "storm/storage/sparse/StateType.h"
#include "storm/utility/OsDetection.h"
 
namespace storm {
namespace storage {
 
// Typedef the most common state container.
typedef storm::storage::FlatSet<sparse::state_type> FlatSetStateContainer;
 
std::ostream& operator<<(std::ostream& out, FlatSetStateContainer const& block);
 
class StateBlock {
   public:
    typedef FlatSetStateContainer container_type;
    typedef container_type::value_type value_type;
    static_assert(std::is_same<value_type, sparse::state_type>::value, "Illegal value type of container.");
    typedef container_type::iterator iterator;
    typedef container_type::const_iterator const_iterator;
 
    // Default constructors.
    StateBlock() = default;
    StateBlock(StateBlock const& other) = default;
#ifndef WINDOWS
    StateBlock(StateBlock&& other) = default;
    StateBlock& operator=(StateBlock const& other) = default;
    StateBlock& operator=(StateBlock&& other) = default;
#endif
    template<typename InputIterator>
    StateBlock(InputIterator first, InputIterator last, bool sortedAndUnique = false) {
        if (sortedAndUnique) {
            this->states = container_type(boost::container::ordered_unique_range_t(), first, last);
        } else {
            this->states = container_type(first, last);
        }
    }
 
    StateBlock(std::initializer_list<sparse::state_type> list) : states(list.begin(), list.end()) {
        // Intentionally left empty.
    }
 
    bool operator==(StateBlock const& other) const {
        return this->states == other.states;
    }
 
    iterator begin();
 
    const_iterator begin() const;
 
    const_iterator cbegin() const {
        return this->begin();
    };
 
    iterator end();
 
    const_iterator end() const;
 
    const_iterator cend() const {
        return this->end();
    };
 
    bool containsState(value_type const& state) const;
 
    void insert(value_type const& state);
 
    iterator insert(container_type::const_iterator iterator, value_type const& state);
 
    void erase(value_type const& state);
 
    std::size_t size() const;
 
    bool empty() const;
 
    container_type const& getStates() const;
 
   private:
    // The container that holds the states.
    container_type states;
};
 
std::ostream& operator<<(std::ostream& out, StateBlock const& block);
}  // namespace storage
}  // namespace storm
 
#endif /* STORM_STORAGE_BLOCK_H_ */