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

TAO_FlowEndPoint Class Reference

This class is used per flow e.g video flow and an audio flow to encapsulate the transport details. More...

#include <AVStreams_i.h>

Inheritance diagram for TAO_FlowEndPoint:

Inheritance graph
[legend]
Collaboration diagram for TAO_FlowEndPoint:

Collaboration graph
[legend]
List of all members.

Public Member Functions

 TAO_FlowEndPoint (void)
 default constructor.

 TAO_FlowEndPoint (const char *flowname, AVStreams::protocolSpec &protocols, const char *format)
int open (const char *flowname, AVStreams::protocolSpec &protocols, const char *format)
int set_flowname (const char *flowname)
virtual void set_flow_handler (const char *flowname, TAO_AV_Flow_Handler *handler)
virtual int set_protocol_object (const char *flowname, TAO_AV_Protocol_Object *object)
virtual CORBA::Boolean lock (void)
 lock the flow endpoint for a particular flow.

virtual void unlock (void)
 unlock the flow endpoint for subsequent use.

virtual void destroy (void)
 destroy this flow.

virtual AVStreams::StreamEndPoint_ptr related_sep (void)
virtual void related_sep (AVStreams::StreamEndPoint_ptr related_sep)
virtual AVStreams::FlowConnection_ptr related_flow_connection (void)
virtual void related_flow_connection (AVStreams::FlowConnection_ptr related_flow_connection)
 set method for the related flow connection attribute.

virtual AVStreams::FlowEndPoint_ptr get_connected_fep (void)
 returns the other flowendpoint to which this is connected.

virtual CORBA::Boolean use_flow_protocol (const char *fp_name, const CORBA::Any &fp_settings)
virtual void set_format (const char *format)
 sets the data format.

virtual void set_dev_params (const CosPropertyService::Properties &new_settings)
 sets the device parameters.

virtual void set_protocol_restriction (const AVStreams::protocolSpec &the_spec)
 sets the list of protocols to be used.

virtual CORBA::Boolean is_fep_compatible (AVStreams::FlowEndPoint_ptr fep)
 checks whether the passed flowendpoint is compatible with this.

virtual CORBA::Boolean set_peer (AVStreams::FlowConnection_ptr the_fc, AVStreams::FlowEndPoint_ptr the_peer_fep, AVStreams::QoS &the_qos)
 sets the peer flowendpoint.

virtual CORBA::Boolean set_Mcast_peer (AVStreams::FlowConnection_ptr the_fc, AVStreams::MCastConfigIf_ptr a_mcastconfigif, AVStreams::QoS &the_qos)
 sets the multicast peer flowendpoint, not implemented.

virtual CORBA::Boolean connect_to_peer (AVStreams::QoS &the_qos, const char *address, const char *use_flow_protocol)=0
virtual CORBA::Boolean connect_to_peer_i (TAO_FlowSpec_Entry::Role role, AVStreams::QoS &the_qos, const char *address, const char *use_flow_protocol)
 connect to the peer endpoint.

virtual char * go_to_listen (AVStreams::QoS &the_qos, CORBA::Boolean is_mcast, AVStreams::FlowEndPoint_ptr peer, char *&flowProtocol)=0
virtual char * go_to_listen_i (TAO_FlowSpec_Entry::Role role, AVStreams::QoS &the_qos, CORBA::Boolean is_mcast, AVStreams::FlowEndPoint_ptr peer, char *&flowProtocol)
 listen request from the peer.


Protected Attributes

AVStreams::StreamEndPoint_var related_sep_
 The related streamendpoint.

AVStreams::FlowConnection_var related_flow_connection_
 The related flow connection reference.

AVStreams::FlowEndPoint_var peer_fep_
 The peer flowendpoint reference.

AVStreams::protocolSpec protocols_
 Available protocols for this flowendpoint.

AVStreams::protocolSpec protocol_addresses_
 Address information for the protocols.

AVStreams::MCastConfigIf_var mcast_peer_
 The multicast peer endpoint.

CORBA::Boolean lock_
 Lock.

CORBA::String_var format_
CORBA::String_var flowname_
CosPropertyService::Properties dev_params_
TAO_AV_FlowSpecSet flow_spec_set_
CORBA::String_var reverse_channel_

Detailed Description

This class is used per flow e.g video flow and an audio flow to encapsulate the transport details.

Definition at line 883 of file AVStreams_i.h.

Constructor & Destructor Documentation

TAO_FlowEndPoint::TAO_FlowEndPoint (  void   ) 
 

default constructor.

Definition at line 3772 of file AVStreams_i.cpp. 

03773   :lock_ (0)
03774 {
03775 }

TAO_FlowEndPoint::TAO_FlowEndPoint (  const char *  flowname,
AVStreams::protocolSpec &  protocols,
const char *  format
) 
 

Definition at line 3777 of file AVStreams_i.cpp.

References open(), and AVStreams::protocolSpec. 

03780 {
03781   this->open (flowname, protocols, format);
03782 }

Member Function Documentation

virtual CORBA::Boolean TAO_FlowEndPoint::connect_to_peer (  AVStreams::QoS &  the_qos,
const char *  address,
const char *  use_flow_protocol
)  [pure virtual]
 

This should be implemented in both the FlowProducer and consumer and hence is pure virtual since we need to know the role of the flowendpoint to create appropriate protocol objects. eg. in SFP to create Producer Object/ Consumer Object.

Implemented in TAO_FlowProducer, and TAO_FlowConsumer.

CORBA::Boolean TAO_FlowEndPoint::connect_to_peer_i (  TAO_FlowSpec_Entry::Role  role,
AVStreams::QoS &  the_qos,
const char *  address,
const char *  use_flow_protocol
)  [virtual]
 

connect to the peer endpoint.

Definition at line 4177 of file AVStreams_i.cpp.

References ACE_ERROR_RETURN, ACE_NEW_RETURN, flow_spec_set_, format_, TAO_FlowSpec_Entry::get_local_addr_str(), ACE_Unbounded_Set< T >::insert(), ACE_Singleton< TYPE, ACE_LOCK >::instance(), LM_ERROR, TAO_AV_Connector_Registry::open(), reverse_channel_, and ACE_OS::strcpy().

Referenced by TAO_FlowConsumer::connect_to_peer(), and TAO_FlowProducer::connect_to_peer(). 

04181 {
04182   char direction [BUFSIZ];
04183   switch (role)
04184     {
04185     case TAO_FlowSpec_Entry::TAO_AV_PRODUCER:
04186       ACE_OS::strcpy (direction, "IN");
04187       break;
04188     case TAO_FlowSpec_Entry::TAO_AV_CONSUMER:
04189       ACE_OS::strcpy (direction, "OUT");
04190       break;
04191     default:
04192       break;
04193     }
04194   TAO_Forward_FlowSpec_Entry *entry;
04195   ACE_NEW_RETURN (entry,
04196                   TAO_Forward_FlowSpec_Entry (this->flowname_.in (),
04197                                               direction,
04198                                               this->format_.in (),
04199                                               use_flow_protocol,
04200                                               address),
04201                   0);
04202   this->flow_spec_set_.insert (entry);
04203   TAO_AV_Connector_Registry *connector_registry = TAO_AV_CORE::instance ()->connector_registry ();
04204   int result = connector_registry->open (this,
04205                                          TAO_AV_CORE::instance (),
04206                                          this->flow_spec_set_);
04207   if (result < 0)
04208     ACE_ERROR_RETURN ((LM_ERROR, "TAO_FlowEndPoint::connector_registry::open failed\n"), 0);
04209   this->reverse_channel_ = entry->get_local_addr_str ();
04210   return 1;
04211 }

void TAO_FlowEndPoint::destroy (  void   )  [virtual]
 

destroy this flow.

Definition at line 3860 of file AVStreams_i.cpp.

References ACE_DEBUG, ACE_Unbounded_Set< T >::begin(), TAO_AV_Core::deactivate_servant(), ACE_Unbounded_Set< T >::end(), flow_spec_set_, LM_DEBUG, TAO_AV_FlowSpecSetItor, and TAO_debug_level. 

03861 {
03862   int result = TAO_AV_Core::deactivate_servant (this);
03863   if (result < 0)
03864     if (TAO_debug_level > 0) ACE_DEBUG ((LM_DEBUG, "TAO_StreamEndPoint::destroy failed\n"));
03865   TAO_AV_FlowSpecSetItor end = this->flow_spec_set_.end ();
03866   for (TAO_AV_FlowSpecSetItor begin = this->flow_spec_set_.begin ();
03867        begin != end; ++begin)
03868     (*begin)->protocol_object ()->destroy ();
03869 }

AVStreams::FlowEndPoint_ptr TAO_FlowEndPoint::get_connected_fep (  void   )  [virtual]
 

returns the other flowendpoint to which this is connected.

Definition at line 3898 of file AVStreams_i.cpp. 

03899 {
03900   return AVStreams::FlowEndPoint::_duplicate (this->peer_fep_.in ());
03901 }

virtual char* TAO_FlowEndPoint::go_to_listen (  AVStreams::QoS &  the_qos,
CORBA::Boolean  is_mcast,
AVStreams::FlowEndPoint_ptr  peer,
char *&  flowProtocol
)  [pure virtual]
 

This should be implemented in both the FlowProducer and consumer and hence is pure virtual since we need to know the role of the flowendpoint to create appropriate protocol objects. eg. in SFP to create Producer Object/ Consumer Object.

Implemented in TAO_FlowProducer, and TAO_FlowConsumer.

char * TAO_FlowEndPoint::go_to_listen_i (  TAO_FlowSpec_Entry::Role  role,
AVStreams::QoS &  the_qos,
CORBA::Boolean  is_mcast,
AVStreams::FlowEndPoint_ptr  peer,
char *&  flowProtocol
)  [virtual]
 

listen request from the peer.

Definition at line 4092 of file AVStreams_i.cpp.

References ACE_ERROR_RETURN, ACE_NEW_RETURN, flow_spec_set_, format_, TAO_FlowSpec_Entry::get_local_addr_str(), ACE_Unbounded_Set< T >::insert(), ACE_Singleton< TYPE, ACE_LOCK >::instance(), LM_ERROR, TAO_AV_Acceptor_Registry::open(), protocol_addresses_, AVStreams::protocolSpec, ACE_OS::sprintf(), ACE_OS::strcmp(), ACE_OS::strcpy(), CORBA::string_dup(), ACE_OS::strlen(), and ACE_OS::strncmp().

Referenced by TAO_FlowConsumer::go_to_listen(), and TAO_FlowProducer::go_to_listen(). 

04097 {
04098   char direction [BUFSIZ];
04099   switch (role)
04100     {
04101     case TAO_FlowSpec_Entry::TAO_AV_PRODUCER:
04102       ACE_OS::strcpy (direction, "IN");
04103       break;
04104     case TAO_FlowSpec_Entry::TAO_AV_CONSUMER:
04105       ACE_OS::strcpy (direction, "OUT");
04106       break;
04107     default:
04108       break;
04109     }
04110   AVStreams::protocolSpec my_protocol_spec, peer_protocol_spec;
04111   AVStreams::protocolSpec *temp_protocols;
04112   CORBA::Any_var AvailableProtocols_ptr =
04113     peer_fep->get_property_value ("AvailableProtocols");
04114   AvailableProtocols_ptr.in () >>= temp_protocols;
04115   peer_protocol_spec = *temp_protocols;
04116   AvailableProtocols_ptr =
04117     this->get_property_value ("AvailableProtocols");
04118   AvailableProtocols_ptr.in () >>= temp_protocols;
04119   my_protocol_spec = *temp_protocols;
04120   int protocol_match = 0;
04121   CORBA::String_var listen_protocol;
04122   u_int i =0;
04123   for (i=0;i<my_protocol_spec.length ();i++)
04124     {
04125       CORBA::String_var my_protocol_string;
04126       for (u_int j=0;j<peer_protocol_spec.length ();j++)
04127         {
04128           CORBA::String_var peer_protocol_string;
04129           my_protocol_string = CORBA::string_dup (my_protocol_spec[i]);
04130           peer_protocol_string = CORBA::string_dup (peer_protocol_spec[j]);
04131           if (ACE_OS::strcmp (my_protocol_string.in (), peer_protocol_string.in ()) == 0)
04132             {
04133               listen_protocol = my_protocol_string;
04134               protocol_match = 1;
04135               break;
04136             }
04137         }
04138       if (protocol_match)
04139         break;
04140     }
04141   if (!protocol_match)
04142     ACE_ERROR_RETURN ((LM_ERROR, "TAO_FlowEndPoint::go_to_listen failed: no protoocol match\n"), 0);
04143 
04144   for (u_int j=0;j<this->protocol_addresses_.length ();j++)
04145     if (ACE_OS::strncmp (this->protocol_addresses_ [j], listen_protocol.in (), ACE_OS::strlen (listen_protocol.in ())) == 0)
04146       {
04147         // Now listen on that protocol.
04148         TAO_Forward_FlowSpec_Entry *entry;
04149         ACE_NEW_RETURN (entry,
04150                         TAO_Forward_FlowSpec_Entry (this->flowname_.in (),
04151                                                     direction,
04152                                                     this->format_.in (),
04153                                                     flowProtocol,
04154                                                     this->protocol_addresses_ [j]),
04155                         0);
04156 
04157         TAO_AV_Acceptor_Registry *acceptor_registry = TAO_AV_CORE::instance ()->acceptor_registry ();
04158         this->flow_spec_set_.insert (entry);
04159         int result = acceptor_registry->open (this,
04160                                               TAO_AV_CORE::instance (),
04161                                               this->flow_spec_set_);
04162         if (result < 0)
04163           return 0;
04164         char *listen_address = entry->get_local_addr_str ();
04165         char *address;
04166         ACE_NEW_RETURN (address,
04167                         char [BUFSIZ],
04168                         0);
04169         ACE_OS::sprintf (address, "%s=%s", listen_protocol.in (), listen_address);
04170         return address;
04171       }
04172   return 0;
04173 }

CORBA::Boolean TAO_FlowEndPoint::is_fep_compatible (  AVStreams::FlowEndPoint_ptr  fep  )  [virtual]
 

checks whether the passed flowendpoint is compatible with this.

Definition at line 3996 of file AVStreams_i.cpp.

References AVStreams::protocolSpec, ACE_OS::strcmp(), and CORBA::string_dup(). 

03997 {
03998   const char *exception_message = "";
03999   try
04000     {
04001       // check whether the passed flowendpoint is compatible with this flowendpoint.
04002       // should we check for the availableFormats and choose one format.
04003       // get my format value
04004       CORBA::Any_var format_ptr;
04005       CORBA::String_var my_format, peer_format;
04006 
04007       exception_message = "TAO_FlowEndPoint::is_fep_compatible - Format";
04008       format_ptr = this->get_property_value ("Format");
04009 
04010       const char *temp_format;
04011       format_ptr.in () >>= temp_format;
04012       my_format = CORBA::string_dup (temp_format);
04013       // get my peer's format value
04014       exception_message = "TAO_FlowEndPoint::is_fep_compatible - Format[2]";
04015       format_ptr = peer_fep->get_property_value ("Format");
04016       format_ptr.in () >>= temp_format;
04017       peer_format = CORBA::string_dup (temp_format);
04018       if (ACE_OS::strcmp (my_format.in (),
04019                           peer_format.in ()) != 0)
04020         return 0;
04021 
04022       // since formats are same, check for a common protocol
04023       CORBA::Any_var AvailableProtocols_ptr;
04024       AVStreams::protocolSpec my_protocol_spec, peer_protocol_spec;
04025       AVStreams::protocolSpec *temp_protocols;;
04026 
04027       exception_message =
04028         "TAO_FlowEndPoint::is_fep_compatible - AvailableProtocols";
04029       AvailableProtocols_ptr = this->get_property_value ("AvailableProtocols");
04030       AvailableProtocols_ptr.in () >>= temp_protocols;
04031       my_protocol_spec = *temp_protocols;
04032 
04033       exception_message =
04034         "TAO_FlowEndPoint::is_fep_compatible - AvailableProtocols[2]";
04035       AvailableProtocols_ptr = peer_fep->get_property_value ("AvailableProtocols");
04036       AvailableProtocols_ptr.in () >>= temp_protocols;
04037       peer_protocol_spec = *temp_protocols;
04038 
04039       int protocol_match = 0;
04040       for (u_int i=0;i<my_protocol_spec.length ();i++)
04041         {
04042           CORBA::String_var my_protocol_string;
04043           for (u_int j=0;j<peer_protocol_spec.length ();j++)
04044             {
04045               CORBA::String_var peer_protocol_string;
04046               my_protocol_string = CORBA::string_dup (my_protocol_spec[i]);
04047               peer_protocol_string = CORBA::string_dup (peer_protocol_spec[j]);
04048               if (ACE_OS::strcmp (my_protocol_string.in (), peer_protocol_string.in ()) == 0)
04049                 {
04050                   protocol_match = 1;
04051                   break;
04052                 }
04053             }
04054           if (protocol_match)
04055             break;
04056         }
04057       if (!protocol_match)
04058         return 0;
04059     }
04060   catch (const CosPropertyService::PropertyNotFound& nf)
04061     {
04062       nf._tao_print_exception (exception_message);
04063     }
04064   catch (const CORBA::Exception& ex)
04065     {
04066       ex._tao_print_exception ("TAO_FlowEndPoint::is_fep_compatible");
04067       return 0;
04068     }
04069   return 1;
04070 }

CORBA::Boolean TAO_FlowEndPoint::lock (  void   )  [virtual]
 

lock the flow endpoint for a particular flow.

Definition at line 3841 of file AVStreams_i.cpp. 

03842 {
03843   // lock the current flowendpoint
03844 
03845   if (this->lock_)
03846     return 0;
03847   this->lock_ = 1;
03848   return 1;
03849 }

int TAO_FlowEndPoint::open (  const char *  flowname,
AVStreams::protocolSpec &  protocols,
const char *  format
) 
 

Definition at line 3791 of file AVStreams_i.cpp.

References ACE_DEBUG, TAO_FlowSpec_Entry::carrier_protocol_str(), flowname_, format_, LM_DEBUG, protocol_addresses_, AVStreams::protocolSpec, set_format(), set_protocol_restriction(), CORBA::string_dup(), and TAO_debug_level.

Referenced by TAO_FlowConsumer::TAO_FlowConsumer(), TAO_FlowEndPoint(), and TAO_FlowProducer::TAO_FlowProducer(). 

03794 {
03795   this->flowname_ = flowname;
03796   this->format_ = format;
03797 
03798   if (TAO_debug_level > 0) ACE_DEBUG ((LM_DEBUG, "TAO_FlowEndPoint::open\n"));
03799   try
03800     {
03801       CORBA::Any flowname_any;
03802       flowname_any <<= flowname;
03803       this->define_property ("FlowName",
03804                              flowname_any);
03805       this->set_format (format);
03806       this->protocol_addresses_ = protocols;
03807       AVStreams::protocolSpec protocol_spec (protocols.length ());
03808       protocol_spec.length (protocols.length ());
03809       if (TAO_debug_level > 0) ACE_DEBUG ((LM_DEBUG, "%N:%l\n"));
03810       for (u_int i=0;i<protocols.length ();i++)
03811         {
03812           CORBA::String_var address = CORBA::string_dup (protocols [i]);
03813           TAO_Forward_FlowSpec_Entry entry ("", "", "", "", address.in ());
03814           protocol_spec [i] = CORBA::string_dup (entry.carrier_protocol_str ());
03815           if (TAO_debug_level > 0)
03816             ACE_DEBUG ((LM_DEBUG,
03817                         "[%s]\n",
03818                         static_cast<char const*>(protocol_spec[i])));
03819         }
03820       this->set_protocol_restriction (protocol_spec);
03821     }
03822   catch (const CORBA::Exception& ex)
03823     {
03824       ex._tao_print_exception ("TAO_FlowEndPoint::open");
03825       return -1;
03826     }
03827   return 0;
03828 }

void TAO_FlowEndPoint::related_flow_connection (  AVStreams::FlowConnection_ptr  related_flow_connection  )  [virtual]
 

set method for the related flow connection attribute.

Definition at line 3891 of file AVStreams_i.cpp.

References related_flow_connection_. 

03892 {
03893   this->related_flow_connection_ = AVStreams::FlowConnection::_duplicate (related_flow_connection);
03894 }

AVStreams::FlowConnection_ptr TAO_FlowEndPoint::related_flow_connection (  void   )  [virtual]
 

Definition at line 3885 of file AVStreams_i.cpp. 

03886 {
03887   return AVStreams::FlowConnection::_duplicate (this->related_flow_connection_.in ());
03888 }

void TAO_FlowEndPoint::related_sep (  AVStreams::StreamEndPoint_ptr  related_sep  )  [virtual]
 

set method for the related streamendpoint under which this flowendpoint is.

Definition at line 3879 of file AVStreams_i.cpp.

References related_sep_. 

03880 {
03881   this->related_sep_ = AVStreams::StreamEndPoint::_duplicate (related_sep);
03882 }

AVStreams::StreamEndPoint_ptr TAO_FlowEndPoint::related_sep (  void   )  [virtual]
 

get method for the related streamendpoint under which this flowendpoint is.

Definition at line 3872 of file AVStreams_i.cpp. 

03873 {
03874 
03875   return AVStreams::StreamEndPoint::_duplicate (this->related_sep_.in ());
03876 }

void TAO_FlowEndPoint::set_dev_params (  const CosPropertyService::Properties &  new_settings  )  [virtual]
 

sets the device parameters.

Definition at line 3944 of file AVStreams_i.cpp.

References dev_params_. 

03945 {
03946   this->dev_params_ = new_settings;
03947   try
03948     {
03949       CORBA::Any DevParams_property;
03950       DevParams_property <<= new_settings;
03951       this->define_property ("DevParams",
03952                              DevParams_property);
03953     }
03954   catch (const CORBA::Exception& ex)
03955     {
03956       ex._tao_print_exception (
03957         "TAO_FlowEndPoint::set_dev_params");
03958     }
03959 }

void TAO_FlowEndPoint::set_flow_handler (  const char *  flowname,
TAO_AV_Flow_Handler *  handler
)  [virtual]
 

Reimplemented from TAO_Base_StreamEndPoint.

Definition at line 3785 of file AVStreams_i.cpp. 

03787 {
03788 }

int TAO_FlowEndPoint::set_flowname (  const char *  flowname  ) 
 

Definition at line 3832 of file AVStreams_i.cpp.

References flowname_. 

03833 {
03834   this->flowname_ = flowname;
03835   return 0;
03836 }

void TAO_FlowEndPoint::set_format (  const char *  format  )  [virtual]
 

sets the data format.

Definition at line 3925 of file AVStreams_i.cpp.

References format_.

Referenced by open(). 

03926 {
03927   this->format_ = format;
03928   try
03929     {
03930       // make this a property so that is_fep_compatible can query this and
03931       // check if 2 flowendpoints are compatible.
03932       CORBA::Any format_val;
03933       format_val <<= format;
03934       this->define_property ("Format",
03935                              format_val);
03936     }
03937   catch (const CORBA::Exception& ex)
03938     {
03939       ex._tao_print_exception ("TAO_FlowEndpoint::set_format");
03940     }
03941 }

CORBA::Boolean TAO_FlowEndPoint::set_Mcast_peer (  AVStreams::FlowConnection_ptr  the_fc,
AVStreams::MCastConfigIf_ptr  a_mcastconfigif,
AVStreams::QoS &  the_qos
)  [virtual]
 

sets the multicast peer flowendpoint, not implemented.

Definition at line 4083 of file AVStreams_i.cpp. 

04086 {
04087   this->mcast_peer_ = AVStreams::MCastConfigIf::_duplicate (mcast_peer);
04088   return 0;
04089 }

CORBA::Boolean TAO_FlowEndPoint::set_peer (  AVStreams::FlowConnection_ptr  the_fc,
AVStreams::FlowEndPoint_ptr  the_peer_fep,
AVStreams::QoS &  the_qos
)  [virtual]
 

sets the peer flowendpoint.

Definition at line 4073 of file AVStreams_i.cpp.

References peer_fep_. 

04076 {
04077   this->peer_fep_ =
04078     AVStreams::FlowEndPoint::_duplicate (the_peer_fep);
04079   return 1;
04080 }

int TAO_FlowEndPoint::set_protocol_object (  const char *  flowname,
TAO_AV_Protocol_Object *  object
)  [virtual]
 

Reimplemented from TAO_Base_StreamEndPoint.

Definition at line 4214 of file AVStreams_i.cpp. 

04216 {
04217   return 0;
04218 }

void TAO_FlowEndPoint::set_protocol_restriction (  const AVStreams::protocolSpec &  the_spec  )  [virtual]
 

sets the list of protocols to be used.

Definition at line 3962 of file AVStreams_i.cpp.

References ACE_DEBUG, LM_DEBUG, AVStreams::protocolSpec, and TAO_debug_level.

Referenced by open(). 

03963 {
03964   try
03965     {
03966       u_int i = 0;
03967       if (TAO_debug_level > 0) ACE_DEBUG ((LM_DEBUG, "%N:%l\n"));
03968       for (i=0;i<protocols.length ();i++)
03969         {
03970           const char *protocol = (protocols)[i];
03971           if (TAO_debug_level > 0) ACE_DEBUG ((LM_DEBUG, "%s\n", protocol));
03972         }
03973       CORBA::Any AvailableProtocols_property;
03974       AvailableProtocols_property <<= protocols;
03975       this->define_property ("AvailableProtocols",
03976                              AvailableProtocols_property);
03977       AVStreams::protocolSpec *temp_spec;
03978       CORBA::Any_var temp_any = this->get_property_value ("AvailableProtocols");
03979       temp_any.in () >>= temp_spec;
03980       if (TAO_debug_level > 0) ACE_DEBUG ((LM_DEBUG, "%N:%l\n"));
03981       for (i=0;i<temp_spec->length ();i++)
03982         {
03983           const char *protocol = (*temp_spec)[i];
03984           if (TAO_debug_level > 0) ACE_DEBUG ((LM_DEBUG, "%s\n", protocol));
03985         }
03986       this->protocols_ = protocols;
03987     }
03988   catch (const CORBA::Exception& ex)
03989     {
03990       ex._tao_print_exception (
03991         "TAO_FlowEndpoint::set_protocol_restriction");
03992     }
03993 }

void TAO_FlowEndPoint::unlock (  void   )  [virtual]
 

unlock the flow endpoint for subsequent use.

Definition at line 3853 of file AVStreams_i.cpp. 

03854 {
03855   this->lock_ = 0;
03856 }

CORBA::Boolean TAO_FlowEndPoint::use_flow_protocol (  const char *  fp_name,
const CORBA::Any &  fp_settings
)  [virtual]
 

Definition at line 3904 of file AVStreams_i.cpp. 

03906 {
03907   try
03908     {
03909       // Define the property called FlowProtocol
03910       CORBA::Any flowname_property;
03911       flowname_property <<= fp_name;
03912       this->define_property ("FlowProtocol",
03913                              flowname_property);
03914     }
03915   catch (const CORBA::Exception& ex)
03916     {
03917       ex._tao_print_exception (
03918         "TAO_FlowEndPoint::use_flow_protocol");
03919       return 0;
03920     }
03921   return 1;
03922 }

Member Data Documentation

CosPropertyService::Properties TAO_FlowEndPoint::dev_params_ [protected]
 

Definition at line 1023 of file AVStreams_i.h.

Referenced by set_dev_params().

TAO_AV_FlowSpecSet TAO_FlowEndPoint::flow_spec_set_ [protected]
 

Definition at line 1024 of file AVStreams_i.h.

Referenced by connect_to_peer_i(), destroy(), and go_to_listen_i().

CORBA::String_var TAO_FlowEndPoint::flowname_ [protected]
 

Definition at line 1022 of file AVStreams_i.h.

Referenced by open(), and set_flowname().

CORBA::String_var TAO_FlowEndPoint::format_ [protected]
 

Definition at line 1021 of file AVStreams_i.h.

Referenced by connect_to_peer_i(), go_to_listen_i(), open(), and set_format().

CORBA::Boolean TAO_FlowEndPoint::lock_ [protected]
 

Lock.

Definition at line 1019 of file AVStreams_i.h.

AVStreams::MCastConfigIf_var TAO_FlowEndPoint::mcast_peer_ [protected]
 

The multicast peer endpoint.

Definition at line 1016 of file AVStreams_i.h.

AVStreams::FlowEndPoint_var TAO_FlowEndPoint::peer_fep_ [protected]
 

The peer flowendpoint reference.

Definition at line 1007 of file AVStreams_i.h.

Referenced by set_peer().

AVStreams::protocolSpec TAO_FlowEndPoint::protocol_addresses_ [protected]
 

Address information for the protocols.

Definition at line 1013 of file AVStreams_i.h.

Referenced by go_to_listen_i(), and open().

AVStreams::protocolSpec TAO_FlowEndPoint::protocols_ [protected]
 

Available protocols for this flowendpoint.

Definition at line 1010 of file AVStreams_i.h.

AVStreams::FlowConnection_var TAO_FlowEndPoint::related_flow_connection_ [protected]
 

The related flow connection reference.

Definition at line 1004 of file AVStreams_i.h.

Referenced by related_flow_connection().

AVStreams::StreamEndPoint_var TAO_FlowEndPoint::related_sep_ [protected]
 

The related streamendpoint.

Definition at line 1001 of file AVStreams_i.h.

Referenced by related_sep().

CORBA::String_var TAO_FlowEndPoint::reverse_channel_ [protected]
 

Definition at line 1025 of file AVStreams_i.h.

Referenced by connect_to_peer_i().

The documentation for this class was generated from the following files:
Generated on Sun Jan 27 16:07:49 2008 for TAO_AV by doxygen 1.3.6