src/smp/planners/base.h

Go to the documentation of this file.

// TODO: add a flag to indicate whether the planner is initialized properly


#ifndef _SMP_PLANNER_BASE_H_
#define _SMP_PLANNER_BASE_H_

#include <smp/planner_utils/vertex_edge.h>
#include <smp/planner_utils/trajectory.h>

#include <smp/components/extenders/base.h>
#include <smp/components/samplers/base.h>
#include <smp/components/collision_checkers/base.h>
#include <smp/components/distance_evaluators/base.h>
#include <smp/components/model_checkers/base.h>

#include <iostream>
#include <list>

using namespace std;

namespace smp {


    template< class typeparams >
    class planner {

        typedef typename typeparams::state state_t;
        typedef typename typeparams::input input_t;
        typedef typename typeparams::vertex_data vertex_data_t;
        typedef typename typeparams::edge_data edge_data_t;
    
        typedef vertex<typeparams> vertex_t;
        typedef edge<typeparams> edge_t;

        typedef trajectory<typeparams> trajectory_t;

        typedef sampler_base<typeparams> sampler_t;
        typedef distance_evaluator_base<typeparams> distance_evaluator_t;
        typedef extender_base<typeparams> extender_t;
        typedef collision_checker_base<typeparams> collision_checker_t;
        typedef model_checker_base<typeparams> model_checker_t;
    
        typedef int (*vertex_update_func_t)(vertex_t *);
        typedef int (*edge_update_func_t)(edge_t *);
    
        list<vertex_update_func_t> list_update_insert_vertex_functions;
        list<vertex_update_func_t> list_update_delete_vertex_functions;
        list<edge_update_func_t> list_update_insert_edge_functions;
        list<edge_update_func_t> list_update_delete_edge_functions;



        int num_vertices;


    protected:

    
    

        sampler_t &sampler;



        distance_evaluator_t &distance_evaluator;



        extender_t &extender;



        collision_checker_t &collision_checker;



        model_checker_t &model_checker;


    

        int initialize ();

    

    public:

    

        list< vertex_t* > list_vertices;

       
        planner ();
        ~planner ();

    
        planner (sampler_t &sampler_in, distance_evaluator_t &distance_evaluator_in, extender_t &extender_in, 
                 collision_checker_t &collision_checker_in, model_checker_t &model_checker_in);





        int insert_vertex (vertex_t *vertex_in);


        int insert_edge (vertex_t *vertex_src_in, edge_t *edge_in, vertex_t *vertex_dst_in);


        int delete_vertex (vertex_t *vertex_in);


        int delete_edge (edge_t *edge_in);
    




    
        int insert_trajectory (vertex_t *vertex_src_in, trajectory_t *trajectory_in, 
                               list< state_t *> *intermediate_vertices_in, vertex_t *vertex_dst_in = 0);


        int insert_trajectories (vertex_t *vertex_src_in, list< trajectory_t *> *list_trajectories_in, vertex_t *vertex_dst_in = 0);





        int get_num_vertices () {return num_vertices;}







        int init_sampler (sampler_t &sampler_in);


        int init_distance_evaluator (distance_evaluator_t &distance_evaluator_in);


        int init_extender (extender_t &extender_in);


        int init_collision_checker (collision_checker_t &collision_checker_in);


        int init_model_checker (model_checker_t &model_checker_in);





    
        int clear_update_function_list_vertex_insert ();
    
    
        int register_new_update_function_vertex_insert (vertex_update_func_t *vertex_update_func_in);
    

        int clear_update_function_list_vertex_delete ();
    
    
        int register_new_update_function_vertex_delete (vertex_update_func_t *vertex_update_func_in);
    

        int clear_update_function_list_edge_insert ();

    
        int register_new_update_function_edge_insert (edge_update_func_t *edge_update_func_in);
    
    
        int clear_update_function_list_edge_delete ();
    
    
        int register_new_update_function_edge_delete (edge_update_func_t *edge_update_func_in);

    
    };

}

#endif