/* -*- 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.

 *

 */

#ifndef LEMON_BITS_VARIANT_H

#define LEMON_BITS_VARIANT_H

#include <lemon/error.h>

namespace lemon {

  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 <int left, int right>

  struct CTLess {

    static const bool value = left < right;

  };

  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* what() const throw() {

        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;

  };

}

#endif