qtms/src/qtmsstreamimpl.cpp
changeset 51 e61a04404bdf
parent 32 edd273b3192a
equal deleted inserted replaced
44:d141fc1ad77b 51:e61a04404bdf
    23 
    23 
    24 using namespace QTMS;
    24 using namespace QTMS;
    25 using namespace TMS;
    25 using namespace TMS;
    26 
    26 
    27 QTMSStreamImpl::QTMSStreamImpl()
    27 QTMSStreamImpl::QTMSStreamImpl()
    28     {
    28 {
       
    29 }
       
    30 
       
    31 QTMSStreamImpl::~QTMSStreamImpl()
       
    32 {
       
    33     RemoveObserver(*this);
       
    34 }
       
    35 
       
    36 gint QTMSStreamImpl::Create(QTMSCallType callType, QTMSStreamType stype, QTMSStream*& qstrm,
       
    37     TMS::TMSStream*& tmsstrm)
       
    38 {
       
    39     gint ret(QTMS_RESULT_INSUFFICIENT_MEMORY);
       
    40     QTMSStreamImpl* self = new QTMSStreamImpl();
       
    41     if (self) {
       
    42         ret = self->PostConstruct(callType, stype, *self);
       
    43         if (ret != QTMS_RESULT_SUCCESS) {
       
    44             delete self;
       
    45             self = NULL;
       
    46         }
       
    47         self->iStream = tmsstrm;
       
    48         self->AddObserver(*self, NULL);
       
    49     }
       
    50     qstrm = self;
       
    51     return ret;
       
    52 }
       
    53 
       
    54 gint QTMSStreamImpl::PostConstruct(QTMSCallType /*callType*/, QTMSStreamType /*stype*/, QTMSStream& /*parent*/)
       
    55 {
       
    56     gint status(QTMS_RESULT_SUCCESS);
       
    57     return status;
       
    58 }
       
    59 
       
    60 gint QTMSStreamImpl::AddObserver(TMS::TMSStreamObserver& obsrvr, gpointer user_data)
       
    61 {
       
    62     gint ret(QTMS_RESULT_SUCCESS);
       
    63 
       
    64     if (iStream) {
       
    65         iStream->AddObserver(obsrvr, user_data);
    29     }
    66     }
    30 
    67 
    31 QTMSStreamImpl::~QTMSStreamImpl()
    68     return ret;
    32     {
    69 }
    33     RemoveObserver(*this);
    70 
       
    71 gint QTMSStreamImpl::RemoveObserver(TMS::TMSStreamObserver& obsrvr)
       
    72 {
       
    73     gint ret(QTMS_RESULT_SUCCESS);
       
    74 
       
    75     if (iStream) {
       
    76         ret = iStream->RemoveObserver(obsrvr);
    34     }
    77     }
    35 
    78 
    36 gint QTMSStreamImpl::Create(QTMSCallType callType, QTMSStreamType stype,
       
    37         QTMSStream*& qstrm, TMS::TMSStream*& tmsstrm)
       
    38     {
       
    39     gint ret(QTMS_RESULT_INSUFFICIENT_MEMORY);
       
    40     QTMSStreamImpl* self = new QTMSStreamImpl();
       
    41     if (self)
       
    42         {
       
    43         ret = self->PostConstruct(callType, stype, *self);
       
    44         if (ret != QTMS_RESULT_SUCCESS)
       
    45             {
       
    46             delete self;
       
    47             self = NULL;
       
    48             }
       
    49         self->iStream = tmsstrm;
       
    50         self->AddObserver(*self, NULL);
       
    51         }
       
    52     qstrm = self;
       
    53     return ret;
    79     return ret;
    54     }
    80 }
    55 
    81 
    56 gint QTMSStreamImpl::PostConstruct(QTMSCallType /*callType*/,
    82 void QTMSStreamImpl::TMSStreamEvent(const TMS::TMSStream& /*stream*/, TMS::TMSSignalEvent event)
    57         QTMSStreamType /*stype*/, QTMSStream& /*parent*/)
    83 {
    58     {
       
    59     gint status(QTMS_RESULT_SUCCESS);
       
    60     return status;
       
    61     }
       
    62 
       
    63 gint QTMSStreamImpl::AddObserver(TMS::TMSStreamObserver& obsrvr,
       
    64         gpointer user_data)
       
    65     {
       
    66     gint ret(QTMS_RESULT_SUCCESS);
       
    67 
       
    68     if (iStream)
       
    69         {
       
    70         iStream->AddObserver(obsrvr, user_data);
       
    71         }
       
    72 
       
    73     return ret;
       
    74     }
       
    75 
       
    76 gint QTMSStreamImpl::RemoveObserver(TMS::TMSStreamObserver& obsrvr)
       
    77     {
       
    78     gint ret(QTMS_RESULT_SUCCESS);
       
    79 
       
    80     if (iStream)
       
    81         {
       
    82         ret = iStream->RemoveObserver(obsrvr);
       
    83         }
       
    84 
       
    85     return ret;
       
    86     }
       
    87 
       
    88 void QTMSStreamImpl::TMSStreamEvent(const TMS::TMSStream& /*stream*/,
       
    89         TMS::TMSSignalEvent event)
       
    90     {
       
    91     QTMSSignalEvent qevent;
    84     QTMSSignalEvent qevent;
    92 
    85 
    93     qevent.type = event.type;
    86     qevent.type = event.type;
    94     qevent.reason = event.reason;
    87     qevent.reason = event.reason;
    95     qevent.curr_state = event.curr_state;
    88     qevent.curr_state = event.curr_state;
    96     qevent.prev_state = event.prev_state;
    89     qevent.prev_state = event.prev_state;
    97     qevent.event_data = event.event_data;
    90     qevent.event_data = event.event_data;
    98     qevent.user_data = event.user_data;
    91     qevent.user_data = event.user_data;
    99 
    92 
   100     emit QTMS::QTMSStream::TMSStreamEvent(static_cast<QTMSStream&> (*this),
    93     emit QTMS::QTMSStream::TMSStreamEvent(static_cast<QTMSStream&> (*this), qevent);
   101             qevent);
    94 }
   102     }