estar/Algorithm.hpp

Go to the documentation of this file.

/* 
 * Copyright (C) 2005 Roland Philippsen <roland dot philippsen at gmx net>
 * 
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
 * USA
 */


#ifndef ESTAR_ALGORITHM_HPP
#define ESTAR_ALGORITHM_HPP


#include <estar/CSpace.hpp>
#include <estar/Queue.hpp>
#include <estar/Upwind.hpp>
#include <estar/PropagatorFactory.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/scoped_ptr.hpp>
#include <map>


namespace estar {
  
  
  class Kernel;
  
  
  class Algorithm {
  public:
    Algorithm(
              boost::shared_ptr<BaseCSpace> cspace,
              bool check_upwind,
              bool check_local_consistency,
              bool check_queue_key,
              bool auto_reset,
              bool auto_flush);
    
    void AddVertex(vertex_t vertex, const Kernel & kernel);
    
    void AddGoal(vertex_t vertex, double value);
    
    void RemoveGoal(vertex_t vertex);
    
    void RemoveAllGoals();
    
    void Reset();
    
    bool IsGoal(vertex_t vertex) const;
    
    void SetMeta(vertex_t vertex, double meta, const Kernel & kernel);
    
    void ComputeOne(const Kernel & kernel,
                    double slack);
    
    bool HaveWork() const;
    
    boost::shared_ptr<BaseCSpace const> GetCSpace() const { return m_cspace; }
    
    const cspace_t & GetCSpaceGraph() const { return m_cspace_graph; }
    
    const value_map_t & GetValueMap() const { return m_value; }
    
    const meta_map_t & GetMetaMap() const { return m_meta; }

    const rhs_map_t & GetRhsMap() const { return m_rhs; }

    const flag_map_t & GetFlagMap() const { return m_flag; }
    
    const vertexid_map_t & GetVertexIdMap() const
    { return m_cspace->GetVertexIdMap(); }
    
    const Queue & GetQueue() const { return m_queue; }

    const Upwind & GetUpwind() const { return m_upwind; }
    
    Queue & GetQueue() { return m_queue; }
    
    size_t GetStep() const { return m_step; }
    
    double GetLastComputedValue() const { return m_last_computed_value; }
    
    vertex_t GetLastComputedVertex() const { return m_last_computed_vertex; }
    
    double GetLastPoppedKey() const { return m_last_popped_key; }
    
    
  private:
    typedef std::set<vertex_t> goalset_t;
    
    
    void UpdateVertex(vertex_t vertex, const Kernel & kernel);
    void DoComputeOne(const Kernel & kernel, double slack);
    
    boost::shared_ptr<BaseCSpace> m_cspace;
    Queue m_queue;
    Upwind m_upwind;
    
    goalset_t m_goalset;
    
    size_t m_step;
    double m_last_computed_value;
    vertex_t m_last_computed_vertex;
    double m_last_popped_key;
    
    bool m_pending_reset;
    bool m_auto_reset;
    bool m_auto_flush;
    
    cspace_t & m_cspace_graph;
    value_map_t & m_value;
    meta_map_t & m_meta;
    rhs_map_t & m_rhs;
    flag_map_t & m_flag;

    boost::scoped_ptr<PropagatorFactory> m_propfactory;
  };
  
  
} // namespace estar

#endif // ESTAR_ALGORITHM_HPP

---

E* Interpolated Graph Replanner Wed Dec 12 18:55:40 2007