vgl::adt::gstring 泛化字符串类 1.1

包含gstring(泛型字符串类)以及它的派生ustring(宽字符类).

现在贴出来晒晒，改天把case也贴出来下，不过肯定会存在bug的。

而且只实现了一些必须的功能。

#ifndef STRING__
#define  STRING__


#include  " array.h "


namespace  adt
{
    using adt::array;


    template<typename VType,VType VTerm_>
    class gstring
    {
    protected:

    protected:
        array<VType> buf;
        int lenof(VType * copy)
        {
            if(!copy)return 0;
            int i=0;
            for(;copy[i]!=VTerm_;i++);
            return i;
        }

    public:
        int len;
        int set(VType* copy,int l=-1)
        {
            if(!copy)
                buf.renew(0);
            if(l==-1||l<=0)
                l=lenof(copy);
            buf.set(copy,l+1,0,l+1);
            buf.set(l,VTerm_);
            len=l;
            return 1;
        }
        gstring()
        {
            buf.renew(1);
            buf.set(0,VTerm_);
            buf.n_=0;
            len=0;
        }
        gstring(VType * copy,int l=-1)
        {
            set(copy,l);
        }
        gstring(gstring & str)
        {
            set(str.buf(),str.len);
        }
        int add(VType * copy,int l=-1)
        {
            if(!copy)return 0;
            if(l==-1||l<=0)
            {
                
                l=lenof(copy);
            }
            buf.extra(l);
            l+=len+1;

            for(int i=len;i!=l;i++)
            {
                buf.set(i,copy[i-len]);
            }
            len=l-1;
            return 1;
            
        }
        gstring& copyFrom(VType * _src,int _begin,int _len)
        {
            set(_src+_begin,_len);
            return *this;
        }
        gstring& operator = (VType* copy)
        {
            buf.renew(1);
            buf.set(0,VTerm_);
            buf.n_=0;
            len=0;
            add(copy);
            return *this;
        }
        gstring& operator = (gstring & copy)
        {
            set(copy.buf(),copy.len);
            return *this;
        }
        int operator == (gstring & rvalue)
        {
            if(len!=rvalue.len)
                return 0;
            for(int i=0;i!=len;i++)
                if(rvalue.buf[i]!=buf[i])
                    return 0;
            return 1;
        }
        int operator == (VType * rvalue)
        {
            int i=0;
            for(;rvalue[i]!=VTerm_&&buf[i]!=VTerm_;i++)
            {
                if(rvalue[i]!=buf[i])
                    return 0;
            }
            if(rvalue[i]!=VTerm_||buf[i]!=VTerm_)
                return 0;
            return 1;

        }
        VType& operator [](int i)
        {
            return buf[i]; 
        }
        int operator != (gstring & rvalue)
        {
            if(len!=rvalue.len)
                return 1;
            for(int i=0;i!=len;i++)
                if(rvalue.buf[i]!=buf[i])
                    return 1;
            return 0;
        }
        int add(gstring & copy)
        {
            add(copy.buf(),copy.len);
            return 1;
        }
        int mul(VType * copy,int factor,int l=-1)
        {
            if(!copy||factor<=0)return 0;
            if(l==-1||l<=0)
            {
                
                l=lenof(copy);
            }

            buf.extra(factor*l);
            for(int i=0;i!=factor;i++)
                add(copy,l);
            return 1;
        }
        int mul(gstring & copy,int factor)
        {
            if(factor<=0)return 0;


            buf.extra(factor*copy.len);
            for(int i=0;i!=factor;i++)
                add(copy.buf(),copy.len);
            return 1;
        }
        VType* operator()()
        {
            return buf();
        }

        

    };


    class ustring:public gstring<wchar_t,L'\0'>
    {
    public:
        ustring():gstring()
        {
        }
        ustring(wchar_t * copy,int l=-1):gstring( copy, l )
        {
 
        }
        ustring(gstring<wchar_t,L'\0'> & str):gstring( str)
        {

        }
        ustring& operator <<(double i)
        {
            wchar_t t[50];
            atom::d2s(t,i);
            add(t);
            return *this;
        }
        ustring& operator <<(int i)
        {
            wchar_t t[50];
            atom::d2s(t,i);
            add(t);
            return *this;
        }
        ustring& operator <<(wchar_t t_[])
        {
            add(t_);
            return *this;
        }
        ustring& operator <<(char t_[])
        {
            wchar_t t[50];
            int i=0;
            for(;t_[i]!=0;i++)
                t[i]=t_[i];
            t[i]=t_[i];
            add(t);
            return *this;
        }

        ustring& operator <<(bool t)
        {
            if(t==true)
                add(L"true");
            else
                add(L"false");
            return *this;
        }    
    };
    class string:public gstring<char,'\0'>
    {
    public:
        string():gstring()
        {
        }
        string(char * copy,int l=-1):gstring( copy, l )
        {
 
        }
        string(gstring<char,'\0'> & str):gstring( str)
        {

        }
        string& operator <<(double i)
        {
            char t[50];
            atom::d2s(t,i);
            add(t);
            return *this;
        }
        string& operator <<(int i)
        {
            char t[50];
            atom::d2s(t,i);
            add(t);
            return *this;
        }
        string& operator <<(wchar_t t_[])
        {
            char t[50];
            int i=0;
            for(;t_[i]!=0;i++)
                t[i]=t_[i];
            t[i]=t_[i];
            add(t);
            return *this;

        }
        string& operator <<(char t_[])
        {
            add(t_);
            return *this;
        }
        string& operator <<(char t_)
        {
            char _temp[2]={t_,0};

            add(_temp);
            return *this;
        }
        string& operator <<(bool t)
        {
            if(t==true)
                add("true");
            else
                add("false");
            return *this;
        }    
    };
}
#endif