1 // Copyright (c) 2004-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 // Default constructor

    15 // 

    16 //

    17 

    18 inline RRtpSession::RRtpSession()

    19 		: iPtr(NULL)

    20 	{

    21 	}

    22 

    23 

    24 

    25 

    26 /**

    27 Tests whether the RTP session represented by this handle is open.

    28 

    29 @return ETrue, if the session is open, false otherwise. 

    30 */

    31 inline TBool RRtpSession::IsOpen() const

    32 	{

    33 	return (iPtr != NULL);

    34 	}

    35 

    36 

    37 

    38 

    39 /**

    40 Tests whether this session handle represents the same session as

    41 the one represented by the specified handle.

    42 

    43 @param aThat The handle of the session to be compared.

    44 

    45 @return ETrue, if the represented sessions are the same, false otherwise.

    46 */

    47 inline TBool RRtpSession::operator == (RRtpSession aThat) const 

    48 	{ 

    49 	return aThat.iPtr == iPtr;

    50 	}

    51 

    52 

    53 

    54 

    55 /**

    56 Tests whether this session handle represents a different session to the one

    57 represented by the specified handle.

    58 

    59 @param aThat The handle of the session to be compared.

    60 

    61 @return ETrue, if the represented sessions are different, false otherwise.

    62 */

    63 inline TBool RRtpSession::operator != (RRtpSession aThat) const 

    64 	{

    65 	return !(aThat == *this);

    66 	}

    67 

    68 

    69 

    70 

    71 /**

    72 Default constructor

    73 */

    74 inline RRtpSendSource::RRtpSendSource()

    75 		: iPtr(NULL)

    76 	{

    77 	}

    78 

    79 

    80 

    81 /**

    82 Tests whether the send stream represented by this handle is open.

    83 

    84 @return ETrue, if the send stream is open, false otherwise. 

    85 */

    86 inline TBool RRtpSendSource::IsOpen() const

    87 	{

    88 	return (iPtr != NULL);

    89 	}

    90 

    91 

    92 

    93 

    94 /**

    95 Tests whether this send stream handle represents the same send stream as

    96 the one represented by the specified handle.

    97 

    98 @param aThat The handle of the send stream to be compared.

    99 

   100 @return ETrue, if the represented send streams are the same, false otherwise.

   101 */

   102 inline TBool RRtpSendSource::operator == (RRtpSendSource aThat) const 

   103 	{ 

   104 	return aThat.iPtr == iPtr;

   105 	}

   106 

   107 

   108 

   109 

   110 /**

   111 Tests whether this send stream handle represents a different send stream to the one

   112 represented by the specified handle.

   113 

   114 @param aThat The handle of the send stream to be compared.

   115 

   116 @return ETrue, if the represented send streams are different, false otherwise.

   117 */

   118 inline TBool RRtpSendSource::operator != (RRtpSendSource aThat) const 

   119 	{

   120 	return !(aThat == *this);

   121 	}

   122 

   123 

   124 /**

   125 Default constructor

   126 */

   127 inline RRtpReceiveSource::RRtpReceiveSource()

   128 		: iPtr(NULL)

   129 	{

   130 	}

   131 

   132 

   133 

   134 

   135 /**

   136 Tests whether the receive stream represented by this handle is open.

   137 

   138 @return ETrue, if the receive stream is open, false otherwise. 

   139 */

   140 inline TBool RRtpReceiveSource::IsOpen() const

   141 	{

   142 	return (iPtr != NULL);

   143 	}

   144 

   145 

   146 

   147 

   148 /**

   149 Tests whether this receive stream handle represents the same receive stream as

   150 the one represented by the specified handle.

   151 

   152 @param aThat The handle of the receive stream to be compared.

   153 

   154 @return ETrue, if the represented receive streams are the same, false otherwise.

   155 */

   156 inline TBool RRtpReceiveSource::operator == (RRtpReceiveSource aThat) const 

   157 	{ 

   158 	return aThat.iPtr == iPtr;

   159 	}

   160 

   161 

   162 

   163 

   164 /**

   165 Tests whether this receive stream handle represents a different receive stream to the one

   166 represented by the specified handle.

   167 

   168 @param aThat The handle of the receive stream to be compared.

   169 

   170 @return ETrue, if the represented receive streams are different, false otherwise.

   171 */

   172 inline TBool RRtpReceiveSource::operator != (RRtpReceiveSource aThat) const 

   173 	{

   174 	return !(aThat == *this);

   175 	}

   176 

   177 

   178 /**

   179 Default constructor.

   180 */

   181 inline RRtpPacket::RRtpPacket()

   182 		: iPtr(NULL)

   183 	{

   184 	}

   185 

   186 

   187 

   188 

   189 /**

   190 Tests whether this packet object is open.

   191 

   192 @return ETrue, if the packet is open, false otherwise.

   193 */

   194 inline TBool RRtpPacket::IsOpen() const

   195 	{

   196 	return (iPtr != NULL);

   197 	}

   198 

   199 

   200 

   201 

   202 /**

   203 Tests whether this packet handle represents the same packet as

   204 the one represented by the specified handle.

   205 

   206 @param aThat The handle of the packet to be compared.

   207 

   208 @return ETrue, if the represented packets are the same, false otherwise.

   209 */

   210 inline TBool RRtpPacket::operator == (RRtpPacket aThat) const 

   211 	{ 

   212 	return aThat.iPtr == iPtr;

   213 	}

   214 

   215 

   216 

   217 

   218 /**

   219 Tests whether this packet handle represents a different packet to the one

   220 represented by the specified handle.

   221 

   222 @param aThat The handle of the packet to be compared.

   223 

   224 @return ETrue, if the represented packets are different, false otherwise.

   225 */

   226 inline TBool RRtpPacket::operator != (RRtpPacket aThat) const 

   227 	{

   228 	return !(aThat == *this);

   229 	}

   230 

   231 /**

   232 Gets the type of this event.

   233     

   234 @return The event type.

   235 */

   236 inline TRtpEventType TRtpEvent::Type() const 

   237 	{ 

   238 	return iType;

   239 	}

   240 	

   241 /**	

   242 Gets the event status.

   243 	

   244 The meaning of this depends on the event type.

   245 	

   246 @see TRtpEventType

   247 */

   248 inline TInt TRtpEvent::Status() const 

   249 	{ 

   250 	return iStatus;

   251 	}

   252