ACE_Service_Type_Dynamic_Guard Class Reference

A forward service declaration guard. More...

#include <Service_Gestalt.h>

Collaboration diagram for ACE_Service_Type_Dynamic_Guard:

[legend]List of all members.

Public Member Functions
	ACE_Service_Type_Dynamic_Guard (ACE_Service_Repository &r, ACE_TCHAR const *name)
	~ACE_Service_Type_Dynamic_Guard (void)
	Destructor.
Private Attributes
ACE_Service_Repository &	repo_
size_t	repo_begin_
ACE_TCHAR const *const	name_

---

Detailed Description

A forward service declaration guard.

Helps to resolve an issue with hybrid services, i.e. dynamic services, accompanied by static services in the same DLL. Only automatic instances of this class are supposed to exist. Those are created during (dynamic) service initialization and serve to:

(a) Ensure the service we are loading is ordered last in the repository, following any other services it may cause to register, as part of its own registration. This is a common case when loading dynamic services from DLLs - there are often static initializers, which register static services.

(b) The SDG instance destructor detects if the dynamic service initialized successfully and "fixes-up" all the newly registered static services to hold a reference to the DLL, from which they have originated.

Definition at line 481 of file Service_Gestalt.h.

---

Constructor & Destructor Documentation

ACE_BEGIN_VERSIONED_NAMESPACE_DECL ACE_Service_Type_Dynamic_Guard::ACE_Service_Type_Dynamic_Guard	(	ACE_Service_Repository &	r,
		ACE_TCHAR const *	name
	)

Definition at line 39 of file Service_Gestalt.cpp.

References ACE_ASSERT, ACE_DEBUG, ACE_TEXT, ACE::debug(), and LM_DEBUG.

    : repo_ (r)
    // Relocation starts where the next service will be inserted (if any)
    , repo_begin_ (r.current_size ())
    , name_ (name)
# if defined (ACE_MT_SAFE) && (ACE_MT_SAFE != 0)
  // On this thread (for the duration of the initialize() method),
  // we're about to do two things that require locking: (1) fiddle
  // with the repository and (2) load a DLL and hence lock the
  // DLL_Manager.
  //
  // Now if we don't lock the repo here, it is possible that two
  // threads may deadlock on initialization because they can acquire
  // locks (1) and (2) in different order, for instance:
  //
  // T1: loads a DLL (2) and registers a service (1);
  //
  // T2: may be relocating a service (1), which could lead to a
  // (re)opening or uping the ref count on a DLL (2);
  //
  // To prevent this, we lock the repo here, using the repo_monitor_
  // member guard.
    , repo_monitor_ (r.lock_)
#endif
{
    if (ACE::debug ())
        ACE_DEBUG ((LM_DEBUG,
                    ACE_TEXT ("ACE (%P|%t) STDG::<ctor>, repo=%@")
                    ACE_TEXT(", name=%s - begining at [%d]\n"),
                    &this->repo_,
                    this->name_,
                    this->repo_begin_));

  ACE_ASSERT (this->name_ != 0); // No name?
}

ACE_Service_Type_Dynamic_Guard::~ACE_Service_Type_Dynamic_Guard

(

void

)

Destructor.

Definition at line 78 of file Service_Gestalt.cpp.

References ACE_DEBUG, ACE_ERROR, ACE_TEXT, ACE_Service_Type::active(), ACE::debug(), ACE_Service_Type::dll(), ACE_Service_Repository::find_i(), LM_DEBUG, LM_WARNING, ACE_Service_Type_Impl::object(), ACE_Service_Repository::relocate_i(), repo_, and ACE_Service_Type::type().

{
  const ACE_Service_Type *tmp = 0;

  // Lookup without ignoring suspended services. Making sure
  // not to ignore any inactive services, since those may be forward
  // declarations
  size_t slot = 0;
  int const ret = this->repo_.find_i (this->name_, slot, &tmp, false);

  // We inserted it (as inactive), so we expect to find it, right?
  if ((ret < 0 && ret != -2) || tmp == 0)
    {
      if (ACE::debug ())
        ACE_ERROR ((LM_WARNING,
                    ACE_TEXT ("ACE (%P|%t) STDG::<dtor> - Failed (%d) to find %s -> %@\n"),
                    ret, this->name_, tmp));
      return;
    }

  if (tmp->type () != 0)
    {
      // Something has registered a proper (non-forward-decl) service with
      // the same name as our dummy.

      if (ACE::debug ())
        ACE_DEBUG ((LM_DEBUG,
                    ACE_TEXT ("ACE (%P|%t) STDG::<dtor>, repo=%@ [%d], ")
                    ACE_TEXT ("name=%s - updating dependents [%d - %d)\n"),
                    &this->repo_,
                    slot,
                    this->name_,
                    this->repo_begin_,
                    this->repo_.current_size ()));

      // Relocate any services inserted since we were created.
      // Any (static, i.e. DLL = 0) services registered in
      // the context of this guard aren't really static because
      // their code belongs in the DLL's code segment
      this->repo_.relocate_i (this->repo_begin_, this->repo_.current_size (), tmp->dll());

      if (ACE::debug ())
        ACE_DEBUG ((LM_DEBUG,
                    ACE_TEXT ("ACE (%P|%t) STDG::<dtor>, repo=%@ [%d], ")
                    ACE_TEXT ("name=%s - loaded (type=%@, impl=%@, object=%@, active=%d)\n"),
                    &this->repo_,
                    slot,
                    this->name_,
                    tmp,
                    tmp->type (),
                    tmp->type ()->object (),
                    tmp->active ()));
    }
}

---

Member Data Documentation

ACE_TCHAR const* const ACE_Service_Type_Dynamic_Guard::name_ [private]

Definition at line 492 of file Service_Gestalt.h.

ACE_Service_Repository& ACE_Service_Type_Dynamic_Guard::repo_ [private]

Definition at line 490 of file Service_Gestalt.h.

Referenced by ~ACE_Service_Type_Dynamic_Guard().

size_t ACE_Service_Type_Dynamic_Guard::repo_begin_ [private]

Definition at line 491 of file Service_Gestalt.h.

---

The documentation for this class was generated from the following files:

• Service_Gestalt.h
• Service_Gestalt.cpp

---