device-sync.hh

Go to the documentation of this file.

//
// Copyright (c) 2016 CNRS
// Author: NMansard from Florent Lamiraux
//
//
// This file is part of hpp-pinocchio
// hpp-pinocchio 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-pinocchio 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-pinocchio  If not, see
// <http://www.gnu.org/licenses/>.

#ifndef HPP_PINOCCHIO_DEVICE_SYNC_HH
#define HPP_PINOCCHIO_DEVICE_SYNC_HH

# include <hpp/pinocchio/fwd.hh>
# include <hpp/pinocchio/device-data.hh>

namespace hpp {
  namespace pinocchio {
    class HPP_PINOCCHIO_DLLAPI AbstractDevice
    {
      public:

        ModelConstPtr_t   modelPtr() const { return model_; }
        ModelPtr_t        modelPtr()       { return model_; }
        const Model& model()    const { assert(model_); return *model_; }
        Model&       model()          { assert(model_); return *model_; }

        GeomModelConstPtr_t        geomModelPtr() const { return geomModel_; }
        GeomModelPtr_t             geomModelPtr() { return geomModel_; }
        const GeomModel & geomModel() const { assert(geomModel_); return *geomModel_; }
        GeomModel &       geomModel() { assert(geomModel_); return *geomModel_; }

        DataConstPtr_t    dataPtr() const { return d().data_; }
        DataPtr_t         dataPtr() { return d().data_; }
        const Data & data() const { assert(d().data_); return *d().data_; }
        Data &       data() { assert(d().data_); return *d().data_; }

        GeomDataConstPtr_t       geomDataPtr() const { return d().geomData_; }
        GeomDataPtr_t            geomDataPtr()       { return d().geomData_; }
        const GeomData& geomData() const    { assert(d().geomData_); return *d().geomData_; }
        GeomData&       geomData()          { assert(d().geomData_); return *d().geomData_; }

        // -----------------------------------------------------------------------

        const Configuration_t& currentConfiguration () const { return d().currentConfiguration_; }
        virtual bool currentConfiguration (ConfigurationIn_t configuration);

        const vector_t& currentVelocity () const { return d().currentVelocity_; }

        bool currentVelocity (vectorIn_t velocity);

        const vector_t& currentAcceleration () const { return d().currentAcceleration_; }

        bool currentAcceleration (vectorIn_t acceleration);
        // -----------------------------------------------------------------------

        const value_type& mass () const;

        const vector3_t& positionCenterOfMass () const;

        const ComJacobian_t& jacobianCenterOfMass () const;

        // -----------------------------------------------------------------------

        virtual void controlComputation (const Computation_t& flag);
        Computation_t computationFlag () const { return d().computationFlag_; }
        void computeForwardKinematics () { d().computeForwardKinematics(modelPtr()); }
        void computeFramesForwardKinematics () { d().computeFramesForwardKinematics(modelPtr()); }
        void updateGeometryPlacements () { d().updateGeometryPlacements(modelPtr(), geomModelPtr()); }
        // -----------------------------------------------------------------------
      protected:
        AbstractDevice ();
        AbstractDevice (const ModelPtr_t& m, const GeomModelPtr_t& gm);

        virtual DeviceData      & d ()       = 0;
        virtual DeviceData const& d () const = 0;

        // Pinocchio objects
        ModelPtr_t model_;
        GeomModelPtr_t geomModel_;
    }; // class AbstractDevice

    class HPP_PINOCCHIO_DLLAPI DeviceSync : public AbstractDevice
    {
      public:
        DeviceSync (const DevicePtr_t& device, bool lock = true);

        virtual ~DeviceSync ();

        DeviceData      & d ()       { assert (isLocked()); return *d_; }
        DeviceData const& d () const { assert (isLocked()); return *d_; }

        void lock ();
        bool isLocked () const { return d_ != NULL; }
        void unlock ();

      private:
        DevicePtr_t device_;
        DeviceData* d_;
    }; // class DeviceSync
  } // namespace pinocchio
} // namespace hpp

#endif // HPP_PINOCCHIO_DEVICE_SYNC_HH