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
|
#pragma once
#include "Runtime/mecanim/defs.h"
#include "Runtime/mecanim/types.h"
#include "Runtime/Serialize/SerializeTraits.h"
#include <string.h>
namespace mecanim
{
template<int CAPACITY = 128> class basic_string
{
protected:
char eos(){return '\0';}
char mStr[CAPACITY];
void terminatestr(){mStr[CAPACITY-1] = eos();}
public:
typedef char value_type;
typedef char* iterator;
typedef char const * const_iterator;
static const int npos = CAPACITY;
static const int capacity = CAPACITY;
basic_string(){ mStr[0] = eos(); }
basic_string( const basic_string& str ){ strncpy(mStr, str.mStr, max_size()); terminatestr(); }
explicit basic_string( const char * s, std::size_t n = CAPACITY){ strncpy(mStr, s, n); terminatestr(); }
char const* c_str()const{return mStr; }
const char& operator[] ( std::size_t pos ) const{ return mStr[pos]; }
char& operator[] ( std::size_t pos ){ return mStr[pos]; }
iterator begin(){return &mStr[0];}
const_iterator begin() const{return &mStr[0];}
iterator end(){return &mStr[size()];}
const_iterator end() const{return &mStr[size()];}
basic_string& operator= ( const basic_string& str ){ strncpy(mStr, str.mStr, max_size()); terminatestr(); return *this; }
basic_string& operator= ( const char* s ){ strncpy(mStr, s, max_size()); terminatestr(); return *this; }
basic_string& operator+= ( const basic_string& str ){ strncat(mStr, str.mStr, max_size()-size() ); terminatestr(); return *this; }
basic_string& operator+= ( const char* s ){ strncat(mStr, s, max_size()-size()); terminatestr(); return *this; }
int compare ( const basic_string& str ) const { return strcmp(mStr, str.mStr); }
int compare ( const char* s ) const { return strcmp(mStr, s); }
int compare ( size_t pos1, size_t n1, const basic_string& str ) const { return strncmp(mStr+pos1, str.mStr, n1); }
int compare ( size_t pos1, size_t n1, const char* s) const{ return strncmp(mStr+pos1, s, n1); }
basic_string substr ( size_t pos = 0, size_t n = npos ) const{ return basic_string( &mStr[pos], n-pos ); }
size_t find ( const basic_string& str, size_t pos = 0 ) const
{
return find(str.mStr, pos);
}
size_t find ( const char* s, size_t pos = 0 ) const
{
size_t i = npos;
char const* p = strstr(&mStr[pos], s);
if(p)
{
i = reinterpret_cast<size_t>(p) - reinterpret_cast<size_t>(mStr);
}
return i;
}
void resize(size_t size)
{
for(int i = 0; i < size && i < max_size();++i)
mStr[i] = ' ';
mStr[ size < max_size()-1 ? size : max_size()-1 ] = eos();
}
size_t size() const { return strlen(mStr); }
bool empty() const { return size() == 0; }
void clear() { mStr[0] = eos(); }
static size_t max_size(){ return CAPACITY; }
};
template<int CAPACITY1, int CAPACITY2> bool operator==(basic_string<CAPACITY1> const& l, basic_string<CAPACITY2> const& r){ return l.compare(r.c_str()) == 0; }
template<int CAPACITY> bool operator==(basic_string<CAPACITY> const& l, const char* r){ return l.compare(r) == 0; }
template<int CAPACITY1, int CAPACITY2> bool operator!=(basic_string<CAPACITY1> const& l, basic_string<CAPACITY2> const& r){ return l.compare(r.c_str()) != 0; }
template<int CAPACITY> bool operator!=(basic_string<CAPACITY> const& l, const char* r){ return l.compare(r) != 0; }
template<int CAPACITY1, int CAPACITY2> bool operator<(basic_string<CAPACITY1> const& l, basic_string<CAPACITY2> const& r){ return l.compare(r.c_str()) < 0; }
template<int CAPACITY> bool operator<(basic_string<CAPACITY> const& l, const char* r){ return l.compare(r) < 0; }
typedef basic_string<> String;
}
|
