/usr/include/tao/TAO_Singleton.cpp is in libtao-dev 6.0.1-3.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 | // -*- C++ -*-
//
// $Id: TAO_Singleton.cpp 84164 2009-01-15 08:03:08Z johnnyw $
#ifndef TAO_SINGLETON_CPP
#define TAO_SINGLETON_CPP
#include "tao/TAO_Singleton.h"
#if !defined (ACE_LACKS_PRAGMA_ONCE)
# pragma once
#endif /* ACE_LACKS_PRAGMA_ONCE */
#include "tao/TAO_Singleton_Manager.h"
#include "ace/Guard_T.h"
#include "ace/Object_Manager.h"
#include "ace/Log_Msg.h"
#include "ace/os_include/os_typeinfo.h"
#if !defined (__ACE_INLINE__)
#include "tao/TAO_Singleton.inl"
#endif /* __ACE_INLINE__ */
TAO_BEGIN_VERSIONED_NAMESPACE_DECL
template <class TYPE, class ACE_LOCK> void
TAO_Singleton<TYPE, ACE_LOCK>::dump (void)
{
#if defined (ACE_HAS_DUMP)
ACE_TRACE ("TAO_Singleton<TYPE, ACE_LOCK>::dump");
#if !defined (ACE_LACKS_STATIC_DATA_MEMBER_TEMPLATES)
ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("instance_ = %x"),
TAO_Singleton<TYPE, ACE_LOCK>::instance_i ()));
ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP));
#endif /* ACE_LACKS_STATIC_DATA_MEMBER_TEMPLATES */
#endif /* ACE_HAS_DUMP */
}
template <class TYPE, class ACE_LOCK> TAO_Singleton<TYPE, ACE_LOCK> *&
TAO_Singleton<TYPE, ACE_LOCK>::instance_i (void)
{
#if defined (ACE_LACKS_STATIC_DATA_MEMBER_TEMPLATES)
// Pointer to the Singleton instance. This works around a bug with
// G++ and it's (mis-)handling of templates and statics...
static TAO_Singleton<TYPE, ACE_LOCK> *singleton_ = 0;
return singleton_;
#else
return TAO_Singleton<TYPE, ACE_LOCK>::singleton_;
#endif /* ACE_LACKS_STATIC_DATA_MEMBER_TEMPLATES */
}
template <class TYPE, class ACE_LOCK> TYPE *
TAO_Singleton<TYPE, ACE_LOCK>::instance (void)
{
ACE_TRACE ("TAO_Singleton<TYPE, ACE_LOCK>::instance");
TAO_Singleton<TYPE, ACE_LOCK> *&singleton =
TAO_Singleton<TYPE, ACE_LOCK>::instance_i ();
// Perform the Double-Check pattern...
if (singleton == 0)
{
if (TAO_Singleton_Manager::starting_up () ||
TAO_Singleton_Manager::shutting_down ())
{
// The program is still starting up, and therefore assumed
// to be single threaded. There's no need to double-check.
// Or, the TAO_Singleton_Manager instance has been destroyed,
// so the preallocated lock is not available. Either way,
// don't register for destruction with the
// TAO_Singleton_Manager: we'll have to leak this instance.
ACE_NEW_RETURN (singleton, (TAO_Singleton<TYPE, ACE_LOCK>), 0);
}
else
{
#if defined (ACE_MT_SAFE) && (ACE_MT_SAFE != 0)
// Obtain a lock from the ACE_Object_Manager. The pointer
// is static, so we only obtain one per TAO_Singleton
// instantiation.
static ACE_LOCK *lock = 0;
if (ACE_Object_Manager::get_singleton_lock (lock) != 0)
// Failed to acquire the lock!
return 0;
ACE_GUARD_RETURN (ACE_LOCK, ace_mon, *lock, 0);
if (singleton == 0)
{
#endif /* ACE_MT_SAFE */
ACE_NEW_RETURN (singleton, (TAO_Singleton<TYPE, ACE_LOCK>), 0);
// Register for destruction with TAO_Singleton_Manager.
TAO_Singleton_Manager::at_exit (singleton, 0, typeid (TYPE).name());
#if defined (ACE_MT_SAFE) && (ACE_MT_SAFE != 0)
}
#endif /* ACE_MT_SAFE */
}
}
return &singleton->instance_;
}
template <class TYPE, class ACE_LOCK> void
TAO_Singleton<TYPE, ACE_LOCK>::cleanup (void *)
{
delete this;
TAO_Singleton<TYPE, ACE_LOCK>::instance_i () = 0;
}
#if !defined (ACE_LACKS_STATIC_DATA_MEMBER_TEMPLATES)
// Pointer to the Singleton instance.
template <class TYPE, class ACE_LOCK> TAO_Singleton<TYPE, ACE_LOCK> *
TAO_Singleton<TYPE, ACE_LOCK>::singleton_ = 0;
template <class TYPE, class ACE_LOCK> TAO_TSS_Singleton<TYPE, ACE_LOCK> *
TAO_TSS_Singleton<TYPE, ACE_LOCK>::singleton_ = 0;
#endif /* !defined (ACE_LACKS_STATIC_DATA_MEMBER_TEMPLATES) */
template <class TYPE, class ACE_LOCK> void
TAO_TSS_Singleton<TYPE, ACE_LOCK>::dump (void)
{
#if defined (ACE_HAS_DUMP)
ACE_TRACE ("TAO_TSS_Singleton<TYPE, ACE_LOCK>::dump");
#if !defined (ACE_LACKS_STATIC_DATA_MEMBER_TEMPLATES)
ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("instance_ = %x"),
TAO_TSS_Singleton<TYPE, ACE_LOCK>::instance_i ()));
ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP));
#endif /* ACE_LACKS_STATIC_DATA_MEMBER_TEMPLATES */
#endif /* ACE_HAS_DUMP */
}
template <class TYPE, class ACE_LOCK> TAO_TSS_Singleton<TYPE, ACE_LOCK> *&
TAO_TSS_Singleton<TYPE, ACE_LOCK>::instance_i (void)
{
#if defined (ACE_LACKS_STATIC_DATA_MEMBER_TEMPLATES)
// Pointer to the Singleton instance. This works around a bug with
// G++ and it's (mis-)handling of templates and statics...
static TAO_TSS_Singleton<TYPE, ACE_LOCK> *singleton_ = 0;
return singleton_;
#else
return TAO_TSS_Singleton<TYPE, ACE_LOCK>::singleton_;
#endif /* ACE_LACKS_STATIC_DATA_MEMBER_TEMPLATES */
}
template <class TYPE, class ACE_LOCK> TYPE *
TAO_TSS_Singleton<TYPE, ACE_LOCK>::instance (void)
{
ACE_TRACE ("TAO_TSS_Singleton<TYPE, ACE_LOCK>::instance");
TAO_TSS_Singleton<TYPE, ACE_LOCK> *&singleton =
TAO_TSS_Singleton<TYPE, ACE_LOCK>::instance_i ();
// Perform the Double-Check pattern...
if (singleton == 0)
{
if (TAO_Singleton_Manager::starting_up () ||
TAO_Singleton_Manager::shutting_down ())
{
// The program is still starting up, and therefore assumed
// to be single threaded. There's no need to double-check.
// Or, the TAO_Singleton_Manager instance has been destroyed,
// so the preallocated lock is not available. Either way,
// don't register for destruction with the
// TAO_Singleton_Manager: we'll have to leak this instance.
ACE_NEW_RETURN (singleton, (TAO_TSS_Singleton<TYPE, ACE_LOCK>), 0);
}
else
{
#if defined (ACE_MT_SAFE) && (ACE_MT_SAFE != 0)
// Obtain a lock from the ACE_Object_Manager. The pointer
// is static, so we only obtain one per TAO_Singleton
// instantiation.
static ACE_LOCK *lock = 0;
if (ACE_Object_Manager::get_singleton_lock (lock) != 0)
// Failed to acquire the lock!
return 0;
ACE_GUARD_RETURN (ACE_LOCK, ace_mon, *lock, 0);
if (singleton == 0)
{
#endif /* ACE_MT_SAFE */
ACE_NEW_RETURN (singleton, (TAO_TSS_Singleton<TYPE, ACE_LOCK>),
0);
// Register for destruction with TAO_Singleton_Manager.
TAO_Singleton_Manager::at_exit (singleton, 0, typeid (TYPE).name ());
#if defined (ACE_MT_SAFE) && (ACE_MT_SAFE != 0)
}
#endif /* ACE_MT_SAFE */
}
}
return ACE_TSS_GET (&singleton->instance_, TYPE);
}
template <class TYPE, class ACE_LOCK> void
TAO_TSS_Singleton<TYPE, ACE_LOCK>::cleanup (void *)
{
delete this;
TAO_TSS_Singleton<TYPE, ACE_LOCK>::instance_i () = 0;
}
TAO_END_VERSIONED_NAMESPACE_DECL
#endif /* TAO_SINGLETON_CPP */
|