Main Page | Namespace List | Class Hierarchy | Alphabetical List | Class List | File List | Namespace Members | Class Members | File Members | Search for 

TAO_Trader< TRADER_LOCK_TYPE, MAP_LOCK_TYPE > Class Template Reference

This class packages together all the various pieces that provide functionality specified in COS Trading specification. More...

#include <Trader_T.h>

Inheritance diagram for TAO_Trader< TRADER_LOCK_TYPE, MAP_LOCK_TYPE >:

Inheritance graph
[legend]
Collaboration diagram for TAO_Trader< TRADER_LOCK_TYPE, MAP_LOCK_TYPE >:

Collaboration graph
[legend]
List of all members.

Public Types

typedef TAO_Offer_Database<
MAP_LOCK_TYPE > 		Offer_Database
 Offer Database Trait.


Public Member Functions

 TAO_Trader (Trader_Components components=LOOKUP)
virtual ~TAO_Trader (void)
 Destructor.

Offer_Database & offer_database (void)
 Accessor for the structure with all the service offers.

ACE_Lock & lock (void)
 Returns the trader.


Protected Types

typedef TAO_Trader< TRADER_LOCK_TYPE,
MAP_LOCK_TYPE > 		TRADER_SELF
enum  {
  LOOKUP_IF, REGISTER_IF, ADMIN_IF, PROXY_IF,
  LINK_IF
}

Protected Attributes

Offer_Database offer_database_
ACE_Lock_Adapter< TRADER_LOCK_TYPE > lock_
 Lock that guards the state of the trader (its configuration).

PortableServer::ServantBase * ifs_ [5]

Private Member Functions

void operator= (const TAO_Trader< TRADER_LOCK_TYPE, MAP_LOCK_TYPE > &)

Detailed Description

template<class TRADER_LOCK_TYPE, class MAP_LOCK_TYPE>
class TAO_Trader< TRADER_LOCK_TYPE, MAP_LOCK_TYPE >

This class packages together all the various pieces that provide functionality specified in COS Trading specification.

TAO_Trader contains all the components that together represent a single trader. Based on its constructor arguments, TAO_Trader creates instances of appropriate interface implementations as well as instances of objects common to more than one interface (offers, attributes, etc.). TAO_Trader also enforces the proper order on all initializations. TAO_Trader acts like a "glue" class that creates appropriate components, holds everything together, and enforces order. TAO_Trader is parameterized by two types of locks: one for its service service offers, one for its state (configuration).

Definition at line 57 of file Trader_T.h.

Member Typedef Documentation

template<class TRADER_LOCK_TYPE, class MAP_LOCK_TYPE>
typedef TAO_Offer_Database<MAP_LOCK_TYPE> TAO_Trader< TRADER_LOCK_TYPE, MAP_LOCK_TYPE >::Offer_Database
 

Offer Database Trait.

Definition at line 65 of file Trader_T.h.

template<class TRADER_LOCK_TYPE, class MAP_LOCK_TYPE>
typedef TAO_Trader<TRADER_LOCK_TYPE, MAP_LOCK_TYPE> TAO_Trader< TRADER_LOCK_TYPE, MAP_LOCK_TYPE >::TRADER_SELF [protected]
 

Definition at line 86 of file Trader_T.h.

Member Enumeration Documentation

template<class TRADER_LOCK_TYPE, class MAP_LOCK_TYPE>
anonymous enum [protected]
 

Enumeration values:
LOOKUP_IF 
REGISTER_IF 
ADMIN_IF 
PROXY_IF 
LINK_IF 

Definition at line 93 of file Trader_T.h. 

00093 { LOOKUP_IF, REGISTER_IF, ADMIN_IF, PROXY_IF, LINK_IF };

Constructor & Destructor Documentation

template<class TRADER_LOCK_TYPE, class MAP_LOCK_TYPE>
TAO_BEGIN_VERSIONED_NAMESPACE_DECL TAO_Trader< TRADER_LOCK_TYPE, MAP_LOCK_TYPE >::TAO_Trader (  Trader_Components  components = LOOKUP  ) 
 

Constructor which based on its arguments will create a particular type of trader (e.g. Query trader, Simple trader, etc.) The argument is a bitwise OR of desired Trader_Components as listed in enumerated type above.

Definition at line 13 of file Trader_T.cpp.

References ACE_BIT_ENABLED, ACE_NEW, TAO_Trader< TRADER_LOCK_TYPE, MAP_LOCK_TYPE >::ADMIN_IF, TAO_Trading_Components_i::admin_if(), TAO_Trader< TRADER_LOCK_TYPE, MAP_LOCK_TYPE >::ifs_, TAO_Trading_Components_i::link_if(), TAO_Trader< TRADER_LOCK_TYPE, MAP_LOCK_TYPE >::LINK_IF, TAO_Trading_Components_i::lookup_if(), TAO_Trader< TRADER_LOCK_TYPE, MAP_LOCK_TYPE >::LOOKUP_IF, TAO_Trader< TRADER_LOCK_TYPE, MAP_LOCK_TYPE >::PROXY_IF, TAO_Trading_Components_i::proxy_if(), TAO_Trader< TRADER_LOCK_TYPE, MAP_LOCK_TYPE >::REGISTER_IF, TAO_Trading_Components_i::register_if(), and TAO_Trader_Base::trading_components(). 

00014 {
00015 
00016   // @@ Seth, we need a way to propagate the exception out.  This will
00017   // not work on platforms using environment variable.
00018   for (int i = LOOKUP_IF; i <= LINK_IF; i++)
00019     this->ifs_[i] = 0;
00020 
00021   if (ACE_BIT_ENABLED (components, LOOKUP))
00022     {
00023       TAO_Lookup<TRADER_LOCK_TYPE, MAP_LOCK_TYPE>* lookup;
00024 
00025       ACE_NEW (lookup,
00026                (TAO_Lookup<TRADER_LOCK_TYPE, MAP_LOCK_TYPE>) (*this));
00027 
00028       this->trading_components ().lookup_if (lookup->_this ());
00029       lookup->_remove_ref ();
00030 
00031       this->ifs_[LOOKUP_IF] = lookup;
00032     }
00033   if (ACE_BIT_ENABLED (components, REGISTER))
00034     {
00035       TAO_Register<TRADER_LOCK_TYPE, MAP_LOCK_TYPE>* reg;
00036 
00037       ACE_NEW (reg,
00038                (TAO_Register<TRADER_LOCK_TYPE, MAP_LOCK_TYPE>) (*this));
00039 
00040       this->trading_components ().register_if (reg->_this ());
00041       reg->_remove_ref ();
00042 
00043       this->ifs_[REGISTER_IF] = reg;
00044     }
00045   if (ACE_BIT_ENABLED (components, ADMIN))
00046     {
00047       TAO_Admin<TRADER_LOCK_TYPE, MAP_LOCK_TYPE>* admin;
00048 
00049       ACE_NEW (admin,
00050                (TAO_Admin<TRADER_LOCK_TYPE, MAP_LOCK_TYPE>) (*this));
00051 
00052       this->trading_components ().admin_if (admin->_this ());
00053       admin->_remove_ref ();
00054 
00055       this->ifs_[ADMIN_IF] = admin;
00056     }
00057   if (ACE_BIT_ENABLED (components, PROXY))
00058     {
00059       TAO_Proxy<TRADER_LOCK_TYPE, MAP_LOCK_TYPE>* proxy;
00060 
00061       ACE_NEW (proxy,
00062                (TAO_Proxy<TRADER_LOCK_TYPE, MAP_LOCK_TYPE>) (*this));
00063 
00064       this->trading_components ().proxy_if (proxy->_this ());
00065       proxy->_remove_ref ();
00066 
00067       this->ifs_[PROXY_IF] = proxy;
00068     }
00069   if (ACE_BIT_ENABLED (components, LINK))
00070     {
00071       TAO_Link<TRADER_LOCK_TYPE, MAP_LOCK_TYPE>* link;
00072 
00073       ACE_NEW (link,
00074                (TAO_Link<TRADER_LOCK_TYPE, MAP_LOCK_TYPE>) (*this));
00075 
00076       this->trading_components ().link_if (link->_this ());
00077       link->_remove_ref ();
00078 
00079       this->ifs_[LINK_IF] = link;
00080     }
00081 }

template<class TRADER_LOCK_TYPE, class MAP_LOCK_TYPE>
TAO_Trader< TRADER_LOCK_TYPE, MAP_LOCK_TYPE >::~TAO_Trader (  void   )  [virtual]
 

Destructor.

Definition at line 84 of file Trader_T.cpp.

References TAO_Trader< TRADER_LOCK_TYPE, MAP_LOCK_TYPE >::ifs_, TAO_Trader< TRADER_LOCK_TYPE, MAP_LOCK_TYPE >::LINK_IF, and TAO_Trader< TRADER_LOCK_TYPE, MAP_LOCK_TYPE >::LOOKUP_IF. 

00085 {
00086   // Remove Trading Components from POA
00087 
00088 
00089   for (int i = LOOKUP_IF; i <= LINK_IF; i++)
00090     {
00091       if (this->ifs_[i] != 0)
00092         {
00093           try
00094             {
00095               PortableServer::POA_var poa =
00096                 this->ifs_[i]->_default_POA ();
00097 
00098               PortableServer::ObjectId_var id =
00099                 poa->servant_to_id (this->ifs_[i]);
00100 
00101               poa->deactivate_object (id.in ());
00102             }
00103           catch (const CORBA::Exception&)
00104             {
00105               // Don't let exceptions propagate out of this call since
00106               // it's the destructor!
00107             }
00108         }
00109     }
00110 }

Member Function Documentation

template<class TRADER_LOCK_TYPE, class MAP_LOCK_TYPE>
ACE_Lock & TAO_Trader< TRADER_LOCK_TYPE, MAP_LOCK_TYPE >::lock (  void   )  [virtual]
 

Returns the trader.

Implements TAO_Lockable.

Definition at line 120 of file Trader_T.cpp. 

00121 {
00122   return this->lock_;
00123 }

template<class TRADER_LOCK_TYPE, class MAP_LOCK_TYPE>
TAO_Offer_Database< MAP_LOCK_TYPE > & TAO_Trader< TRADER_LOCK_TYPE, MAP_LOCK_TYPE >::offer_database (  void   ) 
 

Accessor for the structure with all the service offers.

Definition at line 114 of file Trader_T.cpp.

References TAO_Trader< TRADER_LOCK_TYPE, MAP_LOCK_TYPE >::offer_database_. 

00115 {
00116   return this->offer_database_;
00117 }

template<class TRADER_LOCK_TYPE, class MAP_LOCK_TYPE>
void TAO_Trader< TRADER_LOCK_TYPE, MAP_LOCK_TYPE >::operator= (  const TAO_Trader< TRADER_LOCK_TYPE, MAP_LOCK_TYPE > &   )  [private]
 

Member Data Documentation

template<class TRADER_LOCK_TYPE, class MAP_LOCK_TYPE>
PortableServer::ServantBase* TAO_Trader< TRADER_LOCK_TYPE, MAP_LOCK_TYPE >::ifs_[5] [protected]
 

Definition at line 95 of file Trader_T.h.

Referenced by TAO_Trader< TRADER_LOCK_TYPE, MAP_LOCK_TYPE >::TAO_Trader(), and TAO_Trader< TRADER_LOCK_TYPE, MAP_LOCK_TYPE >::~TAO_Trader().

template<class TRADER_LOCK_TYPE, class MAP_LOCK_TYPE>
ACE_Lock_Adapter<TRADER_LOCK_TYPE> TAO_Trader< TRADER_LOCK_TYPE, MAP_LOCK_TYPE >::lock_ [protected]
 

Lock that guards the state of the trader (its configuration).

Definition at line 91 of file Trader_T.h.

template<class TRADER_LOCK_TYPE, class MAP_LOCK_TYPE>
Offer_Database TAO_Trader< TRADER_LOCK_TYPE, MAP_LOCK_TYPE >::offer_database_ [protected]
 

Definition at line 88 of file Trader_T.h.

Referenced by TAO_Trader< TRADER_LOCK_TYPE, MAP_LOCK_TYPE >::offer_database().

The documentation for this class was generated from the following files:
Generated on Sun Jan 27 16:20:04 2008 for TAO_CosTrader by doxygen 1.3.6