assertions.h

/* Copyright (C) 2019-2020 IBM Corp.
 * This program is Licensed under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance
 * with the License. You may obtain a copy of the License at
 *   http://www.apache.org/licenses/LICENSE-2.0
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License. See accompanying LICENSE file.
 */
 
// Header guard
#ifndef HELIB_ASSERTIONS_H
#define HELIB_ASSERTIONS_H
 
#include <helib/exceptions.h>
 
namespace helib {
 
template <typename ExceptionTy = ::helib::LogicError, typename T = void>
inline void assertTrue(const T& value, const std::string& message)
{
  static_assert(std::is_base_of<::helib::Exception, ExceptionTy>::value,
                "ExceptionTy must inherit from helib::Exception");
  static_assert(std::is_same<bool, T>::value, "Type T is not boolean");
  if (!value) {
    throw ExceptionTy(message);
  }
}
 
template <typename ExceptionTy = ::helib::LogicError, typename T = void>
inline void assertFalse(T value, const std::string& message)
{
  static_assert(std::is_same<bool, T>::value, "Type T is not boolean");
  static_assert(std::is_base_of<::helib::Exception, ExceptionTy>::value,
                "ExceptionTy must inherit from helib::Exception");
  if (value) {
    throw ExceptionTy(message);
  }
}
 
template <typename ExceptionTy = ::helib::LogicError, typename T = void>
inline void assertEq(const T& a, const T& b, const std::string& message)
{
  static_assert(std::is_base_of<::helib::Exception, ExceptionTy>::value,
                "ExceptionTy must inherit from helib::Exception");
  bool value = a == b;
  if (!value) {
    throw ExceptionTy(message);
  }
}
 
template <typename ExceptionTy = ::helib::LogicError, typename T = void>
inline void assertNeq(const T& a, const T& b, const std::string& message)
{
  static_assert(std::is_base_of<::helib::Exception, ExceptionTy>::value,
                "ExceptionTy must inherit from helib::Exception");
  bool value = a != b;
  if (!value) {
    throw ExceptionTy(message);
  }
}
 
template <typename ExceptionTy = ::helib::LogicError, typename T = void>
inline void assertNotNull(const T& p, const std::string& message)
{
  static_assert(std::is_base_of<::helib::Exception, ExceptionTy>::value,
                "ExceptionTy must inherit from helib::Exception");
  if (p == nullptr) {
    throw ExceptionTy(message);
  }
}
 
template <typename ExceptionTy = ::helib::OutOfRangeError, typename T = void>
inline void assertInRange(const T& elem,
                          const T& min,
                          const T& max,
                          const std::string& message,
                          bool right_inclusive = false)
{
  static_assert(std::is_base_of<::helib::Exception, ExceptionTy>::value,
                "ExceptionTy must inherit from helib::Exception");
  bool min_less = min <= elem;
  if (!min_less) {
    throw ExceptionTy(message);
  }
  bool max_great = right_inclusive ? elem <= max : elem < max;
  if (!max_great) {
    throw ExceptionTy(message);
  }
}
 
} // namespace helib
#endif // End of header guard