/* -*- C++ -*-

 *

 * This file is a part of LEMON, a generic C++ optimization library

 *

 * Copyright (C) 2003-2006

 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport

 * (Egervary Research Group on Combinatorial Optimization, EGRES).

 *

 * Permission to use, modify and distribute this software is granted

 * provided that this copyright notice appears in all copies. For

 * precise terms see the accompanying LICENSE file.

 *

 * This software is provided "AS IS" with no warranty of any kind,

 * express or implied, and with no claim as to its suitability for any

 * purpose.

 *

 */

// This file contains a modified version of the enable_if library from BOOST.

// See the appropriate copyright notice below.

// Boost enable_if library

// Copyright 2003 © The Trustees of Indiana University.

// 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.boost.org/LICENSE_1_0.txt)

//    Authors: Jaakko Järvi (jajarvi at osl.iu.edu)

//             Jeremiah Willcock (jewillco at osl.iu.edu)

//             Andrew Lumsdaine (lums at osl.iu.edu)

#ifndef LEMON_BITS_UTILITY_H

#define LEMON_BITS_UTILITY_H

#include <lemon/error.h>

///\file

///\brief Miscellaneous basic utilities

///

///\todo Please rethink the organisation of the basic files like this.

///E.g. this file might be merged with invalid.h.

namespace lemon

{

  /// Basic type for defining "tags". A "YES" condition for \c enable_if.

  /// Basic type for defining "tags". A "YES" condition for \c enable_if.

  ///

  ///\sa False

  ///

  /// \todo This should go to a separate "basic_types.h" (or something)

  /// file.

  struct True {

    ///\e

    static const bool value = true;

  };

  /// Basic type for defining "tags". A "NO" condition for \c enable_if.

  /// Basic type for defining "tags". A "NO" condition for \c enable_if.

  ///

  ///\sa True

  struct False {

    ///\e

    static const bool value = false;

  };

  class InvalidType {

  private:

    InvalidType();

  };

  template <bool left, bool right>

  struct CTOr {

    static const bool value = true;

  };

  template <>

  struct CTOr<false, false> {

    static const bool value = false;

  };

  template <bool left, bool right>

  struct CTAnd {

    static const bool value = false;

  };

  template <>

  struct CTAnd<true, true> {

    static const bool value = true;

  };

  template <int left, int right>

  struct CTEqual {

    static const bool value = false;

  };

  template <int val>

  struct CTEqual<val, val> {

    static const bool value = true;

  };

  template <bool sless, bool sequal, bool bless>

  struct CTLessImpl {

   static const bool value =

   CTOr<sless, CTAnd<sequal, bless>::value>::value;

  };

  template <int left, int right>

  struct CTLess {

    static const bool value = 

    CTLessImpl<CTLess<left >> 1, right >> 1>::value, 

               CTEqual<left >> 1, right >> 1>::value,

               CTLess<left & 1, right & 1>::value >::value;

  };

  template <int left>

  struct CTLess<left, 0> {

    static const bool value = false;

  };

  template <int right>

  struct CTLess<0, right> {

    static const bool value = true;

  };

  template <>

  struct CTLess<0, 0> {

    static const bool value = false;

  };

  template <>

  struct CTLess<1, 1> {

    static const bool value = false;

  };

  template <bool less, int left, int right>

  struct CTMaxImpl {

    static const int value = left;    

  };

  template <int left, int right>

  struct CTMaxImpl<true, left, right> {

    static const int value = right;

  };

  template <int left, int right>

  struct CTMax {

    static const int value = 

    CTMaxImpl<CTLess<left, right>::value, left, right>::value;

  };

  /// \brief Simple Variant type with two type

  ///

  /// Simple Variant type with two type

  template <typename _First, typename _Second>

  class BiVariant {

  public:

    typedef _First First;

    typedef _Second Second;

    struct WrongStateError : public lemon::LogicError {

    public:

      virtual const char* exceptionName() const {

        return "lemon::BiVariant::WrongStateError";

      }

    };

    BiVariant() {

      flag = true;

      new(reinterpret_cast<First*>(data)) First();

    }

    BiVariant(const First& first) {

      flag = true;

      new(reinterpret_cast<First*>(data)) First(first);

    }

    BiVariant(const Second& second) {

      flag = false;

      new(reinterpret_cast<Second*>(data)) Second(second);

    }

    BiVariant(const BiVariant& bivariant) {

      flag = bivariant.flag;

      if (flag) {

        new(reinterpret_cast<First*>(data)) First(bivariant.first());      

      } else {

        new(reinterpret_cast<Second*>(data)) Second(bivariant.second());      

      }

    }

    ~BiVariant() {

      destroy();

    }

    BiVariant& setFirst() {

      destroy();

      flag = true;

      new(reinterpret_cast<First*>(data)) First();   

      return *this;

    }

    BiVariant& setFirst(const First& first) {

      destroy();

      flag = true;

      new(reinterpret_cast<First*>(data)) First(first);   

      return *this;

    }

    BiVariant& setSecond() {

      destroy();

      flag = false;

      new(reinterpret_cast<Second*>(data)) Second();   

      return *this;

    }

    BiVariant& setSecond(const Second& second) {

      destroy();

      flag = false;

      new(reinterpret_cast<Second*>(data)) Second(second);   

      return *this;

    }

    BiVariant& operator=(const First& first) {

      return setFirst(first);

    }

    BiVariant& operator=(const Second& second) {

      return setSecond(second);

    }

    BiVariant& operator=(const BiVariant& bivariant) {

      if (this == &bivariant) return *this;

      destroy();

      flag = bivariant.flag;

      if (flag) {

        new(reinterpret_cast<First*>(data)) First(bivariant.first());      

      } else {

        new(reinterpret_cast<Second*>(data)) Second(bivariant.second());      

      }

      return *this;

    }

    First& first() {

      LEMON_ASSERT(flag, WrongStateError());

      return *reinterpret_cast<First*>(data); 

    }

    const First& first() const { 

      LEMON_ASSERT(flag, WrongStateError());

      return *reinterpret_cast<const First*>(data); 

    }

    operator First&() { return first(); }

    operator const First&() const { return first(); }

    Second& second() { 

      LEMON_ASSERT(!flag, WrongStateError());

      return *reinterpret_cast<Second*>(data); 

    }

    const Second& second() const { 

      LEMON_ASSERT(!flag, WrongStateError());

      return *reinterpret_cast<const Second*>(data); 

    }

    operator Second&() { return second(); }

    operator const Second&() const { return second(); }

    bool firstState() const { return flag; }

    bool secondState() const { return !flag; }

  private:

    void destroy() {

      if (flag) {

        reinterpret_cast<First*>(data)->~First();

      } else {

        reinterpret_cast<Second*>(data)->~Second();

      }

    }

    char data[CTMax<sizeof(First), sizeof(Second)>::value];

    bool flag;

  };

  template <typename T>

  struct Wrap {

    const T &value;

    Wrap(const T &t) : value(t) {}

  };

  /**************** dummy class to avoid ambiguity ****************/

  template<int T> struct dummy { dummy(int) {} };

  /**************** enable_if from BOOST ****************/

  template <bool B, class T = void>

  struct enable_if_c {

    typedef T type;

  };

  template <class T>

  struct enable_if_c<false, T> {};

  template <class Cond, class T = void> 

  struct enable_if : public enable_if_c<Cond::value, T> {};

  template <bool B, class T>

  struct lazy_enable_if_c {

    typedef typename T::type type;

  };

  template <class T>

  struct lazy_enable_if_c<false, T> {};

  template <class Cond, class T> 

  struct lazy_enable_if : public lazy_enable_if_c<Cond::value, T> {};

  template <bool B, class T = void>

  struct disable_if_c {

    typedef T type;

  };

  template <class T>

  struct disable_if_c<true, T> {};

  template <class Cond, class T = void> 

  struct disable_if : public disable_if_c<Cond::value, T> {};

  template <bool B, class T>

  struct lazy_disable_if_c {

    typedef typename T::type type;

  };

  template <class T>

  struct lazy_disable_if_c<true, T> {};

  template <class Cond, class T> 

  struct lazy_disable_if : public lazy_disable_if_c<Cond::value, T> {};

} // namespace lemon

#endif