implicit.hh

Go to the documentation of this file.

// Copyright (c) 2015 - 2018 CNRS
// Authors: Joseph Mirabel (joseph.mirabel@laas.fr), Florent Lamiraux
//
// This file is part of hpp-constraints.
// hpp-constraints 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-constraints 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-constraints. If not, see <http://www.gnu.org/licenses/>.


#ifndef HPP_CONSTRAINTS_IMPLICIT_HH
# define HPP_CONSTRAINTS_IMPLICIT_HH

# include <hpp/constraints/fwd.hh>
# include <hpp/constraints/config.hh>

namespace hpp {
  namespace constraints {
    class HPP_CONSTRAINTS_DLLAPI Implicit {
      public:
    bool operator== (const Implicit& other) const
    {
      return isEqual (other, true);
    }
        virtual ImplicitPtr_t copy () const;
        static ImplicitPtr_t create
          (const DifferentiableFunctionPtr_t& function);

        static ImplicitPtr_t create
          (const DifferentiableFunctionPtr_t& function, ComparisonTypes_t comp);

        static ImplicitPtr_t create
          (const DifferentiableFunctionPtr_t& function,
           ComparisonTypes_t comp, vectorIn_t rhs);

    static ImplicitPtr_t createCopy (const ImplicitPtr_t& other);

        virtual ~Implicit () {};


        void rightHandSideFromConfig (ConfigurationIn_t config);

        void rightHandSide (vectorIn_t rhs);

        vectorIn_t rightHandSide () const;

        size_type rhsSize () const HPP_CONSTRAINTS_DEPRECATED;

        size_type parameterSize () const;

        size_type rightHandSideSize () const;

        const ComparisonTypes_t& comparisonType () const;

    void comparisonType (const ComparisonTypes_t& comp);

        bool constantRightHandSide () const HPP_CONSTRAINTS_DEPRECATED;

        vectorOut_t rightHandSide ();

        vectorOut_t nonConstRightHandSide () HPP_CONSTRAINTS_DEPRECATED;

        void rightHandSideFunction (const DifferentiableFunctionPtr_t& rhsF);

        const DifferentiableFunctionPtr_t& rightHandSideFunction () const
        {
          return rhsFunction_;
        }

        vectorIn_t rightHandSideAt (const value_type& s);


        DifferentiableFunction& function () const
        {
          return *function_;
        }

        const DifferentiableFunctionPtr_t& functionPtr () const
        {
          return function_;
        }

      protected:
        Implicit (const DifferentiableFunctionPtr_t& function,
            ComparisonTypes_t comp);

        Implicit (const DifferentiableFunctionPtr_t& function,
            ComparisonTypes_t comp, vectorIn_t rhs);

    Implicit (const Implicit& other);

    virtual bool isEqual (const Implicit& other, bool swapAndTest) const;

    // Store weak pointer to itself
    void init (const ImplicitWkPtr_t& weak)
    {
      weak_ = weak;
    }

        friend class ImplicitConstraintSet;
      private:
        ComparisonTypes_t comparison_;
        vector_t rhs_;
        size_type parameterSize_;
        DifferentiableFunctionPtr_t function_;
        DifferentiableFunctionPtr_t rhsFunction_;
    ImplicitWkPtr_t weak_;
    }; // class Implicit
  } // namespace constraints
} // namespace hpp

#endif // HPP_CONSTRAINTS_IMPLICIT_HH