D:/SoftwareEntwicklung/C++/HLC/Tools/SoftPixelEngine/repository/sources/Base/spInputOutputString.hpp

Go to the documentation of this file.

/*
 * String header
 * 
 * This file is part of the "SoftPixel Engine" (Copyright (c) 2008 by Lukas Hermanns)
 * See "SoftPixelEngine.hpp" for license information.
 */

#ifndef __SP_IO_STRING_H__
#define __SP_IO_STRING_H__


#include "Base/spStandard.hpp"

#include <cstdlib>
#include <sstream>
#include <string>
#include <vector>
#include <list>
#include <algorithm>


namespace sp
{
namespace io
{


template <typename T> class string
{
    
    public:
        
        string<T>()
        {
        }
        string<T>(const string<T> &Str) :
            Str_(Str.Str_)
        {
        }
        string<T>(const std::basic_string<T> &Str) :
            Str_(Str)
        {
        }
        string<T>(const std::stringstream &Str) :
            Str_(Str.str())
        {
        }
        template <typename B> string<T>(const B Value)
        {
            std::stringstream SStr;
            SStr << Value;
            Str_ = SStr.str();
        }
        ~string<T>()
        {
        }
        
        /* === Operators === */
        
        string<T>& operator = (const string<T> &Str)
        {
            Str_ = Str.Str_;
            return *this;
        }
        
        bool operator == (const string<T> &Str) const
        {
            return Str_ == Str.Str_;
        }
        bool operator != (const string<T> &Str) const
        {
            return Str_ != Str.Str_;
        }
        
        string<T> operator + (const string<T> &Str) const
        {
            return Str_ + Str.Str_;
        }
        string<T>& operator += (const string<T> &Str)
        {
            Str_ += Str.Str_;
            return *this;
        }
        
        inline T& operator [] (u32 Index)
        {
            return Str_[Index];
        }
        
        inline const T& operator [] (u32 Index) const
        {
            return Str_[Index];
        }
        
        /* === Extra functions === */
        
        inline std::basic_string<T>& str()
        {
            return Str_;
        }
        inline const std::basic_string<T>& str() const
        {
            return Str_;
        }
        inline const T* c_str() const
        {
            return Str_.c_str();
        }
        inline u32 size() const
        {
            return Str_.size();
        }
        inline u32 length() const
        {
            return Str_.length();
        }
        
        inline void resize(u32 Size)
        {
            Str_.resize(Size);
        }
        inline void clear()
        {
            Str_.clear();
        }
        
        inline bool empty() const
        {
            return Str_.empty();
        }
        
        template <typename B> B val() const
        {
            B Value = B(0);
            std::istringstream sstr(Str_);
            sstr >> Value;
            return Value;
        }
        
        string<T> left(u32 Len) const
        {
            if (Len > size())
                return *this;
            return string<T>(Str_.substr(0, Len));
        }
        
        string<T> right(u32 Len) const
        {
            if (Len > size())
                return *this;
            return string<T>(Str_.substr(Str_.size() - Len, Len));
        }
        
        string<T> mid(u32 Pos, u32 Len) const
        {
            if (Pos > size())
                return "";
            if (Pos + Len > size())
                Len = size() - Pos;
            return string<T>(Str_.substr(Pos, Len));
        }
        
        string<T> section(u32 Pos1, u32 Pos2) const
        {
            if (Pos1 > size() || Pos2 > size() || Pos1 > Pos2)
                return "";
            return string<T>(Str_.substr(Pos1, Pos2 - Pos1));
        }
        
        string<T> trim() const
        {
            std::string NewStr = Str_;
            
            for (u32 i = 0; i < NewStr.size();)
            {
                if (NewStr[i] == ' ' || NewStr[i] == '\t')
                    NewStr = NewStr.substr(0, i) + NewStr.substr(i + 1, NewStr.size() - 1);
                else
                    ++i;
            }
            
            return string<T>(NewStr);
        }
        
        string<T> ltrim() const
        {
            u32 i = 0;
            
            while ( i < Str_.size() && ( Str_[i] == ' ' || Str_[i] == '\t' ) )
                ++i;
            
            return string<T>(Str_.substr(i, Str_.size() - i));
        }
        
        string<T> rtrim() const
        {
            s32 i = static_cast<s32>(Str_.size()) - 1;
            
            while ( i >= 0 && ( Str_[i] == ' ' || Str_[i] == '\t' ) )
                --i;
            
            return string<T>(Str_.substr(0, static_cast<u32>(i + 1)));
        }
        
        bool leftEqual(const string<T> &Str, u32 Len) const
        {
            if (Len > size())
                Len = size();
            if (Len > Str.size())
                Len = Str.size();
            
            for (u32 i = 0; i < Len; ++i)
            {
                if (Str_[i] != Str.Str_[i])
                    return false;
            }
            
            return true;
        }
        
        bool rightEqual(const string<T> &Str, u32 Len) const
        {
            if (Len > size())
                Len = size();
            if (Len > Str.size())
                Len = Str.size();
            
            const u32 LenA = Str_.size();
            const u32 LenB = Str.Str_.size();
            
            for (u32 i = 0; i < Len; ++i)
            {
                if (Str_[LenA - i - 1] != Str.Str_[LenB - i - 1])
                    return false;
            }
            
            return true;
        }
        
        u32 getLeftEquality(const string<T> &Str) const
        {
            u32 i = 0;
            
            for (u32 c = std::min(Str_.size(), Str.Str_.size()); i < c; ++i)
            {
                if (Str_[i] != Str.Str_[i])
                    break;
            }
            
            return i;
        }
        
        u32 getRightEquality(const string<T> &Str) const
        {
            u32 i = 0;
            
            const u32 LenA = Str_.size();
            const u32 LenB = Str.Str_.size();
            
            for (u32 c = std::min(Str_.size(), Str.Str_.size()); i < c; ++i)
            {
                if (Str_[LenA - i - 1] != Str.Str_[LenB - i - 1])
                    break;
            }
            
            return i;
        }
        
        inline s32 find(const string<T> &Str, u32 PosBegin = 0) const
        {
            return static_cast<s32>(Str_.find(Str.Str_, PosBegin));
        }
        
        inline s32 rfind(const string<T> &Str, u32 PosBegin = -1) const
        {
            return static_cast<s32>(Str_.rfind(Str.Str_, PosBegin));
        }
        
        s32 findChar(const T &SearchChar, u32 PosBegin = 0) const
        {
            for (u32 i = PosBegin, c = Str_.size(); i < c; ++i)
            {
                if (Str_[i] == SearchChar)
                    return i;
            }
            return -1;
        }
        
        s32 rfindChar(const T &SearchChar, u32 PosBegin = -1) const
        {
            if (PosBegin > 0)
            {
                for (s32 c = static_cast<s32>(Str_.size()), i = (PosBegin < c ? PosBegin : c); i >= 0; --i)
                {
                    if (Str_[i] == SearchChar)
                        return i;
                }
            }
            return -1;
        }
        
        s32 findNot(const string<T> &Str, u32 PosBegin = 0) const
        {
            u32 i = PosBegin, j;
            
            while (i < Str_.size())
            {
                for (j = 0; j < Str.size(); ++j)
                {
                    if (Str_[i] != Str[i])
                        return i;
                }
                ++i;
            }
            
            return -1;
        }
        
        s32 findNotSpaces(u32 PosBegin = 0) const
        {
            u32 i = PosBegin;
            
            while (i < Str_.size())
            {
                if (Str_[i] != ' ' && Str_[i] != '\t')
                    return i;
                ++i;
            }
            
            return -1;
        }
        
        static inline T getUpperChar(T AscChar)
        {
            return (AscChar >= 97 && AscChar <= 122) ? AscChar - 32 : AscChar;
        }
        
        static inline T getLowerChar(T AscChar)
        {
            return (AscChar >= 65 && AscChar <= 90) ? AscChar + 32 : AscChar;
        }
        
        string<T>& makeUpper()
        {
            for (u32 i = 0, c = Str_.size(); i < c; ++i)
            {
                if (Str_[i] >= 97 && Str_[i] <= 122)
                    Str_[i] -= 32;
            }
            return *this;
        }
        string<T>& makeLower()
        {
            for (u32 i = 0, c = Str_.size(); i < c; ++i)
            {
                if (Str_[i] >= 65 && Str_[i] <= 90)
                    Str_[i] += 32;
            }
            return *this;
        }
        
        string<T> upper() const
        {
            string<T> NewStr(*this);
            NewStr.makeUpper();
            return NewStr;
        }
        string<T> lower() const
        {
            string<T> NewStr(*this);
            NewStr.makeLower();
            return NewStr;
        }
        
        string<T> replace(const string<T> &StrFind, const string<T> &StrReplace, u32 PosBegin = 0) const
        {
            std::string NewStr = Str_;
            s32 Pos = PosBegin;
            
            while ( ( Pos = NewStr.find(StrFind.str(), Pos) ) != -1)
            {
                NewStr =
                    NewStr.substr(0, Pos) +
                    StrReplace.str() +
                    NewStr.substr( Pos + StrFind.size(), NewStr.size() - (Pos + StrFind.size()) );
                Pos += StrReplace.size();
            }
            
            return string<T>(NewStr);
        }
        
        /* === Static functions === */
        
        static string<T> ascii(u8 Character)
        {
            return string<T>(std::string(1, Character));
        }
        
        static string<T> space(u32 Count, c8 Ascii = ' ')
        {
            return string<T>(std::string(Count, Ascii));
        }
        
        static string<T> create(const string<T> &Str, u32 Count = 1)
        {
            std::string NewStr;
            
            for (u32 i = 0; i < Count; ++i)
                NewStr += Str.Str_;
            
            return string<T>(NewStr);
        }
        
        static string<T> number(u32 Number, u32 DigitsCount, const c8 Ascii = '0')
        {
            string<T> Str(Number);
            
            if (Str.size() < DigitsCount)
            {
                DigitsCount -= Str.size();
                Str = string<T>::space(DigitsCount, Ascii) + Str;
            }
            
            return Str;
        }
        
        static string<T> numberFloat(f32 Number, u32 DecimalPlaces, bool isFillBlanks = false)
        {
            string<T> Str(Number);
            
            for (s32 i = static_cast<s32>(Str.size()) - 1, j = 0; i >= 0; --i, ++j)
            {
                if (Str[i] == '.')
                {
                    const s32 Count = (DecimalPlaces > 0 ? i + DecimalPlaces + 1 : i);
                    
                    if (isFillBlanks && static_cast<s32>(DecimalPlaces) > j)
                        return Str.left(Count) + string<T>::space(DecimalPlaces - j, '0');
                    
                    return Str.left(Count);
                }
            }
            
            if (isFillBlanks && DecimalPlaces > 0)
                return Str + "." + string<T>::space(DecimalPlaces, '0');
            
            return Str;
        }
        
        static string<T> numberSeperators(const string<T> &Str, const c8 Sep = ',')
        {
            std::basic_string<T> NewStr(Str.Str_);
            
            s32 i = 3 - (NewStr.size() % 3);
            
            for (typename std::basic_string<T>::iterator it = NewStr.begin(); it != NewStr.end(); ++it)
            {
                if (i == 3)
                {
                    i = 0;
                    if (it != NewStr.begin())
                    {
                        it = NewStr.insert(it, Sep);
                        --i;
                    }
                }
                ++i;
            }
            
            return string<T>(NewStr);
        }
        
        /* === Extra operation functions === */
        
        string<T> getPathPart() const
        {
            for (s32 i = static_cast<s32>(Str_.size()) - 1; i >= 0; --i)
            {
                if (Str_[i] == '/' || Str_[i] == '\\')
                    return left(static_cast<u32>(i + 1));
            }
            return string<T>("");
        }
        
        string<T> getExtensionPart() const
        {
            u32 j = 0;
            
            for (s32 i = static_cast<s32>(Str_.size()) - 1; i >= 0; --i, ++j)
            {
                if (Str_[i] == '.')
                    return right(j);
            }
            
            return string<T>("");
        }
        
        string<T> getFilePart() const
        {
            u32 j = 0;
            
            for (s32 i = static_cast<s32>(Str_.size()) - 1; i >= 0; --i, ++j)
            {
                if (Str_[i] == '/' || Str_[i] == '\\')
                    return right(j);
            }
            
            return *this;
        }
        
        // Returns the strict file part of the string (e.g. "C:/Users/Lukas/Documents/Test.txt" -> "Test").
        string<T> getStrictFilePart() const
        {
            s32 i, j, c = static_cast<s32>(Str_.size()) - 1;
            
            for (i = j = c; i >= 0; --i)
            {
                if (j == c && Str_[i] == '.')
                    j = i;
                else if (Str_[i] == '/' || Str_[i] == '\\')
                    return section(static_cast<u32>(i + 1), static_cast<u32>(j));
            }
            
            return *this;
        }
        
        string<T> getRelativePath(string<T> RootPath) const
        {
            if (RootPath.empty())
                return Str_;
            
            const T LastChar = RootPath[RootPath.size() - 1];
            
            if (LastChar != '/' && LastChar != '\\')
                RootPath += "/";
            
            /* Find unequal part after last '/' or '\' character */
            u32 i = 0, j = 0;
            
            for (u32 c = std::min(Str_.size(), RootPath.Str_.size()); i < c; ++i)
            {
                if (string<T>::getLowerChar(Str_[i]) != string<T>::getLowerChar(RootPath.Str_[i]))
                {
                    if ( !( ( Str_[i] == '/' || Str_[i] == '\\' ) &&
                            ( RootPath.Str_[i] == '/' || RootPath.Str_[i] == '\\' ) ) )
                    {
                        break;
                    }
                }
                
                if (Str_[i] == '/' || Str_[i] == '\\')
                    j = i;
            }
            
            /* Get right part of the new string */
            ++j;
            string<T> NewStr = right(size() - j);
            
            /* Append '../' for further directory iteration */
            for (; j < RootPath.size(); ++j)
            {
                if (RootPath[j] == '/' || RootPath[j] == '\\')
                    NewStr = "../" + NewStr;
            }
            
            return NewStr;
        }
        
        void adjustPath()
        {
            *this = replace("\\", "/");
            
            /*
             * Repalce each "../" with "?" that the next 'replace' call
             * will not remove the valid "../" but each redundant "./"
             * and make this operation undo again.
             */
            *this = replace("../", "?");
            *this = replace("./", "");
            *this = replace("?", "../");
        }
        
        string<c8> toAscii() const
        {
            string<c8> ascii;
            ascii.resize(Str_.size());
            
            for (u32 i = 0; i < Str_.size(); ++i)
                ascii[i] = static_cast<c8>(Str_[i]);
            
            return ascii;
        }
        
        string<c16> toUnicode() const
        {
            string<c16> unicode;
            unicode.resize(Str_.size());
            
            for (u32 i = 0; i < Str_.size(); ++i)
                unicode[i] = static_cast<c16>(Str_[i]);
            
            return unicode;
        }
        
    private:
        
        /* Members */
        
        std::basic_string<T> Str_;
        
};

typedef string<c8> stringc;
typedef string<c16> stringw;


/* Extendet template functions */

template <typename T> stringc getHexString(const T &Number)
{
    stringc Str;
    
    for (s32 i = 2*sizeof(T) - 1; i >= 0; --i)
        Str += "0123456789ABCDEF"[((Number >> i*4) & 0xF)];
    
    return Str;
}

template <typename T> T getHexNumber(const io::stringc &Str)
{
    T Result;
    std::stringstream SStr;
    SStr << std::hex << Str.str();
    SStr >> Result;
    return Result;
}

template <typename T> string<T> operator + (const c8* cStr, const string<T> &spStr)
{
    return string<T>(cStr) + spStr;
}

template < class T, template < class TL, class Allocator = std::allocator<TL> > class L > void getListFromString(
    const stringc &Str, L<T> &List, s32 MaxCount = -1)
{
    s32 Pos1 = 0, Pos2 = 0;
    
    /* Search for each ';' character to find all values in the vector */
    while ( ( MaxCount == -1 || MaxCount > 0 ) && Pos1 < Str.size() - 1 && ( Pos1 = Str.find(";", Pos2) ) != -1 )
    {
        List.push_back(Str.section(Pos2, Pos1).val<T>());
        Pos2 = Pos1 + 1;
        if (MaxCount > 0)
            --MaxCount;
    }
}

template <class T> void getListFromString(const stringc &Str, std::vector<T> &List, s32 MaxCount = -1)
{
    getListFromString<T, std::vector>(Str, List, MaxCount);
}

template <class T> void getListFromString(const stringc &Str, std::list<T> &List, s32 MaxCount = -1)
{
    getListFromString<T, std::list>(Str, List, MaxCount);
}


} // /namespace io

} // /namespace sp


#endif



// ================================================================================