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_need_init.h (source / functions) Hit Total Coverage
Test: coverage.info Lines: 6 7 85.7 %
Date: 2013-06-17 Functions: 7 8 87.5 %
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_need_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_NEED_INIT_H
      33             : #define CONTROLLED_VARS_NEED_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 <limits.h>
      46             : #include <sys/types.h>
      47             : #include <stdint.h>
      48             : namespace controlled_vars {
      49             : /** \brief Documentation available online.
      50             :  * Please go to http://snapwebsites.org/project/controlled-vars
      51             :  */
      52             : template<class T> class need_init {
      53             : public:
      54             :         typedef T primary_type_t;
      55             :         need_init(bool v) { f_value = static_cast<primary_type_t>(v); }
      56             :         need_init(char v) { f_value = static_cast<primary_type_t>(v); }
      57             :         need_init(signed char v) { f_value = static_cast<primary_type_t>(v); }
      58             :         need_init(unsigned char v) { f_value = static_cast<primary_type_t>(v); }
      59             : #if !defined(_MSC_VER) || (defined(_WCHAR_T_DEFINED) && defined(_NATIVE_WCHAR_T_DEFINED))
      60             :         need_init(wchar_t v) { f_value = static_cast<primary_type_t>(v); }
      61             : #endif
      62             :         need_init(int16_t v) { f_value = static_cast<primary_type_t>(v); }
      63             :         need_init(uint16_t v) { f_value = static_cast<primary_type_t>(v); }
      64      236926 :         need_init(int32_t v) { f_value = static_cast<primary_type_t>(v); }
      65             :         need_init(uint32_t v) { f_value = static_cast<primary_type_t>(v); }
      66             : #if UINT_MAX == ULONG_MAX
      67             :         need_init(long v) { f_value = static_cast<primary_type_t>(v); }
      68             : #endif
      69             : #if UINT_MAX == ULONG_MAX
      70             :         need_init(unsigned long v) { f_value = static_cast<primary_type_t>(v); }
      71             : #endif
      72             :         need_init(int64_t v) { f_value = static_cast<primary_type_t>(v); }
      73             :         need_init(uint64_t v) { f_value = static_cast<primary_type_t>(v); }
      74             :         need_init(float v) { f_value = static_cast<primary_type_t>(v); }
      75             :         need_init(double v) { f_value = static_cast<primary_type_t>(v); }
      76             : #ifndef __APPLE__
      77             :         need_init(long double v) { f_value = static_cast<primary_type_t>(v); }
      78             : #endif
      79             : #if 0 //def __APPLE__
      80             :         need_init(size_t v) { f_value = static_cast<primary_type_t>(v); }
      81             : #endif
      82             : #if 0 //def __APPLE__
      83             :         need_init(time_t v) { f_value = static_cast<primary_type_t>(v); }
      84             : #endif
      85        2545 :         operator T () const { return f_value; }
      86         632 :         operator T () { return f_value; }
      87             :         T value() const { return f_value; }
      88             :         const T * ptr() const { return &f_value; }
      89             :         T * ptr() { return &f_value; }
      90             :         bool operator ! () const { return !f_value; }
      91             :         T operator ~ () const { return ~f_value; }
      92             :         T operator + () const { return +f_value; }
      93             :         T operator - () const { return -f_value; }
      94        3956 :         need_init& operator ++ () { ++f_value; return *this; }
      95             :         need_init operator ++ (int) { need_init<T> result(*this); ++f_value; return result; }
      96         632 :         need_init& operator -- () { --f_value; return *this; }
      97             :         need_init operator -- (int) { need_init<T> result(*this); --f_value; return result; }
      98           0 :         need_init& operator = (const need_init& n) { f_value = n.f_value; return *this; }
      99             :         need_init& operator = (bool v) { f_value = v; return *this; }
     100             :         need_init& operator = (char v) { f_value = v; return *this; }
     101             :         need_init& operator = (signed char v) { f_value = v; return *this; }
     102             :         need_init& operator = (unsigned char v) { f_value = v; return *this; }
     103             : #if !defined(_MSC_VER) || (defined(_WCHAR_T_DEFINED) && defined(_NATIVE_WCHAR_T_DEFINED))
     104             :         need_init& operator = (wchar_t v) { f_value = v; return *this; }
     105             : #endif
     106             :         need_init& operator = (int16_t v) { f_value = v; return *this; }
     107             :         need_init& operator = (uint16_t v) { f_value = v; return *this; }
     108         534 :         need_init& operator = (int32_t v) { f_value = v; return *this; }
     109             :         need_init& operator = (uint32_t v) { f_value = v; return *this; }
     110             : #if UINT_MAX == ULONG_MAX
     111             :         need_init& operator = (long v) { f_value = v; return *this; }
     112             : #endif
     113             : #if UINT_MAX == ULONG_MAX
     114             :         need_init& operator = (unsigned long v) { f_value = v; return *this; }
     115             : #endif
     116             :         need_init& operator = (int64_t v) { f_value = v; return *this; }
     117             :         need_init& operator = (uint64_t v) { f_value = v; return *this; }
     118             :         need_init& operator = (float v) { f_value = v; return *this; }
     119             :         need_init& operator = (double v) { f_value = v; return *this; }
     120             : #ifndef __APPLE__
     121             :         need_init& operator = (long double v) { f_value = v; return *this; }
     122             : #endif
     123             : #if 0 //def __APPLE__
     124             :         need_init& operator = (size_t v) { f_value = v; return *this; }
     125             : #endif
     126             : #if 0 //def __APPLE__
     127             :         need_init& operator = (time_t v) { f_value = v; return *this; }
     128             : #endif
     129             :         need_init& operator *= (const need_init& n) { f_value *= n.f_value; return *this; }
     130             :         need_init& operator *= (bool v) { f_value *= v; return *this; }
     131             :         need_init& operator *= (char v) { f_value *= v; return *this; }
     132             :         need_init& operator *= (signed char v) { f_value *= v; return *this; }
     133             :         need_init& operator *= (unsigned char v) { f_value *= v; return *this; }
     134             : #if !defined(_MSC_VER) || (defined(_WCHAR_T_DEFINED) && defined(_NATIVE_WCHAR_T_DEFINED))
     135             :         need_init& operator *= (wchar_t v) { f_value *= v; return *this; }
     136             : #endif
     137             :         need_init& operator *= (int16_t v) { f_value *= v; return *this; }
     138             :         need_init& operator *= (uint16_t v) { f_value *= v; return *this; }
     139             :         need_init& operator *= (int32_t v) { f_value *= v; return *this; }
     140             :         need_init& operator *= (uint32_t v) { f_value *= v; return *this; }
     141             : #if UINT_MAX == ULONG_MAX
     142             :         need_init& operator *= (long v) { f_value *= v; return *this; }
     143             : #endif
     144             : #if UINT_MAX == ULONG_MAX
     145             :         need_init& operator *= (unsigned long v) { f_value *= v; return *this; }
     146             : #endif
     147             :         need_init& operator *= (int64_t v) { f_value *= v; return *this; }
     148             :         need_init& operator *= (uint64_t v) { f_value *= v; return *this; }
     149             :         need_init& operator *= (float v) { f_value *= v; return *this; }
     150             :         need_init& operator *= (double v) { f_value *= v; return *this; }
     151             : #ifndef __APPLE__
     152             :         need_init& operator *= (long double v) { f_value *= v; return *this; }
     153             : #endif
     154             : #if 0 //def __APPLE__
     155             :         need_init& operator *= (size_t v) { f_value *= v; return *this; }
     156             : #endif
     157             : #if 0 //def __APPLE__
     158             :         need_init& operator *= (time_t v) { f_value *= v; return *this; }
     159             : #endif
     160             :         need_init& operator /= (const need_init& n) { f_value /= n.f_value; return *this; }
     161             :         need_init& operator /= (bool v) { f_value /= v; return *this; }
     162             :         need_init& operator /= (char v) { f_value /= v; return *this; }
     163             :         need_init& operator /= (signed char v) { f_value /= v; return *this; }
     164             :         need_init& operator /= (unsigned char v) { f_value /= v; return *this; }
     165             : #if !defined(_MSC_VER) || (defined(_WCHAR_T_DEFINED) && defined(_NATIVE_WCHAR_T_DEFINED))
     166             :         need_init& operator /= (wchar_t v) { f_value /= v; return *this; }
     167             : #endif
     168             :         need_init& operator /= (int16_t v) { f_value /= v; return *this; }
     169             :         need_init& operator /= (uint16_t v) { f_value /= v; return *this; }
     170             :         need_init& operator /= (int32_t v) { f_value /= v; return *this; }
     171             :         need_init& operator /= (uint32_t v) { f_value /= v; return *this; }
     172             : #if UINT_MAX == ULONG_MAX
     173             :         need_init& operator /= (long v) { f_value /= v; return *this; }
     174             : #endif
     175             : #if UINT_MAX == ULONG_MAX
     176             :         need_init& operator /= (unsigned long v) { f_value /= v; return *this; }
     177             : #endif
     178             :         need_init& operator /= (int64_t v) { f_value /= v; return *this; }
     179             :         need_init& operator /= (uint64_t v) { f_value /= v; return *this; }
     180             :         need_init& operator /= (float v) { f_value /= v; return *this; }
     181             :         need_init& operator /= (double v) { f_value /= v; return *this; }
     182             : #ifndef __APPLE__
     183             :         need_init& operator /= (long double v) { f_value /= v; return *this; }
     184             : #endif
     185             : #if 0 //def __APPLE__
     186             :         need_init& operator /= (size_t v) { f_value /= v; return *this; }
     187             : #endif
     188             : #if 0 //def __APPLE__
     189             :         need_init& operator /= (time_t v) { f_value /= v; return *this; }
     190             : #endif
     191             :         need_init& operator %= (const need_init& n) { f_value %= n.f_value; return *this; }
     192             :         need_init& operator %= (bool v) { f_value %= v; return *this; }
     193             :         need_init& operator %= (char v) { f_value %= v; return *this; }
     194             :         need_init& operator %= (signed char v) { f_value %= v; return *this; }
     195             :         need_init& operator %= (unsigned char v) { f_value %= v; return *this; }
     196             : #if !defined(_MSC_VER) || (defined(_WCHAR_T_DEFINED) && defined(_NATIVE_WCHAR_T_DEFINED))
     197             :         need_init& operator %= (wchar_t v) { f_value %= v; return *this; }
     198             : #endif
     199             :         need_init& operator %= (int16_t v) { f_value %= v; return *this; }
     200             :         need_init& operator %= (uint16_t v) { f_value %= v; return *this; }
     201             :         need_init& operator %= (int32_t v) { f_value %= v; return *this; }
     202             :         need_init& operator %= (uint32_t v) { f_value %= v; return *this; }
     203             : #if UINT_MAX == ULONG_MAX
     204             :         need_init& operator %= (long v) { f_value %= v; return *this; }
     205             : #endif
     206             : #if UINT_MAX == ULONG_MAX
     207             :         need_init& operator %= (unsigned long v) { f_value %= v; return *this; }
     208             : #endif
     209             :         need_init& operator %= (int64_t v) { f_value %= v; return *this; }
     210             :         need_init& operator %= (uint64_t v) { f_value %= v; return *this; }
     211             : #if 0 //def __APPLE__
     212             :         need_init& operator %= (size_t v) { f_value %= v; return *this; }
     213             : #endif
     214             : #if 0 //def __APPLE__
     215             :         need_init& operator %= (time_t v) { f_value %= v; return *this; }
     216             : #endif
     217             :         need_init& operator += (const need_init& n) { f_value += n.f_value; return *this; }
     218             :         need_init& operator += (bool v) { f_value += v; return *this; }
     219             :         need_init& operator += (char v) { f_value += v; return *this; }
     220             :         need_init& operator += (signed char v) { f_value += v; return *this; }
     221             :         need_init& operator += (unsigned char v) { f_value += v; return *this; }
     222             : #if !defined(_MSC_VER) || (defined(_WCHAR_T_DEFINED) && defined(_NATIVE_WCHAR_T_DEFINED))
     223             :         need_init& operator += (wchar_t v) { f_value += v; return *this; }
     224             : #endif
     225             :         need_init& operator += (int16_t v) { f_value += v; return *this; }
     226             :         need_init& operator += (uint16_t v) { f_value += v; return *this; }
     227             :         need_init& operator += (int32_t v) { f_value += v; return *this; }
     228             :         need_init& operator += (uint32_t v) { f_value += v; return *this; }
     229             : #if UINT_MAX == ULONG_MAX
     230             :         need_init& operator += (long v) { f_value += v; return *this; }
     231             : #endif
     232             : #if UINT_MAX == ULONG_MAX
     233             :         need_init& operator += (unsigned long v) { f_value += v; return *this; }
     234             : #endif
     235             :         need_init& operator += (int64_t v) { f_value += v; return *this; }
     236             :         need_init& operator += (uint64_t v) { f_value += v; return *this; }
     237             :         need_init& operator += (float v) { f_value += v; return *this; }
     238             :         need_init& operator += (double v) { f_value += v; return *this; }
     239             : #ifndef __APPLE__
     240             :         need_init& operator += (long double v) { f_value += v; return *this; }
     241             : #endif
     242             : #if 0 //def __APPLE__
     243             :         need_init& operator += (size_t v) { f_value += v; return *this; }
     244             : #endif
     245             : #if 0 //def __APPLE__
     246             :         need_init& operator += (time_t v) { f_value += v; return *this; }
     247             : #endif
     248             :         need_init& operator -= (const need_init& n) { f_value -= n.f_value; return *this; }
     249             :         need_init& operator -= (bool v) { f_value -= v; return *this; }
     250             :         need_init& operator -= (char v) { f_value -= v; return *this; }
     251             :         need_init& operator -= (signed char v) { f_value -= v; return *this; }
     252             :         need_init& operator -= (unsigned char v) { f_value -= v; return *this; }
     253             : #if !defined(_MSC_VER) || (defined(_WCHAR_T_DEFINED) && defined(_NATIVE_WCHAR_T_DEFINED))
     254             :         need_init& operator -= (wchar_t v) { f_value -= v; return *this; }
     255             : #endif
     256             :         need_init& operator -= (int16_t v) { f_value -= v; return *this; }
     257             :         need_init& operator -= (uint16_t v) { f_value -= v; return *this; }
     258             :         need_init& operator -= (int32_t v) { f_value -= v; return *this; }
     259             :         need_init& operator -= (uint32_t v) { f_value -= v; return *this; }
     260             : #if UINT_MAX == ULONG_MAX
     261             :         need_init& operator -= (long v) { f_value -= v; return *this; }
     262             : #endif
     263             : #if UINT_MAX == ULONG_MAX
     264             :         need_init& operator -= (unsigned long v) { f_value -= v; return *this; }
     265             : #endif
     266             :         need_init& operator -= (int64_t v) { f_value -= v; return *this; }
     267             :         need_init& operator -= (uint64_t v) { f_value -= v; return *this; }
     268             :         need_init& operator -= (float v) { f_value -= v; return *this; }
     269             :         need_init& operator -= (double v) { f_value -= v; return *this; }
     270             : #ifndef __APPLE__
     271             :         need_init& operator -= (long double v) { f_value -= v; return *this; }
     272             : #endif
     273             : #if 0 //def __APPLE__
     274             :         need_init& operator -= (size_t v) { f_value -= v; return *this; }
     275             : #endif
     276             : #if 0 //def __APPLE__
     277             :         need_init& operator -= (time_t v) { f_value -= v; return *this; }
     278             : #endif
     279             :         need_init& operator <<= (const need_init& n) { f_value <<= n.f_value; return *this; }
     280             :         need_init& operator <<= (bool v) { f_value <<= v; return *this; }
     281             :         need_init& operator <<= (char v) { f_value <<= v; return *this; }
     282             :         need_init& operator <<= (signed char v) { f_value <<= v; return *this; }
     283             :         need_init& operator <<= (unsigned char v) { f_value <<= v; return *this; }
     284             : #if !defined(_MSC_VER) || (defined(_WCHAR_T_DEFINED) && defined(_NATIVE_WCHAR_T_DEFINED))
     285             :         need_init& operator <<= (wchar_t v) { f_value <<= v; return *this; }
     286             : #endif
     287             :         need_init& operator <<= (int16_t v) { f_value <<= v; return *this; }
     288             :         need_init& operator <<= (uint16_t v) { f_value <<= v; return *this; }
     289             :         need_init& operator <<= (int32_t v) { f_value <<= v; return *this; }
     290             :         need_init& operator <<= (uint32_t v) { f_value <<= v; return *this; }
     291             : #if UINT_MAX == ULONG_MAX
     292             :         need_init& operator <<= (long v) { f_value <<= v; return *this; }
     293             : #endif
     294             : #if UINT_MAX == ULONG_MAX
     295             :         need_init& operator <<= (unsigned long v) { f_value <<= v; return *this; }
     296             : #endif
     297             :         need_init& operator <<= (int64_t v) { f_value <<= v; return *this; }
     298             :         need_init& operator <<= (uint64_t v) { f_value <<= v; return *this; }
     299             : #if 0 //def __APPLE__
     300             :         need_init& operator <<= (size_t v) { f_value <<= v; return *this; }
     301             : #endif
     302             : #if 0 //def __APPLE__
     303             :         need_init& operator <<= (time_t v) { f_value <<= v; return *this; }
     304             : #endif
     305             :         need_init& operator >>= (const need_init& n) { f_value >>= n.f_value; return *this; }
     306             :         need_init& operator >>= (bool v) { f_value >>= v; return *this; }
     307             :         need_init& operator >>= (char v) { f_value >>= v; return *this; }
     308             :         need_init& operator >>= (signed char v) { f_value >>= v; return *this; }
     309             :         need_init& operator >>= (unsigned char v) { f_value >>= v; return *this; }
     310             : #if !defined(_MSC_VER) || (defined(_WCHAR_T_DEFINED) && defined(_NATIVE_WCHAR_T_DEFINED))
     311             :         need_init& operator >>= (wchar_t v) { f_value >>= v; return *this; }
     312             : #endif
     313             :         need_init& operator >>= (int16_t v) { f_value >>= v; return *this; }
     314             :         need_init& operator >>= (uint16_t v) { f_value >>= v; return *this; }
     315             :         need_init& operator >>= (int32_t v) { f_value >>= v; return *this; }
     316             :         need_init& operator >>= (uint32_t v) { f_value >>= v; return *this; }
     317             : #if UINT_MAX == ULONG_MAX
     318             :         need_init& operator >>= (long v) { f_value >>= v; return *this; }
     319             : #endif
     320             : #if UINT_MAX == ULONG_MAX
     321             :         need_init& operator >>= (unsigned long v) { f_value >>= v; return *this; }
     322             : #endif
     323             :         need_init& operator >>= (int64_t v) { f_value >>= v; return *this; }
     324             :         need_init& operator >>= (uint64_t v) { f_value >>= v; return *this; }
     325             : #if 0 //def __APPLE__
     326             :         need_init& operator >>= (size_t v) { f_value >>= v; return *this; }
     327             : #endif
     328             : #if 0 //def __APPLE__
     329             :         need_init& operator >>= (time_t v) { f_value >>= v; return *this; }
     330             : #endif
     331             :         need_init& operator &= (const need_init& n) { f_value &= n.f_value; return *this; }
     332             :         need_init& operator &= (bool v) { f_value &= v; return *this; }
     333             :         need_init& operator &= (char v) { f_value &= v; return *this; }
     334             :         need_init& operator &= (signed char v) { f_value &= v; return *this; }
     335             :         need_init& operator &= (unsigned char v) { f_value &= v; return *this; }
     336             : #if !defined(_MSC_VER) || (defined(_WCHAR_T_DEFINED) && defined(_NATIVE_WCHAR_T_DEFINED))
     337             :         need_init& operator &= (wchar_t v) { f_value &= v; return *this; }
     338             : #endif
     339             :         need_init& operator &= (int16_t v) { f_value &= v; return *this; }
     340             :         need_init& operator &= (uint16_t v) { f_value &= v; return *this; }
     341             :         need_init& operator &= (int32_t v) { f_value &= v; return *this; }
     342             :         need_init& operator &= (uint32_t v) { f_value &= v; return *this; }
     343             : #if UINT_MAX == ULONG_MAX
     344             :         need_init& operator &= (long v) { f_value &= v; return *this; }
     345             : #endif
     346             : #if UINT_MAX == ULONG_MAX
     347             :         need_init& operator &= (unsigned long v) { f_value &= v; return *this; }
     348             : #endif
     349             :         need_init& operator &= (int64_t v) { f_value &= v; return *this; }
     350             :         need_init& operator &= (uint64_t v) { f_value &= v; return *this; }
     351             : #if 0 //def __APPLE__
     352             :         need_init& operator &= (size_t v) { f_value &= v; return *this; }
     353             : #endif
     354             : #if 0 //def __APPLE__
     355             :         need_init& operator &= (time_t v) { f_value &= v; return *this; }
     356             : #endif
     357             :         need_init& operator |= (const need_init& n) { f_value |= n.f_value; return *this; }
     358             :         need_init& operator |= (bool v) { f_value |= v; return *this; }
     359             :         need_init& operator |= (char v) { f_value |= v; return *this; }
     360             :         need_init& operator |= (signed char v) { f_value |= v; return *this; }
     361             :         need_init& operator |= (unsigned char v) { f_value |= v; return *this; }
     362             : #if !defined(_MSC_VER) || (defined(_WCHAR_T_DEFINED) && defined(_NATIVE_WCHAR_T_DEFINED))
     363             :         need_init& operator |= (wchar_t v) { f_value |= v; return *this; }
     364             : #endif
     365             :         need_init& operator |= (int16_t v) { f_value |= v; return *this; }
     366             :         need_init& operator |= (uint16_t v) { f_value |= v; return *this; }
     367             :         need_init& operator |= (int32_t v) { f_value |= v; return *this; }
     368             :         need_init& operator |= (uint32_t v) { f_value |= v; return *this; }
     369             : #if UINT_MAX == ULONG_MAX
     370             :         need_init& operator |= (long v) { f_value |= v; return *this; }
     371             : #endif
     372             : #if UINT_MAX == ULONG_MAX
     373             :         need_init& operator |= (unsigned long v) { f_value |= v; return *this; }
     374             : #endif
     375             :         need_init& operator |= (int64_t v) { f_value |= v; return *this; }
     376             :         need_init& operator |= (uint64_t v) { f_value |= v; return *this; }
     377             : #if 0 //def __APPLE__
     378             :         need_init& operator |= (size_t v) { f_value |= v; return *this; }
     379             : #endif
     380             : #if 0 //def __APPLE__
     381             :         need_init& operator |= (time_t v) { f_value |= v; return *this; }
     382             : #endif
     383             :         need_init& operator ^= (const need_init& n) { f_value ^= n.f_value; return *this; }
     384             :         need_init& operator ^= (bool v) { f_value ^= v; return *this; }
     385             :         need_init& operator ^= (char v) { f_value ^= v; return *this; }
     386             :         need_init& operator ^= (signed char v) { f_value ^= v; return *this; }
     387             :         need_init& operator ^= (unsigned char v) { f_value ^= v; return *this; }
     388             : #if !defined(_MSC_VER) || (defined(_WCHAR_T_DEFINED) && defined(_NATIVE_WCHAR_T_DEFINED))
     389             :         need_init& operator ^= (wchar_t v) { f_value ^= v; return *this; }
     390             : #endif
     391             :         need_init& operator ^= (int16_t v) { f_value ^= v; return *this; }
     392             :         need_init& operator ^= (uint16_t v) { f_value ^= v; return *this; }
     393             :         need_init& operator ^= (int32_t v) { f_value ^= v; return *this; }
     394             :         need_init& operator ^= (uint32_t v) { f_value ^= v; return *this; }
     395             : #if UINT_MAX == ULONG_MAX
     396             :         need_init& operator ^= (long v) { f_value ^= v; return *this; }
     397             : #endif
     398             : #if UINT_MAX == ULONG_MAX
     399             :         need_init& operator ^= (unsigned long v) { f_value ^= v; return *this; }
     400             : #endif
     401             :         need_init& operator ^= (int64_t v) { f_value ^= v; return *this; }
     402             :         need_init& operator ^= (uint64_t v) { f_value ^= v; return *this; }
     403             : #if 0 //def __APPLE__
     404             :         need_init& operator ^= (size_t v) { f_value ^= v; return *this; }
     405             : #endif
     406             : #if 0 //def __APPLE__
     407             :         need_init& operator ^= (time_t v) { f_value ^= v; return *this; }
     408             : #endif
     409             :         T operator * (const need_init& n) { return f_value * n.f_value; }
     410             :         T operator * (bool v) { return f_value * v; }
     411             :         T operator * (char v) { return f_value * v; }
     412             :         T operator * (signed char v) { return f_value * v; }
     413             :         T operator * (unsigned char v) { return f_value * v; }
     414             : #if !defined(_MSC_VER) || (defined(_WCHAR_T_DEFINED) && defined(_NATIVE_WCHAR_T_DEFINED))
     415             :         T operator * (wchar_t v) { return f_value * v; }
     416             : #endif
     417             :         T operator * (int16_t v) { return f_value * v; }
     418             :         T operator * (uint16_t v) { return f_value * v; }
     419             :         T operator * (int32_t v) { return f_value * v; }
     420             :         T operator * (uint32_t v) { return f_value * v; }
     421             : #if UINT_MAX == ULONG_MAX
     422             :         T operator * (long v) { return f_value * v; }
     423             : #endif
     424             : #if UINT_MAX == ULONG_MAX
     425             :         T operator * (unsigned long v) { return f_value * v; }
     426             : #endif
     427             :         T operator * (int64_t v) { return f_value * v; }
     428             :         T operator * (uint64_t v) { return f_value * v; }
     429             :         T operator * (float v) { return f_value * v; }
     430             :         T operator * (double v) { return f_value * v; }
     431             : #ifndef __APPLE__
     432             :         T operator * (long double v) { return f_value * v; }
     433             : #endif
     434             : #if 0 //def __APPLE__
     435             :         T operator * (size_t v) { return f_value * v; }
     436             : #endif
     437             : #if 0 //def __APPLE__
     438             :         T operator * (time_t v) { return f_value * v; }
     439             : #endif
     440             :         T operator / (const need_init& n) { return f_value / n.f_value; }
     441             :         T operator / (bool v) { return f_value / v; }
     442             :         T operator / (char v) { return f_value / v; }
     443             :         T operator / (signed char v) { return f_value / v; }
     444             :         T operator / (unsigned char v) { return f_value / v; }
     445             : #if !defined(_MSC_VER) || (defined(_WCHAR_T_DEFINED) && defined(_NATIVE_WCHAR_T_DEFINED))
     446             :         T operator / (wchar_t v) { return f_value / v; }
     447             : #endif
     448             :         T operator / (int16_t v) { return f_value / v; }
     449             :         T operator / (uint16_t v) { return f_value / v; }
     450             :         T operator / (int32_t v) { return f_value / v; }
     451             :         T operator / (uint32_t v) { return f_value / v; }
     452             : #if UINT_MAX == ULONG_MAX
     453             :         T operator / (long v) { return f_value / v; }
     454             : #endif
     455             : #if UINT_MAX == ULONG_MAX
     456             :         T operator / (unsigned long v) { return f_value / v; }
     457             : #endif
     458             :         T operator / (int64_t v) { return f_value / v; }
     459             :         T operator / (uint64_t v) { return f_value / v; }
     460             :         T operator / (float v) { return f_value / v; }
     461             :         T operator / (double v) { return f_value / v; }
     462             : #ifndef __APPLE__
     463             :         T operator / (long double v) { return f_value / v; }
     464             : #endif
     465             : #if 0 //def __APPLE__
     466             :         T operator / (size_t v) { return f_value / v; }
     467             : #endif
     468             : #if 0 //def __APPLE__
     469             :         T operator / (time_t v) { return f_value / v; }
     470             : #endif
     471             :         T operator % (const need_init& n) { return f_value % n.f_value; }
     472             :         T operator % (bool v) { return f_value % v; }
     473             :         T operator % (char v) { return f_value % v; }
     474             :         T operator % (signed char v) { return f_value % v; }
     475             :         T operator % (unsigned char v) { return f_value % v; }
     476             : #if !defined(_MSC_VER) || (defined(_WCHAR_T_DEFINED) && defined(_NATIVE_WCHAR_T_DEFINED))
     477             :         T operator % (wchar_t v) { return f_value % v; }
     478             : #endif
     479             :         T operator % (int16_t v) { return f_value % v; }
     480             :         T operator % (uint16_t v) { return f_value % v; }
     481             :         T operator % (int32_t v) { return f_value % v; }
     482             :         T operator % (uint32_t v) { return f_value % v; }
     483             : #if UINT_MAX == ULONG_MAX
     484             :         T operator % (long v) { return f_value % v; }
     485             : #endif
     486             : #if UINT_MAX == ULONG_MAX
     487             :         T operator % (unsigned long v) { return f_value % v; }
     488             : #endif
     489             :         T operator % (int64_t v) { return f_value % v; }
     490             :         T operator % (uint64_t v) { return f_value % v; }
     491             : #if 0 //def __APPLE__
     492             :         T operator % (size_t v) { return f_value % v; }
     493             : #endif
     494             : #if 0 //def __APPLE__
     495             :         T operator % (time_t v) { return f_value % v; }
     496             : #endif
     497             :         T operator + (const need_init& n) { return f_value + n.f_value; }
     498             :         T operator + (bool v) { return f_value + v; }
     499             :         T operator + (char v) { return f_value + v; }
     500             :         T operator + (signed char v) { return f_value + v; }
     501             :         T operator + (unsigned char v) { return f_value + v; }
     502             : #if !defined(_MSC_VER) || (defined(_WCHAR_T_DEFINED) && defined(_NATIVE_WCHAR_T_DEFINED))
     503             :         T operator + (wchar_t v) { return f_value + v; }
     504             : #endif
     505             :         T operator + (int16_t v) { return f_value + v; }
     506             :         T operator + (uint16_t v) { return f_value + v; }
     507             :         T operator + (int32_t v) { return f_value + v; }
     508             :         T operator + (uint32_t v) { return f_value + v; }
     509             : #if UINT_MAX == ULONG_MAX
     510             :         T operator + (long v) { return f_value + v; }
     511             : #endif
     512             : #if UINT_MAX == ULONG_MAX
     513             :         T operator + (unsigned long v) { return f_value + v; }
     514             : #endif
     515             :         T operator + (int64_t v) { return f_value + v; }
     516             :         T operator + (uint64_t v) { return f_value + v; }
     517             :         T operator + (float v) { return f_value + v; }
     518             :         T operator + (double v) { return f_value + v; }
     519             : #ifndef __APPLE__
     520             :         T operator + (long double v) { return f_value + v; }
     521             : #endif
     522             : #if 0 //def __APPLE__
     523             :         T operator + (size_t v) { return f_value + v; }
     524             : #endif
     525             : #if 0 //def __APPLE__
     526             :         T operator + (time_t v) { return f_value + v; }
     527             : #endif
     528             :         T operator - (const need_init& n) { return f_value - n.f_value; }
     529             :         T operator - (bool v) { return f_value - v; }
     530             :         T operator - (char v) { return f_value - v; }
     531             :         T operator - (signed char v) { return f_value - v; }
     532             :         T operator - (unsigned char v) { return f_value - v; }
     533             : #if !defined(_MSC_VER) || (defined(_WCHAR_T_DEFINED) && defined(_NATIVE_WCHAR_T_DEFINED))
     534             :         T operator - (wchar_t v) { return f_value - v; }
     535             : #endif
     536             :         T operator - (int16_t v) { return f_value - v; }
     537             :         T operator - (uint16_t v) { return f_value - v; }
     538             :         T operator - (int32_t v) { return f_value - v; }
     539             :         T operator - (uint32_t v) { return f_value - v; }
     540             : #if UINT_MAX == ULONG_MAX
     541             :         T operator - (long v) { return f_value - v; }
     542             : #endif
     543             : #if UINT_MAX == ULONG_MAX
     544             :         T operator - (unsigned long v) { return f_value - v; }
     545             : #endif
     546             :         T operator - (int64_t v) { return f_value - v; }
     547             :         T operator - (uint64_t v) { return f_value - v; }
     548             :         T operator - (float v) { return f_value - v; }
     549             :         T operator - (double v) { return f_value - v; }
     550             : #ifndef __APPLE__
     551             :         T operator - (long double v) { return f_value - v; }
     552             : #endif
     553             : #if 0 //def __APPLE__
     554             :         T operator - (size_t v) { return f_value - v; }
     555             : #endif
     556             : #if 0 //def __APPLE__
     557             :         T operator - (time_t v) { return f_value - v; }
     558             : #endif
     559             :         T operator << (const need_init& n) { return f_value << n.f_value; }
     560             :         T operator << (bool v) { return f_value << v; }
     561             :         T operator << (char v) { return f_value << v; }
     562             :         T operator << (signed char v) { return f_value << v; }
     563             :         T operator << (unsigned char v) { return f_value << v; }
     564             : #if !defined(_MSC_VER) || (defined(_WCHAR_T_DEFINED) && defined(_NATIVE_WCHAR_T_DEFINED))
     565             :         T operator << (wchar_t v) { return f_value << v; }
     566             : #endif
     567             :         T operator << (int16_t v) { return f_value << v; }
     568             :         T operator << (uint16_t v) { return f_value << v; }
     569             :         T operator << (int32_t v) { return f_value << v; }
     570             :         T operator << (uint32_t v) { return f_value << v; }
     571             : #if UINT_MAX == ULONG_MAX
     572             :         T operator << (long v) { return f_value << v; }
     573             : #endif
     574             : #if UINT_MAX == ULONG_MAX
     575             :         T operator << (unsigned long v) { return f_value << v; }
     576             : #endif
     577             :         T operator << (int64_t v) { return f_value << v; }
     578             :         T operator << (uint64_t v) { return f_value << v; }
     579             : #if 0 //def __APPLE__
     580             :         T operator << (size_t v) { return f_value << v; }
     581             : #endif
     582             : #if 0 //def __APPLE__
     583             :         T operator << (time_t v) { return f_value << v; }
     584             : #endif
     585             :         T operator >> (const need_init& n) { return f_value >> n.f_value; }
     586             :         T operator >> (bool v) { return f_value >> v; }
     587             :         T operator >> (char v) { return f_value >> v; }
     588             :         T operator >> (signed char v) { return f_value >> v; }
     589             :         T operator >> (unsigned char v) { return f_value >> v; }
     590             : #if !defined(_MSC_VER) || (defined(_WCHAR_T_DEFINED) && defined(_NATIVE_WCHAR_T_DEFINED))
     591             :         T operator >> (wchar_t v) { return f_value >> v; }
     592             : #endif
     593             :         T operator >> (int16_t v) { return f_value >> v; }
     594             :         T operator >> (uint16_t v) { return f_value >> v; }
     595             :         T operator >> (int32_t v) { return f_value >> v; }
     596             :         T operator >> (uint32_t v) { return f_value >> v; }
     597             : #if UINT_MAX == ULONG_MAX
     598             :         T operator >> (long v) { return f_value >> v; }
     599             : #endif
     600             : #if UINT_MAX == ULONG_MAX
     601             :         T operator >> (unsigned long v) { return f_value >> v; }
     602             : #endif
     603             :         T operator >> (int64_t v) { return f_value >> v; }
     604             :         T operator >> (uint64_t v) { return f_value >> v; }
     605             : #if 0 //def __APPLE__
     606             :         T operator >> (size_t v) { return f_value >> v; }
     607             : #endif
     608             : #if 0 //def __APPLE__
     609             :         T operator >> (time_t v) { return f_value >> v; }
     610             : #endif
     611             :         T operator & (const need_init& n) { return f_value & n.f_value; }
     612             :         T operator & (bool v) { return f_value & v; }
     613             :         T operator & (char v) { return f_value & v; }
     614             :         T operator & (signed char v) { return f_value & v; }
     615             :         T operator & (unsigned char v) { return f_value & v; }
     616             : #if !defined(_MSC_VER) || (defined(_WCHAR_T_DEFINED) && defined(_NATIVE_WCHAR_T_DEFINED))
     617             :         T operator & (wchar_t v) { return f_value & v; }
     618             : #endif
     619             :         T operator & (int16_t v) { return f_value & v; }
     620             :         T operator & (uint16_t v) { return f_value & v; }
     621             :         T operator & (int32_t v) { return f_value & v; }
     622             :         T operator & (uint32_t v) { return f_value & v; }
     623             : #if UINT_MAX == ULONG_MAX
     624             :         T operator & (long v) { return f_value & v; }
     625             : #endif
     626             : #if UINT_MAX == ULONG_MAX
     627             :         T operator & (unsigned long v) { return f_value & v; }
     628             : #endif
     629             :         T operator & (int64_t v) { return f_value & v; }
     630             :         T operator & (uint64_t v) { return f_value & v; }
     631             : #if 0 //def __APPLE__
     632             :         T operator & (size_t v) { return f_value & v; }
     633             : #endif
     634             : #if 0 //def __APPLE__
     635             :         T operator & (time_t v) { return f_value & v; }
     636             : #endif
     637             :         T operator | (const need_init& n) { return f_value | n.f_value; }
     638             :         T operator | (bool v) { return f_value | v; }
     639             :         T operator | (char v) { return f_value | v; }
     640             :         T operator | (signed char v) { return f_value | v; }
     641             :         T operator | (unsigned char v) { return f_value | v; }
     642             : #if !defined(_MSC_VER) || (defined(_WCHAR_T_DEFINED) && defined(_NATIVE_WCHAR_T_DEFINED))
     643             :         T operator | (wchar_t v) { return f_value | v; }
     644             : #endif
     645             :         T operator | (int16_t v) { return f_value | v; }
     646             :         T operator | (uint16_t v) { return f_value | v; }
     647             :         T operator | (int32_t v) { return f_value | v; }
     648             :         T operator | (uint32_t v) { return f_value | v; }
     649             : #if UINT_MAX == ULONG_MAX
     650             :         T operator | (long v) { return f_value | v; }
     651             : #endif
     652             : #if UINT_MAX == ULONG_MAX
     653             :         T operator | (unsigned long v) { return f_value | v; }
     654             : #endif
     655             :         T operator | (int64_t v) { return f_value | v; }
     656             :         T operator | (uint64_t v) { return f_value | v; }
     657             : #if 0 //def __APPLE__
     658             :         T operator | (size_t v) { return f_value | v; }
     659             : #endif
     660             : #if 0 //def __APPLE__
     661             :         T operator | (time_t v) { return f_value | v; }
     662             : #endif
     663             :         T operator ^ (const need_init& n) { return f_value ^ n.f_value; }
     664             :         T operator ^ (bool v) { return f_value ^ v; }
     665             :         T operator ^ (char v) { return f_value ^ v; }
     666             :         T operator ^ (signed char v) { return f_value ^ v; }
     667             :         T operator ^ (unsigned char v) { return f_value ^ v; }
     668             : #if !defined(_MSC_VER) || (defined(_WCHAR_T_DEFINED) && defined(_NATIVE_WCHAR_T_DEFINED))
     669             :         T operator ^ (wchar_t v) { return f_value ^ v; }
     670             : #endif
     671             :         T operator ^ (int16_t v) { return f_value ^ v; }
     672             :         T operator ^ (uint16_t v) { return f_value ^ v; }
     673             :         T operator ^ (int32_t v) { return f_value ^ v; }
     674             :         T operator ^ (uint32_t v) { return f_value ^ v; }
     675             : #if UINT_MAX == ULONG_MAX
     676             :         T operator ^ (long v) { return f_value ^ v; }
     677             : #endif
     678             : #if UINT_MAX == ULONG_MAX
     679             :         T operator ^ (unsigned long v) { return f_value ^ v; }
     680             : #endif
     681             :         T operator ^ (int64_t v) { return f_value ^ v; }
     682             :         T operator ^ (uint64_t v) { return f_value ^ v; }
     683             : #if 0 //def __APPLE__
     684             :         T operator ^ (size_t v) { return f_value ^ v; }
     685             : #endif
     686             : #if 0 //def __APPLE__
     687             :         T operator ^ (time_t v) { return f_value ^ v; }
     688             : #endif
     689             :         bool operator == (const need_init& n) { return f_value == n.f_value; }
     690             :         bool operator == (bool v) { return f_value == v; }
     691             :         bool operator == (char v) { return f_value == v; }
     692             :         bool operator == (signed char v) { return f_value == v; }
     693             :         bool operator == (unsigned char v) { return f_value == v; }
     694             : #if !defined(_MSC_VER) || (defined(_WCHAR_T_DEFINED) && defined(_NATIVE_WCHAR_T_DEFINED))
     695             :         bool operator == (wchar_t v) { return f_value == v; }
     696             : #endif
     697             :         bool operator == (int16_t v) { return f_value == v; }
     698             :         bool operator == (uint16_t v) { return f_value == v; }
     699             :         bool operator == (int32_t v) { return f_value == v; }
     700             :         bool operator == (uint32_t v) { return f_value == v; }
     701             : #if UINT_MAX == ULONG_MAX
     702             :         bool operator == (long v) { return f_value == v; }
     703             : #endif
     704             : #if UINT_MAX == ULONG_MAX
     705             :         bool operator == (unsigned long v) { return f_value == v; }
     706             : #endif
     707             :         bool operator == (int64_t v) { return f_value == v; }
     708             :         bool operator == (uint64_t v) { return f_value == v; }
     709             :         bool operator == (float v) { return f_value == v; }
     710             :         bool operator == (double v) { return f_value == v; }
     711             : #ifndef __APPLE__
     712             :         bool operator == (long double v) { return f_value == v; }
     713             : #endif
     714             : #if 0 //def __APPLE__
     715             :         bool operator == (size_t v) { return f_value == v; }
     716             : #endif
     717             : #if 0 //def __APPLE__
     718             :         bool operator == (time_t v) { return f_value == v; }
     719             : #endif
     720             :         bool operator != (const need_init& n) { return f_value != n.f_value; }
     721             :         bool operator != (bool v) { return f_value != v; }
     722             :         bool operator != (char v) { return f_value != v; }
     723             :         bool operator != (signed char v) { return f_value != v; }
     724             :         bool operator != (unsigned char v) { return f_value != v; }
     725             : #if !defined(_MSC_VER) || (defined(_WCHAR_T_DEFINED) && defined(_NATIVE_WCHAR_T_DEFINED))
     726             :         bool operator != (wchar_t v) { return f_value != v; }
     727             : #endif
     728             :         bool operator != (int16_t v) { return f_value != v; }
     729             :         bool operator != (uint16_t v) { return f_value != v; }
     730             :         bool operator != (int32_t v) { return f_value != v; }
     731             :         bool operator != (uint32_t v) { return f_value != v; }
     732             : #if UINT_MAX == ULONG_MAX
     733             :         bool operator != (long v) { return f_value != v; }
     734             : #endif
     735             : #if UINT_MAX == ULONG_MAX
     736             :         bool operator != (unsigned long v) { return f_value != v; }
     737             : #endif
     738             :         bool operator != (int64_t v) { return f_value != v; }
     739             :         bool operator != (uint64_t v) { return f_value != v; }
     740             :         bool operator != (float v) { return f_value != v; }
     741             :         bool operator != (double v) { return f_value != v; }
     742             : #ifndef __APPLE__
     743             :         bool operator != (long double v) { return f_value != v; }
     744             : #endif
     745             : #if 0 //def __APPLE__
     746             :         bool operator != (size_t v) { return f_value != v; }
     747             : #endif
     748             : #if 0 //def __APPLE__
     749             :         bool operator != (time_t v) { return f_value != v; }
     750             : #endif
     751             :         bool operator < (const need_init& n) { return f_value < n.f_value; }
     752             :         bool operator < (bool v) { return f_value < v; }
     753             :         bool operator < (char v) { return f_value < v; }
     754             :         bool operator < (signed char v) { return f_value < v; }
     755             :         bool operator < (unsigned char v) { return f_value < v; }
     756             : #if !defined(_MSC_VER) || (defined(_WCHAR_T_DEFINED) && defined(_NATIVE_WCHAR_T_DEFINED))
     757             :         bool operator < (wchar_t v) { return f_value < v; }
     758             : #endif
     759             :         bool operator < (int16_t v) { return f_value < v; }
     760             :         bool operator < (uint16_t v) { return f_value < v; }
     761             :         bool operator < (int32_t v) { return f_value < v; }
     762             :         bool operator < (uint32_t v) { return f_value < v; }
     763             : #if UINT_MAX == ULONG_MAX
     764             :         bool operator < (long v) { return f_value < v; }
     765             : #endif
     766             : #if UINT_MAX == ULONG_MAX
     767             :         bool operator < (unsigned long v) { return f_value < v; }
     768             : #endif
     769             :         bool operator < (int64_t v) { return f_value < v; }
     770             :         bool operator < (uint64_t v) { return f_value < v; }
     771             :         bool operator < (float v) { return f_value < v; }
     772             :         bool operator < (double v) { return f_value < v; }
     773             : #ifndef __APPLE__
     774             :         bool operator < (long double v) { return f_value < v; }
     775             : #endif
     776             : #if 0 //def __APPLE__
     777             :         bool operator < (size_t v) { return f_value < v; }
     778             : #endif
     779             : #if 0 //def __APPLE__
     780             :         bool operator < (time_t v) { return f_value < v; }
     781             : #endif
     782             :         bool operator <= (const need_init& n) { return f_value <= n.f_value; }
     783             :         bool operator <= (bool v) { return f_value <= v; }
     784             :         bool operator <= (char v) { return f_value <= v; }
     785             :         bool operator <= (signed char v) { return f_value <= v; }
     786             :         bool operator <= (unsigned char v) { return f_value <= v; }
     787             : #if !defined(_MSC_VER) || (defined(_WCHAR_T_DEFINED) && defined(_NATIVE_WCHAR_T_DEFINED))
     788             :         bool operator <= (wchar_t v) { return f_value <= v; }
     789             : #endif
     790             :         bool operator <= (int16_t v) { return f_value <= v; }
     791             :         bool operator <= (uint16_t v) { return f_value <= v; }
     792             :         bool operator <= (int32_t v) { return f_value <= v; }
     793             :         bool operator <= (uint32_t v) { return f_value <= v; }
     794             : #if UINT_MAX == ULONG_MAX
     795             :         bool operator <= (long v) { return f_value <= v; }
     796             : #endif
     797             : #if UINT_MAX == ULONG_MAX
     798             :         bool operator <= (unsigned long v) { return f_value <= v; }
     799             : #endif
     800             :         bool operator <= (int64_t v) { return f_value <= v; }
     801             :         bool operator <= (uint64_t v) { return f_value <= v; }
     802             :         bool operator <= (float v) { return f_value <= v; }
     803             :         bool operator <= (double v) { return f_value <= v; }
     804             : #ifndef __APPLE__
     805             :         bool operator <= (long double v) { return f_value <= v; }
     806             : #endif
     807             : #if 0 //def __APPLE__
     808             :         bool operator <= (size_t v) { return f_value <= v; }
     809             : #endif
     810             : #if 0 //def __APPLE__
     811             :         bool operator <= (time_t v) { return f_value <= v; }
     812             : #endif
     813             :         bool operator > (const need_init& n) { return f_value > n.f_value; }
     814             :         bool operator > (bool v) { return f_value > v; }
     815             :         bool operator > (char v) { return f_value > v; }
     816             :         bool operator > (signed char v) { return f_value > v; }
     817             :         bool operator > (unsigned char v) { return f_value > v; }
     818             : #if !defined(_MSC_VER) || (defined(_WCHAR_T_DEFINED) && defined(_NATIVE_WCHAR_T_DEFINED))
     819             :         bool operator > (wchar_t v) { return f_value > v; }
     820             : #endif
     821             :         bool operator > (int16_t v) { return f_value > v; }
     822             :         bool operator > (uint16_t v) { return f_value > v; }
     823             :         bool operator > (int32_t v) { return f_value > v; }
     824             :         bool operator > (uint32_t v) { return f_value > v; }
     825             : #if UINT_MAX == ULONG_MAX
     826             :         bool operator > (long v) { return f_value > v; }
     827             : #endif
     828             : #if UINT_MAX == ULONG_MAX
     829             :         bool operator > (unsigned long v) { return f_value > v; }
     830             : #endif
     831             :         bool operator > (int64_t v) { return f_value > v; }
     832             :         bool operator > (uint64_t v) { return f_value > v; }
     833             :         bool operator > (float v) { return f_value > v; }
     834             :         bool operator > (double v) { return f_value > v; }
     835             : #ifndef __APPLE__
     836             :         bool operator > (long double v) { return f_value > v; }
     837             : #endif
     838             : #if 0 //def __APPLE__
     839             :         bool operator > (size_t v) { return f_value > v; }
     840             : #endif
     841             : #if 0 //def __APPLE__
     842             :         bool operator > (time_t v) { return f_value > v; }
     843             : #endif
     844             :         bool operator >= (const need_init& n) { return f_value >= n.f_value; }
     845             :         bool operator >= (bool v) { return f_value >= v; }
     846             :         bool operator >= (char v) { return f_value >= v; }
     847             :         bool operator >= (signed char v) { return f_value >= v; }
     848             :         bool operator >= (unsigned char v) { return f_value >= v; }
     849             : #if !defined(_MSC_VER) || (defined(_WCHAR_T_DEFINED) && defined(_NATIVE_WCHAR_T_DEFINED))
     850             :         bool operator >= (wchar_t v) { return f_value >= v; }
     851             : #endif
     852             :         bool operator >= (int16_t v) { return f_value >= v; }
     853             :         bool operator >= (uint16_t v) { return f_value >= v; }
     854             :         bool operator >= (int32_t v) { return f_value >= v; }
     855             :         bool operator >= (uint32_t v) { return f_value >= v; }
     856             : #if UINT_MAX == ULONG_MAX
     857             :         bool operator >= (long v) { return f_value >= v; }
     858             : #endif
     859             : #if UINT_MAX == ULONG_MAX
     860             :         bool operator >= (unsigned long v) { return f_value >= v; }
     861             : #endif
     862             :         bool operator >= (int64_t v) { return f_value >= v; }
     863             :         bool operator >= (uint64_t v) { return f_value >= v; }
     864             :         bool operator >= (float v) { return f_value >= v; }
     865             :         bool operator >= (double v) { return f_value >= v; }
     866             : #ifndef __APPLE__
     867             :         bool operator >= (long double v) { return f_value >= v; }
     868             : #endif
     869             : #if 0 //def __APPLE__
     870             :         bool operator >= (size_t v) { return f_value >= v; }
     871             : #endif
     872             : #if 0 //def __APPLE__
     873             :         bool operator >= (time_t v) { return f_value >= v; }
     874             : #endif
     875             : #ifdef CONTROLLED_VARS_DEBUG
     876             :         bool is_initialized() const { return true; }
     877             : #endif
     878             : private:
     879             :         T f_value;
     880             : };
     881             : typedef need_init<bool> mbool_t;
     882             : typedef need_init<char> mchar_t;
     883             : typedef need_init<signed char> mschar_t;
     884             : typedef need_init<unsigned char> muchar_t;
     885             : #if !defined(_MSC_VER) || (defined(_WCHAR_T_DEFINED) && defined(_NATIVE_WCHAR_T_DEFINED))
     886             : typedef need_init<wchar_t> mwchar_t;
     887             : #endif
     888             : typedef need_init<int16_t> mint16_t;
     889             : typedef need_init<uint16_t> muint16_t;
     890             : typedef need_init<int32_t> mint32_t;
     891             : typedef need_init<uint32_t> muint32_t;
     892             : #if UINT_MAX == ULONG_MAX
     893             : typedef need_init<long> mplain_long_t;
     894             : #endif
     895             : #if UINT_MAX == ULONG_MAX
     896             : typedef need_init<unsigned long> mplain_ulong_t;
     897             : #endif
     898             : typedef need_init<int64_t> mint64_t;
     899             : typedef need_init<uint64_t> muint64_t;
     900             : typedef need_init<float> mfloat_t;
     901             : typedef need_init<double> mdouble_t;
     902             : #ifndef __APPLE__
     903             : typedef need_init<long double> mlongdouble_t;
     904             : #endif
     905             : #if 0 //def __APPLE__
     906             : typedef need_init<size_t> msize_t;
     907             : #endif
     908             : #if 0 //def __APPLE__
     909             : typedef need_init<time_t> mtime_t;
     910             : #endif
     911             : } // namespace controlled_vars
     912             : #ifdef _MSC_VER
     913             : #pragma warning(pop)
     914             : #endif
     915             : #endif

Generated by: LCOV version 1.9

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