joint_limits_validator.h

Go to the documentation of this file.

/*
 * Copyright (c) 2018 Pilz GmbH & Co. KG
 *
 * This program 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.

 * 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 Lesser General Public License for more details.

 * You should have received a copy of the GNU Lesser General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

#ifndef JOINT_LIMITS_VALIDATOR_H
#define JOINT_LIMITS_VALIDATOR_H

#include "pilz_extensions/joint_limits_extension.h"
#include "pilz_trajectory_generation/joint_limits_container.h"

namespace pilz {

class JointLimitsValidator{
  public:
    static bool validateAllPositionLimitsEqual(const pilz::JointLimitsContainer& joint_limits);

    static bool validateAllVelocityLimitsEqual(const pilz::JointLimitsContainer& joint_limits);

    static bool validateAllAccelerationLimitsEqual(const pilz::JointLimitsContainer& joint_limits);

    static bool validateAllDecelerationLimitsEqual(const pilz::JointLimitsContainer& joint_limits);

  private:
    static bool validateWithEqualFunc(bool (*eq_func)(const pilz_extensions::JointLimit&,
                                                      const pilz_extensions::JointLimit&),
                                                      const pilz::JointLimitsContainer& joint_limits);

    static bool positionEqual(const pilz_extensions::JointLimit& lhs, const pilz_extensions::JointLimit& rhs);

    static bool velocityEqual(const pilz_extensions::JointLimit& lhs, const pilz_extensions::JointLimit& rhs);

    static bool accelerationEqual(const pilz_extensions::JointLimit& lhs, const pilz_extensions::JointLimit& rhs);

    static bool decelerationEqual(const pilz_extensions::JointLimit& lhs, const pilz_extensions::JointLimit& rhs);

};

class ValidationException: public std::runtime_error
{
  public:
    ValidationException(const std::string error_desc) : std::runtime_error(error_desc) {}
};

class ValidationJointMissingException: public ValidationException
{
  public:
    ValidationJointMissingException(const std::string error_desc) : ValidationException(error_desc) {}
};


class ValidationDifferentLimitsException: public ValidationException
{
  public:
    ValidationDifferentLimitsException(const std::string error_desc) : ValidationException(error_desc) {}
};

class ValidationBoundsViolationException: public ValidationException
{
  public:
    ValidationBoundsViolationException(const std::string error_desc) : ValidationException(error_desc) {}
};

}

#endif // JOINT_LIMITS_VALIDATOR_H