mfbt/DebugOnly.h

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
   3 /* This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 /*
   8  * Provides DebugOnly, a type for variables used only in debug builds (i.e. by
   9  * assertions).
  10  */
  11
  12 #ifndef mozilla_DebugOnly_h
  13 #define mozilla_DebugOnly_h
  14
  15 #include "mozilla/Attributes.h"
  16
  17 namespace mozilla {
  18
  19 /**
  20  * DebugOnly contains a value of type T, but only in debug builds.  In release
  21  * builds, it does not contain a value.  This helper is intended to be used with
  22  * MOZ_ASSERT()-style macros, allowing one to write:
  23  *
  24  *   DebugOnly<bool> check = func();
  25  *   MOZ_ASSERT(check);
  26  *
  27  * more concisely than declaring |check| conditional on #ifdef DEBUG, but also
  28  * without allocating storage space for |check| in release builds.
  29  *
  30  * DebugOnly instances can only be coerced to T in debug builds.  In release
  31  * builds they don't have a value, so type coercion is not well defined.
  32  *
  33  * Note that DebugOnly instances still take up one byte of space, plus padding,
  34  * when used as members of structs.
  35  */
  36 template<typename T>
  37 class DebugOnly
  38 {
  39 public:
  40 #ifdef DEBUG
  41   T value;
  42
  43   DebugOnly() { }
  44   MOZ_IMPLICIT DebugOnly(const T& aOther) : value(aOther) { }
  45   DebugOnly(const DebugOnly& aOther) : value(aOther.value) { }
  46   DebugOnly& operator=(const T& aRhs) {
  47     value = aRhs;
  48     return *this;
  49   }
  50
  51   void operator++(int) { value++; }
  52   void operator--(int) { value--; }
  53
  54   T* operator&() { return &value; }
  55
  56   operator T&() { return value; }
  57   operator const T&() const { return value; }
  58
  59   T& operator->() { return value; }
  60   const T& operator->() const { return value; }
  61
  62 #else
  63   DebugOnly() { }
  64   MOZ_IMPLICIT DebugOnly(const T&) { }
  65   DebugOnly(const DebugOnly&) { }
  66   DebugOnly& operator=(const T&) { return *this; }
  67   void operator++(int) { }
  68   void operator--(int) { }
  69 #endif
  70
  71   /*
  72    * DebugOnly must always have a destructor or else it will
  73    * generate "unused variable" warnings, exactly what it's intended
  74    * to avoid!
  75    */
  76   ~DebugOnly() {}
  77 };
  78
  79 }
  80
  81 #endif /* mozilla_DebugOnly_h */