Mirrors/eepp
1
0
Fork 0
mirror of https://github.com/SpartanJ/eepp.git synced 2026-07-23 03:02:50 +03:00
Code Issues Packages Projects Releases Wiki Activity

Using String::hash as constexpr.

Browse Source 
String minor refactor.

--HG--
branch : dev
This commit is contained in:
Martín Lucas Golini
2019-06-16 20:55:26 -03:00
parent d7aa3f360e
commit 514bf2da2e
3 changed files with 140 additions and 257 deletions
Download Patch File Download Diff File Expand all files Collapse all files

15
include/eepp/core/string.hpp
View File

@@ -58,7 +58,20 @@ class EE_API String {
static constexpr Uint32 hash( const Uint8 * str );
/** @return string hash */
static constexpr Uint32 hash( const char * str );
static constexpr Uint32 hash( const char * str ) {
//! djb2
if ( NULL != str ) {
Uint32 hash = 5381;
Int32 c = 0;
while ( ( c = *str++ ) )
hash = ( ( hash << 5 ) + hash ) + c;
return hash;
}
return 0;
}
/** @return string hash */
static Uint32 hash( const std::string& str );

17
include/eepp/maps/maphelper.hpp
View File

@@ -2,6 +2,7 @@
#define EE_MAPS_MAPHELPER_HPP
#include <eepp/config.hpp>
#include <eepp/core/string.hpp>
namespace EE { namespace Maps {
@@ -92,14 +93,14 @@ class GObjFlags {
};
enum EE_GAMEOBJECT_TYPE {
GAMEOBJECT_TYPE_BASE = 2088954976UL, //String::hash( "Base" )
GAMEOBJECT_TYPE_VIRTUAL = 3708695628UL, //String::hash( "Virtual" )
GAMEOBJECT_TYPE_TEXTUREREGION = 1772101792UL, //String::hash( "SubTexture" )
GAMEOBJECT_TYPE_TEXTUREREGIONEX = 1378537981UL, //String::hash( "SubTextureEx" )
GAMEOBJECT_TYPE_SPRITE = 3517332124UL, //String::hash( "Sprite" )
GAMEOBJECT_TYPE_OBJECT = 3343895260UL, //String::hash( "Object" )
GAMEOBJECT_TYPE_POLYGON = 482716845UL, //String::hash( "Polygon" )
GAMEOBJECT_TYPE_POLYLINE = 3044927249UL //String::hash( "Polyline" )
GAMEOBJECT_TYPE_BASE = String::hash( "Base" ),
GAMEOBJECT_TYPE_VIRTUAL = String::hash( "Virtual" ),
GAMEOBJECT_TYPE_TEXTUREREGION = String::hash( "SubTexture" ),
GAMEOBJECT_TYPE_TEXTUREREGIONEX = String::hash( "SubTextureEx" ),
GAMEOBJECT_TYPE_SPRITE = String::hash( "Sprite" ),
GAMEOBJECT_TYPE_OBJECT = String::hash( "Object" ),
GAMEOBJECT_TYPE_POLYGON = String::hash( "Polygon" ),
GAMEOBJECT_TYPE_POLYLINE = String::hash( "Polyline" )
};
enum EE_LAYER_TYPE {

365
src/eepp/core/string.cpp
View File

@@ -24,21 +24,6 @@ constexpr Uint32 String::hash( const Uint8 * str ) {
return 0;
}
constexpr Uint32 String::hash( const char * str ) {
//! djb2
if ( NULL != str ) {
Uint32 hash = 5381;
Int32 c = 0;
while ( ( c = *str++ ) )
hash = ( ( hash << 5 ) + hash ) + c;
return hash;
}
return 0;
}
Uint32 String::hash( const std::string& str ) {
return String::hash( str.c_str() );
}
@@ -271,33 +256,27 @@ std::string String::format( const char * format, ... ) {
}
String::String()
{
}
{}
String::String(char ansiChar, const std::locale& locale)
{
String::String(char ansiChar, const std::locale& locale) {
mString += Utf32::decodeAnsi(ansiChar, locale);
}
#ifndef EE_NO_WIDECHAR
String::String(wchar_t wideChar)
{
String::String(wchar_t wideChar) {
mString += Utf32::decodeWide(wideChar);
}
#endif
String::String(StringBaseType utf32Char)
{
String::String(StringBaseType utf32Char) {
mString += utf32Char;
}
String::String( const char* uf8String ) {
if (uf8String)
{
if (uf8String) {
std::size_t length = strlen(uf8String);
if (length > 0)
{
if (length > 0) {
mString.reserve(length + 1);
Utf8::toUtf32(uf8String, uf8String + length, std::back_inserter(mString));
@@ -311,64 +290,52 @@ String::String( const std::string& utf8String ) {
Utf8::toUtf32( utf8String.begin(), utf8String.end(), std::back_inserter( mString ) );
}
String::String(const char* ansiString, const std::locale& locale)
{
if (ansiString)
{
String::String(const char* ansiString, const std::locale& locale) {
if (ansiString) {
std::size_t length = strlen(ansiString);
if (length > 0)
{
if (length > 0) {
mString.reserve(length + 1);
Utf32::fromAnsi(ansiString, ansiString + length, std::back_inserter(mString), locale);
}
}
}
String::String(const std::string& ansiString, const std::locale& locale)
{
String::String(const std::string& ansiString, const std::locale& locale) {
mString.reserve(ansiString.length() + 1);
Utf32::fromAnsi(ansiString.begin(), ansiString.end(), std::back_inserter(mString), locale);
}
#ifndef EE_NO_WIDECHAR
String::String(const wchar_t* wideString)
{
if (wideString)
{
String::String(const wchar_t* wideString) {
if (wideString) {
std::size_t length = std::wcslen(wideString);
if (length > 0)
{
if (length > 0) {
mString.reserve(length + 1);
Utf32::fromWide(wideString, wideString + length, std::back_inserter(mString));
}
}
}
String::String(const std::wstring& wideString)
{
String::String(const std::wstring& wideString) {
mString.reserve(wideString.length() + 1);
Utf32::fromWide(wideString.begin(), wideString.end(), std::back_inserter(mString));
}
#endif
String::String(const StringBaseType* utf32String)
{
String::String(const StringBaseType* utf32String) {
if (utf32String)
mString = utf32String;
}
String::String(const StringType& utf32String) :
mString(utf32String)
{
}
{}
String::String(const String& str) :
mString(str.mString)
{
}
{}
String String::fromUtf8( const std::string& utf8String )
{
String String::fromUtf8( const std::string& utf8String ) {
String::StringType utf32;
utf32.reserve( utf8String.length() + 1 );
@@ -378,13 +345,11 @@ String String::fromUtf8( const std::string& utf8String )
return String( utf32 );
}
String::operator std::string() const
{
String::operator std::string() const {
return toAnsiString();
}
std::string String::toAnsiString(const std::locale& locale) const
{
std::string String::toAnsiString(const std::locale& locale) const {
// Prepare the output string
std::string output;
output.reserve(mString.length() + 1);
@@ -396,8 +361,7 @@ std::string String::toAnsiString(const std::locale& locale) const
}
#ifndef EE_NO_WIDECHAR
std::wstring String::toWideString() const
{
std::wstring String::toWideString() const {
// Prepare the output string
std::wstring output;
output.reserve(mString.length() + 1);
@@ -431,100 +395,82 @@ std::basic_string<Uint16> String::toUtf16() const {
return output;
}
Uint32 String::getHash() const
{
Uint32 String::getHash() const {
return String::hash( *this );
}
String& String::operator =(const String& right)
{
String& String::operator =(const String& right) {
mString = right.mString;
return *this;
}
String& String::operator =( const StringBaseType& right )
{
String& String::operator =( const StringBaseType& right ) {
mString = right;
return *this;
}
String& String::operator +=(const String& right)
{
String& String::operator +=(const String& right) {
mString += right.mString;
return *this;
}
String& String::operator +=( const StringBaseType& right )
{
String& String::operator +=( const StringBaseType& right ) {
mString += right;
return *this;
}
String::StringBaseType String::operator [](std::size_t index) const
{
String::StringBaseType String::operator [](std::size_t index) const {
return mString[index];
}
String::StringBaseType& String::operator [](std::size_t index)
{
String::StringBaseType& String::operator [](std::size_t index) {
return mString[index];
}
String::StringBaseType String::at( std::size_t index ) const
{
String::StringBaseType String::at( std::size_t index ) const {
return mString.at( index );
}
void String::push_back( StringBaseType c )
{
void String::push_back( StringBaseType c ) {
mString.push_back( c );
}
void String::swap ( String& str )
{
void String::swap ( String& str ) {
mString.swap( str.mString );
}
void String::clear()
{
void String::clear() {
mString.clear();
}
std::size_t String::size() const
{
std::size_t String::size() const {
return mString.size();
}
std::size_t String::length() const
{
std::size_t String::length() const {
return mString.length();
}
bool String::empty() const
{
bool String::empty() const {
return mString.empty();
}
void String::erase(std::size_t position, std::size_t count)
{
void String::erase(std::size_t position, std::size_t count) {
mString.erase(position, count);
}
String& String::insert(std::size_t position, const String& str)
{
String& String::insert(std::size_t position, const String& str) {
mString.insert(position, str.mString);
return *this;
}
String& String::insert( std::size_t pos1, const String& str, std::size_t pos2, std::size_t n )
{
String& String::insert( std::size_t pos1, const String& str, std::size_t pos2, std::size_t n ) {
mString.insert( pos1, str.mString, pos2, n );
return *this;
}
String& String::insert ( size_t pos1, const char* s, size_t n )
{
String& String::insert ( size_t pos1, const char* s, size_t n ) {
String tmp( s );
mString.insert( pos1, tmp.data(), n );
@@ -532,14 +478,12 @@ String& String::insert ( size_t pos1, const char* s, size_t n )
return *this;
}
String& String::insert ( size_t pos1, size_t n, char c )
{
String& String::insert ( size_t pos1, size_t n, char c ) {
mString.insert( pos1, n, c );
return *this;
}
String& String::insert ( size_t pos1, const char* s )
{
String& String::insert ( size_t pos1, const char* s ) {
String tmp( s );
mString.insert( pos1, tmp.data() );
@@ -547,104 +491,85 @@ String& String::insert ( size_t pos1, const char* s )
return *this;
}
String::Iterator String::insert ( Iterator p, char c )
{
String::Iterator String::insert ( Iterator p, char c ) {
return mString.insert( p, c );
}
void String::insert ( Iterator p, size_t n, char c )
{
void String::insert ( Iterator p, size_t n, char c ) {
mString.insert( p, n, c );
}
const String::StringBaseType* String::c_str() const
{
const String::StringBaseType* String::c_str() const {
return mString.c_str();
}
const String::StringBaseType* String::data() const
{
const String::StringBaseType* String::data() const {
return mString.data();
}
String::Iterator String::begin()
{
String::Iterator String::begin() {
return mString.begin();
}
String::ConstIterator String::begin() const
{
String::ConstIterator String::begin() const {
return mString.begin();
}
String::Iterator String::end()
{
String::Iterator String::end() {
return mString.end();
}
String::ConstIterator String::end() const
{
String::ConstIterator String::end() const {
return mString.end();
}
String::ReverseIterator String::rbegin()
{
String::ReverseIterator String::rbegin() {
return mString.rbegin();
}
String::ConstReverseIterator String::rbegin() const
{
String::ConstReverseIterator String::rbegin() const {
return mString.rbegin();
}
String::ReverseIterator String::rend()
{
String::ReverseIterator String::rend() {
return mString.rend();
}
String::ConstReverseIterator String::rend() const
{
String::ConstReverseIterator String::rend() const {
return mString.rend();
}
void String::resize( std::size_t n, StringBaseType c )
{
void String::resize( std::size_t n, StringBaseType c ) {
mString.resize( n, c );
}
void String::resize( std::size_t n )
{
void String::resize( std::size_t n ) {
mString.resize( n );
}
std::size_t String::max_size() const
{
std::size_t String::max_size() const {
return mString.max_size();
}
void String::reserve( size_t res_arg )
{
void String::reserve( size_t res_arg ) {
mString.reserve( res_arg );
}
std::size_t String::capacity() const
{
std::size_t String::capacity() const {
return mString.capacity();
}
String& String::assign ( const String& str )
{
String& String::assign( const String& str ) {
mString.assign( str.mString );
return *this;
}
String& String::assign ( const String& str, size_t pos, size_t n )
{
String& String::assign( const String& str, size_t pos, size_t n ) {
mString.assign( str.mString, pos, n );
return *this;
}
String& String::assign ( const char* s, size_t n )
String& String::assign( const char* s, size_t n )
{
String tmp( s );
@@ -653,8 +578,7 @@ String& String::assign ( const char* s, size_t n )
return *this;
}
String& String::assign ( const char* s )
{
String& String::assign( const char* s ) {
String tmp( s );
mString.assign( tmp.mString );
@@ -662,29 +586,25 @@ String& String::assign ( const char* s )
return *this;
}
String& String::assign ( size_t n, char c )
{
String& String::assign( size_t n, char c ) {
mString.assign( n, c );
return *this;
}
String& String::append ( const String& str )
{
String& String::append( const String& str ) {
mString.append( str.mString );
return *this;
}
String& String::append ( const String& str, size_t pos, size_t n )
{
String& String::append( const String& str, size_t pos, size_t n ) {
mString.append( str.mString, pos, n );
return *this;
}
String& String::append ( const char* s, size_t n )
{
String& String::append( const char* s, size_t n ) {
String tmp( s );
mString.append( tmp.mString );
@@ -692,8 +612,7 @@ String& String::append ( const char* s, size_t n )
return *this;
}
String& String::append ( const char* s )
{
String& String::append( const char* s ) {
String tmp( s );
mString.append( tmp.mString );
@@ -701,43 +620,37 @@ String& String::append ( const char* s )
return *this;
}
String& String::append ( size_t n, char c )
{
String& String::append( size_t n, char c ) {
mString.append( n, c );
return *this;
}
String& String::append ( std::size_t n, StringBaseType c )
{
String& String::append( std::size_t n, StringBaseType c ) {
mString.append( n, c );
return *this;
}
String& String::replace ( size_t pos1, size_t n1, const String& str )
{
String& String::replace( size_t pos1, size_t n1, const String& str ) {
mString.replace( pos1, n1, str.mString );
return *this;
}
String& String::replace ( Iterator i1, Iterator i2, const String& str )
{
String& String::replace( Iterator i1, Iterator i2, const String& str ) {
mString.replace( i1, i2, str.mString );
return *this;
}
String& String::replace ( size_t pos1, size_t n1, const String& str, size_t pos2, size_t n2 )
{
String& String::replace( size_t pos1, size_t n1, const String& str, size_t pos2, size_t n2 ) {
mString.replace( pos1, n1, str.mString, pos2, n2 );
return *this;
}
String& String::replace ( size_t pos1, size_t n1, const char* s, size_t n2 )
{
String& String::replace( size_t pos1, size_t n1, const char* s, size_t n2 ) {
String tmp( s );
mString.replace( pos1, n1, tmp.data(), n2 );
@@ -745,8 +658,7 @@ String& String::replace ( size_t pos1, size_t n1, const char* s, size_t n2 )
return *this;
}
String& String::replace ( Iterator i1, Iterator i2, const char* s, size_t n2 )
{
String& String::replace( Iterator i1, Iterator i2, const char* s, size_t n2 ) {
String tmp( s );
mString.replace( i1, i2, tmp.data(), n2 );
@@ -754,8 +666,7 @@ String& String::replace ( Iterator i1, Iterator i2, const char* s, size_t n2 )
return *this;
}
String& String::replace ( size_t pos1, size_t n1, const char* s )
{
String& String::replace( size_t pos1, size_t n1, const char* s ) {
String tmp( s );
mString.replace( pos1, n1, tmp.mString );
@@ -763,8 +674,7 @@ String& String::replace ( size_t pos1, size_t n1, const char* s )
return *this;
}
String& String::replace ( Iterator i1, Iterator i2, const char* s )
{
String& String::replace ( Iterator i1, Iterator i2, const char* s ) {
String tmp( s );
mString.replace( i1, i2, tmp.mString );
@@ -772,212 +682,171 @@ String& String::replace ( Iterator i1, Iterator i2, const char* s )
return *this;
}
String& String::replace ( size_t pos1, size_t n1, size_t n2, char c )
{
String& String::replace( size_t pos1, size_t n1, size_t n2, char c ) {
mString.replace( pos1, n1, n2, (StringBaseType)c );
return *this;
}
String& String::replace ( Iterator i1, Iterator i2, size_t n2, char c )
{
String& String::replace ( Iterator i1, Iterator i2, size_t n2, char c ) {
mString.replace( i1, i2, n2, (StringBaseType)c );
return *this;
}
std::size_t String::find( const String& str, std::size_t start ) const
{
std::size_t String::find( const String& str, std::size_t start ) const {
return mString.find( str.mString, start );
}
std::size_t String::find ( const char* s, std::size_t pos, std::size_t n ) const
{
std::size_t String::find( const char* s, std::size_t pos, std::size_t n ) const {
return find( String( s ), pos );
}
std::size_t String::find ( const char* s, std::size_t pos ) const
{
std::size_t String::find( const char* s, std::size_t pos ) const {
return find( String( s ), pos );
}
size_t String::find ( char c, std::size_t pos ) const
{
size_t String::find ( char c, std::size_t pos ) const {
return mString.find( (StringBaseType)c, pos );
}
std::size_t String::rfind ( const String& str, std::size_t pos ) const
{
std::size_t String::rfind( const String& str, std::size_t pos ) const {
return mString.rfind( str.mString, pos );
}
std::size_t String::rfind ( const char* s, std::size_t pos, std::size_t n ) const
{
std::size_t String::rfind( const char* s, std::size_t pos, std::size_t n ) const {
return rfind( String( s ), pos );
}
std::size_t String::rfind ( const char* s, std::size_t pos ) const
{
std::size_t String::rfind( const char* s, std::size_t pos ) const {
return rfind( String( s ), pos );
}
std::size_t String::rfind ( char c, std::size_t pos ) const
{
std::size_t String::rfind( char c, std::size_t pos ) const {
return mString.rfind( c, pos );
}
std::size_t String::copy ( StringBaseType* s, std::size_t n, std::size_t pos ) const
{
std::size_t String::copy( StringBaseType* s, std::size_t n, std::size_t pos ) const {
return mString.copy( s, n, pos );
}
String String::substr ( std::size_t pos, std::size_t n ) const
{
String String::substr( std::size_t pos, std::size_t n ) const {
return String( mString.substr( pos, n ) );
}
int String::compare ( const String& str ) const
{
int String::compare( const String& str ) const {
return mString.compare( str.mString );
}
int String::compare ( const char* s ) const
{
int String::compare( const char* s ) const {
return compare( String( s ) );
}
int String::compare ( std::size_t pos1, std::size_t n1, const String& str ) const
{
int String::compare( std::size_t pos1, std::size_t n1, const String& str ) const {
return mString.compare( pos1, n1, str.mString );
}
int String::compare ( std::size_t pos1, std::size_t n1, const char* s) const
{
int String::compare( std::size_t pos1, std::size_t n1, const char* s) const {
return compare( pos1, n1, String( s ) );
}
int String::compare ( std::size_t pos1, std::size_t n1, const String& str, std::size_t pos2, std::size_t n2 ) const
{
int String::compare( std::size_t pos1, std::size_t n1, const String& str, std::size_t pos2, std::size_t n2 ) const {
return mString.compare( pos1, n1, str.mString, pos2, n2 );
}
int String::compare ( std::size_t pos1, std::size_t n1, const char* s, std::size_t n2) const
{
int String::compare( std::size_t pos1, std::size_t n1, const char* s, std::size_t n2) const {
return compare( pos1, n1, String( s ), 0, n2 );
}
std::size_t String::find_first_of ( const String& str, std::size_t pos ) const
{
std::size_t String::find_first_of( const String& str, std::size_t pos ) const {
return mString.find_first_of( str.mString, pos );
}
std::size_t String::find_first_of ( const char* s, std::size_t pos, std::size_t n ) const
{
std::size_t String::find_first_of( const char* s, std::size_t pos, std::size_t n ) const {
return find_first_of( String( s ), pos );
}
std::size_t String::find_first_of ( const char* s, std::size_t pos ) const
{
std::size_t String::find_first_of( const char* s, std::size_t pos ) const {
return find_first_of( String( s ), pos );
}
std::size_t String::find_first_of ( StringBaseType c, std::size_t pos ) const
{
std::size_t String::find_first_of( StringBaseType c, std::size_t pos ) const {
return mString.find_first_of( c, pos );
}
std::size_t String::find_last_of ( const String& str, std::size_t pos ) const
{
std::size_t String::find_last_of( const String& str, std::size_t pos ) const {
return mString.find_last_of( str.mString, pos );
}
std::size_t String::find_last_of ( const char* s, std::size_t pos, std::size_t n ) const
{
std::size_t String::find_last_of( const char* s, std::size_t pos, std::size_t n ) const {
return find_last_of( String( s ), pos );
}
std::size_t String::find_last_of ( const char* s, std::size_t pos ) const
{
std::size_t String::find_last_of( const char* s, std::size_t pos ) const {
return find_last_of( String( s ), pos );
}
std::size_t String::find_last_of ( StringBaseType c, std::size_t pos) const
{
std::size_t String::find_last_of( StringBaseType c, std::size_t pos) const {
return mString.find_last_of( c, pos );
}
std::size_t String::find_first_not_of ( const String& str, std::size_t pos ) const
{
std::size_t String::find_first_not_of( const String& str, std::size_t pos ) const {
return mString.find_first_not_of( str.mString, pos );
}
std::size_t String::find_first_not_of ( const char* s, std::size_t pos, std::size_t n ) const
{
std::size_t String::find_first_not_of( const char* s, std::size_t pos, std::size_t n ) const {
return find_first_not_of( String( s ), pos );
}
std::size_t String::find_first_not_of ( const char* s, std::size_t pos ) const
{
std::size_t String::find_first_not_of( const char* s, std::size_t pos ) const {
return find_first_not_of( String( s ), pos );
}
std::size_t String::find_first_not_of ( StringBaseType c, std::size_t pos ) const
{
std::size_t String::find_first_not_of( StringBaseType c, std::size_t pos ) const {
return mString.find_first_not_of( c, pos );
}
std::size_t String::find_last_not_of ( const String& str, std::size_t pos ) const
{
std::size_t String::find_last_not_of( const String& str, std::size_t pos ) const {
return mString.find_last_not_of( str.mString, pos );
}
std::size_t String::find_last_not_of ( const char* s, std::size_t pos, std::size_t n ) const
{
std::size_t String::find_last_not_of( const char* s, std::size_t pos, std::size_t n ) const {
return find_last_not_of( String( s ), pos );
}
std::size_t String::find_last_not_of ( const char* s, std::size_t pos ) const
{
std::size_t String::find_last_not_of( const char* s, std::size_t pos ) const {
return find_last_not_of( String( s ), pos );
}
std::size_t String::find_last_not_of ( StringBaseType c, std::size_t pos ) const
{
std::size_t String::find_last_not_of( StringBaseType c, std::size_t pos ) const {
return mString.find_last_not_of( c, pos );
}
bool operator ==(const String& left, const String& right)
{
bool operator ==(const String& left, const String& right) {
return left.mString == right.mString;
}
bool operator !=(const String& left, const String& right)
{
bool operator !=(const String& left, const String& right) {
return !(left == right);
}
bool operator <(const String& left, const String& right)
{
bool operator <(const String& left, const String& right) {
return left.mString < right.mString;
}
bool operator >(const String& left, const String& right)
{
bool operator >(const String& left, const String& right) {
return right < left;
}
bool operator <=(const String& left, const String& right)
{
bool operator <=(const String& left, const String& right) {
return !(right < left);
}
bool operator >=(const String& left, const String& right)
{
bool operator >=(const String& left, const String& right) {
return !(left < right);
}
String operator +(const String& left, const String& right)
{
String operator +(const String& left, const String& right) {
String string = left;
string += right;