Singleton.h

Go to the documentation of this file.
00001 /*
00002  * IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING. By
00003  * downloading, copying, installing or using the software you agree to
00004  * this license. If you do not agree to this license, do not download,
00005  * install, copy or use the software.
00006  * 
00007  * Intel Open Source License 
00008  * 
00009  * Copyright (c) 2004 Intel Corporation. All rights reserved. 
00010  * 
00011  * Redistribution and use in source and binary forms, with or without
00012  * modification, are permitted provided that the following conditions are
00013  * met:
00014  *
00015  *  Redistributions of source code must retain the above copyright
00016  *  notice, this list of conditions and the following disclaimer.
00017  *
00018  *  Redistributions in binary form must reproduce the above copyright
00019  *  notice, this list of conditions and the following disclaimer in the
00020  *  documentation and/or other materials provided with the distribution.
00021  *
00022  *  Neither the name of the Intel Corporation nor the names of its
00023  *  contributors may be used to endorse or promote products derived from
00024  *  this software without specific prior written permission.
00025  *
00026  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
00027  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
00028  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
00029  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE INTEL OR
00030  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
00031  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
00032  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
00033  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
00034  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
00035  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
00036  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
00037  */
00038 #ifndef __SINGLETON_H__
00039 #define __SINGLETON_H__
00040 
00041 #include "../debug/DebugUtils.h"
00042 
00043 namespace oasys {
00044 
00060 template<typename _Class, bool _auto_create = true>
00061 class Singleton;
00062 
00063 // Autocreation of the singleton
00064 template<typename _Class>
00065 class Singleton<_Class, true> {
00066 public:
00067     static _Class* instance() {
00068         // XXX/demmer this has potential race conditions if multiple
00069         // threads try to access the singleton for the first time
00070         
00071         if(instance_ == 0) {
00072             instance_ = new _Class();
00073         }
00074         ASSERT(instance_);
00075 
00076         return instance_;
00077     }
00078     
00079     static _Class* create() {
00080         if (instance_) {
00081             PANIC("Singleton create() method called more than once");
00082         }
00083         
00084         instance_ = new _Class();
00085         return instance_;
00086     }
00087 
00088     static void set_instance(_Class* instance) {
00089         if (instance_) {
00090             PANIC("Singleton set_instance() called with existing object");
00091         }
00092         instance_ = instance;
00093     }
00094     
00095 protected:
00096     static _Class* instance_;
00097 };
00098 
00099 // No autocreation of the instance
00100 template<typename _Class>
00101 class Singleton<_Class, false> {
00102 public:
00103     static _Class* instance() 
00104     {
00105         // XXX/demmer this has potential race conditions if multiple
00106         // threads try to access the singleton for the first time
00107         ASSERT(instance_);
00108         return instance_;
00109     }
00110     
00111     static _Class* create() 
00112     {
00113         if (instance_) 
00114         {
00115             PANIC("Singleton create() method called more than once");
00116         }
00117         
00118         instance_ = new _Class();
00119         return instance_;
00120     }
00121 
00122     static void set_instance(_Class* instance) 
00123     {
00124         if (instance_) 
00125         {
00126             PANIC("Singleton set_instance() called with existing object");
00127         }
00128         instance_ = instance;
00129     }
00130     
00131 protected:
00132     static _Class* instance_;
00133 };
00134 
00145 template<typename _Class>
00146 class SingletonRef {
00147 public:
00148     _Class* operator->() {
00149         return Singleton<_Class>::instance();
00150     }
00151 };
00152 
00153 } // namespace oasys
00154 
00155 #endif // __SINGLETON_H__

Generated on Fri Dec 22 14:48:00 2006 for DTN Reference Implementation by  doxygen 1.5.1