text: /*
   *  Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
   *
   *  Use of this source code is governed by a BSD-style license
   *  that can be found in the LICENSE file in the root of the source
   *  tree. An additional intellectual property rights grant can be found
   *  in the file PATENTS.  All contributing project authors may
   *  be found in the AUTHORS file in the root of the source tree.
   */
  
  // Borrowed from Chromium's src/base/basictypes.h.
  
  #ifndef WEBRTC_SYSTEM_WRAPPERS_INTERFACE_COMPILE_ASSERT_H_
  #define WEBRTC_SYSTEM_WRAPPERS_INTERFACE_COMPILE_ASSERT_H_
  
  // The COMPILE_ASSERT macro can be used to verify that a compile time
  // expression is true. For example, you could use it to verify the
  // size of a static array:
  //
  //   COMPILE_ASSERT(ARRAYSIZE_UNSAFE(content_type_names) == CONTENT_NUM_TYPES,
  //                  content_type_names_incorrect_size);
  //
  // or to make sure a struct is smaller than a certain size:
  //
  //   COMPILE_ASSERT(sizeof(foo) < 128, foo_too_large);
  //
  // The second argument to the macro is the name of the variable. If
  // the expression is false, most compilers will issue a warning/error
  // containing the name of the variable.
  
  // TODO(ajm): Hack to avoid multiple definitions until the base/ of webrtc and
  // libjingle are merged.
  #if !defined(COMPILE_ASSERT)
  template <bool>
  struct CompileAssert {
  };
  
  #define COMPILE_ASSERT(expr, msg) \
    typedef CompileAssert<(bool(expr))> msg[bool(expr) ? 1 : -1]
  #endif  // COMPILE_ASSERT
  
  // Implementation details of COMPILE_ASSERT:
  //
  // - COMPILE_ASSERT works by defining an array type that has -1
  //   elements (and thus is invalid) when the expression is false.
  //
  // - The simpler definition
  //
  //     #define COMPILE_ASSERT(expr, msg) typedef char msg[(expr) ? 1 : -1]
  //
  //   does not work, as gcc supports variable-length arrays whose sizes
  //   are determined at run-time (this is gcc's extension and not part
  //   of the C++ standard).  As a result, gcc fails to reject the
  //   following code with the simple definition:
  //
  //     int foo;
  //     COMPILE_ASSERT(foo, msg); // not supposed to compile as foo is
  //                               // not a compile-time constant.
  //
  // - By using the type CompileAssert<(bool(expr))>, we ensures that
  //   expr is a compile-time constant.  (Template arguments must be
  //   determined at compile-time.)
  //
  // - The outer parentheses in CompileAssert<(bool(expr))> are necessary
  //   to work around a bug in gcc 3.4.4 and 4.0.1.  If we had written
  //
  //     CompileAssert<bool(expr)>
  //
  //   instead, these compilers will refuse to compile
  //
  //     COMPILE_ASSERT(5 > 0, some_message);
  //
  //   (They seem to think the ">" in "5 > 0" marks the end of the
  //   template argument list.)
  //
  // - The array size is (bool(expr) ? 1 : -1), instead of simply
  //
  //     ((expr) ? 1 : -1).
  //
  //   This is to avoid running into a bug in MS VC 7.1, which
  //   causes ((0.0) ? 1 : -1) to incorrectly evaluate to 1.
  
  #endif  // WEBRTC_SYSTEM_WRAPPERS_INTERFACE_COMPILE_ASSERT_H_
  