gzBase.h

Go to the documentation of this file.

// *****************************************************************************
// File         : gzBase.h
// Module       : gzBase
// Description  : Class definition of basic classes such as strings etc.
// Author       : Anders Modén      
// Product      : GizmoBase 2.1.1
//      
// Copyright © 2003- Saab Training Systems AB, Sweden
//          
// NOTE:    GizmoBase is a platform abstraction utility layer for C++. It contains 
//          design patterns and C++ solutions for the advanced programmer.
//
//
// Revision History...                          
//                                  
// Who  Date    Description                     
//                                  
// AMO  980819  Created file 
// AMO  990602  Added support for file traversal    
//
// ******************************************************************************

#ifndef __GZ_BASE_H__
#define __GZ_BASE_H__

#include "gzBasicTypes.h"
#include "gzMemory.h"
#include "gzDebug.h"
#include "gzMutex.h"

#include <string.h>

#if defined GZ_UNIX

#include <dirent.h>

typedef DIR * gzDirHandle;
typedef struct dirent * gzDirEntry;

#else   // non unix

#include "windows.h"
typedef HANDLE gzDirHandle;
typedef WIN32_FIND_DATA gzDirEntry;

#endif

// ----------------------- UNICODE macros for gzString arguments -----------------------

#if defined UNICODE
    #define GZ_T_UNICODE(x)         (x)##.getWideString()
    #define GZ_T_UNICODE_LEN(x)     (x)##.getWideStringLength()
#else
    #define GZ_T_UNICODE(x)         (const char *)(x)
    #define GZ_T_UNICODE_LEN(x)     (x)##.length()
#endif


// ******************** class definitions ***************************************

//******************************************************************************
// Class    : gzString
//                                  
// Purpose  : String objects
//                                  
// Notes    : - 
//                                  
// Revision History...                          
//                                  
// Who  Date    Description                     
//                                  
// AMO  980820  Created 
//                                  
//******************************************************************************

class  GZ_BASE_EXPORT gzString  
{

public:     

    // Type info
    GZ_DECLARE_TYPE_INTERFACE;

    // Constructors 


    gzString():m_string(NULL),m_len(0),m_uniqueID(0),m_hash(0){}


    gzString(const char *str):m_string(NULL),m_len(0),m_uniqueID(0),m_hash(0){ *this = str; }

    gzString(const char *str, gzUShort len);
    
    gzString(const gzString &str);
    
    virtual ~gzString();

    gzString(const gzWideChar *widestr);

    gzString(const gzWideChar *widestr , gzUShort len,gzBool isPlain=FALSE);


    gzString(gzLongLong number,gzUByte radix,gzULong minLen=0);
    
    gzString(gzDouble number,const gzString & format=""); 
    

    gzUShort        length() const      { return m_len; }

    gzVoid          clear();

    const char *    getString() const;

    gzLongLong      num() const;

    gzDouble        real(gzUShort decimalToken='.') const;

    gzDouble        sortval() const;


    gzBool          contains(const gzString & substr, gzUShort startindex=0 , gzBool caseSensitive = TRUE , gzUShort *index=NULL) const;
    

    gzString        rightOf(const gzString & substr, gzBool searchFromEnd = TRUE, gzBool caseSensitive = TRUE ) const;
    

    gzString        leftOf(const gzString & substr, gzBool searchFromStart = TRUE , gzBool caseSensitive = TRUE ) const;
    
    gzString        toLower() const;
    
    gzString        toUpper() const;

    gzString        left(gzULong count,gzBool inverse=FALSE)    const;

    gzString        right(gzULong count,gzBool inverse=FALSE)   const;


    gzString        strip(char c , gzBool left=TRUE , gzBool right=TRUE) const;

    gzString        stripWhiteSpace(gzBool left=TRUE , gzBool right=TRUE) const;

    gzVoid          reverse();

    gzULong         hash()  const   { return m_hash; }

    gzBool          isEmpty() const { return m_len==0; }

    gzBool          isFirst( const gzString &str , gzBool caseSensitive = TRUE) const;

    gzBool          isFirst( const char ch , gzBool caseSensitive = TRUE) const;

    gzBool          isLast( const gzString &str , gzBool caseSensitive = TRUE) const;

    gzBool          isLast( const char ch , gzBool caseSensitive = TRUE) const;


    gzString &      format( const gzString &format, ARG_DECL_LIST );

    gzString &      identifier(gzLongLong number);

    gzUShort        getWideStringLength() const;


    gzUShort        getWideString(gzWideChar *buffer, gzBool appendZero=TRUE) const;

    gzBool          hasEscapedUTF8Chars() const;

    gzBool          isAsciiString() const;


    gzString        convertAsciiToUTF8() const;


    gzString        convertUTF8ToAscii() const;

    gzString        convertUTF8ToNumList(const gzString &format="0x%02x",const gzString &separator=",") const;

    gzString        convertNumListToUTF8() const;

    gzString        convertTextToCtrl() const;

    gzString        convertCtrlToText() const;

    const gzWideChar *  getWideString(gzUShort knownLength=0) const;
    
    /* Remember that BSTR strings can contain zero characters but they are limited to max 255 characters */
    gzArray<gzUByte>    getBSTR() const;
    
    /* Remember that WideBSTR strings can contain zero characters but they are limited to max 65535 characters */
    gzArray<gzWideChar> getWideBSTR() const;

    gzString &      scramble(gzULong code);


    gzLongLong      dotValue(gzULong base=256,gzULong *groups=NULL) const; // e.g. "255.234.245.23"

    gzUShort            substitute(char from,char to);

    gzBool          yesNo();

    /* param size Set to zero if string length shall be calculated. */
    static gzULong  hash(const char *s , gzULong size=0); 
    
    // Unique string management
    gzBool      isUnique() const;
    gzUShort    getUniqueID() const;
    gzBool      makeUnique(gzUShort uniqueID=0);
    gzBool      checkUnique() const;

    // ----- Class Operators ------------------------------

    operator gzLongLong () const { return num(); }

    operator gzDouble ()    const   { return real(); }

    gzString &  operator =(const char *str);

    // Default cast of string to char * (UTF8 or ASCII)
    operator const char *() const;  

    gzString &  operator =(const gzString &str);

    gzString &  operator +=(const char *str);

    gzString    operator +(const char *str) const;
    
    gzString    operator +(const gzString &str) const;

    gzString &  operator +=(const gzString &str);

    gzString &  operator +=(const char c);
    
    gzString &  operator +=(const gzWideChar wc);

    gzString    operator +(const char c) const;
    
    gzString    operator +(const gzWideChar wc) const;

    gzBool      operator !() const { return (m_string == NULL) ? TRUE : (m_string[0] == '\0'); }
    
    char &      operator ()(const gzUShort index);

    gzString    operator ()(const gzUShort index , const gzUShort len) const;

    // ---- Global operators --------------------------------

    GZ_BASE_EXPORT friend gzBool    operator ==(const gzString &str, const char *s);
 
    GZ_BASE_EXPORT friend gzBool    operator ==(const char *s, const gzString &str);
    
    GZ_BASE_EXPORT friend gzBool    operator ==(const gzString &str1, const gzString &str2);

    GZ_BASE_EXPORT friend gzBool    operator !=(const gzString &str, const char *s);
    
    GZ_BASE_EXPORT friend gzBool    operator !=(const char *s, const gzString &str);

    GZ_BASE_EXPORT friend gzBool    operator !=(const gzString &str1, const gzString &str2);

    GZ_BASE_EXPORT friend gzBool    operator <(const gzString &str, const char *s);
    
    GZ_BASE_EXPORT friend gzBool    operator <(const char *s, const gzString &str);

    GZ_BASE_EXPORT friend gzBool    operator <(const gzString &str1, const gzString &str2);

    GZ_BASE_EXPORT friend gzBool    operator >(const gzString &str, const char *s);
    
    GZ_BASE_EXPORT friend gzBool    operator >(const char *s, const gzString &str);

    GZ_BASE_EXPORT friend gzBool    operator >(const gzString &str1, const gzString &str2);

    GZ_BASE_EXPORT friend gzBool    operator <=(const gzString &str, const char *s);
 
    GZ_BASE_EXPORT friend gzBool    operator <=(const char *s, const gzString &str);
    
    GZ_BASE_EXPORT friend gzBool    operator <=(const gzString &str1, const gzString &str2);

    GZ_BASE_EXPORT friend gzBool    operator >=(const gzString &str, const char *s);
 
    GZ_BASE_EXPORT friend gzBool    operator >=(const char *s, const gzString &str);
    
    GZ_BASE_EXPORT friend gzBool    operator >=(const gzString &str1, const gzString &str2);

    // -------------------- static utils ------------------------------

    static gzString spaces(gzUShort count,const char fillChar=' ');

private:

    gzChar      mutable *m_string;
    gzUShort            m_len;
    gzUShort    mutable m_uniqueID;
    gzULong             m_hash;
    
};


const gzString GZ_EMPTY_STRING;

const gzUShort GZ_MAX_SYSTEM_UNIQUE_ID=65535;

const gzUShort GZ_MAX_BASE_UNIQUE_ID=500;

class GZ_BASE_EXPORT gzUniqueString : public gzString
{
public:
    gzUniqueString(const gzString &copy,gzUShort uniqueID=0);
    gzUniqueString(gzUShort uniqueID);

    static gzUShort getNextFreeId();
    static gzBool   isFreeId(gzUShort id);
};

enum gzBeepType
{
    GZ_BEEP_DEFAULT,
    GZ_BEEP_ASTERISK,
    GZ_BEEP_EXCLAMATION,
    GZ_BEEP_HAND,
    GZ_BEEP_QUESTION,
    GZ_BEEP_OK
};

//******************************************************************************
// Generic Utilities
//******************************************************************************

GZ_BASE_EXPORT gzDouble gzRandom();

GZ_BASE_EXPORT const gzDouble &gzRandom(gzULong seqIndex);

GZ_BASE_EXPORT gzBool gzIsPowerOfTwo(gzDouble number);

GZ_BASE_EXPORT gzDouble gzGetUpperPowerOfTwo(gzDouble number);

GZ_BASE_EXPORT gzLong gzGetUpperPowerOfTwoExponent(gzDouble number);

GZ_BASE_EXPORT gzVoid gzLtoA( char * buffer , gzLongLong number , gzUByte radix , gzLong precision=0 , gzLong *len=NULL , gzBool upper=FALSE);

GZ_BASE_EXPORT gzVoid gzLtoA( gzWideChar * buffer , gzLongLong number , gzUByte radix , gzLong precision=0 , gzLong *len=NULL , gzBool upper=FALSE);

GZ_BASE_EXPORT gzVoid gzULtoA( char * buffer , gzULongLong number , gzUByte radix , gzLong precision=0 , gzLong *len=NULL , gzBool upper=FALSE);

GZ_BASE_EXPORT gzVoid gzULtoA( gzWideChar * buffer , gzULongLong number , gzUByte radix , gzLong precision=0 , gzLong *len=NULL , gzBool upper=FALSE);

GZ_BASE_EXPORT gzVoid gzULtoIdent( char * buffer , gzULongLong number , gzLong precision=0 , gzLong *len=NULL );

GZ_BASE_EXPORT gzVoid gzDtoA( char * buffer , gzDouble number , gzLong precision=6 , gzLong *len=NULL);

GZ_BASE_EXPORT gzVoid gzDtoA( gzWideChar * buffer , gzDouble number , gzLong precision=6 , gzLong *len=NULL);

GZ_BASE_EXPORT gzDouble gzFaculty( gzULong num);

GZ_BASE_EXPORT gzDouble gzCombination( gzULong n , gzULong p);

GZ_BASE_EXPORT gzDouble gzPow10(gzShort power);

GZ_BASE_EXPORT gzDouble gzPrecision( gzDouble number , gzULong digits , gzBool round=TRUE);

GZ_BASE_EXPORT gzULong gzUTF8ToULong(const char *adress,gzUByte *size=NULL);

GZ_BASE_EXPORT gzUByte gzULongToUTF8(char *adress,gzULong data);

GZ_BASE_EXPORT gzUByte gzUTF8Size(gzULong data);

GZ_BASE_EXPORT gzUByte gzUTF8Size(const char *adress);

GZ_BASE_EXPORT gzInt gzGetLastSysError();

GZ_BASE_EXPORT gzVoid gzSetLastSysError(gzInt error=0);

GZ_BASE_EXPORT  gzString gzGetSysErrorDescription(gzInt error);

GZ_BASE_EXPORT gzString gzYesNo(gzBool value);

GZ_BASE_EXPORT  gzBool gzBigEndian();

GZ_BASE_EXPORT  gzVoid gzBeep(gzBeepType beepType = GZ_BEEP_DEFAULT);

GZ_BASE_EXPORT  gzBool gzIsValidIpAddress(const gzString& ipAddress, gzUInt groups = 4);

GZ_BASE_EXPORT  gzBool gzAttachConsole();

GZ_BASE_EXPORT  gzString gzRegKeyExpandedString(const gzString &compressed);

//******************************************************************************
// Struct   : gzTranslation
//
// Purpose  : Data item for a translation
//
// Notes    : -
//
// Revision History...
//
// Who  Date    Description
//
// AMO  000531  Created 
//                                  
//******************************************************************************
struct gzTranslation
{
    gzString    language;
    gzString    context;
    gzString    message;
    gzString    translation;
};

GZ_BASE_EXPORT gzArray<gzTranslation> getDefaultTranslations();

enum gzRegKeyHeader
{
    GZ_KEY_LOCAL_MACHINE,
    GZ_KEY_CURRENT_USER,
    GZ_KEY_CLASSES_ROOT,
};

const gzString GZ_DEFAULT_KEY_HEADER    =   "software/Saab Training Systems/GizmoSDK";

//******************************************************************************
// Class    : gzKeyDatabase
//                                  
// Purpose  : Management of key data
//                                  
// Notes    : - 
//                                  
// Revision History...                          
//                                  
// Who  Date    Description                     
//                                  
// AMO  990518  Created 
//                                  
//******************************************************************************
class  GZ_BASE_EXPORT gzKeyDatabase
{
public:
    
    // ------------ global used keys ------------------
    static gzBool   existGlobalKey(gzString key, const gzString & password="");

    static gzVoid   setGlobalKey(gzString key , gzString value, const gzString & password="");
    static gzString getGlobalKey(gzString key, const gzString & password="");
    static gzString getDefaultGlobalKey(gzString key, const gzString &defaultValue , const gzString & password="");
    static gzBool   removeGlobalKey(gzString key, const gzString & password="");

    // ------------ local user key values -------------
    static gzBool   existUserKey(gzString key, const gzString & password="", gzBool onlyUserKey=FALSE);

    static gzVoid   setUserKey(gzString key , gzString value , const gzString & password="");
    static gzString getUserKey(gzString key , const gzString & password="" , gzBool onlyUserKey=FALSE);
    static gzString getDefaultUserKey(gzString key , const gzString &defaultValue , const gzString & password="" , gzBool onlyUserKey=FALSE);
    static gzBool   removeUserKey(gzString key , const gzString & password="", gzBool onlyUserKey=FALSE);

    // ------------ generic key values ----------------
    static gzVoid   setRegKey(gzRegKeyHeader keyRootHeader, gzString  keyHeader, const gzString &keyName , const gzString &value);
    static gzBool   existRegKey(gzRegKeyHeader keyRootHeader, gzString  keyHeader, const gzString &keyName );
    static gzBool   removeRegKey(gzRegKeyHeader keyRootHeader, gzString  keyHeader, const gzString &keyName );
    static gzString getRegKey(gzRegKeyHeader keyRootHeader, gzString  keyHeader, const gzString &keyName );
    static gzString getDefaultRegKey(gzRegKeyHeader keyRootHeader, gzString  keyHeader, const gzString &keyName ,const gzString &defaultValue );

    static gzVoid           setDefaultKeyHeader(const gzString &header);
    static const gzString & getDefaultKeyHeader();

    // ------------ local settings --------------------
    static gzVoid   setLocalRegistry(const gzString &url);
    
};

//******************************************************************************
// Class    : gzDirectory
//                                  
// Purpose  : General purpose class for Filesystem access etc.
//                                  
// Notes    : - 
//                                  
// Revision History...                          
//                                  
// Who  Date    Description                     
//                                  
// AMO  990602  Created 
//                                  
//******************************************************************************
class GZ_BASE_EXPORT gzDirectory
{
public:
    // Searches the system key GIZMO_PATH variable and expands the filename to full path
    static gzString getExtendedFileName(gzString filename);
};

//******************************************************************************
// Class    : gzDirectoryEntry
//                                  
// Purpose  : Holds data about a directory entry
//                                  
// Notes    : - 
//                                  
// Revision History...                          
//                                  
// Who  Date    Description                     
//                                  
// AMO  990602  Created 
//                                  
//******************************************************************************
class GZ_BASE_EXPORT gzDirectoryEntry
{
public:
    gzDirectoryEntry(){};

    gzBool isDirectory();
    
    gzString getPath();
    
    gzString getEntryName();
    
private:

    friend class gzDirectoryIterator;
    gzDirectoryEntry(gzString name , gzString path , gzBool isDirectory);
    
    gzString    m_name;
    gzString    m_path;
    gzBool      m_isDirectory;
};

//******************************************************************************
// Class    : gzDirectoryIterator
//                                  
// Purpose  : iterates a given path to find files or directories
//                                  
// Notes    : - 
//                                  
// Revision History...                          
//                                  
// Who  Date    Description                     
//                                  
// AMO  990602  Created 
//                                  
//******************************************************************************
class  GZ_BASE_EXPORT gzDirectoryIterator
{
public:
    gzDirectoryIterator(const gzString &path , gzBool recursive=FALSE );
    
    virtual ~gzDirectoryIterator();

    gzBool              foundEntry();
    
    gzDirectoryEntry    getEntry();
    
private:

    gzDirHandle         m_dirp;
    gzDirEntry          m_entry;
    gzString            m_path;
    gzBool              m_recursive;
    gzDirectoryEntry    m_currentEntry;
    gzDirectoryIterator *m_iterator;
};

class gzSerializeAdapter; // Forward decl for serializers

//******************************************************************************
// Class    : gzNameInterface
//                                  
// Purpose  : Interface for named objects. 
//                                  
// Notes    : - 
//                                  
// Revision History...                          
//                                  
// Who  Date    Description                     
//                                  
// AMO  990520  Created 
//                                  
//******************************************************************************
class gzNameInterface
{
public:
    GZ_BASE_EXPORT  gzNameInterface(const gzString &name=GZ_EMPTY_STRING);

    GZ_BASE_EXPORT  virtual ~gzNameInterface(){};

    GZ_BASE_EXPORT  const gzString &    getName() const;
    GZ_BASE_EXPORT  gzVoid              setName(const gzString &name);

    GZ_BASE_EXPORT gzVoid   write(gzSerializeAdapter *adapter);
    GZ_BASE_EXPORT gzVoid   read(gzSerializeAdapter *adapter);
    GZ_BASE_EXPORT gzULong  getDataSize(gzSerializeAdapter *adapter=NULL) const;


private:

    gzLateBindData<gzString>    m_name;
};

//******************************************************************************
// Class    : gzUpdateIDInterface
//                                  
// Purpose  : Interface for update numbers of a counter 
//                                  
// Notes    : - 
//                                  
// Revision History...                          
//                                  
// Who  Date    Description                     
//                                  
// AMO  001206  Created 
//                                  
//******************************************************************************
class GZ_BASE_EXPORT gzUpdateIDInterface
{
public:

    gzUpdateIDInterface(){m_updateID=(gzULong)gzPtr2Val(this);}

    gzUpdateIDInterface(const gzUpdateIDInterface &copy){m_updateID=(gzULong)gzPtr2Val(this);}

    gzUpdateIDInterface & operator=(const gzUpdateIDInterface &copy){m_updateID=(gzULong)gzPtr2Val(this);return *this;}

    gzULong getUpdateID()               { return m_updateID; }

    gzVoid  setUpdateID(gzULong id)     { m_updateID=id; }

    gzVoid  updateID()                  { ++m_updateID;}

private:

    gzULong m_updateID;
};

//******************************************************************************
// Class    : gzUpdateIDFeatureInterface
//                                  
// Purpose  : Interface for update numbers of a counter 
//                                  
// Notes    : - 
//                                  
// Revision History...                          
//                                  
// Who  Date    Description                     
//                                  
// AMO  040601  Created 
//                                  
//******************************************************************************
class gzUpdateIDFeatureInterface
{
public:

    GZ_BASE_EXPORT gzUpdateIDFeatureInterface();

    GZ_BASE_EXPORT gzUpdateIDFeatureInterface(const gzUpdateIDFeatureInterface &copy);

    GZ_BASE_EXPORT gzUpdateIDFeatureInterface & operator=(const gzUpdateIDFeatureInterface &copy);

    GZ_BASE_EXPORT gzULong  getUpdateID();

    GZ_BASE_EXPORT gzVoid   setUpdateID(gzULong id);

    GZ_BASE_EXPORT gzVoid   updateID(gzULong featureMask=0xFFFFFFFFUL);

    // Feature mask

    GZ_BASE_EXPORT gzVoid   setFeatureMask(gzULong mask);

    // Done per lookup id
    
    GZ_BASE_EXPORT gzVoid   resetFeatureMask(gzULong mask=0xFFFFFFFFUL,gzULong lookup=0);

    GZ_BASE_EXPORT gzBool   checkFeature(gzULong mask,gzULong lookup=0);

private:

    class gzUpdateIDFeature
    {
    public:

        gzUpdateIDFeature():m_featureMask(0xFFFFFFFFUL){};
        
        gzULong m_featureMask;
    };

    gzULong m_updateID;

    gzDynamicArray<gzUpdateIDFeature>   m_lookup_feature_data;
};

//******************************************************************************
// Class    : gzLookupUpdateID
//                                  
// Purpose  : Manages update id per lockup id
//                                  
// Notes    : - 
//                                  
// Revision History...                          
//                                  
// Who  Date    Description                     
//                                  
// AMO  040601  Created 
//                                  
//******************************************************************************
class gzLookupUpdateID 
{
public:

    GZ_BASE_EXPORT  gzLookupUpdateID();

    GZ_BASE_EXPORT  gzVoid  setUpdateID(gzULong lookup,gzULong id);

    GZ_BASE_EXPORT  gzULong getUpdateID(gzULong lookup);

    GZ_BASE_EXPORT  gzVoid  clear();

private:

    class gzLookupUpdateData 
    {
        public:
            gzLookupUpdateData():m_id(0){}

        gzULong m_id;
    };

    gzDynamicArray<gzLookupUpdateData> m_lookup_id;
};


//******************************************************************************
// Class    : gzUniqueIDManager
//                                  
// Purpose  : Manages a set of unique IDs
//                                  
// Notes    : 
//                                  
// Revision History...                          
//                                  
// Who  Date    Description                     
//                                  
// AMO  030313  Created 
//                                  
//******************************************************************************
class gzUniqueIDManager 
{
public:

    GZ_BASE_EXPORT gzUniqueIDManager();

    GZ_BASE_EXPORT virtual ~gzUniqueIDManager();

    GZ_BASE_EXPORT gzULong allocateID();

    GZ_BASE_EXPORT gzVoid freeID(gzULong id);

private:

    gzQueue<gzULong>    m_idRep;

    gzULong             m_lastID;
};

#endif // __GZ_BASE_H__

---