Line data    Source code

       1             : // Protocol Buffers - Google's data interchange format
       2             : // Copyright 2008 Google Inc.  All rights reserved.
       3             : // https://developers.google.com/protocol-buffers/
       4             : //
       5             : // Redistribution and use in source and binary forms, with or without
       6             : // modification, are permitted provided that the following conditions are
       7             : // met:
       8             : //
       9             : //     * Redistributions of source code must retain the above copyright
      10             : // notice, this list of conditions and the following disclaimer.
      11             : //     * Redistributions in binary form must reproduce the above
      12             : // copyright notice, this list of conditions and the following disclaimer
      13             : // in the documentation and/or other materials provided with the
      14             : // distribution.
      15             : //     * Neither the name of Google Inc. nor the names of its
      16             : // contributors may be used to endorse or promote products derived from
      17             : // this software without specific prior written permission.
      18             : //
      19             : // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
      20             : // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
      21             : // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
      22             : // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
      23             : // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
      24             : // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
      25             : // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
      26             : // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
      27             : // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
      28             : // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
      29             : // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
      30             : 
      31             : // Author: kenton@google.com (Kenton Varda)
      32             : //
      33             : // emulates google3/base/once.h
      34             : //
      35             : // This header is intended to be included only by internal .cc files and
      36             : // generated .pb.cc files.  Users should not use this directly.
      37             : //
      38             : // This is basically a portable version of pthread_once().
      39             : //
      40             : // This header declares:
      41             : // * A type called ProtobufOnceType.
      42             : // * A macro GOOGLE_PROTOBUF_DECLARE_ONCE() which declares a variable of type
      43             : //   ProtobufOnceType.  This is the only legal way to declare such a variable.
      44             : //   The macro may only be used at the global scope (you cannot create local or
      45             : //   class member variables of this type).
      46             : // * A function GoogleOnceInit(ProtobufOnceType* once, void (*init_func)()).
      47             : //   This function, when invoked multiple times given the same ProtobufOnceType
      48             : //   object, will invoke init_func on the first call only, and will make sure
      49             : //   none of the calls return before that first call to init_func has finished.
      50             : // * The user can provide a parameter which GoogleOnceInit() forwards to the
      51             : //   user-provided function when it is called. Usage example:
      52             : //     int a = 10;
      53             : //     GoogleOnceInit(&my_once, &MyFunctionExpectingIntArgument, &a);
      54             : // * This implementation guarantees that ProtobufOnceType is a POD (i.e. no
      55             : //   static initializer generated).
      56             : //
      57             : // This implements a way to perform lazy initialization.  It's more efficient
      58             : // than using mutexes as no lock is needed if initialization has already
      59             : // happened.
      60             : //
      61             : // Example usage:
      62             : //   void Init();
      63             : //   GOOGLE_PROTOBUF_DECLARE_ONCE(once_init);
      64             : //
      65             : //   // Calls Init() exactly once.
      66             : //   void InitOnce() {
      67             : //     GoogleOnceInit(&once_init, &Init);
      68             : //   }
      69             : //
      70             : // Note that if GoogleOnceInit() is called before main() has begun, it must
      71             : // only be called by the thread that will eventually call main() -- that is,
      72             : // the thread that performs dynamic initialization.  In general this is a safe
      73             : // assumption since people don't usually construct threads before main() starts,
      74             : // but it is technically not guaranteed.  Unfortunately, Win32 provides no way
      75             : // whatsoever to statically-initialize its synchronization primitives, so our
      76             : // only choice is to assume that dynamic initialization is single-threaded.
      77             : 
      78             : #ifndef GOOGLE_PROTOBUF_STUBS_ONCE_H__
      79             : #define GOOGLE_PROTOBUF_STUBS_ONCE_H__
      80             : 
      81             : #include <mutex>
      82             : #include <utility>
      83             : 
      84             : namespace google {
      85             : namespace protobuf {
      86             : namespace internal {
      87             : 
      88             : using once_flag = std::once_flag;
      89             : template <typename... Args>
      90          70 : void call_once(Args&&... args ) {
      91          70 :   std::call_once(std::forward<Args>(args)...);
      92          70 : }
      93             : 
      94             : }  // namespace internal
      95             : 
      96             : // TODO(gerbens) remove this once third_party is fully extracted
      97             : using ProtobufOnceType = internal::once_flag;
      98             : 
      99             : inline void GoogleOnceInit(ProtobufOnceType* once, void (*init_func)()) {
     100             :   std::call_once(*once, init_func);
     101             : }
     102             : 
     103             : template <typename Arg>
     104             : inline void GoogleOnceInitArg(ProtobufOnceType* once, void (*init_func)(Arg*),
     105             :                               Arg* arg) {
     106             :   std::call_once(*once, init_func, arg);
     107             : }
     108             : 
     109             : class GoogleOnceDynamic {
     110             :  public:
     111             :   // If this->Init() has not been called before by any thread,
     112             :   // execute (*func_with_arg)(arg) then return.
     113             :   // Otherwise, wait until that prior invocation has finished
     114             :   // executing its function, then return.
     115             :   template<typename T>
     116             :   void Init(void (*func_with_arg)(T*), T* arg) {
     117             :     GoogleOnceInitArg<T>(&this->state_, func_with_arg, arg);
     118             :   }
     119             :  private:
     120             :   ProtobufOnceType state_;
     121             : };
     122             : 
     123             : #define GOOGLE_PROTOBUF_ONCE_TYPE ::google::protobuf::ProtobufOnceType
     124             : #define GOOGLE_PROTOBUF_DECLARE_ONCE(NAME) \
     125             :   ::google::protobuf::ProtobufOnceType NAME
     126             : 
     127             : }  // namespace protobuf
     128             : }  // namespace google
     129             : 
     130             : #endif  // GOOGLE_PROTOBUF_STUBS_ONCE_H__