-
Notifications
You must be signed in to change notification settings - Fork 0
/
StdStringList.cpp
146 lines (114 loc) · 4 KB
/
StdStringList.cpp
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
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
#include "StdFuncs.h"
#include "Lex.h"
#include "StdStringList.h"
#include <string.h>
/**
* Appends one or more strings to the string array.
* Parses a string for substrings, separated by the ';' character, and copies any
* substrings found into an internal buffer. These substrings are then kept track
* of in an array, which can be accessed via the [] operator. Memory is automatically
* allocated for the strings, and it will be freed when the class itself is freed. The
* original string passed in only needs to be valid for the duration of this call.
*
* @date Wednesday 20-Nov-2013 6:37 am, Code HQ Ehinger Tor
* @param a_pccString Ptr to a NULL terminated string to be parsed
* @return KErrNone if the string was parsed successfully
* @return KErrNoMemory if not enough memory was available
*/
TInt CStdStringList::Append(const char *a_pccString)
{
char **Strings;
const char *Token;
TInt Index, Length, NumStrings, RetVal;
/* Create a temporary TLex and configure it to use the ';' character as the */
/* substring separator */
TLex Lex(a_pccString, (TInt) strlen(a_pccString));
Lex.SetWhitespace(";");
/* Determine how many substring are in this string */
NumStrings = (m_iNumStrings + Lex.Count());
/* Allocate an array of ptrs of just the required size and copy any already allocated */
/* string ptrs into it */
if ((Strings = new char *[NumStrings]) != NULL)
{
/* If an array of strings already exists, copy it into the newly allocated array */
if (m_ppcStrings)
{
memcpy(Strings, m_ppcStrings, (m_iNumStrings * sizeof(char *)));
}
/* Iterate through the string and break it up into individual substrings, placing */
/* them into the array allocated above */
Index = m_iNumStrings;
RetVal = KErrNone;
/* Extract all tokens from this line and add them to the array */
while ((Token = Lex.NextToken(&Length)) != NULL)
{
if ((Strings[Index++] = Utils::DuplicateString(Token, Length)) == NULL)
{
RetVal = KErrNoMemory;
break;
}
}
/* If all strings were allocated successfully then save the newly created array and */
/* delete the old one */
if (RetVal == KErrNone)
{
delete [] m_ppcStrings;
m_ppcStrings = Strings;
m_iNumStrings = NumStrings;
}
/* Otherwise the array is in a partially initialised state so delete whatever */
/* strings were allocated and the delete the array. This will leave the class in */
/* a state as though this function had never been called */
else
{
for (Index = m_iNumStrings; Index < NumStrings; ++Index)
{
delete [] Strings[Index];
}
delete [] Strings;
}
}
else
{
RetVal = KErrNoMemory;
}
return(RetVal);
}
/**
* Frees the class's resources and puts it back to its initial state.
* Frees up the strings owned by the class, as well as the array used to keep track
* of the string ptrs. After calling this function, the class instance will be back
* to how it was when it was first initialised, and is able to be reused.
*
* @date Wednesday 20-Nov-2013 6:45 am, Code HQ Ehinger Tor
*/
void CStdStringList::Reset()
{
TInt Index;
/* Free all strings owned by the class */
for (Index = 0; Index < m_iNumStrings; ++Index)
{
delete [] m_ppcStrings[Index];
}
/* Also free the array used to retain their ptrs and indicate that there are zero */
/* strings held by the class */
delete [] m_ppcStrings;
m_ppcStrings = NULL;
m_iNumStrings = 0;
}
/**
* Retrieves a string at a given index in the array.
* Once the strings have been parsed into the array of strings, this function can be used
* to access them.
*
* @pre Index passed in must be between 0 and the value returned by CStdStringList::Count()
*
* @date Tuesday 19-Nov-2013 7:55 am, Code HQ Ehinger Tor
* @param a_iIndex Index of the string to be retrieved
* @return Ptr to the string at the given index
*/
const char *CStdStringList::operator[](TInt a_iIndex)
{
ASSERTM(((a_iIndex >= 0) && (a_iIndex < m_iNumStrings)), "CStdStringList::operator[]() => Index passed in is out of range");
return(m_ppcStrings[a_iIndex]);
}