RakString.h

Go to the documentation of this file.

#ifndef __RAK_STRING_H
#define __RAK_STRING_H 

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

class SimpleMutex;

namespace RakNet
{

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 char c );

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

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

        
        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;

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

        void SetChar( unsigned index, unsigned char c );

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

        void Truncate(unsigned length);

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

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

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

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

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

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

        int StrCmp(const RakString &rhs) 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;

        RakNet::RakString& URLEncode(void);

        RakNet::RakString& URLDecode(void);

        RakNet::RakString& SQLEscape(void);

        RakNet::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, int languageId=0, bool writeLanguageId=false) const;

        static void SerializeCompressed(const char *str, BitStream *bs, int 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 unsigned int nPos;


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

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

protected:
        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 *sharedString, size_t bytes);
};

}

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


#endif