wpkg test coverage results

Coverage test results of the Windows Packager by Made to Order Software Corporation.

LCOV - code coverage report
Current view: top level - controlled_vars - controlled_vars_limited_auto_init.h (source / functions) Hit Total Coverage
Test: coverage.info Lines: 9 10 90.0 %
Date: 2013-06-17 Functions: 51 68 75.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : // WARNING: do not edit; this is an auto-generated
       2             : // WARNING: file; please, use the generator named
       3             : // WARNING: controlled_vars to re-generate
       4             : //
       5             : // File:        controlled_vars_limited_auto_init.h
       6             : // Object:      Help you by constraining basic types like classes.
       7             : //
       8             : // Copyright:   Copyright (c) 2005-2012 Made to Order Software Corp.
       9             : //              All Rights Reserved.
      10             : //
      11             : // http://snapwebsites.org/
      12             : // contact@m2osw.com
      13             : //
      14             : // Permission is hereby granted, free of charge, to any person obtaining a copy
      15             : // of this software and associated documentation files (the "Software"), to deal
      16             : // in the Software without restriction, including without limitation the rights
      17             : // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
      18             : // copies of the Software, and to permit persons to whom the Software is
      19             : // furnished to do so, subject to the following conditions:
      20             : //
      21             : // The above copyright notice and this permission notice shall be included in
      22             : // all copies or substantial portions of the Software.
      23             : //
      24             : // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
      25             : // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
      26             : // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
      27             : // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
      28             : // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
      29             : // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
      30             : // THE SOFTWARE.
      31             : //
      32             : #ifndef CONTROLLED_VARS_LIMITED_AUTO_INIT_H
      33             : #define CONTROLLED_VARS_LIMITED_AUTO_INIT_H
      34             : #ifdef _MSC_VER
      35             : #pragma warning(push)
      36             : #pragma warning(disable: 4005 4018 4244 4800)
      37             : #if _MSC_VER > 1000
      38             : #pragma once
      39             : #endif
      40             : #elif defined(__GNUC__)
      41             : #if (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4)
      42             : #pragma once
      43             : #endif
      44             : #endif
      45             : #include "controlled_vars_exceptions.h"
      46             : #include "controlled_vars_static_assert.h"
      47             : namespace controlled_vars {
      48             : /** \brief Documentation available online.
      49             :  * Please go to http://snapwebsites.org/project/controlled-vars
      50             :  */
      51             : template<class T, T min, T max, T init_value = 0> class limited_auto_init {
      52             : public:
      53             :         typedef T primary_type_t;
      54             :         static const T DEFAULT_VALUE = init_value;
      55             :         static const primary_type_t MIN_BOUND = min;
      56             :         static const primary_type_t MAX_BOUND = max;
      57             :         CONTROLLED_VARS_STATIC_ASSERT(min <= max);
      58             :         CONTROLLED_VARS_STATIC_ASSERT(init_value >= min && init_value <= max);
      59     1263404 :         template<class L> T check(L v) {
      60             : #ifdef CONTROLLED_VARS_LIMITED
      61             : #ifdef __GNUC__
      62             : #pragma GCC diagnostic push
      63             : #pragma GCC diagnostic ignored "-Wlogical-op"
      64             : #endif
      65             :                 if(v < min || v > max) throw controlled_vars_error_out_of_bounds("value out of bounds");
      66             : #ifdef __GNUC__
      67             : #pragma GCC diagnostic pop
      68             : #endif
      69             : #endif
      70     1263404 :                 return static_cast<primary_type_t>(v);
      71             :         }
      72      521987 :         limited_auto_init() { f_value = check(init_value); }
      73             :         limited_auto_init(bool v) { f_value = check(v); }
      74             :         limited_auto_init(char v) { f_value = check(v); }
      75             :         limited_auto_init(signed char v) { f_value = check(v); }
      76             :         limited_auto_init(unsigned char v) { f_value = check(v); }
      77             : #if !defined(_MSC_VER) || (defined(_WCHAR_T_DEFINED) && defined(_NATIVE_WCHAR_T_DEFINED))
      78             :         limited_auto_init(wchar_t v) { f_value = check(v); }
      79             : #endif
      80             :         limited_auto_init(int16_t v) { f_value = check(v); }
      81             :         limited_auto_init(uint16_t v) { f_value = check(v); }
      82        2778 :         limited_auto_init(int32_t v) { f_value = check(v); }
      83             :         limited_auto_init(uint32_t v) { f_value = check(v); }
      84             : #if UINT_MAX == ULONG_MAX
      85             :         limited_auto_init(long v) { f_value = check(v); }
      86             : #endif
      87             : #if UINT_MAX == ULONG_MAX
      88             :         limited_auto_init(unsigned long v) { f_value = check(v); }
      89             : #endif
      90             :         limited_auto_init(int64_t v) { f_value = check(v); }
      91             :         limited_auto_init(uint64_t v) { f_value = check(v); }
      92             :         limited_auto_init(float v) { f_value = check(v); }
      93             :         limited_auto_init(double v) { f_value = check(v); }
      94             : #ifndef __APPLE__
      95             :         limited_auto_init(long double v) { f_value = check(v); }
      96             : #endif
      97             : #if 0 //def __APPLE___
      98             :         limited_auto_init(size_t v) { f_value = check(v); }
      99             : #endif
     100             : #if 0 //def __APPLE___
     101             :         limited_auto_init(time_t v) { f_value = check(v); }
     102             : #endif
     103     1173889 :         operator T () const { return f_value; }
     104   112076536 :         operator T () { return f_value; }
     105             :         T value() const { return f_value; }
     106             :         const T * ptr() const { return &f_value; }
     107             :         T * ptr() { return &f_value; }
     108             :         bool operator ! () const { return !f_value; }
     109             :         T operator ~ () const { return ~f_value; }
     110             :         T operator + () const { return +f_value; }
     111             :         T operator - () const { return -f_value; }
     112             :         limited_auto_init& operator ++ () { if(f_value + 1 > max) throw controlled_vars_error_out_of_bounds("++ would render value out of bounds"); ++f_value; return *this; }
     113             :         limited_auto_init operator ++ (int) { limited_auto_init<T, min, max> result(*this); if(f_value + 1 > max) throw controlled_vars_error_out_of_bounds("++ would render value out of bounds"); ++f_value; return result; }
     114             :         limited_auto_init& operator -- () { if(f_value - 1 < min) throw controlled_vars_error_out_of_bounds("-- would render value out of bounds"); --f_value; return *this; }
     115             :         limited_auto_init operator -- (int) { limited_auto_init<T, min, max> result(*this); if(f_value - 1 < min) throw controlled_vars_error_out_of_bounds("-- would render value out of bounds"); --f_value; return result; }
     116           0 :         limited_auto_init& operator = (const limited_auto_init& n) { f_value = check(n.f_value); return *this; }
     117        4167 :         limited_auto_init& operator = (bool v) { f_value = check(v); return *this; }
     118             :         limited_auto_init& operator = (char v) { f_value = check(v); return *this; }
     119             :         limited_auto_init& operator = (signed char v) { f_value = check(v); return *this; }
     120             :         limited_auto_init& operator = (unsigned char v) { f_value = check(v); return *this; }
     121             : #if !defined(_MSC_VER) || (defined(_WCHAR_T_DEFINED) && defined(_NATIVE_WCHAR_T_DEFINED))
     122             :         limited_auto_init& operator = (wchar_t v) { f_value = check(v); return *this; }
     123             : #endif
     124             :         limited_auto_init& operator = (int16_t v) { f_value = check(v); return *this; }
     125             :         limited_auto_init& operator = (uint16_t v) { f_value = check(v); return *this; }
     126      733083 :         limited_auto_init& operator = (int32_t v) { f_value = check(v); return *this; }
     127             :         limited_auto_init& operator = (uint32_t v) { f_value = check(v); return *this; }
     128             : #if UINT_MAX == ULONG_MAX
     129             :         limited_auto_init& operator = (long v) { f_value = check(v); return *this; }
     130             : #endif
     131             : #if UINT_MAX == ULONG_MAX
     132             :         limited_auto_init& operator = (unsigned long v) { f_value = check(v); return *this; }
     133             : #endif
     134        1389 :         limited_auto_init& operator = (int64_t v) { f_value = check(v); return *this; }
     135             :         limited_auto_init& operator = (uint64_t v) { f_value = check(v); return *this; }
     136             :         limited_auto_init& operator = (float v) { f_value = check(v); return *this; }
     137             :         limited_auto_init& operator = (double v) { f_value = check(v); return *this; }
     138             : #ifndef __APPLE__
     139             :         limited_auto_init& operator = (long double v) { f_value = check(v); return *this; }
     140             : #endif
     141             : #if 0 //def __APPLE___
     142             :         limited_auto_init& operator = (size_t v) { f_value = check(v); return *this; }
     143             : #endif
     144             : #if 0 //def __APPLE___
     145             :         limited_auto_init& operator = (time_t v) { f_value = check(v); return *this; }
     146             : #endif
     147             :         limited_auto_init& operator *= (const limited_auto_init& n) { f_value = check(f_value * n.f_value); return *this; }
     148             :         limited_auto_init& operator *= (bool v) { f_value = check(f_value * v); return *this; }
     149             :         limited_auto_init& operator *= (char v) { f_value = check(f_value * v); return *this; }
     150             :         limited_auto_init& operator *= (signed char v) { f_value = check(f_value * v); return *this; }
     151             :         limited_auto_init& operator *= (unsigned char v) { f_value = check(f_value * v); return *this; }
     152             : #if !defined(_MSC_VER) || (defined(_WCHAR_T_DEFINED) && defined(_NATIVE_WCHAR_T_DEFINED))
     153             :         limited_auto_init& operator *= (wchar_t v) { f_value = check(f_value * v); return *this; }
     154             : #endif
     155             :         limited_auto_init& operator *= (int16_t v) { f_value = check(f_value * v); return *this; }
     156             :         limited_auto_init& operator *= (uint16_t v) { f_value = check(f_value * v); return *this; }
     157             :         limited_auto_init& operator *= (int32_t v) { f_value = check(f_value * v); return *this; }
     158             :         limited_auto_init& operator *= (uint32_t v) { f_value = check(f_value * v); return *this; }
     159             : #if UINT_MAX == ULONG_MAX
     160             :         limited_auto_init& operator *= (long v) { f_value = check(f_value * v); return *this; }
     161             : #endif
     162             : #if UINT_MAX == ULONG_MAX
     163             :         limited_auto_init& operator *= (unsigned long v) { f_value = check(f_value * v); return *this; }
     164             : #endif
     165             :         limited_auto_init& operator *= (int64_t v) { f_value = check(f_value * v); return *this; }
     166             :         limited_auto_init& operator *= (uint64_t v) { f_value = check(f_value * v); return *this; }
     167             :         limited_auto_init& operator *= (float v) { f_value = check(f_value * v); return *this; }
     168             :         limited_auto_init& operator *= (double v) { f_value = check(f_value * v); return *this; }
     169             : #ifndef __APPLE__
     170             :         limited_auto_init& operator *= (long double v) { f_value = check(f_value * v); return *this; }
     171             : #endif
     172             : #if 0 //def __APPLE___
     173             :         limited_auto_init& operator *= (size_t v) { f_value = check(f_value * v); return *this; }
     174             : #endif
     175             : #if 0 //def __APPLE___
     176             :         limited_auto_init& operator *= (time_t v) { f_value = check(f_value * v); return *this; }
     177             : #endif
     178             :         limited_auto_init& operator /= (const limited_auto_init& n) { f_value = check(f_value / n.f_value); return *this; }
     179             :         limited_auto_init& operator /= (bool v) { f_value = check(f_value / v); return *this; }
     180             :         limited_auto_init& operator /= (char v) { f_value = check(f_value / v); return *this; }
     181             :         limited_auto_init& operator /= (signed char v) { f_value = check(f_value / v); return *this; }
     182             :         limited_auto_init& operator /= (unsigned char v) { f_value = check(f_value / v); return *this; }
     183             : #if !defined(_MSC_VER) || (defined(_WCHAR_T_DEFINED) && defined(_NATIVE_WCHAR_T_DEFINED))
     184             :         limited_auto_init& operator /= (wchar_t v) { f_value = check(f_value / v); return *this; }
     185             : #endif
     186             :         limited_auto_init& operator /= (int16_t v) { f_value = check(f_value / v); return *this; }
     187             :         limited_auto_init& operator /= (uint16_t v) { f_value = check(f_value / v); return *this; }
     188             :         limited_auto_init& operator /= (int32_t v) { f_value = check(f_value / v); return *this; }
     189             :         limited_auto_init& operator /= (uint32_t v) { f_value = check(f_value / v); return *this; }
     190             : #if UINT_MAX == ULONG_MAX
     191             :         limited_auto_init& operator /= (long v) { f_value = check(f_value / v); return *this; }
     192             : #endif
     193             : #if UINT_MAX == ULONG_MAX
     194             :         limited_auto_init& operator /= (unsigned long v) { f_value = check(f_value / v); return *this; }
     195             : #endif
     196             :         limited_auto_init& operator /= (int64_t v) { f_value = check(f_value / v); return *this; }
     197             :         limited_auto_init& operator /= (uint64_t v) { f_value = check(f_value / v); return *this; }
     198             :         limited_auto_init& operator /= (float v) { f_value = check(f_value / v); return *this; }
     199             :         limited_auto_init& operator /= (double v) { f_value = check(f_value / v); return *this; }
     200             : #ifndef __APPLE__
     201             :         limited_auto_init& operator /= (long double v) { f_value = check(f_value / v); return *this; }
     202             : #endif
     203             : #if 0 //def __APPLE___
     204             :         limited_auto_init& operator /= (size_t v) { f_value = check(f_value / v); return *this; }
     205             : #endif
     206             : #if 0 //def __APPLE___
     207             :         limited_auto_init& operator /= (time_t v) { f_value = check(f_value / v); return *this; }
     208             : #endif
     209             :         limited_auto_init& operator %= (const limited_auto_init& n) { f_value = check(f_value % n.f_value); return *this; }
     210             :         limited_auto_init& operator %= (bool v) { f_value = check(f_value % v); return *this; }
     211             :         limited_auto_init& operator %= (char v) { f_value = check(f_value % v); return *this; }
     212             :         limited_auto_init& operator %= (signed char v) { f_value = check(f_value % v); return *this; }
     213             :         limited_auto_init& operator %= (unsigned char v) { f_value = check(f_value % v); return *this; }
     214             : #if !defined(_MSC_VER) || (defined(_WCHAR_T_DEFINED) && defined(_NATIVE_WCHAR_T_DEFINED))
     215             :         limited_auto_init& operator %= (wchar_t v) { f_value = check(f_value % v); return *this; }
     216             : #endif
     217             :         limited_auto_init& operator %= (int16_t v) { f_value = check(f_value % v); return *this; }
     218             :         limited_auto_init& operator %= (uint16_t v) { f_value = check(f_value % v); return *this; }
     219             :         limited_auto_init& operator %= (int32_t v) { f_value = check(f_value % v); return *this; }
     220             :         limited_auto_init& operator %= (uint32_t v) { f_value = check(f_value % v); return *this; }
     221             : #if UINT_MAX == ULONG_MAX
     222             :         limited_auto_init& operator %= (long v) { f_value = check(f_value % v); return *this; }
     223             : #endif
     224             : #if UINT_MAX == ULONG_MAX
     225             :         limited_auto_init& operator %= (unsigned long v) { f_value = check(f_value % v); return *this; }
     226             : #endif
     227             :         limited_auto_init& operator %= (int64_t v) { f_value = check(f_value % v); return *this; }
     228             :         limited_auto_init& operator %= (uint64_t v) { f_value = check(f_value % v); return *this; }
     229             : #if 0 //def __APPLE___
     230             :         limited_auto_init& operator %= (size_t v) { f_value = check(f_value % v); return *this; }
     231             : #endif
     232             : #if 0 //def __APPLE___
     233             :         limited_auto_init& operator %= (time_t v) { f_value = check(f_value % v); return *this; }
     234             : #endif
     235             :         limited_auto_init& operator += (const limited_auto_init& n) { f_value = check(f_value + n.f_value); return *this; }
     236             :         limited_auto_init& operator += (bool v) { f_value = check(f_value + v); return *this; }
     237             :         limited_auto_init& operator += (char v) { f_value = check(f_value + v); return *this; }
     238             :         limited_auto_init& operator += (signed char v) { f_value = check(f_value + v); return *this; }
     239             :         limited_auto_init& operator += (unsigned char v) { f_value = check(f_value + v); return *this; }
     240             : #if !defined(_MSC_VER) || (defined(_WCHAR_T_DEFINED) && defined(_NATIVE_WCHAR_T_DEFINED))
     241             :         limited_auto_init& operator += (wchar_t v) { f_value = check(f_value + v); return *this; }
     242             : #endif
     243             :         limited_auto_init& operator += (int16_t v) { f_value = check(f_value + v); return *this; }
     244             :         limited_auto_init& operator += (uint16_t v) { f_value = check(f_value + v); return *this; }
     245             :         limited_auto_init& operator += (int32_t v) { f_value = check(f_value + v); return *this; }
     246             :         limited_auto_init& operator += (uint32_t v) { f_value = check(f_value + v); return *this; }
     247             : #if UINT_MAX == ULONG_MAX
     248             :         limited_auto_init& operator += (long v) { f_value = check(f_value + v); return *this; }
     249             : #endif
     250             : #if UINT_MAX == ULONG_MAX
     251             :         limited_auto_init& operator += (unsigned long v) { f_value = check(f_value + v); return *this; }
     252             : #endif
     253             :         limited_auto_init& operator += (int64_t v) { f_value = check(f_value + v); return *this; }
     254             :         limited_auto_init& operator += (uint64_t v) { f_value = check(f_value + v); return *this; }
     255             :         limited_auto_init& operator += (float v) { f_value = check(f_value + v); return *this; }
     256             :         limited_auto_init& operator += (double v) { f_value = check(f_value + v); return *this; }
     257             : #ifndef __APPLE__
     258             :         limited_auto_init& operator += (long double v) { f_value = check(f_value + v); return *this; }
     259             : #endif
     260             : #if 0 //def __APPLE___
     261             :         limited_auto_init& operator += (size_t v) { f_value = check(f_value + v); return *this; }
     262             : #endif
     263             : #if 0 //def __APPLE___
     264             :         limited_auto_init& operator += (time_t v) { f_value = check(f_value + v); return *this; }
     265             : #endif
     266             :         limited_auto_init& operator -= (const limited_auto_init& n) { f_value = check(f_value - n.f_value); return *this; }
     267             :         limited_auto_init& operator -= (bool v) { f_value = check(f_value - v); return *this; }
     268             :         limited_auto_init& operator -= (char v) { f_value = check(f_value - v); return *this; }
     269             :         limited_auto_init& operator -= (signed char v) { f_value = check(f_value - v); return *this; }
     270             :         limited_auto_init& operator -= (unsigned char v) { f_value = check(f_value - v); return *this; }
     271             : #if !defined(_MSC_VER) || (defined(_WCHAR_T_DEFINED) && defined(_NATIVE_WCHAR_T_DEFINED))
     272             :         limited_auto_init& operator -= (wchar_t v) { f_value = check(f_value - v); return *this; }
     273             : #endif
     274             :         limited_auto_init& operator -= (int16_t v) { f_value = check(f_value - v); return *this; }
     275             :         limited_auto_init& operator -= (uint16_t v) { f_value = check(f_value - v); return *this; }
     276             :         limited_auto_init& operator -= (int32_t v) { f_value = check(f_value - v); return *this; }
     277             :         limited_auto_init& operator -= (uint32_t v) { f_value = check(f_value - v); return *this; }
     278             : #if UINT_MAX == ULONG_MAX
     279             :         limited_auto_init& operator -= (long v) { f_value = check(f_value - v); return *this; }
     280             : #endif
     281             : #if UINT_MAX == ULONG_MAX
     282             :         limited_auto_init& operator -= (unsigned long v) { f_value = check(f_value - v); return *this; }
     283             : #endif
     284             :         limited_auto_init& operator -= (int64_t v) { f_value = check(f_value - v); return *this; }
     285             :         limited_auto_init& operator -= (uint64_t v) { f_value = check(f_value - v); return *this; }
     286             :         limited_auto_init& operator -= (float v) { f_value = check(f_value - v); return *this; }
     287             :         limited_auto_init& operator -= (double v) { f_value = check(f_value - v); return *this; }
     288             : #ifndef __APPLE__
     289             :         limited_auto_init& operator -= (long double v) { f_value = check(f_value - v); return *this; }
     290             : #endif
     291             : #if 0 //def __APPLE___
     292             :         limited_auto_init& operator -= (size_t v) { f_value = check(f_value - v); return *this; }
     293             : #endif
     294             : #if 0 //def __APPLE___
     295             :         limited_auto_init& operator -= (time_t v) { f_value = check(f_value - v); return *this; }
     296             : #endif
     297             :         limited_auto_init& operator <<= (const limited_auto_init& n) { f_value = check(f_value << n.f_value); return *this; }
     298             :         limited_auto_init& operator <<= (bool v) { f_value = check(f_value << v); return *this; }
     299             :         limited_auto_init& operator <<= (char v) { f_value = check(f_value << v); return *this; }
     300             :         limited_auto_init& operator <<= (signed char v) { f_value = check(f_value << v); return *this; }
     301             :         limited_auto_init& operator <<= (unsigned char v) { f_value = check(f_value << v); return *this; }
     302             : #if !defined(_MSC_VER) || (defined(_WCHAR_T_DEFINED) && defined(_NATIVE_WCHAR_T_DEFINED))
     303             :         limited_auto_init& operator <<= (wchar_t v) { f_value = check(f_value << v); return *this; }
     304             : #endif
     305             :         limited_auto_init& operator <<= (int16_t v) { f_value = check(f_value << v); return *this; }
     306             :         limited_auto_init& operator <<= (uint16_t v) { f_value = check(f_value << v); return *this; }
     307             :         limited_auto_init& operator <<= (int32_t v) { f_value = check(f_value << v); return *this; }
     308             :         limited_auto_init& operator <<= (uint32_t v) { f_value = check(f_value << v); return *this; }
     309             : #if UINT_MAX == ULONG_MAX
     310             :         limited_auto_init& operator <<= (long v) { f_value = check(f_value << v); return *this; }
     311             : #endif
     312             : #if UINT_MAX == ULONG_MAX
     313             :         limited_auto_init& operator <<= (unsigned long v) { f_value = check(f_value << v); return *this; }
     314             : #endif
     315             :         limited_auto_init& operator <<= (int64_t v) { f_value = check(f_value << v); return *this; }
     316             :         limited_auto_init& operator <<= (uint64_t v) { f_value = check(f_value << v); return *this; }
     317             : #if 0 //def __APPLE___
     318             :         limited_auto_init& operator <<= (size_t v) { f_value = check(f_value << v); return *this; }
     319             : #endif
     320             : #if 0 //def __APPLE___
     321             :         limited_auto_init& operator <<= (time_t v) { f_value = check(f_value << v); return *this; }
     322             : #endif
     323             :         limited_auto_init& operator >>= (const limited_auto_init& n) { f_value = check(f_value >> n.f_value); return *this; }
     324             :         limited_auto_init& operator >>= (bool v) { f_value = check(f_value >> v); return *this; }
     325             :         limited_auto_init& operator >>= (char v) { f_value = check(f_value >> v); return *this; }
     326             :         limited_auto_init& operator >>= (signed char v) { f_value = check(f_value >> v); return *this; }
     327             :         limited_auto_init& operator >>= (unsigned char v) { f_value = check(f_value >> v); return *this; }
     328             : #if !defined(_MSC_VER) || (defined(_WCHAR_T_DEFINED) && defined(_NATIVE_WCHAR_T_DEFINED))
     329             :         limited_auto_init& operator >>= (wchar_t v) { f_value = check(f_value >> v); return *this; }
     330             : #endif
     331             :         limited_auto_init& operator >>= (int16_t v) { f_value = check(f_value >> v); return *this; }
     332             :         limited_auto_init& operator >>= (uint16_t v) { f_value = check(f_value >> v); return *this; }
     333             :         limited_auto_init& operator >>= (int32_t v) { f_value = check(f_value >> v); return *this; }
     334             :         limited_auto_init& operator >>= (uint32_t v) { f_value = check(f_value >> v); return *this; }
     335             : #if UINT_MAX == ULONG_MAX
     336             :         limited_auto_init& operator >>= (long v) { f_value = check(f_value >> v); return *this; }
     337             : #endif
     338             : #if UINT_MAX == ULONG_MAX
     339             :         limited_auto_init& operator >>= (unsigned long v) { f_value = check(f_value >> v); return *this; }
     340             : #endif
     341             :         limited_auto_init& operator >>= (int64_t v) { f_value = check(f_value >> v); return *this; }
     342             :         limited_auto_init& operator >>= (uint64_t v) { f_value = check(f_value >> v); return *this; }
     343             : #if 0 //def __APPLE___
     344             :         limited_auto_init& operator >>= (size_t v) { f_value = check(f_value >> v); return *this; }
     345             : #endif
     346             : #if 0 //def __APPLE___
     347             :         limited_auto_init& operator >>= (time_t v) { f_value = check(f_value >> v); return *this; }
     348             : #endif
     349             :         limited_auto_init& operator &= (const limited_auto_init& n) { f_value = check(f_value & n.f_value); return *this; }
     350             :         limited_auto_init& operator &= (bool v) { f_value = check(f_value & v); return *this; }
     351             :         limited_auto_init& operator &= (char v) { f_value = check(f_value & v); return *this; }
     352             :         limited_auto_init& operator &= (signed char v) { f_value = check(f_value & v); return *this; }
     353             :         limited_auto_init& operator &= (unsigned char v) { f_value = check(f_value & v); return *this; }
     354             : #if !defined(_MSC_VER) || (defined(_WCHAR_T_DEFINED) && defined(_NATIVE_WCHAR_T_DEFINED))
     355             :         limited_auto_init& operator &= (wchar_t v) { f_value = check(f_value & v); return *this; }
     356             : #endif
     357             :         limited_auto_init& operator &= (int16_t v) { f_value = check(f_value & v); return *this; }
     358             :         limited_auto_init& operator &= (uint16_t v) { f_value = check(f_value & v); return *this; }
     359             :         limited_auto_init& operator &= (int32_t v) { f_value = check(f_value & v); return *this; }
     360             :         limited_auto_init& operator &= (uint32_t v) { f_value = check(f_value & v); return *this; }
     361             : #if UINT_MAX == ULONG_MAX
     362             :         limited_auto_init& operator &= (long v) { f_value = check(f_value & v); return *this; }
     363             : #endif
     364             : #if UINT_MAX == ULONG_MAX
     365             :         limited_auto_init& operator &= (unsigned long v) { f_value = check(f_value & v); return *this; }
     366             : #endif
     367             :         limited_auto_init& operator &= (int64_t v) { f_value = check(f_value & v); return *this; }
     368             :         limited_auto_init& operator &= (uint64_t v) { f_value = check(f_value & v); return *this; }
     369             : #if 0 //def __APPLE___
     370             :         limited_auto_init& operator &= (size_t v) { f_value = check(f_value & v); return *this; }
     371             : #endif
     372             : #if 0 //def __APPLE___
     373             :         limited_auto_init& operator &= (time_t v) { f_value = check(f_value & v); return *this; }
     374             : #endif
     375             :         limited_auto_init& operator |= (const limited_auto_init& n) { f_value = check(f_value | n.f_value); return *this; }
     376             :         limited_auto_init& operator |= (bool v) { f_value = check(f_value | v); return *this; }
     377             :         limited_auto_init& operator |= (char v) { f_value = check(f_value | v); return *this; }
     378             :         limited_auto_init& operator |= (signed char v) { f_value = check(f_value | v); return *this; }
     379             :         limited_auto_init& operator |= (unsigned char v) { f_value = check(f_value | v); return *this; }
     380             : #if !defined(_MSC_VER) || (defined(_WCHAR_T_DEFINED) && defined(_NATIVE_WCHAR_T_DEFINED))
     381             :         limited_auto_init& operator |= (wchar_t v) { f_value = check(f_value | v); return *this; }
     382             : #endif
     383             :         limited_auto_init& operator |= (int16_t v) { f_value = check(f_value | v); return *this; }
     384             :         limited_auto_init& operator |= (uint16_t v) { f_value = check(f_value | v); return *this; }
     385             :         limited_auto_init& operator |= (int32_t v) { f_value = check(f_value | v); return *this; }
     386             :         limited_auto_init& operator |= (uint32_t v) { f_value = check(f_value | v); return *this; }
     387             : #if UINT_MAX == ULONG_MAX
     388             :         limited_auto_init& operator |= (long v) { f_value = check(f_value | v); return *this; }
     389             : #endif
     390             : #if UINT_MAX == ULONG_MAX
     391             :         limited_auto_init& operator |= (unsigned long v) { f_value = check(f_value | v); return *this; }
     392             : #endif
     393             :         limited_auto_init& operator |= (int64_t v) { f_value = check(f_value | v); return *this; }
     394             :         limited_auto_init& operator |= (uint64_t v) { f_value = check(f_value | v); return *this; }
     395             : #if 0 //def __APPLE___
     396             :         limited_auto_init& operator |= (size_t v) { f_value = check(f_value | v); return *this; }
     397             : #endif
     398             : #if 0 //def __APPLE___
     399             :         limited_auto_init& operator |= (time_t v) { f_value = check(f_value | v); return *this; }
     400             : #endif
     401             :         limited_auto_init& operator ^= (const limited_auto_init& n) { f_value = check(f_value ^ n.f_value); return *this; }
     402             :         limited_auto_init& operator ^= (bool v) { f_value = check(f_value ^ v); return *this; }
     403             :         limited_auto_init& operator ^= (char v) { f_value = check(f_value ^ v); return *this; }
     404             :         limited_auto_init& operator ^= (signed char v) { f_value = check(f_value ^ v); return *this; }
     405             :         limited_auto_init& operator ^= (unsigned char v) { f_value = check(f_value ^ v); return *this; }
     406             : #if !defined(_MSC_VER) || (defined(_WCHAR_T_DEFINED) && defined(_NATIVE_WCHAR_T_DEFINED))
     407             :         limited_auto_init& operator ^= (wchar_t v) { f_value = check(f_value ^ v); return *this; }
     408             : #endif
     409             :         limited_auto_init& operator ^= (int16_t v) { f_value = check(f_value ^ v); return *this; }
     410             :         limited_auto_init& operator ^= (uint16_t v) { f_value = check(f_value ^ v); return *this; }
     411             :         limited_auto_init& operator ^= (int32_t v) { f_value = check(f_value ^ v); return *this; }
     412             :         limited_auto_init& operator ^= (uint32_t v) { f_value = check(f_value ^ v); return *this; }
     413             : #if UINT_MAX == ULONG_MAX
     414             :         limited_auto_init& operator ^= (long v) { f_value = check(f_value ^ v); return *this; }
     415             : #endif
     416             : #if UINT_MAX == ULONG_MAX
     417             :         limited_auto_init& operator ^= (unsigned long v) { f_value = check(f_value ^ v); return *this; }
     418             : #endif
     419             :         limited_auto_init& operator ^= (int64_t v) { f_value = check(f_value ^ v); return *this; }
     420             :         limited_auto_init& operator ^= (uint64_t v) { f_value = check(f_value ^ v); return *this; }
     421             : #if 0 //def __APPLE___
     422             :         limited_auto_init& operator ^= (size_t v) { f_value = check(f_value ^ v); return *this; }
     423             : #endif
     424             : #if 0 //def __APPLE___
     425             :         limited_auto_init& operator ^= (time_t v) { f_value = check(f_value ^ v); return *this; }
     426             : #endif
     427             :         T operator * (const limited_auto_init& n) { return f_value * n.f_value; }
     428             :         T operator * (bool v) { return f_value * v; }
     429             :         T operator * (char v) { return f_value * v; }
     430             :         T operator * (signed char v) { return f_value * v; }
     431             :         T operator * (unsigned char v) { return f_value * v; }
     432             : #if !defined(_MSC_VER) || (defined(_WCHAR_T_DEFINED) && defined(_NATIVE_WCHAR_T_DEFINED))
     433             :         T operator * (wchar_t v) { return f_value * v; }
     434             : #endif
     435             :         T operator * (int16_t v) { return f_value * v; }
     436             :         T operator * (uint16_t v) { return f_value * v; }
     437             :         T operator * (int32_t v) { return f_value * v; }
     438             :         T operator * (uint32_t v) { return f_value * v; }
     439             : #if UINT_MAX == ULONG_MAX
     440             :         T operator * (long v) { return f_value * v; }
     441             : #endif
     442             : #if UINT_MAX == ULONG_MAX
     443             :         T operator * (unsigned long v) { return f_value * v; }
     444             : #endif
     445             :         T operator * (int64_t v) { return f_value * v; }
     446             :         T operator * (uint64_t v) { return f_value * v; }
     447             :         T operator * (float v) { return f_value * v; }
     448             :         T operator * (double v) { return f_value * v; }
     449             : #ifndef __APPLE__
     450             :         T operator * (long double v) { return f_value * v; }
     451             : #endif
     452             : #if 0 //def __APPLE___
     453             :         T operator * (size_t v) { return f_value * v; }
     454             : #endif
     455             : #if 0 //def __APPLE___
     456             :         T operator * (time_t v) { return f_value * v; }
     457             : #endif
     458             :         T operator / (const limited_auto_init& n) { return f_value / n.f_value; }
     459             :         T operator / (bool v) { return f_value / v; }
     460             :         T operator / (char v) { return f_value / v; }
     461             :         T operator / (signed char v) { return f_value / v; }
     462             :         T operator / (unsigned char v) { return f_value / v; }
     463             : #if !defined(_MSC_VER) || (defined(_WCHAR_T_DEFINED) && defined(_NATIVE_WCHAR_T_DEFINED))
     464             :         T operator / (wchar_t v) { return f_value / v; }
     465             : #endif
     466             :         T operator / (int16_t v) { return f_value / v; }
     467             :         T operator / (uint16_t v) { return f_value / v; }
     468             :         T operator / (int32_t v) { return f_value / v; }
     469             :         T operator / (uint32_t v) { return f_value / v; }
     470             : #if UINT_MAX == ULONG_MAX
     471             :         T operator / (long v) { return f_value / v; }
     472             : #endif
     473             : #if UINT_MAX == ULONG_MAX
     474             :         T operator / (unsigned long v) { return f_value / v; }
     475             : #endif
     476             :         T operator / (int64_t v) { return f_value / v; }
     477             :         T operator / (uint64_t v) { return f_value / v; }
     478             :         T operator / (float v) { return f_value / v; }
     479             :         T operator / (double v) { return f_value / v; }
     480             : #ifndef __APPLE__
     481             :         T operator / (long double v) { return f_value / v; }
     482             : #endif
     483             : #if 0 //def __APPLE___
     484             :         T operator / (size_t v) { return f_value / v; }
     485             : #endif
     486             : #if 0 //def __APPLE___
     487             :         T operator / (time_t v) { return f_value / v; }
     488             : #endif
     489             :         T operator % (const limited_auto_init& n) { return f_value % n.f_value; }
     490             :         T operator % (bool v) { return f_value % v; }
     491             :         T operator % (char v) { return f_value % v; }
     492             :         T operator % (signed char v) { return f_value % v; }
     493             :         T operator % (unsigned char v) { return f_value % v; }
     494             : #if !defined(_MSC_VER) || (defined(_WCHAR_T_DEFINED) && defined(_NATIVE_WCHAR_T_DEFINED))
     495             :         T operator % (wchar_t v) { return f_value % v; }
     496             : #endif
     497             :         T operator % (int16_t v) { return f_value % v; }
     498             :         T operator % (uint16_t v) { return f_value % v; }
     499             :         T operator % (int32_t v) { return f_value % v; }
     500             :         T operator % (uint32_t v) { return f_value % v; }
     501             : #if UINT_MAX == ULONG_MAX
     502             :         T operator % (long v) { return f_value % v; }
     503             : #endif
     504             : #if UINT_MAX == ULONG_MAX
     505             :         T operator % (unsigned long v) { return f_value % v; }
     506             : #endif
     507             :         T operator % (int64_t v) { return f_value % v; }
     508             :         T operator % (uint64_t v) { return f_value % v; }
     509             : #if 0 //def __APPLE___
     510             :         T operator % (size_t v) { return f_value % v; }
     511             : #endif
     512             : #if 0 //def __APPLE___
     513             :         T operator % (time_t v) { return f_value % v; }
     514             : #endif
     515             :         T operator + (const limited_auto_init& n) { return f_value + n.f_value; }
     516             :         T operator + (bool v) { return f_value + v; }
     517             :         T operator + (char v) { return f_value + v; }
     518             :         T operator + (signed char v) { return f_value + v; }
     519             :         T operator + (unsigned char v) { return f_value + v; }
     520             : #if !defined(_MSC_VER) || (defined(_WCHAR_T_DEFINED) && defined(_NATIVE_WCHAR_T_DEFINED))
     521             :         T operator + (wchar_t v) { return f_value + v; }
     522             : #endif
     523             :         T operator + (int16_t v) { return f_value + v; }
     524             :         T operator + (uint16_t v) { return f_value + v; }
     525             :         T operator + (int32_t v) { return f_value + v; }
     526             :         T operator + (uint32_t v) { return f_value + v; }
     527             : #if UINT_MAX == ULONG_MAX
     528             :         T operator + (long v) { return f_value + v; }
     529             : #endif
     530             : #if UINT_MAX == ULONG_MAX
     531             :         T operator + (unsigned long v) { return f_value + v; }
     532             : #endif
     533             :         T operator + (int64_t v) { return f_value + v; }
     534             :         T operator + (uint64_t v) { return f_value + v; }
     535             :         T operator + (float v) { return f_value + v; }
     536             :         T operator + (double v) { return f_value + v; }
     537             : #ifndef __APPLE__
     538             :         T operator + (long double v) { return f_value + v; }
     539             : #endif
     540             : #if 0 //def __APPLE___
     541             :         T operator + (size_t v) { return f_value + v; }
     542             : #endif
     543             : #if 0 //def __APPLE___
     544             :         T operator + (time_t v) { return f_value + v; }
     545             : #endif
     546             :         T operator - (const limited_auto_init& n) { return f_value - n.f_value; }
     547             :         T operator - (bool v) { return f_value - v; }
     548             :         T operator - (char v) { return f_value - v; }
     549             :         T operator - (signed char v) { return f_value - v; }
     550             :         T operator - (unsigned char v) { return f_value - v; }
     551             : #if !defined(_MSC_VER) || (defined(_WCHAR_T_DEFINED) && defined(_NATIVE_WCHAR_T_DEFINED))
     552             :         T operator - (wchar_t v) { return f_value - v; }
     553             : #endif
     554             :         T operator - (int16_t v) { return f_value - v; }
     555             :         T operator - (uint16_t v) { return f_value - v; }
     556             :         T operator - (int32_t v) { return f_value - v; }
     557             :         T operator - (uint32_t v) { return f_value - v; }
     558             : #if UINT_MAX == ULONG_MAX
     559             :         T operator - (long v) { return f_value - v; }
     560             : #endif
     561             : #if UINT_MAX == ULONG_MAX
     562             :         T operator - (unsigned long v) { return f_value - v; }
     563             : #endif
     564             :         T operator - (int64_t v) { return f_value - v; }
     565             :         T operator - (uint64_t v) { return f_value - v; }
     566             :         T operator - (float v) { return f_value - v; }
     567             :         T operator - (double v) { return f_value - v; }
     568             : #ifndef __APPLE__
     569             :         T operator - (long double v) { return f_value - v; }
     570             : #endif
     571             : #if 0 //def __APPLE___
     572             :         T operator - (size_t v) { return f_value - v; }
     573             : #endif
     574             : #if 0 //def __APPLE___
     575             :         T operator - (time_t v) { return f_value - v; }
     576             : #endif
     577             :         T operator << (const limited_auto_init& n) { return f_value << n.f_value; }
     578             :         T operator << (bool v) { return f_value << v; }
     579             :         T operator << (char v) { return f_value << v; }
     580             :         T operator << (signed char v) { return f_value << v; }
     581             :         T operator << (unsigned char v) { return f_value << v; }
     582             : #if !defined(_MSC_VER) || (defined(_WCHAR_T_DEFINED) && defined(_NATIVE_WCHAR_T_DEFINED))
     583             :         T operator << (wchar_t v) { return f_value << v; }
     584             : #endif
     585             :         T operator << (int16_t v) { return f_value << v; }
     586             :         T operator << (uint16_t v) { return f_value << v; }
     587             :         T operator << (int32_t v) { return f_value << v; }
     588             :         T operator << (uint32_t v) { return f_value << v; }
     589             : #if UINT_MAX == ULONG_MAX
     590             :         T operator << (long v) { return f_value << v; }
     591             : #endif
     592             : #if UINT_MAX == ULONG_MAX
     593             :         T operator << (unsigned long v) { return f_value << v; }
     594             : #endif
     595             :         T operator << (int64_t v) { return f_value << v; }
     596             :         T operator << (uint64_t v) { return f_value << v; }
     597             : #if 0 //def __APPLE___
     598             :         T operator << (size_t v) { return f_value << v; }
     599             : #endif
     600             : #if 0 //def __APPLE___
     601             :         T operator << (time_t v) { return f_value << v; }
     602             : #endif
     603             :         T operator >> (const limited_auto_init& n) { return f_value >> n.f_value; }
     604             :         T operator >> (bool v) { return f_value >> v; }
     605             :         T operator >> (char v) { return f_value >> v; }
     606             :         T operator >> (signed char v) { return f_value >> v; }
     607             :         T operator >> (unsigned char v) { return f_value >> v; }
     608             : #if !defined(_MSC_VER) || (defined(_WCHAR_T_DEFINED) && defined(_NATIVE_WCHAR_T_DEFINED))
     609             :         T operator >> (wchar_t v) { return f_value >> v; }
     610             : #endif
     611             :         T operator >> (int16_t v) { return f_value >> v; }
     612             :         T operator >> (uint16_t v) { return f_value >> v; }
     613             :         T operator >> (int32_t v) { return f_value >> v; }
     614             :         T operator >> (uint32_t v) { return f_value >> v; }
     615             : #if UINT_MAX == ULONG_MAX
     616             :         T operator >> (long v) { return f_value >> v; }
     617             : #endif
     618             : #if UINT_MAX == ULONG_MAX
     619             :         T operator >> (unsigned long v) { return f_value >> v; }
     620             : #endif
     621             :         T operator >> (int64_t v) { return f_value >> v; }
     622             :         T operator >> (uint64_t v) { return f_value >> v; }
     623             : #if 0 //def __APPLE___
     624             :         T operator >> (size_t v) { return f_value >> v; }
     625             : #endif
     626             : #if 0 //def __APPLE___
     627             :         T operator >> (time_t v) { return f_value >> v; }
     628             : #endif
     629             :         T operator & (const limited_auto_init& n) { return f_value & n.f_value; }
     630             :         T operator & (bool v) { return f_value & v; }
     631             :         T operator & (char v) { return f_value & v; }
     632             :         T operator & (signed char v) { return f_value & v; }
     633             :         T operator & (unsigned char v) { return f_value & v; }
     634             : #if !defined(_MSC_VER) || (defined(_WCHAR_T_DEFINED) && defined(_NATIVE_WCHAR_T_DEFINED))
     635             :         T operator & (wchar_t v) { return f_value & v; }
     636             : #endif
     637             :         T operator & (int16_t v) { return f_value & v; }
     638             :         T operator & (uint16_t v) { return f_value & v; }
     639             :         T operator & (int32_t v) { return f_value & v; }
     640             :         T operator & (uint32_t v) { return f_value & v; }
     641             : #if UINT_MAX == ULONG_MAX
     642             :         T operator & (long v) { return f_value & v; }
     643             : #endif
     644             : #if UINT_MAX == ULONG_MAX
     645             :         T operator & (unsigned long v) { return f_value & v; }
     646             : #endif
     647             :         T operator & (int64_t v) { return f_value & v; }
     648             :         T operator & (uint64_t v) { return f_value & v; }
     649             : #if 0 //def __APPLE___
     650             :         T operator & (size_t v) { return f_value & v; }
     651             : #endif
     652             : #if 0 //def __APPLE___
     653             :         T operator & (time_t v) { return f_value & v; }
     654             : #endif
     655             :         T operator | (const limited_auto_init& n) { return f_value | n.f_value; }
     656             :         T operator | (bool v) { return f_value | v; }
     657             :         T operator | (char v) { return f_value | v; }
     658             :         T operator | (signed char v) { return f_value | v; }
     659             :         T operator | (unsigned char v) { return f_value | v; }
     660             : #if !defined(_MSC_VER) || (defined(_WCHAR_T_DEFINED) && defined(_NATIVE_WCHAR_T_DEFINED))
     661             :         T operator | (wchar_t v) { return f_value | v; }
     662             : #endif
     663             :         T operator | (int16_t v) { return f_value | v; }
     664             :         T operator | (uint16_t v) { return f_value | v; }
     665             :         T operator | (int32_t v) { return f_value | v; }
     666             :         T operator | (uint32_t v) { return f_value | v; }
     667             : #if UINT_MAX == ULONG_MAX
     668             :         T operator | (long v) { return f_value | v; }
     669             : #endif
     670             : #if UINT_MAX == ULONG_MAX
     671             :         T operator | (unsigned long v) { return f_value | v; }
     672             : #endif
     673             :         T operator | (int64_t v) { return f_value | v; }
     674             :         T operator | (uint64_t v) { return f_value | v; }
     675             : #if 0 //def __APPLE___
     676             :         T operator | (size_t v) { return f_value | v; }
     677             : #endif
     678             : #if 0 //def __APPLE___
     679             :         T operator | (time_t v) { return f_value | v; }
     680             : #endif
     681             :         T operator ^ (const limited_auto_init& n) { return f_value ^ n.f_value; }
     682             :         T operator ^ (bool v) { return f_value ^ v; }
     683             :         T operator ^ (char v) { return f_value ^ v; }
     684             :         T operator ^ (signed char v) { return f_value ^ v; }
     685             :         T operator ^ (unsigned char v) { return f_value ^ v; }
     686             : #if !defined(_MSC_VER) || (defined(_WCHAR_T_DEFINED) && defined(_NATIVE_WCHAR_T_DEFINED))
     687             :         T operator ^ (wchar_t v) { return f_value ^ v; }
     688             : #endif
     689             :         T operator ^ (int16_t v) { return f_value ^ v; }
     690             :         T operator ^ (uint16_t v) { return f_value ^ v; }
     691             :         T operator ^ (int32_t v) { return f_value ^ v; }
     692             :         T operator ^ (uint32_t v) { return f_value ^ v; }
     693             : #if UINT_MAX == ULONG_MAX
     694             :         T operator ^ (long v) { return f_value ^ v; }
     695             : #endif
     696             : #if UINT_MAX == ULONG_MAX
     697             :         T operator ^ (unsigned long v) { return f_value ^ v; }
     698             : #endif
     699             :         T operator ^ (int64_t v) { return f_value ^ v; }
     700             :         T operator ^ (uint64_t v) { return f_value ^ v; }
     701             : #if 0 //def __APPLE___
     702             :         T operator ^ (size_t v) { return f_value ^ v; }
     703             : #endif
     704             : #if 0 //def __APPLE___
     705             :         T operator ^ (time_t v) { return f_value ^ v; }
     706             : #endif
     707             :         bool operator == (const limited_auto_init& n) { return f_value == n.f_value; }
     708             :         bool operator == (bool v) { return f_value == v; }
     709             :         bool operator == (char v) { return f_value == v; }
     710             :         bool operator == (signed char v) { return f_value == v; }
     711             :         bool operator == (unsigned char v) { return f_value == v; }
     712             : #if !defined(_MSC_VER) || (defined(_WCHAR_T_DEFINED) && defined(_NATIVE_WCHAR_T_DEFINED))
     713             :         bool operator == (wchar_t v) { return f_value == v; }
     714             : #endif
     715             :         bool operator == (int16_t v) { return f_value == v; }
     716             :         bool operator == (uint16_t v) { return f_value == v; }
     717             :         bool operator == (int32_t v) { return f_value == v; }
     718             :         bool operator == (uint32_t v) { return f_value == v; }
     719             : #if UINT_MAX == ULONG_MAX
     720             :         bool operator == (long v) { return f_value == v; }
     721             : #endif
     722             : #if UINT_MAX == ULONG_MAX
     723             :         bool operator == (unsigned long v) { return f_value == v; }
     724             : #endif
     725             :         bool operator == (int64_t v) { return f_value == v; }
     726             :         bool operator == (uint64_t v) { return f_value == v; }
     727             :         bool operator == (float v) { return f_value == v; }
     728             :         bool operator == (double v) { return f_value == v; }
     729             : #ifndef __APPLE__
     730             :         bool operator == (long double v) { return f_value == v; }
     731             : #endif
     732             : #if 0 //def __APPLE___
     733             :         bool operator == (size_t v) { return f_value == v; }
     734             : #endif
     735             : #if 0 //def __APPLE___
     736             :         bool operator == (time_t v) { return f_value == v; }
     737             : #endif
     738             :         bool operator != (const limited_auto_init& n) { return f_value != n.f_value; }
     739             :         bool operator != (bool v) { return f_value != v; }
     740             :         bool operator != (char v) { return f_value != v; }
     741             :         bool operator != (signed char v) { return f_value != v; }
     742             :         bool operator != (unsigned char v) { return f_value != v; }
     743             : #if !defined(_MSC_VER) || (defined(_WCHAR_T_DEFINED) && defined(_NATIVE_WCHAR_T_DEFINED))
     744             :         bool operator != (wchar_t v) { return f_value != v; }
     745             : #endif
     746             :         bool operator != (int16_t v) { return f_value != v; }
     747             :         bool operator != (uint16_t v) { return f_value != v; }
     748             :         bool operator != (int32_t v) { return f_value != v; }
     749             :         bool operator != (uint32_t v) { return f_value != v; }
     750             : #if UINT_MAX == ULONG_MAX
     751             :         bool operator != (long v) { return f_value != v; }
     752             : #endif
     753             : #if UINT_MAX == ULONG_MAX
     754             :         bool operator != (unsigned long v) { return f_value != v; }
     755             : #endif
     756             :         bool operator != (int64_t v) { return f_value != v; }
     757             :         bool operator != (uint64_t v) { return f_value != v; }
     758             :         bool operator != (float v) { return f_value != v; }
     759             :         bool operator != (double v) { return f_value != v; }
     760             : #ifndef __APPLE__
     761             :         bool operator != (long double v) { return f_value != v; }
     762             : #endif
     763             : #if 0 //def __APPLE___
     764             :         bool operator != (size_t v) { return f_value != v; }
     765             : #endif
     766             : #if 0 //def __APPLE___
     767             :         bool operator != (time_t v) { return f_value != v; }
     768             : #endif
     769             :         bool operator < (const limited_auto_init& n) { return f_value < n.f_value; }
     770             :         bool operator < (bool v) { return f_value < v; }
     771             :         bool operator < (char v) { return f_value < v; }
     772             :         bool operator < (signed char v) { return f_value < v; }
     773             :         bool operator < (unsigned char v) { return f_value < v; }
     774             : #if !defined(_MSC_VER) || (defined(_WCHAR_T_DEFINED) && defined(_NATIVE_WCHAR_T_DEFINED))
     775             :         bool operator < (wchar_t v) { return f_value < v; }
     776             : #endif
     777             :         bool operator < (int16_t v) { return f_value < v; }
     778             :         bool operator < (uint16_t v) { return f_value < v; }
     779             :         bool operator < (int32_t v) { return f_value < v; }
     780             :         bool operator < (uint32_t v) { return f_value < v; }
     781             : #if UINT_MAX == ULONG_MAX
     782             :         bool operator < (long v) { return f_value < v; }
     783             : #endif
     784             : #if UINT_MAX == ULONG_MAX
     785             :         bool operator < (unsigned long v) { return f_value < v; }
     786             : #endif
     787             :         bool operator < (int64_t v) { return f_value < v; }
     788             :         bool operator < (uint64_t v) { return f_value < v; }
     789             :         bool operator < (float v) { return f_value < v; }
     790             :         bool operator < (double v) { return f_value < v; }
     791             : #ifndef __APPLE__
     792             :         bool operator < (long double v) { return f_value < v; }
     793             : #endif
     794             : #if 0 //def __APPLE___
     795             :         bool operator < (size_t v) { return f_value < v; }
     796             : #endif
     797             : #if 0 //def __APPLE___
     798             :         bool operator < (time_t v) { return f_value < v; }
     799             : #endif
     800             :         bool operator <= (const limited_auto_init& n) { return f_value <= n.f_value; }
     801             :         bool operator <= (bool v) { return f_value <= v; }
     802             :         bool operator <= (char v) { return f_value <= v; }
     803             :         bool operator <= (signed char v) { return f_value <= v; }
     804             :         bool operator <= (unsigned char v) { return f_value <= v; }
     805             : #if !defined(_MSC_VER) || (defined(_WCHAR_T_DEFINED) && defined(_NATIVE_WCHAR_T_DEFINED))
     806             :         bool operator <= (wchar_t v) { return f_value <= v; }
     807             : #endif
     808             :         bool operator <= (int16_t v) { return f_value <= v; }
     809             :         bool operator <= (uint16_t v) { return f_value <= v; }
     810             :         bool operator <= (int32_t v) { return f_value <= v; }
     811             :         bool operator <= (uint32_t v) { return f_value <= v; }
     812             : #if UINT_MAX == ULONG_MAX
     813             :         bool operator <= (long v) { return f_value <= v; }
     814             : #endif
     815             : #if UINT_MAX == ULONG_MAX
     816             :         bool operator <= (unsigned long v) { return f_value <= v; }
     817             : #endif
     818             :         bool operator <= (int64_t v) { return f_value <= v; }
     819             :         bool operator <= (uint64_t v) { return f_value <= v; }
     820             :         bool operator <= (float v) { return f_value <= v; }
     821             :         bool operator <= (double v) { return f_value <= v; }
     822             : #ifndef __APPLE__
     823             :         bool operator <= (long double v) { return f_value <= v; }
     824             : #endif
     825             : #if 0 //def __APPLE___
     826             :         bool operator <= (size_t v) { return f_value <= v; }
     827             : #endif
     828             : #if 0 //def __APPLE___
     829             :         bool operator <= (time_t v) { return f_value <= v; }
     830             : #endif
     831             :         bool operator > (const limited_auto_init& n) { return f_value > n.f_value; }
     832             :         bool operator > (bool v) { return f_value > v; }
     833             :         bool operator > (char v) { return f_value > v; }
     834             :         bool operator > (signed char v) { return f_value > v; }
     835             :         bool operator > (unsigned char v) { return f_value > v; }
     836             : #if !defined(_MSC_VER) || (defined(_WCHAR_T_DEFINED) && defined(_NATIVE_WCHAR_T_DEFINED))
     837             :         bool operator > (wchar_t v) { return f_value > v; }
     838             : #endif
     839             :         bool operator > (int16_t v) { return f_value > v; }
     840             :         bool operator > (uint16_t v) { return f_value > v; }
     841             :         bool operator > (int32_t v) { return f_value > v; }
     842             :         bool operator > (uint32_t v) { return f_value > v; }
     843             : #if UINT_MAX == ULONG_MAX
     844             :         bool operator > (long v) { return f_value > v; }
     845             : #endif
     846             : #if UINT_MAX == ULONG_MAX
     847             :         bool operator > (unsigned long v) { return f_value > v; }
     848             : #endif
     849             :         bool operator > (int64_t v) { return f_value > v; }
     850             :         bool operator > (uint64_t v) { return f_value > v; }
     851             :         bool operator > (float v) { return f_value > v; }
     852             :         bool operator > (double v) { return f_value > v; }
     853             : #ifndef __APPLE__
     854             :         bool operator > (long double v) { return f_value > v; }
     855             : #endif
     856             : #if 0 //def __APPLE___
     857             :         bool operator > (size_t v) { return f_value > v; }
     858             : #endif
     859             : #if 0 //def __APPLE___
     860             :         bool operator > (time_t v) { return f_value > v; }
     861             : #endif
     862             :         bool operator >= (const limited_auto_init& n) { return f_value >= n.f_value; }
     863             :         bool operator >= (bool v) { return f_value >= v; }
     864             :         bool operator >= (char v) { return f_value >= v; }
     865             :         bool operator >= (signed char v) { return f_value >= v; }
     866             :         bool operator >= (unsigned char v) { return f_value >= v; }
     867             : #if !defined(_MSC_VER) || (defined(_WCHAR_T_DEFINED) && defined(_NATIVE_WCHAR_T_DEFINED))
     868             :         bool operator >= (wchar_t v) { return f_value >= v; }
     869             : #endif
     870             :         bool operator >= (int16_t v) { return f_value >= v; }
     871             :         bool operator >= (uint16_t v) { return f_value >= v; }
     872             :         bool operator >= (int32_t v) { return f_value >= v; }
     873             :         bool operator >= (uint32_t v) { return f_value >= v; }
     874             : #if UINT_MAX == ULONG_MAX
     875             :         bool operator >= (long v) { return f_value >= v; }
     876             : #endif
     877             : #if UINT_MAX == ULONG_MAX
     878             :         bool operator >= (unsigned long v) { return f_value >= v; }
     879             : #endif
     880             :         bool operator >= (int64_t v) { return f_value >= v; }
     881             :         bool operator >= (uint64_t v) { return f_value >= v; }
     882             :         bool operator >= (float v) { return f_value >= v; }
     883             :         bool operator >= (double v) { return f_value >= v; }
     884             : #ifndef __APPLE__
     885             :         bool operator >= (long double v) { return f_value >= v; }
     886             : #endif
     887             : #if 0 //def __APPLE___
     888             :         bool operator >= (size_t v) { return f_value >= v; }
     889             : #endif
     890             : #if 0 //def __APPLE___
     891             :         bool operator >= (time_t v) { return f_value >= v; }
     892             : #endif
     893             : #ifdef CONTROLLED_VARS_DEBUG
     894             :         bool is_initialized() const { return true; }
     895             : #endif
     896             : private:
     897             :         T f_value;
     898             : };
     899             : typedef limited_auto_init<bool, false, true, false> flbool_t;
     900             : typedef flbool_t zlbool_t;
     901             : typedef limited_auto_init<bool, false, true, true> tlbool_t;
     902             : } // namespace controlled_vars
     903             : #ifdef _MSC_VER
     904             : #pragma warning(pop)
     905             : #endif
     906             : #endif

Generated by: LCOV version 1.9

The wpkg tool is an open source tool created by Made to Order Software Corporation.