struct.hpp

Go to the documentation of this file.

#ifndef MSMAZES_CORE_MAZE_STRUCT_HPP
#define MSMAZES_CORE_MAZE_STRUCT_HPP

// boost::graph_traits
#include <boost/graph/graph_traits.hpp>
// boost::vecS, boost::listS, and boost::bidirectionalS
#include <boost/graph/graph_selectors.hpp>
// boost::property, boost::no_property, boost::vertex_index1_t,
// boost::vertex_index2_t, and boost::edge_index_t
#include <boost/graph/properties.hpp>
// boost::adjacency_list
#include <boost/graph/adjacency_list.hpp>

namespace msmazes {


template <
#ifndef MSMAZES_DOX
    typename CellIndex
#endif  /* MSMAZES_DOX */
>
class MazeStruct
{
 public:
#ifdef MSMAZES_DOX
    typedef implementation_defined EdgeIndex;
#else
    typedef std::size_t  // The member typedef vertices_size_type of Graph.
            EdgeIndex;
#endif  /* MSMAZES_DOX */

#ifdef MSMAZES_DOX
    typedef implementation_defined Graph;
#else
    typedef boost::adjacency_list<
                boost::listS
              , boost::vecS
              , boost::bidirectionalS  // For easier path-making.
              , boost::property<
                    boost::vertex_index1_t
                  , CellIndex
                  , boost::property<
                        boost::vertex_index2_t
                      , CellIndex
                    >
                >
              , boost::property<
                    boost::edge_index_t
                  , EdgeIndex
                >
              , boost::no_property
            >
            Graph;
#endif  /* MSMAZES_DOX */

#ifdef MSMAZES_DOX
    typedef implementation_defined Vertex;
#else
    typedef typename boost::graph_traits<Graph>::vertex_descriptor
            Vertex;
#endif  /* MSMAZES_DOX */

 private:
    Graph     _graph;
    Vertex    _source;
    Vertex    _target;
    EdgeIndex _max_out_degree;

    MazeStruct(const MazeStruct& copy)
    {
    }

 public:

    MazeStruct()
      : _graph()
      , _source(boost::graph_traits<Graph>::null_vertex())
      , _target(boost::graph_traits<Graph>::null_vertex())
      , _max_out_degree()
    {
    }

    inline Graph& getGraph()
    {
        return _graph;
    }

    inline const Graph& getGraph() const
    {
        return _graph;
    }

    inline Vertex getSourceVertex() const
    {
        return _source;
    }

    inline void setSourceVertex(const Vertex vertex)
    {
        _source = vertex;
    }

    inline Vertex getTargetVertex() const
    {
        return _target;
    }

    inline void setTargetVertex(const Vertex vertex)
    {
        _target = vertex;
    }

    inline EdgeIndex getMaxOutDegree() const
    {
        return _max_out_degree;
    }

    void setMaxOutDegree(const EdgeIndex max_out_degree)
    {
        _max_out_degree = max_out_degree;

        if (!_max_out_degree)
        {
            typename boost::graph_traits<Graph>::vertex_iterator vi, vi_end;
            EdgeIndex                                            degree;

            for (
                boost::tie(vi, vi_end) = boost::vertices(_graph);
                vi != vi_end;
                ++vi
            )
            {
                degree = boost::out_degree(*vi, _graph);

                if (_max_out_degree < degree)
                {
                    _max_out_degree = degree;
                }
            }
        }
    }
};
}  // namespace msmazes

#endif  /* MSMAZES_CORE_MAZE_STRUCT_HPP */

---

Multi-State Mazes in C++ is hosted by . Use the Table of Contents for navigation.