1 /* 2 * Copyright (C) 2007 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 #ifndef ANDROID_UTILS_SINGLETON_H 17 #define ANDROID_UTILS_SINGLETON_H 18 #include <stdint.h> 19 // some vendor code assumes they have atoi() after including this file. 20 #include <stdlib.h> 21 #include <sys/types.h> 22 #include <utils/Mutex.h> 23 #include <cutils/compiler.h> 24 namespace android { 25 // --------------------------------------------------------------------------- 26 // Singleton<TYPE> may be used in multiple libraries, only one of which should 27 // define the static member variables using ANDROID_SINGLETON_STATIC_INSTANCE. 28 // Turn off -Wundefined-var-template so other users don't get: 29 // instantiation of variable 'android::Singleton<TYPE>::sLock' required here, 30 // but no definition is available 31 #if defined(__clang__) 32 #pragma clang diagnostic push 33 #pragma clang diagnostic ignored "-Wundefined-var-template" 34 #endif 35 // DO NOT USE: Please use scoped static initialization. For instance: 36 // MyClass& getInstance() { 37 // static MyClass gInstance(...); 38 // return gInstance; 39 // } 40 template <typename TYPE> 41 class ANDROID_API Singleton 42 { 43 public: getInstance()44 static TYPE& getInstance() { 45 Mutex::Autolock _l(sLock); 46 TYPE* instance = sInstance; 47 if (instance == nullptr) { 48 instance = new TYPE(); 49 sInstance = instance; 50 } 51 return *instance; 52 } hasInstance()53 static bool hasInstance() { 54 Mutex::Autolock _l(sLock); 55 return sInstance != nullptr; 56 } 57 58 protected: ~Singleton()59 ~Singleton() { } Singleton()60 Singleton() { } 61 private: 62 Singleton(const Singleton&); 63 Singleton& operator = (const Singleton&); 64 static Mutex sLock; 65 static TYPE* sInstance; 66 }; 67 #if defined(__clang__) 68 #pragma clang diagnostic pop 69 #endif 70 /* 71 * use ANDROID_SINGLETON_STATIC_INSTANCE(TYPE) in your implementation file 72 * (eg: <TYPE>.cpp) to create the static instance of Singleton<>'s attributes, 73 * and avoid to have a copy of them in each compilation units Singleton<TYPE> 74 * is used. 75 * NOTE: we use a version of Mutex ctor that takes a parameter, because 76 * for some unknown reason using the default ctor doesn't emit the variable! 77 */ 78 #define ANDROID_SINGLETON_STATIC_INSTANCE(TYPE) \ 79 template<> ::android::Mutex \ 80 (::android::Singleton< TYPE >::sLock)(::android::Mutex::PRIVATE); \ 81 template<> TYPE* ::android::Singleton< TYPE >::sInstance(nullptr); /* NOLINT */ \ 82 template class ::android::Singleton< TYPE >; 83 // --------------------------------------------------------------------------- 84 } // namespace android 85 #endif // ANDROID_UTILS_SINGLETON_H 86