strptrlen.h

跨操作系统的微型中间件

/*
    File:       StrPtrLen.h

    Contains:   Definition of class that tracks a string ptr and a length.
                Note: this is NOT a string container class! It is a string PTR container
                class. It therefore does not copy the string and store it internally. If
                you deallocate the string to which this object points to, and continue 
                to use it, you will be in deep doo-doo.
                
                It is also non-encapsulating, basically a struct with some simple methods.
                    

*/

#ifndef __STRPTRLEN_H__
#define __STRPTRLEN_H__

#ifdef __Win32__
#pragma warning(disable:4786)
#endif


#include <string.h>
#include "OSHeaders.h"
#include <ctype.h> 
#include "MyAssert.h"

#define STRPTRLENTESTING 0

//
//说明:本类的数据不属于自己，仅仅进行字符串的操作
//

class StrPtrLen
{
    public:

        //构造函数
        StrPtrLen() : Ptr(NULL), Len(0) {}
        StrPtrLen(char* sp) : Ptr(sp), Len(sp != NULL ? strlen(sp) : 0) {}
        StrPtrLen(char *sp, UInt32 len) : Ptr(sp), Len(len) {}

		//析构函数
        virtual ~StrPtrLen();
   
        //各类操作


		//字符串的比较操作
        
		Bool Equal(const StrPtrLen &compare) const;
        Bool Equal(const char* compare) const;

        Bool EqualIgnoreCase(const char* compare, const UInt32 len) const;
        Bool EqualIgnoreCase(const StrPtrLen &compare) const { return EqualIgnoreCase(compare.Ptr, compare.Len); }       
		Bool NumEqualIgnoreCase(const char* compare, const UInt32 len) const;
        
		void Delete() { delete [] Ptr; Ptr = NULL; Len = 0; }


		//大小写转换操作
	    char *ToUpper() { for (UInt32 x = 0; x < Len ; x++) Ptr[x] = toupper (Ptr[x]); return Ptr;}
        

		//字符串查找操作
        char *FindStringCase(char *queryCharStr, StrPtrLen *resultStr, Bool caseSensitive) const;

        char *FindString(StrPtrLen *queryStr, StrPtrLen *outResultStr)              {   Assert(queryStr != NULL);   Assert(queryStr->Ptr != NULL); Assert(0 == queryStr->Ptr[queryStr->Len]);
                                                                                        return FindStringCase(queryStr->Ptr, outResultStr,TRUE);    
                                                                                    }
        
        char *FindStringIgnoreCase(StrPtrLen *queryStr, StrPtrLen *outResultStr)    {   Assert(queryStr != NULL);   Assert(queryStr->Ptr != NULL); Assert(0 == queryStr->Ptr[queryStr->Len]); 
                                                                                        return FindStringCase(queryStr->Ptr, outResultStr,FALSE); 
                                                                                    }

        char *FindString(StrPtrLen *queryStr)                                       {   Assert(queryStr != NULL);   Assert(queryStr->Ptr != NULL); Assert(0 == queryStr->Ptr[queryStr->Len]); 
                                                                                        return FindStringCase(queryStr->Ptr, NULL,TRUE);    
                                                                                    }
        
        char *FindStringIgnoreCase(StrPtrLen *queryStr)                             {   Assert(queryStr != NULL);   Assert(queryStr->Ptr != NULL); Assert(0 == queryStr->Ptr[queryStr->Len]); 
                                                                                        return FindStringCase(queryStr->Ptr, NULL,FALSE); 
                                                                                    }
                                                                                    
        char *FindString(char *queryCharStr)                                        { return FindStringCase(queryCharStr, NULL,TRUE);   }
        char *FindStringIgnoreCase(char *queryCharStr)                              { return FindStringCase(queryCharStr, NULL,FALSE);  }
        char *FindString(char *queryCharStr, StrPtrLen *outResultStr)               { return FindStringCase(queryCharStr, outResultStr,TRUE);   }
        char *FindStringIgnoreCase(char *queryCharStr, StrPtrLen *outResultStr)     { return FindStringCase(queryCharStr, outResultStr,FALSE);  }

        char *FindString(StrPtrLen &query, StrPtrLen *outResultStr)                 { return FindString( &query, outResultStr);             }
        char *FindStringIgnoreCase(StrPtrLen &query, StrPtrLen *outResultStr)       { return FindStringIgnoreCase( &query, outResultStr);   }
        char *FindString(StrPtrLen &query)                                          { return FindString( &query);           }
        char *FindStringIgnoreCase(StrPtrLen &query)                                { return FindStringIgnoreCase( &query); }
        



		//赋值操作，不拷贝数据
        StrPtrLen& operator=(const StrPtrLen& newStr) { Ptr = newStr.Ptr; Len = newStr.Len;
                                                        return *this; }
        char operator[](int i) { /*Assert(i<Len);i*/ return Ptr[i]; }
        void Set(char* inPtr, UInt32 inLen) { Ptr = inPtr; Len = inLen; }
        void Set(char* inPtr) { Ptr = inPtr; Len = (inPtr) ?  ::strlen(inPtr) : 0; }
        
		//void Delete() { delete [] Ptr; Ptr = NULL; Len = 0; }


        //This is a non-encapsulating interface. The class allows you to access its
        //data.
        char*       Ptr;
        UInt32      Len;

	// added by samsmith
	const char* GetConstPtr(){return (const char*)Ptr;};

		//打印输出的操作
        void    PrintStr();
        void    PrintStr(char *appendStr);
        void    PrintStrEOL(char* stopStr = NULL, char *appendStr = NULL);
 
        //去掉空格的操作
        UInt32    TrimTrailingWhitespace();
        UInt32    TrimLeadingWhitespace();
        UInt32	  RemoveWhitespace();
        void      TrimWhitespace() { TrimLeadingWhitespace(); TrimTrailingWhitespace(); }

		//生成一个新的有自己空间的String传给其他模块
        char*     GetAsCString() const;

#if STRPTRLENTESTING
        static Bool   Test();
#endif

    private:

        static UInt8    sCaseInsensitiveMask[];
        static UInt8    sNonPrintChars[];
};


/*
class StrPtrLenDel : public StrPtrLen
{
  public:
     StrPtrLenDel() : StrPtrLen() {}
     StrPtrLenDel(char* sp) : StrPtrLen(sp) {}
     StrPtrLenDel(char *sp, UInt32 len) : StrPtrLen(sp,len) {}
     ~StrPtrLenDel() { Delete(); }
};
*/

#endif // __STRPTRLEN_H__