hastring.h

Go to the documentation of this file.

#ifndef HASTRING_H
#define HASTRING_H

#if defined(_MSC_VER)
#pragma warning (disable:4786)
#endif

// Use STL string
#include <string>

#if defined(_MSC_VER)
using namespace std;
#define _stricmp stricmp
#if !defined(DllImport)
        #define DllImport   __declspec( dllimport )
#endif
#if !defined(DllExport)
        #define DllExport   __declspec( dllexport )
#endif
#endif 

#include "hastl.h"

class HaString: public string
{
public:
        HaString() {}
        HaString(const string& bas_str): string(bas_str) {}
        HaString(const HaString& str): string(str) {}
        HaString(const char* s): string(s) {}
        HaString(const char* s, size_type n): string(s,n) {}
        virtual ~HaString() {}

        const char* trunc_space();  
        void convert_to_upper();    
        void convert_to_lower();    

        static HaString GetDirFromFileName(HaString fname);     
        static HaString GetPrefixFromFullName(HaString fname);  
    static HaString GetExtFromFileName(HaString fname);     

};

class StrDoubleMap;

class StrDoubleMap_itr
{
public:
        StrDoubleMap_itr( StrDoubleMap& new_map);
    StrDoubleMap_itr( StrDoubleMap_itr& ref);

        HaString GetKey();
        double   GetVal();
        int GetFirst();
        int GetNext();

protected:
        map<HaString, double, less<HaString> >::iterator itr;
        StrDoubleMap& int_map;
};

class StrDoubleMap: public map<HaString, double, less<HaString> >
{
public:

        typedef StrDoubleMap_itr iterator;

        void clear();
        int count(const char* str);
        int size();

        double GetVal(const char* str);
        void SetVal(const char* str, double val);
        int ierr; 
};

class StrStrMap;

class StrStrMap_itr
{
public:
        StrStrMap_itr( StrStrMap& new_map);
        StrStrMap_itr( StrStrMap_itr& ref);
        
        const char* GetKey();
        const char* GetVal();
        int GetFirst();
        int GetNext();

protected:
        map<HaString, HaString, less<HaString> >::iterator itr;
        StrStrMap& int_map;
};

class StrStrMap: public map<HaString, HaString, less<HaString> >
{
public:

        typedef StrStrMap_itr iterator;

        void clear();
        int count(const char* str);
        int size();

        const char* GetVal(const char* str);
        void SetVal(const char* str, const char* val);
        int ierr; 

};

class StrVec: public vector<HaString>
{
public:
        StrVec() {}
        StrVec(size_type n): vector<HaString>(n) {}
        StrVec(const vector<HaString>& str_vec): vector<HaString>(str_vec) {}

//  vector<> functions to be accessible through SWIG in python
//      
//  void reserve(size_t n); 
//  void resize(size_t n, const char* str);
//  size_t size();
//  void push_back(const char* str);
//  
        
    const char* GetVal(size_t idx);
        void SetVal(size_t idx, const char* val);
    
};


#if defined(linux) || defined(__DECCXX)
extern int _fstrnicmp(const char *s1, const char *s2, size_t n);
#endif

#if !defined(_MSC_VER)
extern int stricmp( const char* str1, const char* str2); 
                                                         
#endif    

extern int strcmp_trunc(const char* str1, const char* str2); 

extern int strcpy_to_fort(char* str_fort, const char* c_str, int len_fort); 

extern int stricmp_trunc(const char* str1, const char* str2); 

#endif /* !HASTRING_H */

---