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 3820 of file AVStreams_i.cpp.

03821   :lock_ (0)
03822 {
03823 }

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

Definition at line 3825 of file AVStreams_i.cpp.

References open().

03828 {
03829   this->open (flowname, protocols, format);
03830 }

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 4225 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_Ex< T, C >::insert(), ACE_Singleton< TYPE, ACE_LOCK >::instance(), LM_ERROR, TAO_AV_Connector_Registry::open(), reverse_channel_, ACE_OS::strcpy(), TAO_FlowSpec_Entry::TAO_AV_CONSUMER, and TAO_FlowSpec_Entry::TAO_AV_PRODUCER.

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

04229 {
04230   char direction [BUFSIZ];
04231   switch (role)
04232     {
04233     case TAO_FlowSpec_Entry::TAO_AV_PRODUCER:
04234       ACE_OS::strcpy (direction, "IN");
04235       break;
04236     case TAO_FlowSpec_Entry::TAO_AV_CONSUMER:
04237       ACE_OS::strcpy (direction, "OUT");
04238       break;
04239     default:
04240       break;
04241     }
04242   TAO_Forward_FlowSpec_Entry *entry;
04243   ACE_NEW_RETURN (entry,
04244                   TAO_Forward_FlowSpec_Entry (this->flowname_.in (),
04245                                               direction,
04246                                               this->format_.in (),
04247                                               use_flow_protocol,
04248                                               address),
04249                   0);
04250   this->flow_spec_set_.insert (entry);
04251   TAO_AV_Connector_Registry *connector_registry = TAO_AV_CORE::instance ()->connector_registry ();
04252   int result = connector_registry->open (this,
04253                                          TAO_AV_CORE::instance (),
04254                                          this->flow_spec_set_);
04255   if (result < 0)
04256     ACE_ERROR_RETURN ((LM_ERROR, "TAO_FlowEndPoint::connector_registry::open failed\n"), 0);
04257   this->reverse_channel_ = entry->get_local_addr_str ();
04258   return 1;
04259 }

void TAO_FlowEndPoint::destroy ( void   )  [virtual]

destroy this flow.

Definition at line 3908 of file AVStreams_i.cpp.

References ACE_DEBUG, TAO_AV_Core::deactivate_servant(), ACE_Unbounded_Set_Ex< T, C >::end(), flow_spec_set_, LM_DEBUG, and TAO_debug_level.

03909 {
03910   int result = TAO_AV_Core::deactivate_servant (this);
03911   if (result < 0)
03912     if (TAO_debug_level > 0) ACE_DEBUG ((LM_DEBUG, "TAO_StreamEndPoint::destroy failed\n"));
03913   TAO_AV_FlowSpecSetItor end = this->flow_spec_set_.end ();
03914   for (TAO_AV_FlowSpecSetItor begin = this->flow_spec_set_.begin ();
03915        begin != end; ++begin)
03916     (*begin)->protocol_object ()->destroy ();
03917 }

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

returns the other flowendpoint to which this is connected.

Definition at line 3946 of file AVStreams_i.cpp.

03947 {
03948   return AVStreams::FlowEndPoint::_duplicate (this->peer_fep_.in ());
03949 }

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 4140 of file AVStreams_i.cpp.

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

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

04145 {
04146   char direction [BUFSIZ];
04147   switch (role)
04148     {
04149     case TAO_FlowSpec_Entry::TAO_AV_PRODUCER:
04150       ACE_OS::strcpy (direction, "IN");
04151       break;
04152     case TAO_FlowSpec_Entry::TAO_AV_CONSUMER:
04153       ACE_OS::strcpy (direction, "OUT");
04154       break;
04155     default:
04156       break;
04157     }
04158   AVStreams::protocolSpec my_protocol_spec, peer_protocol_spec;
04159   AVStreams::protocolSpec *temp_protocols;
04160   CORBA::Any_var AvailableProtocols_ptr =
04161     peer_fep->get_property_value ("AvailableProtocols");
04162   AvailableProtocols_ptr.in () >>= temp_protocols;
04163   peer_protocol_spec = *temp_protocols;
04164   AvailableProtocols_ptr =
04165     this->get_property_value ("AvailableProtocols");
04166   AvailableProtocols_ptr.in () >>= temp_protocols;
04167   my_protocol_spec = *temp_protocols;
04168   int protocol_match = 0;
04169   CORBA::String_var listen_protocol;
04170   u_int i =0;
04171   for (i=0;i<my_protocol_spec.length ();i++)
04172     {
04173       CORBA::String_var my_protocol_string;
04174       for (u_int j=0;j<peer_protocol_spec.length ();j++)
04175         {
04176           CORBA::String_var peer_protocol_string;
04177           my_protocol_string = CORBA::string_dup (my_protocol_spec[i]);
04178           peer_protocol_string = CORBA::string_dup (peer_protocol_spec[j]);
04179           if (ACE_OS::strcmp (my_protocol_string.in (), peer_protocol_string.in ()) == 0)
04180             {
04181               listen_protocol = my_protocol_string;
04182               protocol_match = 1;
04183               break;
04184             }
04185         }
04186       if (protocol_match)
04187         break;
04188     }
04189   if (!protocol_match)
04190     ACE_ERROR_RETURN ((LM_ERROR, "TAO_FlowEndPoint::go_to_listen failed: no protoocol match\n"), 0);
04191 
04192   for (u_int j=0;j<this->protocol_addresses_.length ();j++)
04193     if (ACE_OS::strncmp (this->protocol_addresses_ [j], listen_protocol.in (), ACE_OS::strlen (listen_protocol.in ())) == 0)
04194       {
04195         // Now listen on that protocol.
04196         TAO_Forward_FlowSpec_Entry *entry;
04197         ACE_NEW_RETURN (entry,
04198                         TAO_Forward_FlowSpec_Entry (this->flowname_.in (),
04199                                                     direction,
04200                                                     this->format_.in (),
04201                                                     flowProtocol,
04202                                                     this->protocol_addresses_ [j]),
04203                         0);
04204 
04205         TAO_AV_Acceptor_Registry *acceptor_registry = TAO_AV_CORE::instance ()->acceptor_registry ();
04206         this->flow_spec_set_.insert (entry);
04207         int result = acceptor_registry->open (this,
04208                                               TAO_AV_CORE::instance (),
04209                                               this->flow_spec_set_);
04210         if (result < 0)
04211           return 0;
04212         char *listen_address = entry->get_local_addr_str ();
04213         char *address;
04214         ACE_NEW_RETURN (address,
04215                         char [BUFSIZ],
04216                         0);
04217         ACE_OS::sprintf (address, "%s=%s", listen_protocol.in (), listen_address);
04218         return address;
04219       }
04220   return 0;
04221 }

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

checks whether the passed flowendpoint is compatible with this.

Definition at line 4044 of file AVStreams_i.cpp.

References CORBA::Exception::_tao_print_exception(), ACE_OS::strcmp(), and CORBA::string_dup().

04045 {
04046   const char *exception_message = "";
04047   try
04048     {
04049       // check whether the passed flowendpoint is compatible with this flowendpoint.
04050       // should we check for the availableFormats and choose one format.
04051       // get my format value
04052       CORBA::Any_var format_ptr;
04053       CORBA::String_var my_format, peer_format;
04054 
04055       exception_message = "TAO_FlowEndPoint::is_fep_compatible - Format";
04056       format_ptr = this->get_property_value ("Format");
04057 
04058       const char *temp_format;
04059       format_ptr.in () >>= temp_format;
04060       my_format = CORBA::string_dup (temp_format);
04061       // get my peer's format value
04062       exception_message = "TAO_FlowEndPoint::is_fep_compatible - Format[2]";
04063       format_ptr = peer_fep->get_property_value ("Format");
04064       format_ptr.in () >>= temp_format;
04065       peer_format = CORBA::string_dup (temp_format);
04066       if (ACE_OS::strcmp (my_format.in (),
04067                           peer_format.in ()) != 0)
04068         return 0;
04069 
04070       // since formats are same, check for a common protocol
04071       CORBA::Any_var AvailableProtocols_ptr;
04072       AVStreams::protocolSpec my_protocol_spec, peer_protocol_spec;
04073       AVStreams::protocolSpec *temp_protocols;;
04074 
04075       exception_message =
04076         "TAO_FlowEndPoint::is_fep_compatible - AvailableProtocols";
04077       AvailableProtocols_ptr = this->get_property_value ("AvailableProtocols");
04078       AvailableProtocols_ptr.in () >>= temp_protocols;
04079       my_protocol_spec = *temp_protocols;
04080 
04081       exception_message =
04082         "TAO_FlowEndPoint::is_fep_compatible - AvailableProtocols[2]";
04083       AvailableProtocols_ptr = peer_fep->get_property_value ("AvailableProtocols");
04084       AvailableProtocols_ptr.in () >>= temp_protocols;
04085       peer_protocol_spec = *temp_protocols;
04086 
04087       int protocol_match = 0;
04088       for (u_int i=0;i<my_protocol_spec.length ();i++)
04089         {
04090           CORBA::String_var my_protocol_string;
04091           for (u_int j=0;j<peer_protocol_spec.length ();j++)
04092             {
04093               CORBA::String_var peer_protocol_string;
04094               my_protocol_string = CORBA::string_dup (my_protocol_spec[i]);
04095               peer_protocol_string = CORBA::string_dup (peer_protocol_spec[j]);
04096               if (ACE_OS::strcmp (my_protocol_string.in (), peer_protocol_string.in ()) == 0)
04097                 {
04098                   protocol_match = 1;
04099                   break;
04100                 }
04101             }
04102           if (protocol_match)
04103             break;
04104         }
04105       if (!protocol_match)
04106         return 0;
04107     }
04108   catch (const CosPropertyService::PropertyNotFound& nf)
04109     {
04110       nf._tao_print_exception (exception_message);
04111     }
04112   catch (const CORBA::Exception& ex)
04113     {
04114       ex._tao_print_exception ("TAO_FlowEndPoint::is_fep_compatible");
04115       return 0;
04116     }
04117   return 1;
04118 }

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

lock the flow endpoint for a particular flow.

Definition at line 3889 of file AVStreams_i.cpp.

References lock_.

03890 {
03891   // lock the current flowendpoint
03892 
03893   if (this->lock_)
03894     return 0;
03895   this->lock_ = 1;
03896   return 1;
03897 }

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

Definition at line 3839 of file AVStreams_i.cpp.

References CORBA::Exception::_tao_print_exception(), ACE_DEBUG, flowname_, format_, LM_DEBUG, protocol_addresses_, 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().

03842 {
03843   this->flowname_ = flowname;
03844   this->format_ = format;
03845 
03846   if (TAO_debug_level > 0) ACE_DEBUG ((LM_DEBUG, "TAO_FlowEndPoint::open\n"));
03847   try
03848     {
03849       CORBA::Any flowname_any;
03850       flowname_any <<= flowname;
03851       this->define_property ("FlowName",
03852                              flowname_any);
03853       this->set_format (format);
03854       this->protocol_addresses_ = protocols;
03855       AVStreams::protocolSpec protocol_spec (protocols.length ());
03856       protocol_spec.length (protocols.length ());
03857       if (TAO_debug_level > 0) ACE_DEBUG ((LM_DEBUG, "%N:%l\n"));
03858       for (u_int i=0;i<protocols.length ();i++)
03859         {
03860           CORBA::String_var address = CORBA::string_dup (protocols [i]);
03861           TAO_Forward_FlowSpec_Entry entry ("", "", "", "", address.in ());
03862           protocol_spec [i] = CORBA::string_dup (entry.carrier_protocol_str ());
03863           if (TAO_debug_level > 0)
03864             ACE_DEBUG ((LM_DEBUG,
03865                         "[%s]\n",
03866                         static_cast<char const*>(protocol_spec[i])));
03867         }
03868       this->set_protocol_restriction (protocol_spec);
03869     }
03870   catch (const CORBA::Exception& ex)
03871     {
03872       ex._tao_print_exception ("TAO_FlowEndPoint::open");
03873       return -1;
03874     }
03875   return 0;
03876 }

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

set method for the related flow connection attribute.

Definition at line 3939 of file AVStreams_i.cpp.

References related_flow_connection_.

03940 {
03941   this->related_flow_connection_ = AVStreams::FlowConnection::_duplicate (related_flow_connection);
03942 }

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

Definition at line 3933 of file AVStreams_i.cpp.

03934 {
03935   return AVStreams::FlowConnection::_duplicate (this->related_flow_connection_.in ());
03936 }

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 3927 of file AVStreams_i.cpp.

References related_sep_.

03928 {
03929   this->related_sep_ = AVStreams::StreamEndPoint::_duplicate (related_sep);
03930 }

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

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

Definition at line 3920 of file AVStreams_i.cpp.

03921 {
03922 
03923   return AVStreams::StreamEndPoint::_duplicate (this->related_sep_.in ());
03924 }

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

sets the device parameters.

Definition at line 3992 of file AVStreams_i.cpp.

References CORBA::Exception::_tao_print_exception(), and dev_params_.

03993 {
03994   this->dev_params_ = new_settings;
03995   try
03996     {
03997       CORBA::Any DevParams_property;
03998       DevParams_property <<= new_settings;
03999       this->define_property ("DevParams",
04000                              DevParams_property);
04001     }
04002   catch (const CORBA::Exception& ex)
04003     {
04004       ex._tao_print_exception (
04005         "TAO_FlowEndPoint::set_dev_params");
04006     }
04007 }

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

Reimplemented from TAO_Base_StreamEndPoint.

Definition at line 3833 of file AVStreams_i.cpp.

03835 {
03836 }

int TAO_FlowEndPoint::set_flowname ( const char *  flowname  ) 

Definition at line 3880 of file AVStreams_i.cpp.

References flowname_.

03881 {
03882   this->flowname_ = flowname;
03883   return 0;
03884 }

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

sets the data format.

Definition at line 3973 of file AVStreams_i.cpp.

References CORBA::Exception::_tao_print_exception(), and format_.

Referenced by open().

03974 {
03975   this->format_ = format;
03976   try
03977     {
03978       // make this a property so that is_fep_compatible can query this and
03979       // check if 2 flowendpoints are compatible.
03980       CORBA::Any format_val;
03981       format_val <<= format;
03982       this->define_property ("Format",
03983                              format_val);
03984     }
03985   catch (const CORBA::Exception& ex)
03986     {
03987       ex._tao_print_exception ("TAO_FlowEndpoint::set_format");
03988     }
03989 }

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 4131 of file AVStreams_i.cpp.

References mcast_peer_.

04134 {
04135   this->mcast_peer_ = AVStreams::MCastConfigIf::_duplicate (mcast_peer);
04136   return 0;
04137 }

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 4121 of file AVStreams_i.cpp.

References peer_fep_.

04124 {
04125   this->peer_fep_ =
04126     AVStreams::FlowEndPoint::_duplicate (the_peer_fep);
04127   return 1;
04128 }

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

Reimplemented from TAO_Base_StreamEndPoint.

Definition at line 4262 of file AVStreams_i.cpp.

04264 {
04265   return 0;
04266 }

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

sets the list of protocols to be used.

Definition at line 4010 of file AVStreams_i.cpp.

References CORBA::Exception::_tao_print_exception(), ACE_DEBUG, LM_DEBUG, protocols_, and TAO_debug_level.

Referenced by open().

04011 {
04012   try
04013     {
04014       u_int i = 0;
04015       if (TAO_debug_level > 0) ACE_DEBUG ((LM_DEBUG, "%N:%l\n"));
04016       for (i=0;i<protocols.length ();i++)
04017         {
04018           const char *protocol = (protocols)[i];
04019           if (TAO_debug_level > 0) ACE_DEBUG ((LM_DEBUG, "%s\n", protocol));
04020         }
04021       CORBA::Any AvailableProtocols_property;
04022       AvailableProtocols_property <<= protocols;
04023       this->define_property ("AvailableProtocols",
04024                              AvailableProtocols_property);
04025       AVStreams::protocolSpec *temp_spec;
04026       CORBA::Any_var temp_any = this->get_property_value ("AvailableProtocols");
04027       temp_any.in () >>= temp_spec;
04028       if (TAO_debug_level > 0) ACE_DEBUG ((LM_DEBUG, "%N:%l\n"));
04029       for (i=0;i<temp_spec->length ();i++)
04030         {
04031           const char *protocol = (*temp_spec)[i];
04032           if (TAO_debug_level > 0) ACE_DEBUG ((LM_DEBUG, "%s\n", protocol));
04033         }
04034       this->protocols_ = protocols;
04035     }
04036   catch (const CORBA::Exception& ex)
04037     {
04038       ex._tao_print_exception (
04039         "TAO_FlowEndpoint::set_protocol_restriction");
04040     }
04041 }

void TAO_FlowEndPoint::unlock ( void   )  [virtual]

unlock the flow endpoint for subsequent use.

Definition at line 3901 of file AVStreams_i.cpp.

References lock_.

03902 {
03903   this->lock_ = 0;
03904 }

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

Definition at line 3952 of file AVStreams_i.cpp.

References CORBA::Exception::_tao_print_exception().

03954 {
03955   try
03956     {
03957       // Define the property called FlowProtocol
03958       CORBA::Any flowname_property;
03959       flowname_property <<= fp_name;
03960       this->define_property ("FlowProtocol",
03961                              flowname_property);
03962     }
03963   catch (const CORBA::Exception& ex)
03964     {
03965       ex._tao_print_exception (
03966         "TAO_FlowEndPoint::use_flow_protocol");
03967       return 0;
03968     }
03969   return 1;
03970 }

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 TAO_FlowProducer::connect_mcast(), connect_to_peer_i(), destroy(), go_to_listen_i(), TAO_FlowConsumer::start(), TAO_FlowProducer::start(), TAO_FlowConsumer::stop(), and TAO_FlowProducer::stop().

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 TAO_FlowProducer::connect_mcast(), 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.

Referenced by lock(), and unlock().

AVStreams::MCastConfigIf_var TAO_FlowEndPoint::mcast_peer_ [protected]

The multicast peer endpoint.

Definition at line 1016 of file AVStreams_i.h.

Referenced by set_Mcast_peer().

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.

Referenced by TAO_FlowProducer::connect_mcast(), and set_protocol_restriction().

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 Tue Feb 2 17:48:09 2010 for TAO_AV by  doxygen 1.4.7