tribool.hpp

Go to the documentation of this file.

/*
 * Copyright 2015, alex at staticlibs.net
 *
 * 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.
 */

// Copyright Douglas Gregor 2002-2004. Use, modification and
// distribution is subject to the Boost Software License, Version
// 1.0. (See accompanying file LICENSE_1_0.txt or copy at
// http://www.pion.org/LICENSE_1_0.txt)

#ifndef STATICLIB_SUPPORT_TRIBOOL_HPP
#define STATICLIB_SUPPORT_TRIBOOL_HPP

namespace staticlib { namespace support { namespace logic {

class tribool;

namespace detail {

struct indeterminate_t {
};

} // end namespace detail

typedef bool (*indeterminate_keyword_t)(tribool, detail::indeterminate_t);

inline bool
indeterminate(tribool x,
              detail::indeterminate_t dummy = detail::indeterminate_t());

class tribool
{
private:
  struct dummy {
    void nonnull() {};
  };

  typedef void (dummy::*safe_bool)();

public:
  tribool() : value(false_value) {}

  tribool(bool initial_value) : value(initial_value? true_value : false_value) {}

  tribool(indeterminate_keyword_t) : value(indeterminate_value) {}

  operator safe_bool() const
  {
    return value == true_value? &dummy::nonnull : 0;
  }

  enum value_t { false_value, true_value, indeterminate_value } value;
};

// Check if the given tribool has an indeterminate value. Also doubles as a
// keyword for the 'indeterminate' value
inline bool indeterminate(tribool x, detail::indeterminate_t)
{
  return x.value == tribool::indeterminate_value;
}

inline tribool operator!(tribool x)
{
  return x.value == tribool::false_value? tribool(true)
        :x.value == tribool::true_value? tribool(false)
        :tribool(indeterminate);
}

inline tribool operator&&(tribool x, tribool y)
{
  if (static_cast<bool>(!x) || static_cast<bool>(!y))
    return false;
  else if (static_cast<bool>(x) && static_cast<bool>(y))
    return true;
  else
    return indeterminate;
}

inline tribool operator&&(tribool x, bool y)
{ return y? x : tribool(false); }

inline tribool operator&&(bool x, tribool y)
{ return x? y : tribool(false); }

inline tribool operator&&(indeterminate_keyword_t, tribool x)
{ return !x? tribool(false) : tribool(indeterminate); }

inline tribool operator&&(tribool x, indeterminate_keyword_t)
{ return !x? tribool(false) : tribool(indeterminate); }

inline tribool operator||(tribool x, tribool y)
{
  if (static_cast<bool>(!x) && static_cast<bool>(!y))
    return false;
  else if (static_cast<bool>(x) || static_cast<bool>(y))
    return true;
  else
    return indeterminate;
}

inline tribool operator||(tribool x, bool y)
{ return y? tribool(true) : x; }

inline tribool operator||(bool x, tribool y)
{ return x? tribool(true) : y; }

inline tribool operator||(indeterminate_keyword_t, tribool x)
{ return x? tribool(true) : tribool(indeterminate); }

inline tribool operator||(tribool x, indeterminate_keyword_t)
{ return x? tribool(true) : tribool(indeterminate); }

inline tribool operator==(tribool x, tribool y)
{
  if (indeterminate(x) || indeterminate(y))
    return indeterminate;
  else
    return (x && y) || (!x && !y);
}

inline tribool operator==(tribool x, bool y) { return x == tribool(y); }

inline tribool operator==(bool x, tribool y) { return tribool(x) == y; }

inline tribool operator==(indeterminate_keyword_t, tribool x)
{ return tribool(indeterminate) == x; }

inline tribool operator==(tribool x, indeterminate_keyword_t)
{ return tribool(indeterminate) == x; }

inline tribool operator!=(tribool x, tribool y)
{
  if (indeterminate(x) || indeterminate(y))
    return indeterminate;
  else
    return !((x && y) || (!x && !y));
}

inline tribool operator!=(tribool x, bool y) { return x != tribool(y); }

inline tribool operator!=(bool x, tribool y) { return tribool(x) != y; }

inline tribool operator!=(indeterminate_keyword_t, tribool x)
{ return tribool(indeterminate) != x; }

inline tribool operator!=(tribool x, indeterminate_keyword_t)
{ return x != tribool(indeterminate); }

} } } // end namespace staticlib::support::logic

// Pull tribool and indeterminate into namespace "sl::support"
namespace staticlib { namespace support {
  using logic::tribool;
  using logic::indeterminate;
} }

#define STATICLIB_HTTPSERVER_TRIBOOL_THIRD_STATE(Name)                                 \
inline bool                                                             \
Name(staticlib::support::logic::tribool x,                                           \
     staticlib::support::logic::detail::indeterminate_t =                            \
       staticlib::support::logic::detail::indeterminate_t())                         \
{ return x.value == staticlib::support::logic::tribool::indeterminate_value; }

#endif // STATICLIB_SUPPORT_TRIBOOL_HPP