FUtils/FUStringBuilder.h

Go to the documentation of this file.

/*
    Copyright (C) 2005-2006 Feeling Software Inc.
    MIT License: http://www.opensource.org/licenses/mit-license.php
*/
/*
    Based on the FS Import classes:
    Copyright (C) 2005-2006 Feeling Software Inc
    Copyright (C) 2005-2006 Autodesk Media Entertainment
    MIT License: http://www.opensource.org/licenses/mit-license.php
*/

#ifndef _FCU_STRING_BUILDER_
#define _FCU_STRING_BUILDER_

template <class Char, class SPrintF>
class FUStringBuilderT
{
private:
    Char* buffer;
    size_t reserved;
    size_t size;

public:
    typedef std::basic_string<Char> String;

    FUStringBuilderT(const String& sz);

    FUStringBuilderT(const Char* sz);

    FUStringBuilderT(Char ch, size_t count);

    FUStringBuilderT(size_t reserved);

    FUStringBuilderT();

    ~FUStringBuilderT();

    void reserve(size_t length);

    inline size_t length() { return size; }

    void clear();

    inline bool empty() { return size == 0; }

    void append(Char c);

    void append(const String& sz);

    void append(const Char* sz);

    void append(const FUStringBuilderT& b);

    void append(int32 i);
    void append(uint32 i); 
    void append(uint64 i); 
    inline void append(int i) { append((int32) i); } 
#ifdef _W64
    inline void append(_W64 unsigned int i) { append((uint32) i); } 
#else
    inline void append(unsigned int i) { append((uint32) i); } 
#endif 

    void append(float f);
    void append(double f); 
    template<typename TYPE> inline FUStringBuilderT& operator+=(const TYPE& val) { append(val); return *this; }

    void appendLine(const Char* sz);

    void remove(int32 start);

    void remove(int32 start, int32 end);

    inline void pop_back() { if (size > 0) --size; }

    template<typename TYPE> inline void set(const TYPE& val) { clear(); append(val); }
    template<typename TYPE> inline FUStringBuilderT& operator=(const TYPE& val) { clear(); append(val); return *this; } 
    String ToString();
    operator String() { return ToString(); } 
    const Char* ToCharPtr();
    operator const Char*() { return ToCharPtr(); } 
    int32 index(Char c);

    int32 rindex(Char c);

private:
    void enlarge(size_t minimum);
};

class SprintF
{
public:
    void PrintInt32(char* output, uint32 length, int32 i) { snprintf(output, length, "%i", i); } 

    void PrintUInt32(char* output, uint32 length, uint32 i) { snprintf(output, length, "%u", i); }
    void PrintUInt64(char* output, uint32 length, uint64 i) { snprintf(output, length, "%u", i); } 
    void PrintFloat(char* output, uint32 length, double f) { snprintf(output, length, "%f", f); }

    size_t StrLen(const char* in) { return strlen(in); }
};

class SFprintF
{
public:
    void PrintInt32(fchar* output, uint32 length, int32 i) { fsnprintf(output, length, FC("%i"), i); }

    void PrintUInt32(fchar* output, uint32 length, uint32 i) { fsnprintf(output, length, FC("%u"), i); }

    void PrintUInt64(fchar* output, uint32 length, uint64 i) { fsnprintf(output, length, FC("%u"), i); }

    void PrintFloat(fchar* output, uint32 length, double f) { fsnprintf(output, length, FC("%f"), f); }

    size_t StrLen(const fchar* in) { return fstrlen(in); }
};

typedef FUStringBuilderT<fchar, SFprintF> FUStringBuilder; 
typedef FUStringBuilderT<char, SprintF> FUSStringBuilder;  
FCOLLADA_EXPORT extern FUStringBuilder globalBuilder; 

FCOLLADA_EXPORT extern FUSStringBuilder globalSBuilder;

#include "FUtils/FUStringBuilder.hpp"

#endif // _FCU_STRING_BUILDER_

---