strclass.h

Go to the documentation of this file.

/**********************************************************************
 *<
    FILE: strclass.h

    DESCRIPTION:

    CREATED BY: Dan Silva

    HISTORY:

 *> Copyright (c) 1994, All Rights Reserved.
 **********************************************************************/

#pragma once
#include <windows.h>
#include "maxheap.h"
#include "strbasic.h"
#include "tab.h"
#include "coreexp.h"

/*-------------------------------------------------------------------------------
  SR NOTE64

  "Only" supports 2G strings.

-------------------------------------------------------------------------------*/ 

//-----------------------------------------------------------------------
// CStr: Simple char string class
//-----------------------------------------------------------------------
class CStr: public MaxHeapOperators {
    char *buf;
    public:
        UtilExport CStr(); 
        UtilExport CStr(const char *cs);
        UtilExport CStr(const mwchar_t *wcstr);
        UtilExport CStr(const CStr& ws);
        UtilExport ~CStr(); 
        UtilExport char *data();
        UtilExport const char *data() const;
        UtilExport operator char *();
        UtilExport operator const char *() const;

        // realloc to nchars (padding with blanks)
        UtilExport void Resize(int nchars);

        UtilExport int Length() const { return ByteCount(); }
        int length() const { return Length(); }
        UtilExport int ByteCount() const;
        UtilExport int LanguageCharacterCount() const;

        BOOL isNull() const { return Length()==0?1:0; }

        UtilExport CStr & operator=(const CStr& cs);
        UtilExport CStr & operator=(const mwchar_t *wcstr);
        UtilExport CStr & operator=(const char *cs);

        // Concatenation operators.
        UtilExport CStr operator+(const CStr& cs) const;
        UtilExport CStr& operator+=(const CStr& cs); 
        CStr& Append(const CStr& cs)  { return ((*this) += cs); }
        CStr& append(const CStr& cs)  { return ((*this) += cs); }
        UtilExport CStr& remove(int pos);   // remove all chars from pos to end
        UtilExport CStr& remove(int pos, int N);    // remove N chars from pos to end

        // Substring operator
        UtilExport CStr Substr(int start, int nchars) const;
        UtilExport CStr MultiByteCharacterSubString(int firstCharacterIndex, int numberOfMBCharacters) const;
        UtilExport int FindMBCharacterFirstByteIndex(int characterIndex) const;
        UtilExport int FindMBCharacterLastByteIndex(int characterIndex) const;

        UtilExport char& operator[](int i);
        // SR NOTE64: was const char&, which is slower but would also confuse 64 builds.
        UtilExport char operator[](int i) const;    

        // Char search:(return -1 if not found)
        UtilExport int first(char c) const;
        UtilExport int last(char c) const;

        // Comparison
        UtilExport int operator==(const CStr &cs) const;
        UtilExport int operator!=(const CStr &cs) const;
        UtilExport int operator<(const CStr &cs) const;
        UtilExport int operator<=(const CStr &ws) const;
        UtilExport int operator>(const CStr &ws) const;
        UtilExport int operator>=(const CStr &ws) const;

        UtilExport void toUpper();
        UtilExport void toLower();

        UtilExport int printf(const char *format, ...);

        UtilExport int vprintf(const char *format, va_list args);
    };


//-----------------------------------------------------------------------
// WStr: Simple Wide char string class
//-----------------------------------------------------------------------
class WStr: public MaxHeapOperators {
    mwchar_t *buf;
    public:
        UtilExport WStr();
        UtilExport WStr(const char *cs);
        UtilExport WStr(const mwchar_t *wcstr);
        UtilExport WStr(const WStr& ws);
        UtilExport ~WStr();
        UtilExport mwchar_t *data();
        UtilExport const mwchar_t *data() const;
        UtilExport operator mwchar_t *();
        UtilExport operator const mwchar_t *() const;

        // realloc to nchars (padding with blanks)
        UtilExport void Resize(int nchars);
        UtilExport int Length() const;
        int length() const { return Length(); }
        UtilExport int ByteCount() const;
        UtilExport int LanguageCharacterCount() const;
        BOOL isNull() const { return Length()==0?1:0; }

        UtilExport WStr & operator=(const WStr& ws);
        UtilExport WStr & operator=(const mwchar_t *wcstr);
        UtilExport WStr & operator=(const char *cstr);

        // Concatenation operators.
        UtilExport WStr operator+(const WStr& ws) const; 
        UtilExport WStr & operator+=(const WStr& ws); 
        WStr& Append(const WStr& ws) { return ((*this) += ws); }
        WStr& append(const WStr& ws)  { return ((*this) += ws); }
        UtilExport WStr& remove(int pos);   // remove chars from pos to end
        UtilExport WStr& remove(int pos, int N);    // remove N chars from pos to end

        // Substring operator
        UtilExport WStr Substr(int start, int nchars) const;
        mwchar_t& operator[](int i) {
            DbgAssert((buf != NULL) && (i >= 0) && (i <= Length())); 
            return buf[i];
        }
        mwchar_t operator[](int i) const {
            DbgAssert((buf != NULL) && (i >= 0) && (i <= Length())); 
            return buf[i];
        }

        // Char search:(return -1 if not found)
        UtilExport int first(mwchar_t c) const;
        UtilExport int last(mwchar_t c) const;

        // Comparison
        UtilExport int operator==(const WStr &ws) const;
        UtilExport int operator!=(const WStr &ws) const;
        UtilExport int operator<(const WStr &ws) const;
        UtilExport int operator<=(const WStr &ws) const;
        UtilExport int operator>(const WStr &ws) const;
        UtilExport int operator>=(const WStr &ws) const;

        UtilExport void toUpper();
        UtilExport void toLower();

        UtilExport int printf(const mwchar_t *format, ...);

        UtilExport int vprintf(const mwchar_t *format, va_list args);
    };                  

#ifdef _UNICODE
#define TSTR WStr
#else
#define TSTR CStr
#endif

#ifdef _UNICODE
    #ifdef _UNICODE_MODULE_FOR_MBCS_MAX
        typedef CStr    MSTR;
    #else
        typedef WStr    MSTR;
    #endif
#else
    typedef CStr    MSTR;
#endif

//--FilterList----------------------------------------------------------------------
// A class whose sole purpose is for building up a  filter list to passing to
// GetSaveFileName and GetOpenFileName.  It automatically puts in the embedded nulls
// and two terminating nulls.
//   Example:
//
//  FilterList filterList;
//  filterList.Append( _M("Max files(*.max)"));
//  filterList.Append( _M("*.max"));
//  ofn.lpstrFilter  = filterList;
//  GetSaveFileName(&ofn)
//----------------------------------------------------------------------------------

class FilterList: public MaxHeapOperators {
    Tab<const MCHAR> buf;
    int m_filterIndex;
    int m_newFilterIndex;
    public:
        UtilExport FilterList();
        UtilExport void Append(const MCHAR *name);
        UtilExport void Append(FilterList& filters);
        UtilExport operator const MCHAR *(); 

        UtilExport int GetFilterIndex();

        UtilExport void SetFilterIndex(int filterIndex);

        UtilExport int GetNewFilterIndex();

        UtilExport void SetNewFilterIndex(int filterIndex);

        UtilExport const MCHAR* GetFilterDescriptor(unsigned int filterIndex);

        UtilExport const MCHAR* GetFilterExtension(unsigned int filterIndex);
    };


CoreExport void SplitFilename(const CStr& name, CStr* p, CStr* f, CStr* e);
CoreExport void SplitFilename(LPCSTR name, LPSTR p, LPSTR f, LPSTR e);
CoreExport void SplitFilename(const WStr& name, WStr* p, WStr* f, WStr* e);
CoreExport void SplitFilename(LPCWSTR name, LPWSTR p, LPWSTR f, LPWSTR e);

UtilExport void SplitFilenameOld(LPCSTR name, LPSTR p, LPSTR f, LPSTR e);
UtilExport void SplitFilenameOld(const CStr& name, CStr* p, CStr* f, CStr* e);
UtilExport void SplitFilenameOld(const WStr& name, WStr* p, WStr* f, WStr* e);
UtilExport void SplitFilenameOld(LPCWSTR name, LPWSTR p, LPWSTR f, LPWSTR e);
/*--------------------------------------------------
Split filename "name" into 
p  path
f  filename.ext
-------------------------------------------------*/
CoreExport void SplitPathFile(const MSTR& name,MSTR* p, MSTR* f);

/* /brief SplitPathFileOld only handles actual file names passed, not AssetId strings. */
UtilExport void SplitPathFileOld(const MSTR& name,MSTR* p, MSTR* f);
/*--------------------------------------------------
Check to see if s matches the pattern in ptrn
-------------------------------------------------*/

UtilExport BOOL MatchPattern(const MSTR &s, const MSTR &ptrn, BOOL ignoreCase=TRUE);


//-------------------------------------------------------------------------
// A Case Sensitive "smart" alphanumeric compare that sorts things so that
// numerical suffices come out in numerical order.
//-------------------------------------------------------------------------
UtilExport int MaxAlphaNumComp(MCHAR *a, MCHAR *b);


//-------------------------------------------------------------------------
// A Case Insensitive "smart" alphanumeric compare that sorts things so that
// numerical suffices come out in numerical order.
//-------------------------------------------------------------------------
UtilExport int MaxAlphaNumCompI(const MCHAR *a, const MCHAR *b);