Public Member Functions | Protected Member Functions | Private Attributes

ACEXML_Svcconf_Handler Class Reference

ACEXML_Svcconf_Handler is an example SAX event handler. More...

#include <Svcconf_Handler.h>

Inheritance diagram for ACEXML_Svcconf_Handler:
Inheritance graph
[legend]
Collaboration diagram for ACEXML_Svcconf_Handler:
Collaboration graph
[legend]

List of all members.

Public Member Functions

 ACEXML_Svcconf_Handler (void)
virtual ~ACEXML_Svcconf_Handler (void)
virtual void characters (const ACEXML_Char *ch, int start, int length ACEXML_ENV_ARG_DECL)
virtual void endDocument (ACEXML_ENV_SINGLE_ARG_DECL)
virtual void endElement (const ACEXML_Char *namespaceURI, const ACEXML_Char *localName, const ACEXML_Char *qName ACEXML_ENV_ARG_DECL)
virtual void endPrefixMapping (const ACEXML_Char *prefix ACEXML_ENV_ARG_DECL)
virtual void ignorableWhitespace (const ACEXML_Char *ch, int start, int length ACEXML_ENV_ARG_DECL)
virtual void processingInstruction (const ACEXML_Char *target, const ACEXML_Char *data ACEXML_ENV_ARG_DECL)
virtual void setDocumentLocator (ACEXML_Locator *locator)
virtual void skippedEntity (const ACEXML_Char *name ACEXML_ENV_ARG_DECL)
virtual void startDocument (ACEXML_ENV_SINGLE_ARG_DECL)
virtual void startElement (const ACEXML_Char *namespaceURI, const ACEXML_Char *localName, const ACEXML_Char *qName, ACEXML_Attributes *atts ACEXML_ENV_ARG_DECL)
virtual void startPrefixMapping (const ACEXML_Char *prefix, const ACEXML_Char *uri ACEXML_ENV_ARG_DECL)
virtual void notationDecl (const ACEXML_Char *name, const ACEXML_Char *publicId, const ACEXML_Char *systemId ACEXML_ENV_ARG_DECL)
virtual void unparsedEntityDecl (const ACEXML_Char *name, const ACEXML_Char *publicId, const ACEXML_Char *systemId, const ACEXML_Char *notationName ACEXML_ENV_ARG_DECL)
virtual ACEXML_InputSourceresolveEntity (const ACEXML_Char *publicId, const ACEXML_Char *systemId ACEXML_ENV_ARG_DECL)
virtual void error (ACEXML_SAXParseException &exception ACEXML_ENV_ARG_DECL)
virtual void fatalError (ACEXML_SAXParseException &exception ACEXML_ENV_ARG_DECL)
virtual void warning (ACEXML_SAXParseException &exception ACEXML_ENV_ARG_DECL)

Protected Member Functions

int get_stream_id (ACEXML_Attributes *alist ACEXML_ENV_ARG_DECL)
int get_id (ACEXML_Attributes *alist ACEXML_ENV_ARG_DECL)
int get_dynamic_attrs (ACEXML_Attributes *alist ACEXML_ENV_ARG_DECL)
int get_initializer_attrs (ACEXML_Attributes *alist ACEXML_ENV_ARG_DECL)
int get_static_attrs (ACEXML_Attributes *alist ACEXML_ENV_ARG_DECL)

Private Attributes

int in_stream_def_
 We are parsing a stream definition.
int in_module_
 We are defining a steam module.
ACE_Service_Typestream_svc_type_
 stream_ holds the actually Stream_Type object managed by stream_svc_type_.
ACE_Stream_Typestream_
ACE_Parsed_Info parsed_info_
ACE_Parsed_Info stream_info_
ACEXML_Locatorlocator_

Detailed Description

ACEXML_Svcconf_Handler is an example SAX event handler.

This SAX event handler try to regenerate the XML document it reads with correct indentation.

Definition at line 85 of file Svcconf_Handler.h.


Constructor & Destructor Documentation

ACEXML_Svcconf_Handler::ACEXML_Svcconf_Handler ( void   ) 

Definition at line 22 of file Svcconf_Handler.cpp.

  : in_stream_def_ (0),
    in_module_ (0),
    stream_svc_type_ (0),
    stream_ (0)
{
  // no-op
}

ACEXML_Svcconf_Handler::~ACEXML_Svcconf_Handler ( void   )  [virtual]

Definition at line 31 of file Svcconf_Handler.cpp.

{
  // no-op
}


Member Function Documentation

virtual void ACEXML_Svcconf_Handler::characters ( const ACEXML_Char ch,
int  start,
int length  ACEXML_ENV_ARG_DECL 
) [virtual]
virtual void ACEXML_Svcconf_Handler::endDocument ( ACEXML_ENV_SINGLE_ARG_DECL   )  [virtual]

Reimplemented from ACEXML_DefaultHandler.

void ACEXML_Svcconf_Handler::endElement ( const ACEXML_Char namespaceURI,
const ACEXML_Char localName,
const ACEXML_Char *qName  ACEXML_ENV_ARG_DECL 
) [virtual]

Reimplemented from ACEXML_DefaultHandler.

Definition at line 51 of file Svcconf_Handler.cpp.

{
  if (ACE_OS::strcmp (qName, ACE_TEXT ("dynamic")) == 0)
    {
      ACE_Parsed_Info *active_info = (this->in_stream_def_ == 0 ?
                                      &this->parsed_info_ :
                                      &this->stream_info_);

      // We must allocate a string here to ensure that the
      // name is still available by the time the
      // ACE_Service_Type_Dynamic_Guard is destructed.
      ACE_TString name = active_info->name ();
      ACE_Service_Type_Dynamic_Guard dummy (
        *ACE_Service_Config::current ()->current_service_repository (),
        name.c_str ());
      ACE_DLL svc_dll;

      if (svc_dll.open (active_info->path ()) == -1)
        {
          // build the error message
          ACE_TString msg (ACE_TEXT ("Cannot locate DLL: '"));
          msg += ACE_TString (active_info->path ());
          msg += ACE_TString (ACE_TEXT ("' for entity '"));
          msg += ACE_TString (active_info->name ());
          msg += ACE_TString (ACE_TEXT ("'\n"));

          ACEXML_THROW (ACEXML_SAXException (msg.c_str ()));
        }

      void *(*func) (ACE_Service_Object_Exterminator *) = 0;
      ACE_Service_Object_Exterminator gobbler = 0;
      void *symbol = 0;

      long temp_ptr =
        reinterpret_cast<long> (svc_dll.symbol (active_info->init_func ()));
      func = reinterpret_cast<void *(*)(ACE_Service_Object_Exterminator *)> (temp_ptr);

      if (func == 0)
        {
          // build the error message
          ACE_TString msg (ACE_TEXT ("Cannot locate init function: '"));
          msg += ACE_TString (active_info->init_func ());
          msg += ACE_TString (ACE_TEXT ("' for entity '"));
          msg += ACE_TString (active_info->name ());
          msg += ACE_TString (ACE_TEXT ("'\n"));

          ACEXML_THROW (ACEXML_SAXException (msg.c_str ()));
        }
      symbol = (*func)(&gobbler); // target object created in the loaded DLL.

      ACE_Service_Type_Impl *stp = ACE_Service_Config::create_service_type_impl
        (active_info->name (),
         active_info->service_type (),
         symbol,
         ACE_Service_Type::DELETE_THIS |
         ACE_Service_Type::DELETE_OBJ,
         gobbler);

      if (this->in_stream_def_)
        {
//           ACE_DEBUG ((LM_INFO, ACE_TEXT ("Create dynamic %s for stream\n"),
//                       this->stream_info_.name ()));
          if (active_info->service_type () == ACE_Service_Type::STREAM)
            {
              this->stream_ = (ACE_Stream_Type *) stp;
            }
          else
            {
              // We will not retain this stream
              delete stp;

              // build the error message
              ACE_TString msg (ACE_TEXT ("Expecting Stream type in stream header"));
              msg += ACE_TString (ACE_TEXT (" for entity '"));
              msg += ACE_TString (active_info->name ());
              msg += ACE_TString (ACE_TEXT ("'\n"));

              ACEXML_THROW (ACEXML_SAXException (msg.c_str ()));
            }

          this->stream_svc_type_ =
            ACE_Service_Config::create_service_type (this->stream_info_.name (),
                                                     this->stream_,
                                                     svc_dll,
                                                     this->stream_info_.active ());

        }
      else
        {
          if (this->in_module_)
            {
              ACE_ARGV args (active_info->init_params ());

              ACE_Module_Type *mt = (ACE_Module_Type *) stp;

              ACE_Module<ACE_SYNCH> *mp = (ACE_Module<ACE_SYNCH> *) mt->object ();

              if (ACE_OS::strcmp (mp->name (), active_info->name ()) != 0)
                {
                  ACE_DEBUG ((LM_DEBUG,
                              ACE_TEXT ("warning: assigning Module_Type name %s to Module %s since names differ\n"),
                              active_info->name (),
                              mp->name ()));
                  mp->name (active_info->name ());
                }

              if (mt->init (args.argc (), args.argv ()) == -1
                  || this->stream_->push (mt) == -1)
                {
                  // build the error message
                  ACE_TString msg (ACE_TEXT ("Error initializing module"));
                  msg += ACE_TString (ACE_TEXT (" for entity '"));
                  msg += ACE_TString (active_info->name ());
                  msg += ACE_TString (ACE_TEXT ("'\n"));

                  ACEXML_THROW (ACEXML_SAXException (msg.c_str ()));
                }


//               ACE_DEBUG ((LM_INFO, ACE_TEXT ("Push dynamic %s into stream %s\n"),
//                           this->parsed_info_.name (),
//                           this->stream_info_.name ()));
            }
          else
            {
              ACE_Service_Type *stype =
                ACE_Service_Config::create_service_type (active_info->name (),
                                                         stp,
                                                         svc_dll,
                                                         active_info->active ());
              // @@ Check error here.

              //               ACE_DEBUG ((LM_INFO, ACE_TEXT ("Apply dynamic %s\n"),
//                           this->parsed_info_.name ()));
              if (ACE_Service_Config::initialize (stype,
                                                  active_info->init_params ()) == -1)
                {
                  // If it did not initialize correctly, the
                  // ACE_Service_Config doesn't own this object
                  delete stype;

                  // build the error message
                  ACE_TString msg (ACE_TEXT ("Failed to initialize dynamic service"));
                  msg += ACE_TString (ACE_TEXT (" for entity '"));
                  msg += ACE_TString (active_info->name ());
                  msg += ACE_TString (ACE_TEXT ("'\n"));

                  ACEXML_THROW (ACEXML_SAXException (msg.c_str ()));
                }
            }
          this->parsed_info_.reset ();
        }
    }
  else if (ACE_OS::strcmp (qName, ACE_TEXT ("static")) == 0)
    {
      if (this->in_stream_def_)
        {
          // @@ Couldn't make sense out of the original Svc_Conf.y.
          ACE_DEBUG ((LM_ERROR, ACE_TEXT ("Create static %s for stream\n"),
                      this->stream_info_.name ()));
        }
      else
        {
          if (this->in_module_)
            {
              // @@ Couldn't make sense out of the original Svc_Conf.y.
              ACE_DEBUG ((LM_ERROR, ACE_TEXT ("Push static %s into stream %s\n"),
                          this->parsed_info_.name (),
                          this->stream_info_.name ()));
            }
          else
            {
//               ACE_DEBUG ((LM_INFO, ACE_TEXT ("Apply static %s\n"),
//                           this->parsed_info_.name ()));
              if (ACE_Service_Config::initialize (this->parsed_info_.name (),
                                                  this->parsed_info_.init_params ()) == -1)
                {
                  // build the error message
                  ACE_TString msg (ACE_TEXT ("Failed to initialize static service"));
                  msg += ACE_TString (ACE_TEXT (" for entity '"));
                  msg += ACE_TString (this->parsed_info_.name ());
                  msg += ACE_TString (ACE_TEXT ("'\n"));

                  ACEXML_THROW (ACEXML_SAXException (msg.c_str ()));
                }
            }
          this->parsed_info_.reset ();
        }
    }
  else if (ACE_OS::strcmp (qName, ACE_TEXT ("module")) == 0)
    {
      this->in_module_ = 0;
    }
  else if (ACE_OS::strcmp (qName, ACE_TEXT ("streamdef")) == 0)
    {
//       ACE_DEBUG ((LM_INFO, ACE_TEXT ("Apply stream %s of type %s\n"),
//                   this->stream_info_.name (),
//                   this->stream_info_.name ()));
      ACE_Service_Config::initialize (this->stream_svc_type_,
                                      this->stream_info_.init_params ());

      this->stream_info_.reset ();
      this->stream_svc_type_ = 0;
      this->stream_ = 0;
    }
  else if (ACE_OS::strcmp (qName, ACE_TEXT ("stream")) == 0)
    {
//       ACE_DEBUG ((LM_INFO, ACE_TEXT ("Apply stream %s of type %s\n"),
//                   this->stream_info_.name (),
//                   this->stream_info_.name ()));
      this->stream_info_.reset ();
    }
  else
    {
    }
}

virtual void ACEXML_Svcconf_Handler::endPrefixMapping ( const ACEXML_Char *prefix  ACEXML_ENV_ARG_DECL  )  [virtual]

Reimplemented from ACEXML_DefaultHandler.

virtual void ACEXML_Svcconf_Handler::error ( ACEXML_SAXParseException &exception  ACEXML_ENV_ARG_DECL  )  [virtual]

Receive notification of a recoverable error.

Reimplemented from ACEXML_DefaultHandler.

virtual void ACEXML_Svcconf_Handler::fatalError ( ACEXML_SAXParseException &exception  ACEXML_ENV_ARG_DECL  )  [virtual]

Receive notification of a non-recoverable error.

Reimplemented from ACEXML_DefaultHandler.

int ACEXML_Svcconf_Handler::get_dynamic_attrs ( ACEXML_Attributes *alist  ACEXML_ENV_ARG_DECL  )  [protected]

Get the dynamic tag attributes.

Definition at line 618 of file Svcconf_Handler.cpp.

{
  if (alist != 0)
    {
      ACE_Parsed_Info *info = (this->in_stream_def_ == 0 ?
                               &this->parsed_info_ :
                               &this->stream_info_);
      for (size_t i = 0; i < alist->getLength (); ++i)
        {
          if (ACE_OS::strcmp (alist->getQName (i), ACE_TEXT ("id")) == 0)
            {
              info->name (alist->getValue (i));
            }
          else if (ACE_OS::strcmp (alist->getQName (i), ACE_TEXT ("status")) == 0)
            {
              if (ACE_OS::strcmp (alist->getValue (i), ACE_TEXT ("inactive")) == 0)
                {
                  info->active (0);
                }
              else if (ACE_OS::strcmp (alist->getValue (i), ACE_TEXT ("active")) == 0)
                {
                  info->active (1);
                }
              else
                {
                  // build the error message
                  ACE_TString msg (ACE_TEXT ("Invalid attribute value '"));
                  msg += ACE_TString (alist->getQName (i));
                  msg += ACE_TString (ACE_TEXT ("', expecting 'active' or 'inactive'"));
                  msg += ACE_TString (ACE_TEXT (" for entity '"));
                  msg += ACE_TString (info->name ());
                  msg += ACE_TString (ACE_TEXT ("'\n"));

                  ACEXML_THROW_RETURN (ACEXML_SAXException (msg.c_str ()),
                                       -1);
                }
            }
          else if (ACE_OS::strcmp (alist->getQName (i), ACE_TEXT ("type")) == 0)
            {
              if (ACE_OS::strcasecmp (alist->getValue (i), ACE_TEXT ("service_object")) == 0)
                {
                  info->service_type (ACE_Service_Type::SERVICE_OBJECT);
                }
              else if (ACE_OS::strcasecmp (alist->getValue (i), ACE_TEXT ("stream")) == 0)
                {
                  info->service_type (ACE_Service_Type::STREAM);
                }
              else if (ACE_OS::strcasecmp (alist->getValue (i), ACE_TEXT ("module")) == 0)
                {
                  info->service_type (ACE_Service_Type::MODULE);
                }
              else
                {
                  // build the error message
                  ACE_TString msg (ACE_TEXT ("Invalid Service_Object attribute value'"));
                  msg += ACE_TString (alist->getQName (i));
                  msg += ACE_TString (ACE_TEXT ("' for entity '"));
                  msg += ACE_TString (info->name ());
                  msg += ACE_TString (ACE_TEXT ("'\n"));

                  ACEXML_THROW_RETURN (ACEXML_SAXException (msg.c_str ()),
                                  -1);
                }
            }
          else
            {
              // build the error message
              ACE_TString msg (ACE_TEXT ("Invalid attribute'"));
              msg += ACE_TString (alist->getQName (i));
              msg += ACE_TString (ACE_TEXT ("' for entity '"));
              msg += ACE_TString (info->name ());
              msg += ACE_TString (ACE_TEXT ("'\n"));

              ACEXML_THROW_RETURN (ACEXML_SAXException (msg.c_str ()), -1);
            }
        }
    }
  return 0;
}

int ACEXML_Svcconf_Handler::get_id ( ACEXML_Attributes *alist  ACEXML_ENV_ARG_DECL  )  [protected]

Get the only attribute in <resume>, <suspend>, <remove>

Definition at line 591 of file Svcconf_Handler.cpp.

{
  if (alist != 0)
    for (size_t i = 0; i < alist->getLength (); ++i)
      {
        if (ACE_OS::strcmp (alist->getQName (i), ACE_TEXT ("id")) == 0)
          {
            this->parsed_info_.name (alist->getValue (i));
          }
        else
          {
            // build the error message
            ACE_TString msg (ACE_TEXT ("Invalid attribute '"));
            msg += ACE_TString (alist->getQName (i));
            msg += ACE_TString (ACE_TEXT ("', expecting 'id'"));
            msg += ACE_TString (ACE_TEXT (" for entity '"));
            msg += ACE_TString (this->parsed_info_.name ());
            msg += ACE_TString (ACE_TEXT ("'\n"));

            ACEXML_THROW_RETURN (ACEXML_SAXException (msg.c_str ()),
                            -1);
          }
      }
  return 0;
}

int ACEXML_Svcconf_Handler::get_initializer_attrs ( ACEXML_Attributes *alist  ACEXML_ENV_ARG_DECL  )  [protected]

Get the initializer tag attributes.

Definition at line 699 of file Svcconf_Handler.cpp.

{
  if (alist != 0)
    {
      ACE_Parsed_Info *info = (this->in_stream_def_ == 0 ?
                               &this->parsed_info_ :
                               &this->stream_info_);
      for (size_t i = 0; i < alist->getLength (); ++i)
        {
          if (ACE_OS::strcmp (alist->getQName (i), ACE_TEXT ("init")) == 0)
            {
              info->init_func (alist->getValue (i));
            }
          else if (ACE_OS::strcmp (alist->getQName (i), ACE_TEXT ("path")) == 0)
            {
              info->path (alist->getValue (i));
            }
          else if (ACE_OS::strcmp (alist->getQName (i), ACE_TEXT ("params")) == 0)
            {
              info->init_params (alist->getValue (i));
            }
          else
            {
              // build the error message
              ACE_TString msg (ACE_TEXT ("Invalid initializer attribute'"));
              msg += ACE_TString (alist->getQName (i));
              msg += ACE_TString (ACE_TEXT ("' for entity '"));
              msg += ACE_TString (info->name ());
              msg += ACE_TString (ACE_TEXT ("'\n"));

              ACEXML_THROW_RETURN (ACEXML_SAXException (msg.c_str ()), -1);
            }
        }
    }
  return 0;
}

int ACEXML_Svcconf_Handler::get_static_attrs ( ACEXML_Attributes *alist  ACEXML_ENV_ARG_DECL  )  [protected]

Get the static tag attributes.

Definition at line 737 of file Svcconf_Handler.cpp.

{
  if (alist != 0)
    {
      ACE_Parsed_Info *info = (this->in_stream_def_ == 0 ?
                               &this->parsed_info_ :
                               &this->stream_info_);
      for (size_t i = 0; i < alist->getLength (); ++i)
        {
          if (ACE_OS::strcmp (alist->getQName (i), ACE_TEXT ("id")) == 0)
            {
              info->name (alist->getValue (i));
            }
          else if (ACE_OS::strcmp (alist->getQName (i), ACE_TEXT ("params")) == 0)
            {
              info->init_params (alist->getValue (i));
            }
          else
            {
              // build the error message
              ACE_TString msg (ACE_TEXT ("Invalid static attribute '"));
              msg += ACE_TString (alist->getQName (i));
              msg += ACE_TString (ACE_TEXT ("' for entity '"));
              msg += ACE_TString (info->name ());
              msg += ACE_TString (ACE_TEXT ("'\n"));

              ACEXML_THROW_RETURN (ACEXML_SAXException (msg.c_str ()), -1);
            }
        }
    }
  return 0;
}

int ACEXML_Svcconf_Handler::get_stream_id ( ACEXML_Attributes *alist  ACEXML_ENV_ARG_DECL  )  [protected]

Get the only attribute in <stream> or <streamdef>.

Definition at line 565 of file Svcconf_Handler.cpp.

{
  if (alist != 0)
    for (size_t i = 0; i < alist->getLength (); ++i)
      {
        if (ACE_OS::strcmp (alist->getQName (i), ACE_TEXT ("id")) == 0)
          {
            this->stream_info_.name (alist->getValue (i));
          }
        else
          {
            // build the error message
            ACE_TString msg (ACE_TEXT ("Invalid stream attribute '"));
            msg += ACE_TString (alist->getQName (i));
            msg += ACE_TString (ACE_TEXT ("' for entity '"));
            msg += ACE_TString (this->stream_info_.name ());
            msg += ACE_TString (ACE_TEXT ("'\n"));

            ACEXML_THROW_RETURN (ACEXML_SAXException (msg.c_str ()),
                                 -1);
          }
      }
  return 0;
}

virtual void ACEXML_Svcconf_Handler::ignorableWhitespace ( const ACEXML_Char ch,
int  start,
int length  ACEXML_ENV_ARG_DECL 
) [virtual]

Reimplemented from ACEXML_DefaultHandler.

virtual void ACEXML_Svcconf_Handler::notationDecl ( const ACEXML_Char name,
const ACEXML_Char publicId,
const ACEXML_Char *systemId  ACEXML_ENV_ARG_DECL 
) [virtual]

Reimplemented from ACEXML_DefaultHandler.

virtual void ACEXML_Svcconf_Handler::processingInstruction ( const ACEXML_Char target,
const ACEXML_Char *data  ACEXML_ENV_ARG_DECL 
) [virtual]

Reimplemented from ACEXML_DefaultHandler.

virtual ACEXML_InputSource* ACEXML_Svcconf_Handler::resolveEntity ( const ACEXML_Char publicId,
const ACEXML_Char *systemId  ACEXML_ENV_ARG_DECL 
) [virtual]

Reimplemented from ACEXML_DefaultHandler.

void ACEXML_Svcconf_Handler::setDocumentLocator ( ACEXML_Locator locator  )  [virtual]

Reimplemented from ACEXML_DefaultHandler.

Definition at line 292 of file Svcconf_Handler.cpp.

{
  this->locator_ = locator;
}

virtual void ACEXML_Svcconf_Handler::skippedEntity ( const ACEXML_Char *name  ACEXML_ENV_ARG_DECL  )  [virtual]

Reimplemented from ACEXML_DefaultHandler.

virtual void ACEXML_Svcconf_Handler::startDocument ( ACEXML_ENV_SINGLE_ARG_DECL   )  [virtual]

Reimplemented from ACEXML_DefaultHandler.

virtual void ACEXML_Svcconf_Handler::startElement ( const ACEXML_Char namespaceURI,
const ACEXML_Char localName,
const ACEXML_Char qName,
ACEXML_Attributes *atts  ACEXML_ENV_ARG_DECL 
) [virtual]

Reimplemented from ACEXML_DefaultHandler.

virtual void ACEXML_Svcconf_Handler::startPrefixMapping ( const ACEXML_Char prefix,
const ACEXML_Char *uri  ACEXML_ENV_ARG_DECL 
) [virtual]

Reimplemented from ACEXML_DefaultHandler.

virtual void ACEXML_Svcconf_Handler::unparsedEntityDecl ( const ACEXML_Char name,
const ACEXML_Char publicId,
const ACEXML_Char systemId,
const ACEXML_Char *notationName  ACEXML_ENV_ARG_DECL 
) [virtual]

Reimplemented from ACEXML_DefaultHandler.

virtual void ACEXML_Svcconf_Handler::warning ( ACEXML_SAXParseException &exception  ACEXML_ENV_ARG_DECL  )  [virtual]

Receive notification of a warning.

Reimplemented from ACEXML_DefaultHandler.


Member Data Documentation

We are defining a steam module.

Definition at line 255 of file Svcconf_Handler.h.

We are parsing a stream definition.

Definition at line 252 of file Svcconf_Handler.h.

Definition at line 267 of file Svcconf_Handler.h.

Definition at line 263 of file Svcconf_Handler.h.

Definition at line 259 of file Svcconf_Handler.h.

Definition at line 265 of file Svcconf_Handler.h.

stream_ holds the actually Stream_Type object managed by stream_svc_type_.

Definition at line 258 of file Svcconf_Handler.h.


The documentation for this class was generated from the following files:
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines