DynStr.h

// Copyright (c) 2007, Arne Steinarson
// Licensing for DynObj project - see DynObj-license.txt in this folder

#ifndef DYNSTR_H
#define DYNSTR_H

#include <string.h>  // For strlen

// %%DYNOBJ section general
// This section is auto-generated and manual changes will be lost when regenerated!!
#ifdef DO_IMPLEMENT_DYNSTR
    #define DO_IMPLEMENTING     // If app has not defined it already
#endif
#include "dynobj/DynObj.h"

// --- Forward class declarations ---
class DynStr;

// --- For each declared class, doTypeInfo template specializations ---
DO_DECL_TYPE_INFO(DynStr,DYNSTR_TYPE_ID);

// %%DYNOBJ section end


// Template prototype
template<class T> 
class DynArrI;

// Helper to get a NULL reference
#define DynStrNull ((DynStr&)*(DynStr*)0)


// A string interface that is Unicode aware. It stores strings 
// in UTF8 format. A character is handled as 'int', except for
// in operator = where wchar_t is used for combined Unix/Win32 
// compatibility.

// This points to the character after the end of a string (the 
// NUL character). Index -1 will point to the last character, 
// but sometimes, we need to point after that one.
#define STR_AT_END ((int)0x80000000)    

// %%DYNOBJ class(dyni) flags(notypeid)
class DynStr : public DynObj {
public:
    virtual DynObjType* docall doGetType( const DynI **pself=0 ) const;
    
    virtual DynStr&     docall  AssignA(const char *s, int l=-1){ return *this; }
    //virtual bool      docall  operator == (const char *s) const { return false; }
    virtual int         docall  Strcmp(const char *s) const { return 0; }
    virtual int         docall  Stricmp(const char *s) const { return false; }
    
    virtual const char* docall  Get( ) const { return NULL; }
    virtual int         docall  GetByte(int ix) const { return -1; }    // Returns one byte (8-bit char)
    virtual int         docall  GetUniChar(int ix) const { return -1; } // Returns one Unicode code-point (32-bit)
    virtual bool        docall  SetByte( int ix, char ch ) { return false; }
    virtual bool        docall  SetUniChar( int ix, int ch ) { return false; }
    
    virtual int         docall  Length() const { return -1; };          // Length in Unicode characters
    virtual int         docall  ByteSize() const { return -1; };        // Nr of bytes before NUL
    
    virtual DynStr&     docall  Insert(int at, const char *s, int byte_len) { return *this; }
    virtual DynStr&     docall  InsertChar(int at, int ch){ return *this; }
    virtual DynStr&     docall  Remove(int pos, int cnt){ return *this; }

    virtual DynStr&     docall  AppendW(const wchar_t *s, int l=-1){ return *this; }
    
    virtual DynStr& docall Reset() { return *this; }

    virtual const char* docall  Right(int from_pos) const { return 0; };
    virtual DynStr&     docall  Strip(bool left=true, bool right=true) { return *this; }
    
    virtual bool        docall  IsEmpty() const { return false; }

    virtual int         docall  SubstChar(int ch_find, int ch_repl) { return -1; }
    virtual int         docall  Subst(const char *s_find, const char *s_repl) { return -1; }
    
    virtual int         docall  Find(const char *str) const { return -1; }
    virtual bool        docall  FindAt(const char *str, int pos=0) const { return false; }

    virtual int         docall  FindBytePos(const char *str) const { return -1; }
    virtual bool        docall  FindAtBytePos(const char *str, int pos=0) const { return false; }
    
    virtual int         docall BytePos2Index( int pb ){ return -1; }
    virtual int         docall Index2BytePos( int pi ){ return -1; } 

#if DO_RETURN_STRUCT_WITH_DTOR_SAFE==1     

    struct DynStrRetVal : protected DynObjRetVal { 
        DynStrRetVal( DynStr *pds ) : DynObjRetVal(pds) { } 
        DynStr *Release(){ return (DynStr*)DynObjRetVal::Release(); } 
        operator const char*() { return m_pdo ? ((DynStr*)m_pdo)->Get() : NULL; } 
        // Allow several + operations to be applied. Since this is a temp val,
        // we can append internally.
        DynStrRetVal& operator + (const char* ps) { 
            if(m_pdo) ((DynStr*)m_pdo)->Append(ps); 
            return *this;
        }
    };
        
    virtual DynStrRetVal docall  Concat(const char *str){ return DynStrRetVal(NULL); }
#else

    virtual void        docall Concat_CannotUse( const char* str ){ } 
#endif     

    virtual wchar_t*    docall ToWideChar( DynArrI<wchar_t>& wa ){ return NULL; } 



    DynStr& operator = (const char *s){ return AssignA(s,-1); }
    DynStr& operator = (const wchar_t *s){ return AssignW(s,-1); }
    bool operator == (const char *s) const { return !Strcmp(s); }
    bool operator !=(const char *s) const { return Strcmp(s)!=0; }

    operator const char* () const { return Get(); } 
    const char* c_str() const { return Get(); } 

    //DynStr& Reset() { Trunc(0); return *this; }

    DynStr& AssignW(const wchar_t *pws, int l=-1){ Trunc(0); AppendW(pws,l); return *this; } 
    DynStr& Prepend(const char *s){ return Insert(0,s,-1); }
    DynStr& Append(const char *s){ return Insert(STR_AT_END,s,-1); }
    DynStr& Prepend(int ch){ return InsertChar(0,ch); return *this; }
    DynStr& Append(int ch){ return InsertChar(STR_AT_END,ch); return *this; }
    DynStr& Insert(int at, const char *s){ 
        if(s) Insert(at,s,(int)strlen(s)); 
        return *this; 
    }

    DynStr& operator += (const char *s) { return Append(s); }
    DynStr& operator += (const wchar_t *ws) { return AppendW(ws); }

#if DO_RETURN_STRUCT_WITH_DTOR_SAFE==1     
    DynStrRetVal operator + (const char *s) { return Concat(s); }
#endif     
    
    DynStr& operator += (int ch) { Append(ch); return *this; }  // NOTE: Does not react on incorrect Unicode char
    bool    StartsWith(const char *str) const { return FindAt(str,0); }
    bool    EndsWith(const char *str) const { return FindAt(str,STR_AT_END); }

    DynStr& Suffix(const char *str){ if(!FindAt(str,STR_AT_END)) Append(str); return *this; }
    DynStr& Prefix(const char *str){ if(!FindAt(str,0)) Prepend(str); return *this; }

    DynStr& Trunc( int at ){ return Remove(at,-1); }
    int operator [] (int ix) const { return GetUniChar(ix); }
    
    // Inline functions for appending formatted args
    DynStr& AppendArg( bool b, const char *fmt=NULL ){ 
        if( fmt ){
            char buf[64]; 
            int l=sprintf(buf,fmt,b); 
            if( l>0 ) Append(buf);
        }
        else Append( b ? "true" : "false" );
        return *this;
    }
    DynStr& AppendArg( int i, const char *fmt="%d" ){ 
        char buf[64]; 
        int l=sprintf(buf,fmt,i); 
        if( l>0 ) Append(buf);
        return *this;
    }
    DynStr& AppendArg( unsigned int i, const char *fmt="%u" ){ 
        char buf[64]; 
        int l=sprintf(buf,fmt,i); 
        if( l>0 ) Append(buf);
        return *this;
    }
    DynStr& AppendArg( char ch, const char *fmt="%c" ){ 
        char buf[64]; 
        int l=sprintf(buf,fmt,ch); 
        if( l>0 ) Append(buf);
        return *this;
    }
    DynStr& AppendArg( unsigned char ch, const char *fmt="%c" ){ 
        char buf[64]; 
        int l=sprintf(buf,fmt,ch); 
        if( l>0 ) Append(buf);
        return *this;
    }
    DynStr& AppendArg( double d, const char *fmt="%e" ){ 
        char buf[64]; 
        int l=sprintf(buf,fmt,d); 
        if( l>0 ) Append(buf);
        return *this;
    }
    DynStr& AppendArg( const void* pv, const char *fmt="%p" ){ 
        char buf[64]; 
        int l=sprintf(buf,fmt,pv); 
        if( l>0 ) Append(buf);
        return *this;
    }
    DynStr& AppendArg( const char *s, const char *fmt="%s" ){ 
        // Don't use any format string here, we'd have problems with length.
        if( s ) Append(s);
        return *this;
    }
    DynStr& AppendArg( const wchar_t *ws, const char *fmt="%s" ){ 
        // Don't use any format string here, we'd have problems with length.
        if( ws ) AppendW(ws);
        return *this;
    }

    #if DO_USE_TEMPLATES==1
    // Providing a convenient (and type safe) templated based way of 
    // formatting / appending text to a DynStr.
    #include "DynStrPrintf.hpp" 
    #endif // DO_USE_TEMPLATES==1
};

// %%DYNOBJ section implement
// This section is auto-generated and manual changes will be lost when regenerated!!
#ifdef DO_IMPLEMENT_DYNSTR

// Generate type information that auto-registers on module load
DynObjType g_do_vtype_DynStr("DynStr","DynObj",DYNSTR_TYPE_ID,0,sizeof(DynStr),NULL,NULL,__FILE__);
DynObjType* DynStr::doGetType( const DynI **pself ) const {
   if(pself) *pself=(const DynI*)(const void*)this;
   return &g_do_vtype_DynStr;
}
#endif //DO_IMPLEMENT_...
// %%DYNOBJ section end

#endif // DYNSTR_H

---