locked-joint.hh

Go to the documentation of this file.

// Copyright (c) 2015 - 2018, LAAS-CNRS
// Authors: Florent Lamiraux, Joseph Mirabel
//
// This file is part of hpp-core.
// hpp-core is free software: you can redistribute it
// and/or modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation, either version
// 3 of the License, or (at your option) any later version.
//
// hpp-core 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 Lesser Public License for more details.  You should have
// received a copy of the GNU Lesser General Public License along with
// hpp-core. If not, see <http://www.gnu.org/licenses/>.


#ifndef HPP_CONSTRAINTS_LOCKED_JOINT_HH
# define HPP_CONSTRAINTS_LOCKED_JOINT_HH

# include <hpp/pinocchio/joint.hh>

# include <hpp/constraints/explicit.hh>

namespace hpp {
  namespace constraints {


    class HPP_CONSTRAINTS_DLLAPI LockedJoint : public Explicit
    {
    public:
      virtual ImplicitPtr_t copy () const;

      static LockedJointPtr_t create (const JointPtr_t& joint,
                      const LiegroupElement& value);

      static LockedJointPtr_t create (const JointPtr_t& joint,
                                      const size_type index,
                      vectorIn_t value);

      static LockedJointPtr_t create (const DevicePtr_t& dev,
                                      const size_type index,
                      vectorIn_t value);

      static LockedJointPtr_t createCopy (LockedJointConstPtr_t other);

      size_type rankInConfiguration () const;

      size_type rankInVelocity () const;

      size_type configSize () const;

      size_type numberDof () const;

      const LiegroupSpacePtr_t& configSpace () const;

      vectorIn_t value () const;

      void value (vectorIn_t value);

      void rightHandSideFromConfig (ConfigurationIn_t config);

      const JointPtr_t& joint ()
      {
        return joint_;
      }
      const std::string& jointName () const {
        return jointName_;
      }
      std::ostream& print (std::ostream& os) const;
    protected:
      LockedJoint (const JointPtr_t& joint, const LiegroupElement& value);
      LockedJoint (const JointPtr_t& joint, const size_type index,
          vectorIn_t value);
      LockedJoint (const DevicePtr_t& robot, const size_type index,
          vectorIn_t value);
      LockedJoint (const LockedJoint& other);
      virtual bool isEqual (const Implicit& other, bool swapAndTest) const;

      void init (const LockedJointPtr_t& self);

    private:
      std::string jointName_;
      JointPtr_t joint_;
      LiegroupSpacePtr_t configSpace_;
      LockedJointWkPtr_t weak_;

    }; // class LockedJoint

    inline std::ostream& operator<< (std::ostream& os, const LockedJoint& lj)
    {
      return lj.print (os);
    }
  } // namespace constraints
} // namespace hpp
#endif // HPP_CONSTRAINTS_LOCKED_JOINT_HH