state.hh

Go to the documentation of this file.

// Copyright (c) 2014, LAAS-CNRS
// Authors: Joseph Mirabel (joseph.mirabel@laas.fr)
//
 
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// 1. Redistributions of source code must retain the above copyright
//    notice, this list of conditions and the following disclaimer.
//
// 2. Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
// DAMAGE.
 
#ifndef HPP_MANIPULATION_GRAPH_STATE_HH
#define HPP_MANIPULATION_GRAPH_STATE_HH
 
#include <functional>
#include <hpp/constraints/implicit.hh>
#include <hpp/core/config-projector.hh>
#include <hpp/core/constraint-set.hh>
 
#include "hpp/manipulation/config.hh"
#include "hpp/manipulation/fwd.hh"
#include "hpp/manipulation/graph/edge.hh"
#include "hpp/manipulation/graph/fwd.hh"
#include "hpp/manipulation/graph/graph-component.hh"
 
namespace hpp {
namespace manipulation {
using constraints::Implicit;
using constraints::ImplicitPtr_t;
namespace graph {
 
class HPP_MANIPULATION_DLLAPI State : public GraphComponent {
 public:
  typedef std::function<EdgePtr_t(const std::string&, const GraphWkPtr_t&,
                                  const StateWkPtr_t&, const StateWkPtr_t&)>
      EdgeFactory;
  ~State();
 
  static StatePtr_t create(const std::string& name);
 
  EdgePtr_t linkTo(const std::string& name, const StatePtr_t& to,
                   const size_type& w = 1, EdgeFactory create = Edge::create);
 
  virtual bool contains(ConfigurationIn_t config) const;
 
  inline bool isWaypoint() const { return isWaypoint_; }
 
  inline void isWaypoint(bool isWaypoint) { isWaypoint_ = isWaypoint; }
 
  StateSelectorWkPtr_t stateSelector() const { return selector_; }
 
  void stateSelector(const StateSelectorWkPtr_t& parent) {
    selector_ = parent;
  };
 
  const Neighbors_t& neighbors() const { return neighbors_; }
 
  Edges_t neighborEdges() const { return neighbors_.values(); }
 
  const Edges_t& hiddenNeighbors() const { return hiddenNeighbors_; }
 
  void updateWeight(const EdgePtr_t& edge, const Weight_t& w);
 
  Weight_t getWeight(const EdgePtr_t& edge);
 
  ConstraintSetPtr_t configConstraint() const {
    throwIfNotInitialized();
    return configConstraints_;
  }
 
  virtual void addNumericalConstraint(const ImplicitPtr_t& numConstraint);
 
  virtual void addNumericalConstraintForPath(const ImplicitPtr_t& nm) {
    invalidate();
    numericalConstraintsForPath_.push_back(nm);
  }
 
  bool insertNumericalConstraintsForPath(ConfigProjectorPtr_t& proj) const {
    for (const auto& nc : numericalConstraintsForPath_) proj->add(nc);
    return !numericalConstraintsForPath_.empty();
  }
 
  const NumericalConstraints_t& numericalConstraintsForPath() const {
    return numericalConstraintsForPath_;
  }
 
  std::ostream& dotPrint(std::ostream& os, dot::DrawingAttributes da =
                                               dot::DrawingAttributes()) const;
 
 protected:
  void init(const StateWkPtr_t& self);
 
  State(const std::string& name);
 
  std::ostream& print(std::ostream& os) const;
 
  virtual void populateTooltip(dot::Tooltip& tp) const;
 
  virtual void initialize();
 
 private:
  Neighbors_t neighbors_;
  Edges_t hiddenNeighbors_;
 
  ConstraintSetPtr_t configConstraints_;
 
  NumericalConstraints_t numericalConstraintsForPath_;
 
  StateSelectorWkPtr_t selector_;
 
  StateWkPtr_t wkPtr_;
 
  bool isWaypoint_;
};  // class State
 
}  // namespace graph
}  // namespace manipulation
}  // namespace hpp
 
#endif  // HPP_MANIPULATION_GRAPH_STATE_HH