axioms/axioms.hh

// This file is a part of Catsfoot.
// Copyright (C) 2011  Uni Research
// Copyright (C) 2011  Valentin David
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser 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 Public License for more details.
//
// You should have received a copy of the GNU Lesser Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.

#ifndef __AXIOMS_HH
# define __AXIOMS_HH


# include <string>
# include <sstream>
# include <catsfoot-config.hh>
# include <iostream>
# include "../type_traits/always_false.hh"

namespace catsfoot {
  struct axiom_failure {
  private:
    std::string _msg;

  public:
    const std::string& msg() const { return _msg; }

    axiom_failure(const std::string& _msg):
      _msg(_msg) {}

    axiom_failure(std::string&& _msg):
      _msg(std::move(_msg)) {}

    axiom_failure(std::string&& func,
                  std::string&& file,
                  unsigned line,
                  std::string&& expr):
      _msg() {
      std::stringstream ss;
      ss << std::move(file) << ":" << line << ":";
      ss << " Axiom " << std::move(func) << " failed.";
      ss << std::endl << std::endl;
      ss << "Expression was: " << std::move(expr) << std::endl;
      _msg = ss.str();
    }

    axiom_failure(const axiom_failure&) = default;

    axiom_failure(axiom_failure&& other): _msg(std::move(other._msg)) {}

    axiom_failure& operator=(axiom_failure&& other) {
      std::swap(_msg, other._msg);
      return *this;
    }

    axiom_failure& operator=(const axiom_failure& other) {
      return *this = axiom_failure(other);
    }
  };

# ifdef __CATSFOOT_ENABLE_TESTING_RT
#  include "../extern_decl.hh"

  namespace details {
    EXTERN
    void reached_function(std::string&& func,
                          std::string&& file,
                          unsigned line);

    EXTERN
    void register_function(std::string&& func,
                           std::string&& file,
                           unsigned line);
  }

  EXTERN
  bool check_unverified(std::ostream& s = std::cerr);
# else
  namespace details {
    template <typename T = std::string>
    extern
    void reached_function(T&&,
                          std::string&&,
                          unsigned) {
      static_assert(details::always_false<T>::value,
                    "You probably called a functionality that is available "
                    "only if you link with the runtime library. In this case "
                    "include catsfoot_testing.hh instead of catsfoot.hh");
    }

    template <typename T = std::string>
    extern
    void register_function(T&&,
                           std::string&&,
                           unsigned) {
      static_assert(details::always_false<T>::value,
                    "You probably called a functionality that is available "
                    "only if you link with the runtime library. In this case "
                    "include catsfoot_testing.hh instead of catsfoot.hh");
    }
  }

  template <typename T = std::ostream>
  extern
  bool check_unverified(T& = std::cerr) {
    static_assert(details::always_false<T>::value,
                  "You probably called a functionality that is available "
                  "only if you link with the runtime library. In this case "
                  "include catsfoot_testing.hh instead of catsfoot.hh");
    return false;
  }
# endif
}

# define _catsfoot__test_axiom(FUN, FILE, LINE, EXPR)        \
  { ::catsfoot::details::reached_function(FUN, FILE, LINE);  \
    if (!(EXPR))                                             \
      throw ::catsfoot::axiom_failure(FUN,                   \
                                      FILE, LINE, #EXPR); }  \
  ::catsfoot::details::register_function(FUN, FILE, LINE);

# if defined(DEFINE___PRETTY_FUNCTION__) && \
  defined(DEFINE___FILE__) && \
  defined(DEFINE___LINE__)
#   define axiom_assert(expr) _catsfoot__test_axiom(__PRETTY_FUNCTION__, \
                                  __FILE__, \
                                  __LINE__, \
                                  expr)
# elif defined(DEFINE___func__) && \
  defined(DEFINE___FILE__) && \
  defined(DEFINE___LINE__)
#   define axiom_assert(expr) _catsfoot__test_axiom(__func__, \
                                  __FILE__, \
                                  __LINE__, \
                                  expr)
# else


#   define axiom_assert(expr) _catsfoot__test_axiom("<unknown>", \
                                  "<unknown>", \
                                  0, \
                                  expr)
# endif

#endif