source/global.cxx


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94


#include "global.hxx"

using ::rtl::OUString;

namespace dpsource {

SimpleSharedString::StringTable::StringTable() :
    mnStrCount(0)
{
    // empty string (ID = 0)
    maSharedStrings.push_back(OUString());
    maSharedStringIds.insert( SharedStrMap::value_type(OUString(), mnStrCount++) );
}

SimpleSharedString::StringTable::StringTable(const SimpleSharedString::StringTable& r) :
    maSharedStrings(r.maSharedStrings),
    maSharedStringIds(r.maSharedStringIds),
    mnStrCount(r.mnStrCount)
{
}

SimpleSharedString::StringTable::~StringTable()
{
}

StrID SimpleSharedString::StringTable::insertString(const OUString& aStr)
{
    SharedStrMap::const_iterator itr = maSharedStringIds.find(aStr),
        itrEnd = maSharedStringIds.end();

    if (itr == itrEnd)
    {
        // new string.
        maSharedStrings.push_back(aStr);
        maSharedStringIds.insert( SharedStrMap::value_type(aStr, mnStrCount) );
        return mnStrCount++;
    }

    // existing string.
    return itr->second;
}

StrID SimpleSharedString::StringTable::getStringId(const OUString& aStr)
{
    SharedStrMap::const_iterator itr = maSharedStringIds.find(aStr),
        itrEnd = maSharedStringIds.end();
    if (itr == itrEnd)
    {
        // string not found.
        return insertString(aStr);
    }
    return itr->second;
}

const OUString* SimpleSharedString::StringTable::getString(StrID nId) const
{
    if (nId >= mnStrCount)
        return NULL;

    return &maSharedStrings[nId];
}

// ----------------------------------------------------------------------------

SimpleSharedString::SimpleSharedString()
{
}

SimpleSharedString::SimpleSharedString(const SimpleSharedString& r) :
    maStringTable(r.maStringTable)
{
}

SimpleSharedString::~SimpleSharedString()
{
}

StrID SimpleSharedString::insertString(const OUString& aStr)
{
    return maStringTable.insertString(aStr);
}

const OUString* SimpleSharedString::getString(StrID nId)
{
    return maStringTable.getString(nId);
}

StrID SimpleSharedString::getStringId(const OUString& aStr)
{
    return maStringTable.getStringId(aStr);
}

}