lemon-0.x: lemon/bits/utility.h@ab368e0ab662

     1 /* -*- C++ -*-

     2  *

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

     4  *

     5  * Copyright (C) 2003-2006

     6  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport

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

     8  *

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

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

    11  * precise terms see the accompanying LICENSE file.

    12  *

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

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

    15  * purpose.

    16  *

    17  */

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

    20 // See the appropriate copyright notice below.

    22 // Boost enable_if library

    24 // Copyright 2003 © The Trustees of Indiana University.

    26 // Use, modification, and distribution is subject to the Boost Software

    27 // License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at

    28 // http://www.boost.org/LICENSE_1_0.txt)

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

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

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

    35 #ifndef LEMON_BITS_UTILITY_H

    36 #define LEMON_BITS_UTILITY_H

    38 #include <lemon/error.h>

    40 ///\file

    41 ///\brief Miscellaneous basic utilities

    42 ///

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

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

    47 namespace lemon

    48 {

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

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

    53   ///

    54   ///\sa False

    55   ///

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

    57   /// file.

    58   struct True {

    59     ///\e

    60     static const bool value = true;

    61   };

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

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

    66   ///

    67   ///\sa True

    68   struct False {

    69     ///\e

    70     static const bool value = false;

    71   };

    74   class InvalidType {

    75   private:

    76     InvalidType();

    77   };

    79   template <bool left, bool right>

    80   struct CTOr {

    81     static const bool value = true;

    82   };

    84   template <>

    85   struct CTOr<false, false> {

    86     static const bool value = false;

    87   };

    89   template <bool left, bool right>

    90   struct CTAnd {

    91     static const bool value = false;

    92   };

    94   template <>

    95   struct CTAnd<true, true> {

    96     static const bool value = true;

    97   };

    99   template <int left, int right>

   100   struct CTEqual {

   101     static const bool value = false;

   102   };

   104   template <int val>

   105   struct CTEqual<val, val> {

   106     static const bool value = true;

   107   };

   110   template <int left, int right>

   111   struct CTLess {

   112     static const bool value = left < right;

   113   };

   115   template <int left>

   116   struct CTLess<left, 0> {

   117     static const bool value = false;

   118   };

   120   template <int right>

   121   struct CTLess<0, right> {

   122     static const bool value = true;

   123   };

   125   template <>

   126   struct CTLess<0, 0> {

   127     static const bool value = false;

   128   };

   130   template <>

   131   struct CTLess<1, 1> {

   132     static const bool value = false;

   133   };

   135   template <bool less, int left, int right>

   136   struct CTMaxImpl {

   137     static const int value = left;

   138   };

   140   template <int left, int right>

   141   struct CTMaxImpl<true, left, right> {

   142     static const int value = right;

   143   };

   145   template <int left, int right>

   146   struct CTMax {

   147     static const int value =

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

   149   };

   152   /// \brief Simple Variant type with two type

   153   ///

   154   /// Simple Variant type with two type

   155   template <typename _First, typename _Second>

   156   class BiVariant {

   157   public:

   159     typedef _First First;

   160     typedef _Second Second;

   162     struct WrongStateError : public lemon::LogicError {

   163     public:

   164       virtual const char* exceptionName() const {

   165         return "lemon::BiVariant::WrongStateError";

   166       }

   167     };

   169     BiVariant() {

   170       flag = true;

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

   172     }

   174     BiVariant(const First& first) {

   175       flag = true;

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

   177     }

   179     BiVariant(const Second& second) {

   180       flag = false;

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

   182     }

   184     BiVariant(const BiVariant& bivariant) {

   185       flag = bivariant.flag;

   186       if (flag) {

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

   188       } else {

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

   190       }

   191     }

   193     ~BiVariant() {

   194       destroy();

   195     }

   197     BiVariant& setFirst() {

   198       destroy();

   199       flag = true;

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

   201       return *this;

   202     }

   204     BiVariant& setFirst(const First& first) {

   205       destroy();

   206       flag = true;

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

   208       return *this;

   209     }

   211     BiVariant& setSecond() {

   212       destroy();

   213       flag = false;

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

   215       return *this;

   216     }

   218     BiVariant& setSecond(const Second& second) {

   219       destroy();

   220       flag = false;

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

   222       return *this;

   223     }

   225     BiVariant& operator=(const First& first) {

   226       return setFirst(first);

   227     }

   229     BiVariant& operator=(const Second& second) {

   230       return setSecond(second);

   231     }

   234     BiVariant& operator=(const BiVariant& bivariant) {

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

   236       destroy();

   237       flag = bivariant.flag;

   238       if (flag) {

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

   240       } else {

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

   242       }

   243       return *this;

   244     }

   246     First& first() {

   247       LEMON_ASSERT(flag, WrongStateError());

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

   249     }

   251     const First& first() const {

   252       LEMON_ASSERT(flag, WrongStateError());

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

   254     }

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

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

   259     Second& second() {

   260       LEMON_ASSERT(!flag, WrongStateError());

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

   262     }

   264     const Second& second() const {

   265       LEMON_ASSERT(!flag, WrongStateError());

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

   267     }

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

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

   272     bool firstState() const { return flag; }

   273     bool secondState() const { return !flag; }

   275   private:

   277     void destroy() {

   278       if (flag) {

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

   280       } else {

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

   282       }

   283     }

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

   286     bool flag;

   287   };

   289   template <typename T>

   290   struct Wrap {

   291     const T &value;

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

   293   };

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

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

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

   301   template <bool B, class T = void>

   302   struct enable_if_c {

   303     typedef T type;

   304   };

   306   template <class T>

   307   struct enable_if_c<false, T> {};

   309   template <class Cond, class T = void>

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

   312   template <bool B, class T>

   313   struct lazy_enable_if_c {

   314     typedef typename T::type type;

   315   };

   317   template <class T>

   318   struct lazy_enable_if_c<false, T> {};

   320   template <class Cond, class T>

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

   324   template <bool B, class T = void>

   325   struct disable_if_c {

   326     typedef T type;

   327   };

   329   template <class T>

   330   struct disable_if_c<true, T> {};

   332   template <class Cond, class T = void>

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

   335   template <bool B, class T>

   336   struct lazy_disable_if_c {

   337     typedef typename T::type type;

   338   };

   340   template <class T>

   341   struct lazy_disable_if_c<true, T> {};

   343   template <class Cond, class T>

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

   346 } // namespace lemon

   348 #endif

author	athos
	Mon, 17 Jul 2006 11:56:17 +0000
changeset 2148	ab368e0ab662
parent 2077	d687c0033bb5
child 2151	38ec4a930c05
permissions	-rw-r--r--