← Back to branch summary

~ubuntu-branches/ubuntu/oneiric/kdepim/oneiric-updates

« back to all changes in this revision

Viewing changes to mimelib/disptype.cpp

  • Committer: Package Import Robot
  • Author(s): Philip Muškovac
  • Date: 2011-06-28 19:33:24 UTC
  • mfrom: (0.2.13) (0.1.13 sid)
  • Revision ID: package-import@ubuntu.com-20110628193324-8yvjs8sdv9rdoo6c
Tags: 4:4.7.0-0ubuntu1
* New upstream release
  - update install files
  - add missing kdepim-doc package to control file
  - Fix Vcs lines
  - kontact breaks/replaces korganizer << 4:4.6.80
  - tighten the dependency of kdepim-dev on libkdepim4 to fix lintian error

Show diffs side-by-side

added added

removed removed

Lines of Context:
mimelib/disptype.cpp
1
 
//=============================================================================
2
 
// File:       disptype.cpp
3
 
// Contents:   Definitions for DwDispositionType
4
 
// Maintainer: Doug Sauder <dwsauder@fwb.gulf.net>
5
 
// WWW:        http://www.fwb.gulf.net/~dwsauder/mimepp.html
6
 
//
7
 
// Copyright (c) 1996, 1997 Douglas W. Sauder
8
 
// All rights reserved.
9
 
//
10
 
// IN NO EVENT SHALL DOUGLAS W. SAUDER BE LIABLE TO ANY PARTY FOR DIRECT,
11
 
// INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT OF
12
 
// THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF DOUGLAS W. SAUDER
13
 
// HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
14
 
//
15
 
// DOUGLAS W. SAUDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, BUT
16
 
// NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
17
 
// PARTICULAR PURPOSE.  THE SOFTWARE PROVIDED HEREUNDER IS ON AN "AS IS"
18
 
// BASIS, AND DOUGLAS W. SAUDER HAS NO OBLIGATION TO PROVIDE MAINTENANCE,
19
 
// SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
20
 
//
21
 
//=============================================================================
22
 
 
23
 
#define DW_IMPLEMENTATION
24
 
 
25
 
#include <mimelib/config.h>
26
 
#include <mimelib/debug.h>
27
 
#include <mimelib/string.h>
28
 
#include <mimelib/param.h>
29
 
#include <mimelib/disptype.h>
30
 
#include <mimelib/token.h>
31
 
#include <mimelib/enum.h>
32
 
 
33
 
 
34
 
const char* const DwDispositionType::sClassName = "DwDispositionType";
35
 
 
36
 
 
37
 
DwDispositionType* (*DwDispositionType::sNewDispositionType)(
38
 
    const DwString&, DwMessageComponent*) = 0;
39
 
 
40
 
 
41
 
DwDispositionType* DwDispositionType::NewDispositionType(
42
 
    const DwString& aStr, DwMessageComponent* aParent)
43
 
{
44
 
    if (sNewDispositionType) {
45
 
        return sNewDispositionType(aStr, aParent);
46
 
    }
47
 
    else {
48
 
        return new DwDispositionType(aStr, aParent);
49
 
    }
50
 
}
51
 
 
52
 
 
53
 
DwDispositionType::DwDispositionType()
54
 
{
55
 
    mDispositionType = DwMime::kDispTypeNull;
56
 
    mFirstParameter = 0;
57
 
    mClassId = kCidDispositionType;
58
 
    mClassName = sClassName;
59
 
}
60
 
 
61
 
 
62
 
DwDispositionType::DwDispositionType(const DwDispositionType& aDispType)
63
 
  : DwFieldBody(aDispType),
64
 
    mDispositionTypeStr(aDispType.mDispositionTypeStr),
65
 
    mFilenameStr(aDispType.mFilenameStr)
66
 
{
67
 
    mFirstParameter = 0;
68
 
    mDispositionType = aDispType.mDispositionType;
69
 
    if (aDispType.mFirstParameter) {
70
 
        CopyParameterList(aDispType.mFirstParameter);
71
 
    }
72
 
    mClassId = kCidDispositionType;
73
 
    mClassName = sClassName;
74
 
}
75
 
 
76
 
 
77
 
DwDispositionType::DwDispositionType(const DwString& aStr,
78
 
    DwMessageComponent* aParent)
79
 
  : DwFieldBody(aStr, aParent)
80
 
{
81
 
    mDispositionType = DwMime::kDispTypeNull;
82
 
    mFirstParameter = 0;
83
 
    mClassId = kCidDispositionType;
84
 
    mClassName = sClassName;
85
 
}
86
 
 
87
 
 
88
 
DwDispositionType::~DwDispositionType()
89
 
{
90
 
    if (mFirstParameter) {
91
 
        DeleteParameterList();
92
 
    }
93
 
}
94
 
 
95
 
 
96
 
const DwDispositionType& DwDispositionType::operator = (
97
 
    const DwDispositionType& aDispType)
98
 
{
99
 
    if (this == &aDispType) return *this;
100
 
    mDispositionType    = aDispType.mDispositionType;
101
 
    mDispositionTypeStr = aDispType.mDispositionTypeStr;
102
 
    mFilenameStr        = aDispType.mFilenameStr;
103
 
 
104
 
    if (mFirstParameter) {
105
 
        DeleteParameterList();
106
 
    }
107
 
    if (aDispType.mFirstParameter) {
108
 
        CopyParameterList(aDispType.mFirstParameter);
109
 
    }
110
 
 
111
 
    if (mParent) {
112
 
        mParent->SetModified();
113
 
    }
114
 
 
115
 
    return *this;
116
 
}
117
 
 
118
 
 
119
 
int DwDispositionType::DispositionType() const
120
 
{
121
 
    return mDispositionType;
122
 
}
123
 
 
124
 
 
125
 
void DwDispositionType::SetDispositionType(int aType)
126
 
{
127
 
    mDispositionType = aType;
128
 
    EnumToStr();
129
 
    SetModified();
130
 
}
131
 
 
132
 
 
133
 
const DwString& DwDispositionType::DispositionTypeStr() const
134
 
{
135
 
    return mDispositionTypeStr;
136
 
}
137
 
 
138
 
 
139
 
void DwDispositionType::SetDispositionTypeStr(const DwString& aStr)
140
 
{
141
 
    mDispositionTypeStr = aStr;
142
 
    StrToEnum();
143
 
    SetModified();
144
 
}
145
 
 
146
 
 
147
 
const DwString& DwDispositionType::Filename() const
148
 
{
149
 
    DwParameter* param = mFirstParameter;
150
 
    while (param) {
151
 
        if (DwStrcasecmp(param->Attribute(), "filename") == 0) {
152
 
            // Filename parameter found. Return its value.
153
 
            // Implementation note: this member function is const, which
154
 
            // forbids us from assigning to mFilenameStr.  The following
155
 
            // trick gets around this.  (ANSI implementations could use the
156
 
            // "mutable" declaration).
157
 
            DwDispositionType* _this = (DwDispositionType*) this;
158
 
            _this->mFilenameStr = param->Value();
159
 
            break;
160
 
        }
161
 
        param = param->Next();
162
 
    }
163
 
    return mFilenameStr;
164
 
}
165
 
 
166
 
 
167
 
void DwDispositionType::SetFilename(const DwString& aStr)
168
 
{
169
 
    mFilenameStr = aStr;
170
 
    // Search for filename parameter in parameter list.  If found, set its
171
 
    // value.
172
 
    DwParameter* param = mFirstParameter;
173
 
    while (param) {
174
 
        if (DwStrcasecmp(param->Attribute(), "filename") == 0) {
175
 
            param->SetValue(mFilenameStr);
176
 
            return;
177
 
        }
178
 
        param = param->Next();
179
 
    }
180
 
    // Boundary parameter not found. Add it.
181
 
    param = DwParameter::NewParameter("", 0);
182
 
    param->SetAttribute("Filename");
183
 
    param->SetValue(aStr);
184
 
    AddParameter(param);
185
 
}
186
 
 
187
 
 
188
 
DwParameter* DwDispositionType::FirstParameter() const
189
 
{
190
 
    return mFirstParameter;
191
 
}
192
 
 
193
 
 
194
 
void DwDispositionType::AddParameter(DwParameter* aParam)
195
 
{
196
 
    _AddParameter(aParam);
197
 
    SetModified();
198
 
}
199
 
 
200
 
 
201
 
void DwDispositionType::_AddParameter(DwParameter* aParam)
202
 
{
203
 
    if (!mFirstParameter) {
204
 
        mFirstParameter = aParam;
205
 
    }
206
 
    else {
207
 
        DwParameter* cur = mFirstParameter;
208
 
        if( cur ) {
209
 
            DwParameter* next = cur->Next();
210
 
            while (next) {
211
 
                cur = next;
212
 
                next = cur->Next();
213
 
            }
214
 
            cur->SetNext(aParam);
215
 
        }
216
 
    }
217
 
    aParam->SetParent(this);
218
 
}
219
 
 
220
 
 
221
 
void DwDispositionType::Parse()
222
 
{
223
 
    mIsModified = 0;
224
 
    mDispositionType = DwMime::kDispTypeNull;
225
 
    mDispositionTypeStr = "";
226
 
    if (mFirstParameter) {
227
 
        DeleteParameterList();
228
 
    }
229
 
    if (mString.length() == 0) return;
230
 
    DwRfc1521Tokenizer tokenizer(mString);
231
 
    int found = 0;
232
 
    while (!found && tokenizer.Type() != eTkNull) {
233
 
        if (tokenizer.Type() == eTkToken) {
234
 
            mDispositionTypeStr = tokenizer.Token();
235
 
            found = 1;
236
 
        }
237
 
        ++tokenizer;
238
 
    }
239
 
    // Get parameters
240
 
    DwTokenString tokenStr(mString);
241
 
    while (1) {
242
 
        // Get ';'
243
 
        found = 0;
244
 
        while (!found && tokenizer.Type() != eTkNull) {
245
 
            if (tokenizer.Type() == eTkTspecial
246
 
                && tokenizer.Token()[0] == ';') {
247
 
                found = 1;
248
 
            }
249
 
            ++tokenizer;
250
 
        }
251
 
        if (tokenizer.Type() == eTkNull) {
252
 
            // No more parameters
253
 
            break;
254
 
        }
255
 
        tokenStr.SetFirst(tokenizer);
256
 
        // Get attribute
257
 
        DwString attrib;
258
 
        int attribFound = 0;
259
 
        while (!attribFound && tokenizer.Type() != eTkNull) {
260
 
            if (tokenizer.Type() == eTkToken) {
261
 
                attrib = tokenizer.Token();
262
 
                attribFound = 1;
263
 
            }
264
 
            ++tokenizer;
265
 
        }
266
 
        // Get '='
267
 
        found = 0;
268
 
        while (!found && tokenizer.Type() != eTkNull) {
269
 
            if (tokenizer.Type() == eTkTspecial
270
 
                && tokenizer.Token()[0] == '=') {
271
 
                found = 1;
272
 
            }
273
 
            ++tokenizer;
274
 
        }
275
 
        // Get value
276
 
        int valueFound = 0;
277
 
        while (!valueFound && tokenizer.Type() != eTkNull) {
278
 
            if (tokenizer.Type() == eTkToken
279
 
                || tokenizer.Type() == eTkQuotedString) {
280
 
                valueFound = 1;
281
 
            }
282
 
            ++tokenizer;
283
 
        }
284
 
        if (attribFound && valueFound) {
285
 
            tokenStr.ExtendTo(tokenizer);
286
 
            DwParameter* param =
287
 
                DwParameter::NewParameter(tokenStr.Tokens(), this);
288
 
            param->Parse();
289
 
            _AddParameter(param);
290
 
        }
291
 
    }
292
 
    StrToEnum();
293
 
}
294
 
 
295
 
 
296
 
void DwDispositionType::Assemble()
297
 
{
298
 
    if (!mIsModified) return;
299
 
    mString = "";
300
 
    if (mDispositionTypeStr.length() == 0)
301
 
        return;
302
 
    mString += mDispositionTypeStr;
303
 
    DwParameter* param = FirstParameter();
304
 
    while (param) {
305
 
        param->Assemble();
306
 
        if (IsFolding()) {
307
 
            mString += ";" DW_EOL "  ";
308
 
        }
309
 
        else {
310
 
            mString += "; ";
311
 
        }
312
 
        mString += param->AsString();
313
 
        param = param->Next();
314
 
    }
315
 
    mIsModified = 0;
316
 
}
317
 
 
318
 
 
319
 
DwMessageComponent* DwDispositionType::Clone() const
320
 
{
321
 
    return new DwDispositionType(*this);
322
 
}
323
 
 
324
 
 
325
 
void DwDispositionType::EnumToStr()
326
 
{
327
 
    switch (mDispositionType) {
328
 
    case DwMime::kDispTypeInline:
329
 
        mDispositionTypeStr = "inline";
330
 
        break;
331
 
    case DwMime::kDispTypeAttachment:
332
 
        mDispositionTypeStr = "attachment";
333
 
        break;
334
 
    }
335
 
}
336
 
 
337
 
 
338
 
void DwDispositionType::StrToEnum()
339
 
{
340
 
    switch (mDispositionTypeStr[0]) {
341
 
    case 'i':
342
 
        if (DwStrcasecmp(mDispositionTypeStr, "inline") == 0) {
343
 
            mDispositionType = DwMime::kDispTypeInline;
344
 
        }
345
 
        else {
346
 
            mDispositionType = DwMime::kDispTypeUnknown;
347
 
        }
348
 
        break;
349
 
    case 'a':
350
 
        if (DwStrcasecmp(mDispositionTypeStr, "attachment") == 0) {
351
 
            mDispositionType = DwMime::kDispTypeAttachment;
352
 
        }
353
 
        else {
354
 
            mDispositionType = DwMime::kDispTypeUnknown;
355
 
        }
356
 
        break;
357
 
    }
358
 
}
359
 
 
360
 
 
361
 
void DwDispositionType::DeleteParameterList()
362
 
{
363
 
    DwParameter* param = mFirstParameter;
364
 
    while (param) {
365
 
        DwParameter* nextParam = param->Next();
366
 
        delete param;
367
 
        param = nextParam;
368
 
    }
369
 
    mFirstParameter = 0;
370
 
    SetModified();
371
 
}
372
 
 
373
 
 
374
 
void DwDispositionType::CopyParameterList(DwParameter* aFirst)
375
 
{
376
 
    DwParameter* param = aFirst;
377
 
    while (param) {
378
 
        DwParameter* newParam = (DwParameter*) param->Clone();
379
 
        AddParameter(newParam);
380
 
        param = param->Next();
381
 
    }
382
 
}
383
 
 
384
 
 
385
 
#if defined(DW_DEBUG_VERSION)
386
 
void DwDispositionType::PrintDebugInfo(std::ostream& aStrm, int aDepth) const
387
 
{
388
 
    aStrm <<
389
 
    "------------ Debug info for DwDispositionType class ------------\n";
390
 
    _PrintDebugInfo(aStrm);
391
 
    int depth = aDepth - 1;
392
 
    depth = (depth >= 0) ? depth : 0;
393
 
    if (aDepth == 0 || depth > 0) {
394
 
        DwParameter* param = mFirstParameter;
395
 
        while (param) {
396
 
            param->PrintDebugInfo(aStrm, depth);
397
 
            param = param->Next();
398
 
        }
399
 
    }
400
 
}
401
 
#else
402
 
void DwDispositionType::PrintDebugInfo(std::ostream&, int) const {}
403
 
#endif // defined(DW_DEBUG_VERSION)
404
 
 
405
 
 
406
 
#if defined(DW_DEBUG_VERSION)
407
 
void DwDispositionType::_PrintDebugInfo(std::ostream& aStrm) const
408
 
{
409
 
    DwFieldBody::_PrintDebugInfo(aStrm);
410
 
    aStrm << "Disposition Type: " << mDispositionTypeStr
411
 
        << " (" << mDispositionType    << ")\n";
412
 
    aStrm << "Filename:         " << mFilenameStr << "\n";
413
 
    aStrm << "Parameters:       ";
414
 
    DwParameter* param = mFirstParameter;
415
 
    if (param) {
416
 
        int count = 0;
417
 
        while (param) {
418
 
            if (count) aStrm << ' ';
419
 
            aStrm << param->ObjectId();
420
 
            param = param->Next();
421
 
            ++count;
422
 
        }
423
 
        aStrm << '\n';
424
 
    }
425
 
    else {
426
 
        aStrm << "(none)\n";
427
 
    }
428
 
}
429
 
#else
430
 
void DwDispositionType::_PrintDebugInfo(std::ostream& ) const {}
431
 
#endif // defined(DW_DEBUG_VERSION)
432
 
 
433
 
 
434
 
void DwDispositionType::CheckInvariants() const
435
 
{
436
 
#if defined(DW_DEBUG_VERSION)
437
 
    mDispositionTypeStr.CheckInvariants();
438
 
    mFilenameStr.CheckInvariants();
439
 
    DwParameter* param = mFirstParameter;
440
 
    while (param) {
441
 
        param->CheckInvariants();
442
 
        assert((DwMessageComponent*) this == param->Parent());
443
 
        param = param->Next();
444
 
    }
445
 
#endif // defined(DW_DEBUG_VERSION)
446
 
}