Skip to content
GitLab
Projects
Groups
Snippets
Help
Loading...
Help
Help
Support
Community forum
Keyboard shortcuts
?
Submit feedback
Contribute to GitLab
Sign in
Toggle navigation
JPScore
Project overview
Project overview
Details
Activity
Releases
Repository
Repository
Files
Commits
Branches
Tags
Contributors
Graph
Compare
Issues
92
Issues
92
List
Boards
Labels
Service Desk
Milestones
Merge Requests
3
Merge Requests
3
CI / CD
CI / CD
Pipelines
Jobs
Schedules
Operations
Operations
Incidents
Environments
Packages & Registries
Packages & Registries
Container Registry
Analytics
Analytics
CI / CD
Repository
Value Stream
Wiki
Wiki
Snippets
Snippets
Members
Members
Collapse sidebar
Close sidebar
Activity
Graph
Create a new issue
Jobs
Commits
Issue Boards
Open sidebar
JuPedSim
JPScore
Commits
6effc948
Commit
6effc948
authored
Jun 17, 2015
by
Ulrich Kemloh
Browse files
Options
Browse Files
Download
Email Patches
Plain Diff
Enable STL and restore original tinyxml licence
parent
53fb69f7
Changes
6
Expand all
Hide whitespace changes
Inline
Side-by-side
Showing
6 changed files
with
4522 additions
and
4495 deletions
+4522
-4495
tinyxml/tinystr.cpp
tinyxml/tinystr.cpp
+47
-42
tinyxml/tinystr.h
tinyxml/tinystr.h
+260
-280
tinyxml/tinyxml.cpp
tinyxml/tinyxml.cpp
+1156
-1061
tinyxml/tinyxml.h
tinyxml/tinyxml.h
+1587
-1820
tinyxml/tinyxmlerror.cpp
tinyxml/tinyxmlerror.cpp
+22
-21
tinyxml/tinyxmlparser.cpp
tinyxml/tinyxmlparser.cpp
+1450
-1271
No files found.
tinyxml/tinystr.cpp
View file @
6effc948
...
...
@@ -36,71 +36,76 @@ TiXmlString::Rep TiXmlString::nullrep_ = { 0, 0, { '\0' } };
void
TiXmlString
::
reserve
(
size_type
cap
)
{
if
(
cap
>
capacity
())
{
TiXmlString
tmp
;
tmp
.
init
(
length
(),
cap
);
memcpy
(
tmp
.
start
(),
data
(),
length
());
swap
(
tmp
);
}
if
(
cap
>
capacity
())
{
TiXmlString
tmp
;
tmp
.
init
(
length
(),
cap
);
memcpy
(
tmp
.
start
(),
data
(),
length
());
swap
(
tmp
);
}
}
TiXmlString
&
TiXmlString
::
assign
(
const
char
*
str
,
size_type
len
)
{
size_type
cap
=
capacity
();
if
(
len
>
cap
||
cap
>
3
*
(
len
+
8
))
{
TiXmlString
tmp
;
tmp
.
init
(
len
);
memcpy
(
tmp
.
start
(),
str
,
len
);
swap
(
tmp
);
}
else
{
memmove
(
start
(),
str
,
len
);
set_size
(
len
);
}
return
*
this
;
size_type
cap
=
capacity
();
if
(
len
>
cap
||
cap
>
3
*
(
len
+
8
))
{
TiXmlString
tmp
;
tmp
.
init
(
len
);
memcpy
(
tmp
.
start
(),
str
,
len
);
swap
(
tmp
);
}
else
{
memmove
(
start
(),
str
,
len
);
set_size
(
len
);
}
return
*
this
;
}
TiXmlString
&
TiXmlString
::
append
(
const
char
*
str
,
size_type
len
)
{
size_type
newsize
=
length
()
+
len
;
if
(
newsize
>
capacity
())
{
reserve
(
newsize
+
capacity
());
}
memmove
(
finish
(),
str
,
len
);
set_size
(
newsize
);
return
*
this
;
size_type
newsize
=
length
()
+
len
;
if
(
newsize
>
capacity
())
{
reserve
(
newsize
+
capacity
());
}
memmove
(
finish
(),
str
,
len
);
set_size
(
newsize
);
return
*
this
;
}
TiXmlString
operator
+
(
const
TiXmlString
&
a
,
const
TiXmlString
&
b
)
{
TiXmlString
tmp
;
tmp
.
reserve
(
a
.
length
()
+
b
.
length
());
tmp
+=
a
;
tmp
+=
b
;
return
tmp
;
TiXmlString
tmp
;
tmp
.
reserve
(
a
.
length
()
+
b
.
length
());
tmp
+=
a
;
tmp
+=
b
;
return
tmp
;
}
TiXmlString
operator
+
(
const
TiXmlString
&
a
,
const
char
*
b
)
{
TiXmlString
tmp
;
TiXmlString
::
size_type
b_len
=
static_cast
<
TiXmlString
::
size_type
>
(
strlen
(
b
)
);
tmp
.
reserve
(
a
.
length
()
+
b_len
);
tmp
+=
a
;
tmp
.
append
(
b
,
b_len
);
return
tmp
;
TiXmlString
tmp
;
TiXmlString
::
size_type
b_len
=
static_cast
<
TiXmlString
::
size_type
>
(
strlen
(
b
)
);
tmp
.
reserve
(
a
.
length
()
+
b_len
);
tmp
+=
a
;
tmp
.
append
(
b
,
b_len
);
return
tmp
;
}
TiXmlString
operator
+
(
const
char
*
a
,
const
TiXmlString
&
b
)
{
TiXmlString
tmp
;
TiXmlString
::
size_type
a_len
=
static_cast
<
TiXmlString
::
size_type
>
(
strlen
(
a
)
);
tmp
.
reserve
(
a_len
+
b
.
length
());
tmp
.
append
(
a
,
a_len
);
tmp
+=
b
;
return
tmp
;
TiXmlString
tmp
;
TiXmlString
::
size_type
a_len
=
static_cast
<
TiXmlString
::
size_type
>
(
strlen
(
a
)
);
tmp
.
reserve
(
a_len
+
b
.
length
());
tmp
.
append
(
a
,
a_len
);
tmp
+=
b
;
return
tmp
;
}
#endif
// TIXML_USE_STL
#endif
// TIXML_USE_STL
tinyxml/tinystr.h
View file @
6effc948
/**
* \file tinystr.h
* \date Jul 4, 2014
* \version v0.6
* \copyright <2009-2014> Forschungszentrum Jülich GmbH. All rights reserved.
*
* \section License
* This file is part of JuPedSim.
*
* JuPedSim is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* any later version.
*
* JuPedSim is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with JuPedSim. If not, see <http://www.gnu.org/licenses/>.
*
* \section Description
*
*
**/
/*
www.sourceforge.net/projects/tinyxml
This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any
damages arising from the use of this software.
Permission is granted to anyone to use this software for any
purpose, including commercial applications, and to alter it and
redistribute it freely, subject to the following restrictions:
1. The origin of this software must not be misrepresented; you must
not claim that you wrote the original software. If you use this
software in a product, an acknowledgment in the product documentation
would be appreciated but is not required.
2. Altered source versions must be plainly marked as such, and
must not be misrepresented as being the original software.
3. This notice may not be removed or altered from any source
distribution.
*/
#ifndef TIXML_USE_STL
...
...
@@ -34,266 +30,247 @@
#include <assert.h>
#include <string.h>
/*
The support for explicit isn't that universal, and it isn't really
required - it is used to check that the TiXmlString class isn't incorrectly
used. Be nice to old compilers and macro it here:
/*
The support for explicit isn't that universal, and it isn't really
required - it is used to check that the TiXmlString class isn't incorrectly
used. Be nice to old compilers and macro it here:
*/
#if defined(_MSC_VER) && (_MSC_VER >= 1200 )
// Microsoft visual studio, version 6 and higher.
#define TIXML_EXPLICIT explicit
// Microsoft visual studio, version 6 and higher.
#define TIXML_EXPLICIT explicit
#elif defined(__GNUC__) && (__GNUC__ >= 3 )
// GCC version 3 and higher.s
#define TIXML_EXPLICIT explicit
// GCC version 3 and higher.s
#define TIXML_EXPLICIT explicit
#else
#define TIXML_EXPLICIT
#define TIXML_EXPLICIT
#endif
/*
TiXmlString is an emulation of a subset of the std::string template.
Its purpose is to allow compiling TinyXML on compilers with no or poor STL support.
Only the member functions relevant to the TinyXML project have been implemented.
The buffer allocation is made by a simplistic power of 2 like mechanism : if we increase
a string and there's no more room, we allocate a buffer twice as big as we need.
TiXmlString is an emulation of a subset of the std::string template.
Its purpose is to allow compiling TinyXML on compilers with no or poor STL support.
Only the member functions relevant to the TinyXML project have been implemented.
The buffer allocation is made by a simplistic power of 2 like mechanism : if we increase
a string and there's no more room, we allocate a buffer twice as big as we need.
*/
class
TiXmlString
{
public
:
// The size type used
typedef
size_t
size_type
;
// Error value for find primitive
static
const
size_type
npos
;
// = -1;
// TiXmlString empty constructor
TiXmlString
()
:
rep_
(
&
nullrep_
)
{
}
// TiXmlString copy constructor
TiXmlString
(
const
TiXmlString
&
copy
)
:
rep_
(
0
)
{
init
(
copy
.
length
());
memcpy
(
start
(),
copy
.
data
(),
length
());
}
// TiXmlString constructor, based on a string
TIXML_EXPLICIT
TiXmlString
(
const
char
*
copy
)
:
rep_
(
0
)
{
init
(
static_cast
<
size_type
>
(
strlen
(
copy
)
));
memcpy
(
start
(),
copy
,
length
());
}
// TiXmlString constructor, based on a string
TIXML_EXPLICIT
TiXmlString
(
const
char
*
str
,
size_type
len
)
:
rep_
(
0
)
{
init
(
len
);
memcpy
(
start
(),
str
,
len
);
}
// TiXmlString destructor
~
TiXmlString
()
{
quit
();
}
TiXmlString
&
operator
=
(
const
char
*
copy
)
{
return
assign
(
copy
,
(
size_type
)
strlen
(
copy
));
}
TiXmlString
&
operator
=
(
const
TiXmlString
&
copy
)
{
return
assign
(
copy
.
start
(),
copy
.
length
());
}
// += operator. Maps to append
TiXmlString
&
operator
+=
(
const
char
*
suffix
)
{
return
append
(
suffix
,
static_cast
<
size_type
>
(
strlen
(
suffix
)
));
}
// += operator. Maps to append
TiXmlString
&
operator
+=
(
char
single
)
{
return
append
(
&
single
,
1
);
}
// += operator. Maps to append
TiXmlString
&
operator
+=
(
const
TiXmlString
&
suffix
)
{
return
append
(
suffix
.
data
(),
suffix
.
length
());
}
// Convert a TiXmlString into a null-terminated char *
const
char
*
c_str
()
const
{
return
rep_
->
str
;
}
// Convert a TiXmlString into a char * (need not be null terminated).
const
char
*
data
()
const
{
return
rep_
->
str
;
}
// Return the length of a TiXmlString
size_type
length
()
const
{
return
rep_
->
size
;
}
// Alias for length()
size_type
size
()
const
{
return
rep_
->
size
;
}
// Checks if a TiXmlString is empty
bool
empty
()
const
{
return
rep_
->
size
==
0
;
}
// Return capacity of string
size_type
capacity
()
const
{
return
rep_
->
capacity
;
}
// single char extraction
const
char
&
at
(
size_type
index
)
const
{
assert
(
index
<
length
()
);
return
rep_
->
str
[
index
];
}
// [] operator
char
&
operator
[]
(
size_type
index
)
const
{
assert
(
index
<
length
()
);
return
rep_
->
str
[
index
];
}
// find a char in a string. Return TiXmlString::npos if not found
size_type
find
(
char
lookup
)
const
{
return
find
(
lookup
,
0
);
}
// find a char in a string from an offset. Return TiXmlString::npos if not found
size_type
find
(
char
tofind
,
size_type
offset
)
const
{
if
(
offset
>=
length
())
return
npos
;
for
(
const
char
*
p
=
c_str
()
+
offset
;
*
p
!=
'\0'
;
++
p
)
{
if
(
*
p
==
tofind
)
return
static_cast
<
size_type
>
(
p
-
c_str
()
);
}
return
npos
;
}
void
clear
()
{
//Lee:
//The original was just too strange, though correct:
// TiXmlString().swap(*this);
//Instead use the quit & re-init:
quit
();
init
(
0
,
0
);
}
/* Function to reserve a big amount of data when we know we'll need it. Be aware that this
function DOES NOT clear the content of the TiXmlString if any exists.
*/
void
reserve
(
size_type
cap
);
TiXmlString
&
assign
(
const
char
*
str
,
size_type
len
);
TiXmlString
&
append
(
const
char
*
str
,
size_type
len
);
void
swap
(
TiXmlString
&
other
)
{
Rep
*
r
=
rep_
;
rep_
=
other
.
rep_
;
other
.
rep_
=
r
;
}
private:
void
init
(
size_type
sz
)
{
init
(
sz
,
sz
);
}
void
set_size
(
size_type
sz
)
{
rep_
->
str
[
rep_
->
size
=
sz
]
=
'\0'
;
}
char
*
start
()
const
{
return
rep_
->
str
;
}
char
*
finish
()
const
{
return
rep_
->
str
+
rep_
->
size
;
}
struct
Rep
{
size_type
size
,
capacity
;
char
str
[
1
];
};
void
init
(
size_type
sz
,
size_type
cap
)
{
if
(
cap
)
{
// Lee: the original form:
// rep_ = static_cast<Rep*>(operator new(sizeof(Rep) + cap));
// doesn't work in some cases of new being overloaded. Switching
// to the normal allocation, although use an 'int' for systems
// that are overly picky about structure alignment.
const
size_type
bytesNeeded
=
sizeof
(
Rep
)
+
cap
;
const
size_type
intsNeeded
=
(
bytesNeeded
+
sizeof
(
int
)
-
1
)
/
sizeof
(
int
);
rep_
=
reinterpret_cast
<
Rep
*>
(
new
int
[
intsNeeded
]
);
rep_
->
str
[
rep_
->
size
=
sz
]
=
'\0'
;
rep_
->
capacity
=
cap
;
}
else
{
rep_
=
&
nullrep_
;
}
}
void
quit
()
{
if
(
rep_
!=
&
nullrep_
)
{
// The rep_ is really an array of ints. (see the allocator, above).
// Cast it back before delete, so the compiler won't incorrectly call destructors.
delete
[]
(
reinterpret_cast
<
int
*>
(
rep_
)
);
}
}
Rep
*
rep_
;
static
Rep
nullrep_
;
class
TiXmlString
{
public
:
// The size type used
typedef
size_t
size_type
;
// Error value for find primitive
static
const
size_type
npos
;
// = -1;
// TiXmlString empty constructor
TiXmlString
()
:
rep_
(
&
nullrep_
)
{
}
// TiXmlString copy constructor
TiXmlString
(
const
TiXmlString
&
copy
)
:
rep_
(
0
)
{
init
(
copy
.
length
());
memcpy
(
start
(),
copy
.
data
(),
length
());
}
// TiXmlString constructor, based on a string
TIXML_EXPLICIT
TiXmlString
(
const
char
*
copy
)
:
rep_
(
0
)
{
init
(
static_cast
<
size_type
>
(
strlen
(
copy
)
));
memcpy
(
start
(),
copy
,
length
());
}
// TiXmlString constructor, based on a string
TIXML_EXPLICIT
TiXmlString
(
const
char
*
str
,
size_type
len
)
:
rep_
(
0
)
{
init
(
len
);
memcpy
(
start
(),
str
,
len
);
}
// TiXmlString destructor
~
TiXmlString
()
{
quit
();
}
TiXmlString
&
operator
=
(
const
char
*
copy
)
{
return
assign
(
copy
,
(
size_type
)
strlen
(
copy
));
}
TiXmlString
&
operator
=
(
const
TiXmlString
&
copy
)
{
return
assign
(
copy
.
start
(),
copy
.
length
());
}
// += operator. Maps to append
TiXmlString
&
operator
+=
(
const
char
*
suffix
)
{
return
append
(
suffix
,
static_cast
<
size_type
>
(
strlen
(
suffix
)
));
}
// += operator. Maps to append
TiXmlString
&
operator
+=
(
char
single
)
{
return
append
(
&
single
,
1
);
}
// += operator. Maps to append
TiXmlString
&
operator
+=
(
const
TiXmlString
&
suffix
)
{
return
append
(
suffix
.
data
(),
suffix
.
length
());
}
// Convert a TiXmlString into a null-terminated char *
const
char
*
c_str
()
const
{
return
rep_
->
str
;
}
// Convert a TiXmlString into a char * (need not be null terminated).
const
char
*
data
()
const
{
return
rep_
->
str
;
}
// Return the length of a TiXmlString
size_type
length
()
const
{
return
rep_
->
size
;
}
// Alias for length()
size_type
size
()
const
{
return
rep_
->
size
;
}
// Checks if a TiXmlString is empty
bool
empty
()
const
{
return
rep_
->
size
==
0
;
}
// Return capacity of string
size_type
capacity
()
const
{
return
rep_
->
capacity
;
}
// single char extraction
const
char
&
at
(
size_type
index
)
const
{
assert
(
index
<
length
()
);
return
rep_
->
str
[
index
];
}
// [] operator
char
&
operator
[]
(
size_type
index
)
const
{
assert
(
index
<
length
()
);
return
rep_
->
str
[
index
];
}
// find a char in a string. Return TiXmlString::npos if not found
size_type
find
(
char
lookup
)
const
{
return
find
(
lookup
,
0
);
}
// find a char in a string from an offset. Return TiXmlString::npos if not found
size_type
find
(
char
tofind
,
size_type
offset
)
const
{
if
(
offset
>=
length
())
return
npos
;
for
(
const
char
*
p
=
c_str
()
+
offset
;
*
p
!=
'\0'
;
++
p
)
{
if
(
*
p
==
tofind
)
return
static_cast
<
size_type
>
(
p
-
c_str
()
);
}
return
npos
;
}
void
clear
()
{
//Lee:
//The original was just too strange, though correct:
// TiXmlString().swap(*this);
//Instead use the quit & re-init:
quit
();
init
(
0
,
0
);
}
/* Function to reserve a big amount of data when we know we'll need it. Be aware that this
function DOES NOT clear the content of the TiXmlString if any exists.
*/
void
reserve
(
size_type
cap
);
TiXmlString
&
assign
(
const
char
*
str
,
size_type
len
);
TiXmlString
&
append
(
const
char
*
str
,
size_type
len
);
void
swap
(
TiXmlString
&
other
)
{
Rep
*
r
=
rep_
;
rep_
=
other
.
rep_
;
other
.
rep_
=
r
;
}
private:
void
init
(
size_type
sz
)
{
init
(
sz
,
sz
);
}
void
set_size
(
size_type
sz
)
{
rep_
->
str
[
rep_
->
size
=
sz
]
=
'\0'
;
}
char
*
start
()
const
{
return
rep_
->
str
;
}
char
*
finish
()
const
{
return
rep_
->
str
+
rep_
->
size
;
}
struct
Rep
{
size_type
size
,
capacity
;
char
str
[
1
];
};
void
init
(
size_type
sz
,
size_type
cap
)
{
if
(
cap
)
{
// Lee: the original form:
// rep_ = static_cast<Rep*>(operator new(sizeof(Rep) + cap));
// doesn't work in some cases of new being overloaded. Switching
// to the normal allocation, although use an 'int' for systems
// that are overly picky about structure alignment.
const
size_type
bytesNeeded
=
sizeof
(
Rep
)
+
cap
;
const
size_type
intsNeeded
=
(
bytesNeeded
+
sizeof
(
int
)
-
1
)
/
sizeof
(
int
);
rep_
=
reinterpret_cast
<
Rep
*>
(
new
int
[
intsNeeded
]
);
rep_
->
str
[
rep_
->
size
=
sz
]
=
'\0'
;
rep_
->
capacity
=
cap
;
}
else
{
rep_
=
&
nullrep_
;
}
}
void
quit
()
{
if
(
rep_
!=
&
nullrep_
)
{
// The rep_ is really an array of ints. (see the allocator, above).
// Cast it back before delete, so the compiler won't incorrectly call destructors.
delete
[]
(
reinterpret_cast
<
int
*>
(
rep_
)
);
}
}
Rep
*
rep_
;
static
Rep
nullrep_
;
}
;
inline
bool
operator
==
(
const
TiXmlString
&
a
,
const
TiXmlString
&
b
)
{
return
(
a
.
length
()
==
b
.
length
()
)
// optimization on some platforms
&&
(
strcmp
(
a
.
c_str
(),
b
.
c_str
())
==
0
);
// actual compare
return
(
a
.
length
()
==
b
.
length
()
)
// optimization on some platforms
&&
(
strcmp
(
a
.
c_str
(),
b
.
c_str
())
==
0
);
// actual compare
}
inline
bool
operator
<
(
const
TiXmlString
&
a
,
const
TiXmlString
&
b
)
{
return
strcmp
(
a
.
c_str
(),
b
.
c_str
())
<
0
;
return
strcmp
(
a
.
c_str
(),
b
.
c_str
())
<
0
;
}
inline
bool
operator
!=
(
const
TiXmlString
&
a
,
const
TiXmlString
&
b
)
{
return
!
(
a
==
b
);
}
inline
bool
operator
>
(
const
TiXmlString
&
a
,
const
TiXmlString
&
b
)
{
return
b
<
a
;
}
inline
bool
operator
<=
(
const
TiXmlString
&
a
,
const
TiXmlString
&
b
)
{
return
!
(
b
<
a
);
}
inline
bool
operator
>=
(
const
TiXmlString
&
a
,
const
TiXmlString
&
b
)
{
return
!
(
a
<
b
);
}
inline
bool
operator
!=
(
const
TiXmlString
&
a
,
const
TiXmlString
&
b
)
{
return
!
(
a
==
b
);
}
inline
bool
operator
>
(
const
TiXmlString
&
a
,
const
TiXmlString
&
b
)
{
return
b
<
a
;
}
inline
bool
operator
<=
(
const
TiXmlString
&
a
,
const
TiXmlString
&
b
)
{
return
!
(
b
<
a
);
}
inline
bool
operator
>=
(
const
TiXmlString
&
a
,
const
TiXmlString
&
b
)
{
return
!
(
a
<
b
);
}
inline
bool
operator
==
(
const
TiXmlString
&
a
,
const
char
*
b
)
{
return
strcmp
(
a
.
c_str
(),
b
)
==
0
;
}
inline
bool
operator
==
(
const
char
*
a
,
const
TiXmlString
&
b
)
{
return
b
==
a
;
}
inline
bool
operator
!=
(
const
TiXmlString
&
a
,
const
char
*
b
)
{
return
!
(
a
==
b
);
}
inline
bool
operator
!=
(
const
char
*
a
,
const
TiXmlString
&
b
)