rndf_parser.H

#ifndef CAJUN_RNDF_PARSER_H
#define CAJUN_RNDF_PARSER_H


// Copyright (C) 2006, 2007 University of Louisiana at Lafayette
// Authors: Pablo Mejia


#include <set>
#include <string>
#include <vector>
#include "rndf_builder.H"


namespace cajun
{
class rndf_parser_t;
};


int rndf_parse (char const *path_,
                cajun::rndf_parser_t *parser_,
                cajun::rndf_builder_t *builder_);


namespace cajun
{


class rndf_parser_t
{
public:
        bool parse (std::string const &path_, rndf_builder_t *builder_);

protected:
        friend int ::rndf_parse (char const *path_,
                                 cajun::rndf_parser_t *parser_,
                                 cajun::rndf_builder_t *builder_);

        std::string m_path;

        unsigned m_id[3];

        unsigned m_num_segments;
        unsigned m_num_lanes;

        unsigned m_num_zones;
        unsigned m_num_spots;

        unsigned m_num_waypts;

        void error (unsigned line_, char const *msg_);

        bool next_segment (unsigned id_);
        bool segment_list_complete ();
        bool next_lane (unsigned id_[2]);
        bool lane_list_complete ();

        bool next_zone (unsigned id_);
        bool zone_list_complete ();
        bool next_perimeter (unsigned id_[2]);
        bool next_spot (unsigned id_[2]);
        bool spot_list_complete ();

        bool next_waypt (unsigned id_[3]);
        bool waypt_list_complete ();

        bool valid_waypt (unsigned id_[3]);

        class waypt_id_t
        {
        public:
                waypt_id_t () { m_id[0] = m_id[1] = m_id[2] = 0; }
                waypt_id_t (unsigned const id_[3])
                        { for (unsigned i = 0; i < 3; i++) m_id[i] = id_[i]; }

                bool operator< (waypt_id_t const &v_) const
                {
                        for (unsigned i = 0; i < 3; i++)
                                if (m_id[i] != v_.m_id[i])
                                        return m_id[i] < v_.m_id[i];
                        return false;
                }
        private:
                unsigned m_id[3];
        };
        std::set<waypt_id_t> m_waypt;

        void register_waypt (unsigned id_[3]);

        struct waypt_ref_t
        {
                unsigned line;
                waypt_id_t id;
        };
        std::vector<waypt_ref_t> m_waypt_ref;

        void register_waypt_ref (unsigned line_, unsigned id_[3]);

        struct checkpt_t
        {
                unsigned line;
                unsigned checkpt_id;
                waypt_id_t id;
        };
        std::vector<checkpt_t> m_checkpt;

        void register_checkpt (unsigned line_,
                               unsigned checkpt_id_, unsigned id_[3]);

        bool verify_refs ();
};


};


#endif

---