string.h

Go to the documentation of this file.

/*
 *  Original work: Copyright (c) 2014, Oculus VR, Inc.
 *  All rights reserved.
 *
 *  This source code is licensed under the BSD-style license found in the
 *  RakNet License.txt file in the licenses directory of this source tree. An additional grant 
 *  of patent rights can be found in the RakNet Patents.txt file in the same directory.
 *
 *
 *  Modified work: Copyright (c) 2016-2017, SLikeSoft UG (haftungsbeschränkt)
 *
 *  This source code was modified by SLikeSoft. Modifications are licensed under the MIT-style
 *  license found in the license.txt file in the root directory of this source tree.
 */

#ifndef __RAK_STRING_H
#define __RAK_STRING_H 

#include "Export.h"
#include "DS_List.h"
#include "types.h" // int64_t
#include <stdio.h>
#include "stdarg.h"


#ifdef _WIN32



#include "WindowsIncludes.h"
#endif

namespace SLNet
{
class SimpleMutex;
class BitStream;

class RAK_DLL_EXPORT RakString
{
public:
    // Constructors
    RakString();
    RakString(char input);
    RakString(unsigned char input);
    RakString(const unsigned char *format, ...);
    RakString(const char *format, ...);
    ~RakString();
    RakString( const RakString & rhs);

    operator const char* () const {return sharedString->c_str;}

    const char *C_String(void) const {return sharedString->c_str;}

    // Lets you modify the string. Do not make the string longer - however, you can make it shorter, or change the contents.
    // Pointer is only valid in the scope of RakString itself
    char *C_StringUnsafe(void) {Clone(); return sharedString->c_str;}

    RakString& operator = ( const RakString& rhs );
    RakString& operator = ( const char *str );
    RakString& operator = ( char *str );
    RakString& operator = ( const unsigned char *str );
    RakString& operator = ( char unsigned *str );
    RakString& operator = ( const char c );

    RakString& operator +=( const RakString& rhs);
    RakString& operator += ( const char *str );
    RakString& operator += ( char *str );
    RakString& operator += ( const unsigned char *str );
    RakString& operator += ( char unsigned *str );
    RakString& operator += ( const char c );

    unsigned char operator[] ( const unsigned int position ) const;

#ifdef _WIN32
    // Return as Wide char
    // Deallocate with DeallocWideChar
    WCHAR * ToWideChar(void);
    void DeallocWideChar(WCHAR * w);

    void FromWideChar(const wchar_t *source);
    static SLNet::RakString FromWideChar_S(const wchar_t *source);
#endif
    
    size_t Find(const char *stringToFind,size_t pos = 0 );

    bool operator==(const RakString &rhs) const;
    bool operator==(const char *str) const;
    bool operator==(char *str) const;

    // Comparison
    bool operator < ( const RakString& right ) const;
    bool operator <= ( const RakString& right ) const;
    bool operator > ( const RakString& right ) const;
    bool operator >= ( const RakString& right ) const;

    bool operator!=(const RakString &rhs) const;
    bool operator!=(const char *str) const;
    bool operator!=(char *str) const;

    const char * ToLower(void);

    const char * ToUpper(void);

    void Set(const char *format, ...);

    RakString Assign(const char *str,size_t pos, size_t n );

    bool IsEmpty(void) const;

    size_t GetLength(void) const;
    size_t GetLengthUTF8(void) const;

    void Replace(unsigned index, unsigned count, unsigned char c);

    void SetChar( unsigned index, unsigned char c );

    void SetChar( unsigned index, SLNet::RakString s );

    void Truncate(unsigned int length);
    void TruncateUTF8(unsigned int length);

    // Gets the substring starting at index for count characters
    RakString SubStr(unsigned int index, size_t count) const;

    void Erase(unsigned int index, unsigned int count);

    void TerminateAtFirstCharacter(char c);
    void TerminateAtLastCharacter(char c);

    void StartAfterFirstCharacter(char c);
    void StartAfterLastCharacter(char c);

    int GetCharacterCount(char c);
    
    void RemoveCharacter(char c);

    static SLNet::RakString NonVariadic(const char *str);

    static unsigned long ToInteger(const char *str);
    static unsigned long ToInteger(const RakString &rs);

    static int ReadIntFromSubstring(const char *str, size_t pos, size_t n);

    // Like strncat, but for a fixed length
    void AppendBytes(const char *bytes, size_t count);

    int StrCmp(const RakString &rhs) const;

    int StrNCmp(const RakString &rhs, size_t num) const;

    int StrICmp(const RakString &rhs) const;

    void Clear(void);

    void Printf(void);

    void FPrintf(FILE *fp);

    bool IPAddressMatch(const char *IP);

    bool ContainsNonprintableExceptSpaces(void) const;

    bool IsEmailAddress(void) const;

    SLNet::RakString& URLEncode(void);

    SLNet::RakString& URLDecode(void);

    void SplitURI(SLNet::RakString &header, SLNet::RakString &domain, SLNet::RakString &path);

    SLNet::RakString& SQLEscape(void);

    static SLNet::RakString FormatForPOST(const char* uri, const char* contentType, const char* body, const char* extraHeaders="");
    static SLNet::RakString FormatForPUT(const char* uri, const char* contentType, const char* body, const char* extraHeaders="");

    static SLNet::RakString FormatForGET(const char* uri, const char* extraHeaders="");

    static SLNet::RakString FormatForDELETE(const char* uri, const char* extraHeaders="");

    SLNet::RakString& MakeFilePath(void);

    static void FreeMemory(void);
    static void FreeMemoryNoMutex(void);

    void Serialize(BitStream *bs) const;

    static void Serialize(const char *str, BitStream *bs);

    void SerializeCompressed(BitStream *bs, uint8_t languageId=0, bool writeLanguageId=false) const;

    static void SerializeCompressed(const char *str, BitStream *bs, uint8_t languageId=0, bool writeLanguageId=false);

    bool Deserialize(BitStream *bs);

    static bool Deserialize(char *str, BitStream *bs);

    bool DeserializeCompressed(BitStream *bs, bool readLanguageId=false);

    static bool DeserializeCompressed(char *str, BitStream *bs, bool readLanguageId=false);

    static const char *ToString(int64_t i);
    static const char *ToString(uint64_t i);

    static size_t GetSizeToAllocate(size_t bytes)
    {
        const size_t smallStringSize = 128-sizeof(unsigned int)-sizeof(size_t)-sizeof(char*)*2;
        if (bytes<=smallStringSize)
            return smallStringSize;
        else
            return bytes*2;
    }

    struct SharedString
    {
        SimpleMutex *refCountMutex;
        unsigned int refCount;
        size_t bytesUsed;
        char *bigString;
        char *c_str;
        char smallString[128-sizeof(unsigned int)-sizeof(size_t)-sizeof(char*)*2];      
    };

    RakString( SharedString *_sharedString );

    SharedString *sharedString;

//  static SimpleMutex poolMutex;
//  static DataStructures::MemoryPool<SharedString> pool;
    static SharedString emptyString;

    //static SharedString *sharedStringFreeList;
    //static unsigned int sharedStringFreeListAllocationCount;
    static DataStructures::List<SharedString*> freeList;

    static int RakStringComp( RakString const &key, RakString const &data );

    static void LockMutex(void);
    static void UnlockMutex(void);

protected:
    static SLNet::RakString FormatForPUTOrPost(const char* type, const char* uri, const char* contentType, const char* body, const char* extraHeaders);
    void Allocate(size_t len);
    void Assign(const char *str);
    void Assign(const char *str, va_list ap);
    
    void Clone(void);
    void Free(void);
    unsigned char ToLower(unsigned char c);
    unsigned char ToUpper(unsigned char c);
    void Realloc(SharedString *inSharedString, size_t bytes);
};

}

const SLNet::RakString RAK_DLL_EXPORT operator+(const SLNet::RakString &lhs, const SLNet::RakString &rhs);


#endif