|
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 // Name : CSIPAcceptContactHeader.cpp |
|
15 // Part of : SIP Codec |
|
16 // Version : SIP/4.0 |
|
17 // |
|
18 |
|
19 |
|
20 |
|
21 |
|
22 #include "sipacceptcontactheader.h" |
|
23 #include "CSIPAcceptContactHeaderParams.h" |
|
24 #include "SIPSyntaxCheck.h" |
|
25 #include "CSIPTokenizer.h" |
|
26 #include "sipcodecerr.h" |
|
27 #include "sipstrings.h" |
|
28 #include "sipstrconsts.h" |
|
29 #include "sipcodecutils.h" |
|
30 #include "_sipcodecdefs.h" |
|
31 |
|
32 const TInt KAsterisk(42); |
|
33 |
|
34 // ---------------------------------------------------------------------------- |
|
35 // CSIPAcceptContactHeader::DecodeL |
|
36 // ---------------------------------------------------------------------------- |
|
37 // |
|
38 EXPORT_C RPointerArray<CSIPAcceptContactHeader> |
|
39 CSIPAcceptContactHeader::DecodeL(const TDesC8& aValue) |
|
40 { |
|
41 RPointerArray<CSIPHeaderBase> baseheaders = BaseDecodeL(aValue); |
|
42 CSIPHeaderBase::PushLC(&baseheaders); |
|
43 RPointerArray<CSIPAcceptContactHeader> acceptHeaders; |
|
44 CleanupClosePushL(acceptHeaders); |
|
45 TInt count = baseheaders.Count(); |
|
46 for (TInt i=0; i < count; i++) |
|
47 { |
|
48 CSIPAcceptContactHeader* header = |
|
49 static_cast<CSIPAcceptContactHeader*>(baseheaders[i]); |
|
50 User::LeaveIfError (acceptHeaders.Append(header)); |
|
51 } |
|
52 CleanupStack::Pop(); // acceptHeaders |
|
53 CleanupStack::Pop(); // baseheaders |
|
54 baseheaders.Close(); |
|
55 return acceptHeaders; |
|
56 } |
|
57 |
|
58 // ---------------------------------------------------------------------------- |
|
59 // CSIPAcceptContactHeader::NewL |
|
60 // ---------------------------------------------------------------------------- |
|
61 // |
|
62 EXPORT_C CSIPAcceptContactHeader* CSIPAcceptContactHeader::NewL() |
|
63 { |
|
64 CSIPAcceptContactHeader* self = CSIPAcceptContactHeader::NewLC(); |
|
65 CleanupStack::Pop(self); |
|
66 return self; |
|
67 } |
|
68 |
|
69 // ---------------------------------------------------------------------------- |
|
70 // CSIPAcceptContactHeader::NewLC |
|
71 // ---------------------------------------------------------------------------- |
|
72 // |
|
73 EXPORT_C CSIPAcceptContactHeader* CSIPAcceptContactHeader::NewLC() |
|
74 { |
|
75 CSIPAcceptContactHeader* self = new(ELeave) CSIPAcceptContactHeader; |
|
76 CleanupStack::PushL(self); |
|
77 self->ConstructL(); |
|
78 return self; |
|
79 } |
|
80 |
|
81 // ---------------------------------------------------------------------------- |
|
82 // CSIPAcceptContactHeader::CSIPAcceptContactHeader |
|
83 // ---------------------------------------------------------------------------- |
|
84 // |
|
85 CSIPAcceptContactHeader::CSIPAcceptContactHeader() |
|
86 : CSIPParameterHeaderBase(';') |
|
87 { |
|
88 } |
|
89 |
|
90 // ---------------------------------------------------------------------------- |
|
91 // CSIPAcceptContactHeader::ConstructL |
|
92 // ---------------------------------------------------------------------------- |
|
93 // |
|
94 void CSIPAcceptContactHeader::ConstructL() |
|
95 { |
|
96 iParams = new (ELeave) CSIPAcceptContactHeaderParams; |
|
97 } |
|
98 |
|
99 // ---------------------------------------------------------------------------- |
|
100 // CSIPAcceptContactHeader::ConstructL |
|
101 // ---------------------------------------------------------------------------- |
|
102 // |
|
103 void CSIPAcceptContactHeader::ConstructL( |
|
104 const CSIPAcceptContactHeader& aAcceptContactHeader) |
|
105 { |
|
106 iParams = CSIPAcceptContactHeaderParams::NewL( |
|
107 *(aAcceptContactHeader.iParams)); |
|
108 } |
|
109 |
|
110 // ---------------------------------------------------------------------------- |
|
111 // CSIPAcceptContactHeader::~CSIPAcceptContactHeader |
|
112 // ---------------------------------------------------------------------------- |
|
113 // |
|
114 EXPORT_C CSIPAcceptContactHeader::~CSIPAcceptContactHeader() |
|
115 { |
|
116 delete iParams; |
|
117 } |
|
118 |
|
119 // ---------------------------------------------------------------------------- |
|
120 // CSIPAcceptContactHeader::operator== |
|
121 // ---------------------------------------------------------------------------- |
|
122 // |
|
123 EXPORT_C TBool CSIPAcceptContactHeader::operator==( |
|
124 const CSIPAcceptContactHeader& aHeader) const |
|
125 { |
|
126 return (*iParams == *(aHeader.iParams)); |
|
127 } |
|
128 |
|
129 // ---------------------------------------------------------------------------- |
|
130 // CSIPAcceptContactHeader::InternalizeValueL |
|
131 // ---------------------------------------------------------------------------- |
|
132 // |
|
133 EXPORT_C CSIPHeaderBase* |
|
134 CSIPAcceptContactHeader::InternalizeValueL(RReadStream& aReadStream) |
|
135 { |
|
136 CSIPAcceptContactHeader* header = new (ELeave)CSIPAcceptContactHeader; |
|
137 CleanupStack::PushL(header); |
|
138 header->DoInternalizeValueL(aReadStream); |
|
139 CleanupStack::Pop(header); |
|
140 return header; |
|
141 } |
|
142 |
|
143 // ---------------------------------------------------------------------------- |
|
144 // CSIPAcceptContactHeader::CloneL |
|
145 // ---------------------------------------------------------------------------- |
|
146 // |
|
147 EXPORT_C CSIPHeaderBase* CSIPAcceptContactHeader::CloneL() const |
|
148 { |
|
149 CSIPAcceptContactHeader* header = new (ELeave)CSIPAcceptContactHeader; |
|
150 CleanupStack::PushL(header); |
|
151 header->ConstructL(*this); |
|
152 CleanupStack::Pop(header); |
|
153 return header; |
|
154 } |
|
155 |
|
156 // ---------------------------------------------------------------------------- |
|
157 // CSIPAcceptContactHeader::Name |
|
158 // ---------------------------------------------------------------------------- |
|
159 // |
|
160 EXPORT_C RStringF CSIPAcceptContactHeader::Name() const |
|
161 { |
|
162 return SIPStrings::StringF(SipStrConsts::EAcceptContactHeader); |
|
163 } |
|
164 |
|
165 // ---------------------------------------------------------------------------- |
|
166 // CSIPAcceptContactHeader::HasCompactName |
|
167 // ---------------------------------------------------------------------------- |
|
168 // |
|
169 TBool CSIPAcceptContactHeader::HasCompactName() const |
|
170 { |
|
171 return ETrue; |
|
172 } |
|
173 |
|
174 // ---------------------------------------------------------------------------- |
|
175 // CSIPAcceptContactHeader::CompactName |
|
176 // ---------------------------------------------------------------------------- |
|
177 // |
|
178 RStringF CSIPAcceptContactHeader::CompactName() const |
|
179 { |
|
180 return SIPStrings::StringF(SipStrConsts::EAcceptContactHeaderCompact); |
|
181 } |
|
182 |
|
183 // ---------------------------------------------------------------------------- |
|
184 // CSIPAcceptContactHeader::MoreThanOneAllowed |
|
185 // ---------------------------------------------------------------------------- |
|
186 // |
|
187 TBool CSIPAcceptContactHeader::MoreThanOneAllowed() const |
|
188 { |
|
189 return ETrue; |
|
190 } |
|
191 |
|
192 // ---------------------------------------------------------------------------- |
|
193 // CSIPAcceptContactHeader::PreferredPlaceInMessage |
|
194 // ---------------------------------------------------------------------------- |
|
195 // |
|
196 CSIPHeaderBase::TPreferredPlace |
|
197 CSIPAcceptContactHeader::PreferredPlaceInMessage() const |
|
198 { |
|
199 return CSIPHeaderBase::EMiddle; |
|
200 } |
|
201 |
|
202 // ---------------------------------------------------------------------------- |
|
203 // CSIPAcceptContactHeader::BaseDecodeL |
|
204 // ---------------------------------------------------------------------------- |
|
205 // |
|
206 RPointerArray<CSIPHeaderBase> |
|
207 CSIPAcceptContactHeader::BaseDecodeL(const TDesC8& aValue) |
|
208 { |
|
209 RPointerArray<CSIPHeaderBase> headers; |
|
210 CSIPHeaderBase::PushLC(&headers); |
|
211 TLex8 lex(aValue); |
|
212 lex.SkipSpace(); |
|
213 if (lex.Remainder().Length() > 0) |
|
214 { |
|
215 CSIPTokenizer* tokenizer = CSIPTokenizer::NewLC(aValue, ','); |
|
216 for (TInt i=0; i < tokenizer->Tokens().Count(); i++) |
|
217 { |
|
218 CSIPAcceptContactHeader* header = |
|
219 new(ELeave)CSIPAcceptContactHeader; |
|
220 CleanupStack::PushL(header); |
|
221 header->ConstructL(); |
|
222 header->ParseL(tokenizer->Tokens()[i]); |
|
223 User::LeaveIfError (headers.Append(header)); |
|
224 CleanupStack::Pop(header); |
|
225 } |
|
226 CleanupStack::PopAndDestroy(tokenizer); |
|
227 } |
|
228 else |
|
229 { |
|
230 User::Leave(KErrSipCodecAcceptContactHeader); |
|
231 } |
|
232 CleanupStack::Pop(); // headers |
|
233 return headers; |
|
234 } |
|
235 |
|
236 // ---------------------------------------------------------------------------- |
|
237 // CSIPAcceptContactHeader::ExternalizeValueL |
|
238 // ---------------------------------------------------------------------------- |
|
239 // |
|
240 void CSIPAcceptContactHeader::ExternalizeValueL(RWriteStream& aWriteStream) const |
|
241 { |
|
242 iParams->ExternalizeL(aWriteStream); |
|
243 } |
|
244 |
|
245 // ---------------------------------------------------------------------------- |
|
246 // CSIPAcceptContactHeader::ToTextMandatoryPartLC |
|
247 // ---------------------------------------------------------------------------- |
|
248 // |
|
249 HBufC8* CSIPAcceptContactHeader::ToTextMandatoryPartLC() const |
|
250 { |
|
251 HBufC8* mandatorypart = HBufC8::NewLC(1); |
|
252 mandatorypart->Des().Append(KAsterisk); |
|
253 return mandatorypart; |
|
254 } |
|
255 |
|
256 // ---------------------------------------------------------------------------- |
|
257 // CSIPAcceptContactHeader::ParseMandatoryPartL |
|
258 // ---------------------------------------------------------------------------- |
|
259 // |
|
260 void CSIPAcceptContactHeader::ParseMandatoryPartL(const TDesC8& aMandatoryPart) |
|
261 { |
|
262 TLex8 lex(aMandatoryPart); |
|
263 lex.SkipSpace(); |
|
264 if(lex.Get() != KAsterisk) // Should be asterisk '*' |
|
265 { |
|
266 User::Leave(KErrSipCodecAcceptContactHeader); |
|
267 } |
|
268 } |
|
269 |
|
270 // ---------------------------------------------------------------------------- |
|
271 // CSIPAcceptContactHeader::Params |
|
272 // ---------------------------------------------------------------------------- |
|
273 // |
|
274 const CSIPParamContainerBase& CSIPAcceptContactHeader::Params() const |
|
275 { |
|
276 return *iParams; |
|
277 } |
|
278 |
|
279 // ---------------------------------------------------------------------------- |
|
280 // CSIPAcceptContactHeader::Params |
|
281 // ---------------------------------------------------------------------------- |
|
282 // |
|
283 CSIPParamContainerBase& CSIPAcceptContactHeader::Params() |
|
284 { |
|
285 return *iParams; |
|
286 } |
|
287 |
|
288 // ---------------------------------------------------------------------------- |
|
289 // CSIPAcceptContactHeader::DoInternalizeValueL |
|
290 // ---------------------------------------------------------------------------- |
|
291 // |
|
292 void CSIPAcceptContactHeader::DoInternalizeValueL(RReadStream& aReadStream) |
|
293 { |
|
294 iParams = CSIPAcceptContactHeaderParams::InternalizeL(aReadStream); |
|
295 } |