SbString.h

Go to the documentation of this file.

/*
 *
 *  Copyright (C) 2000 Silicon Graphics, Inc.  All Rights Reserved. 
 *
 *  This library is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU Lesser General Public
 *  License as published by the Free Software Foundation; either
 *  version 2.1 of the License, or (at your option) any later version.
 *
 *  This library is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *  Lesser General Public License for more details.
 *
 *  Further, this software is distributed without any warranty that it is
 *  free of the rightful claim of any third person regarding infringement
 *  or the like.  Any license provided herein, whether implied or
 *  otherwise, applies only to this software file.  Patent licenses, if
 *  any, provided herein do not apply to combinations of this program with
 *  other software, or any other product whatsoever.
 * 
 *  You should have received a copy of the GNU Lesser General Public
 *  License along with this library; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 *  Contact information: Silicon Graphics, Inc., 1600 Amphitheatre Pkwy,
 *  Mountain View, CA  94043, or:
 * 
 *  http://www.sgi.com 
 * 
 *  For further information regarding this notice, see: 
 * 
 *  http://oss.sgi.com/projects/GenInfo/NoticeExplan/
 *
 */
 
 
/*
 * Copyright (C) 1990,91   Silicon Graphics, Inc.
 *
 _______________________________________________________________________
 ______________  S I L I C O N   G R A P H I C S   I N C .  ____________
 |
 |   $Revision: 1.1.1.1 $
 |
 |   Description:
 |      This file contains definitions of the SbString and SbName
 |      classes, which are useful variations on our friend, the
 |      character string.
 |
 |   Author(s)          : Paul S. Strauss, Nick Thompson
 |
 ______________  S I L I C O N   G R A P H I C S   I N C .  ____________
 _______________________________________________________________________
 */
 
#ifndef _SB_STRING_
#define _SB_STRING_
 
#include <Inventor/system/SbSystem.h>
#include <Inventor/SbBasic.h>
 
#include <string.h>
 
#ifdef WIN32
#define oiv_strdup _strdup
#else
#define oiv_strdup strdup
#endif
 
 
 
class INVENTOR_API SbString {
  public:
 
    SbString()                          { string = staticStorage; 
                                          string[0] = '\0'; }
 
    SbString(const char *str)           { string = staticStorage;
                                          *this = str; }
 
    SbString(const char *str, int start, int end);
 
    SbString(const SbString &str)       { string = staticStorage;
                                          *this = str.string; }
 
    SbString(int digitString);
 
    ~SbString();
 
    uint32_t            hash()          { return SbString::hash(string); }
 
    int                 getLength() const       { return static_cast<int>(strlen(string)); }
 
    void                makeEmpty(bool freeOld = TRUE);
 
    const char *        getString() const       { return string; }
 
    SbString            getSubString(int startChar, int endChar = -1) const;
 
    void                deleteSubString(int startChar, int endChar = -1);
 
    SbString &          operator =(const char *str);
    SbString &          operator =(const SbString &str)
        { return (*this = str.string); }
 
    SbString &          operator +=(const char *str);
 
    SbString &          operator +=(const SbString &str);
 
    bool                   operator !() const { return (string[0] == '\0'); }
 
    friend INVENTOR_API bool               operator ==(const SbString &str, const char *s);
 
    friend INVENTOR_API bool               operator ==(const char *s, const SbString &str)
        { return (str == s); }
 
 
    friend INVENTOR_API bool               operator ==(const SbString &str1, const SbString &str2)
        { return (str1 == str2.string); }
 
    friend INVENTOR_API bool               operator !=(const SbString &str, const char *s);
 
    friend INVENTOR_API bool               operator !=(const char *s, const SbString &str)
        { return (str != s); }
 
    friend INVENTOR_API bool               operator !=(const SbString &str1,
                                    const SbString &str2)
        { return (str1 != str2.string); }
 
    friend INVENTOR_API bool               operator <(const SbString &str, const char *s);
 
    friend INVENTOR_API bool               operator <(const char *s, const SbString &str)
        { return (str < s); }
    
    friend INVENTOR_API bool               operator <(const SbString &str1, const SbString &str2)
        { return (str1 < str2.string); }
 
  SoINTERNAL public:
 
    static uint32_t     hash(const char *s);    // Hash function
 
  private:
    char                *string;                
    int                 storageSize;
 
#define SB_STRING_STATIC_STORAGE_SIZE           32
    char                staticStorage[SB_STRING_STATIC_STORAGE_SIZE];
 
    void                expand(int bySize);     
};
 
 
 
SoINTERNAL class INVENTOR_API SbNameEntry {
 
  public:
    bool                isEmpty() const   { return (string[0] == '\0'); }
 
    bool                isEqual(const char *s) const
        { return (string[0] == s[0] && ! strcmp(string, s)); }
 
  private:
    static int          nameTableSize;  
    static SbNameEntry  **nameTable;    
    static struct SbNameChunk *chunk;   
 
    const char          *string;        
    uint32_t            hashValue;      
    SbNameEntry         *next;          
 
    static void         initClass();
 
    SbNameEntry(const char *s, uint32_t h, SbNameEntry *n)
        { string = s; hashValue = h; next = n; }
 
    static const SbNameEntry *  insert(const char *s);
 
friend INVENTOR_API class SbName;
};
 
 
 
 
 
class INVENTOR_API SbName {
  public:
 
    SbName();
 
    SbName(const char *s)               { entry = SbNameEntry::insert(s); }
 
    SbName(const SbString &s)   { entry = SbNameEntry::insert(s.getString()); }
 
    SbName(const SbName &n)                     { entry = n.entry; }
 
    ~SbName()                                   {}
 
    const char          *getString() const      { return entry->string; }
 
    int                 getLength() const   { return static_cast<int>(strlen(entry->string)); }
 
    static bool         isIdentStartChar(char c);
 
    static bool         isIdentChar(char c);
 
    static bool         isBaseNameStartChar(char c);
 
    static bool         isBaseNameChar(char c);
 
    bool                operator !() const   { return entry->isEmpty(); }
 
    friend INVENTOR_API bool               operator ==(const SbName &n, const char *s)
        { return n.entry->isEqual(s); }
 
    friend INVENTOR_API bool               operator ==(const char *s, const SbName &n)
        { return n.entry->isEqual(s); }
 
    friend INVENTOR_API bool               operator ==(const SbName &n1, const SbName &n2)
        { return n1.entry == n2.entry; }
 
    friend INVENTOR_API bool               operator !=(const SbName &n, const char *s)
        { return ! n.entry->isEqual(s); }
 
    friend INVENTOR_API bool               operator !=(const char *s, const SbName &n)
        { return ! n.entry->isEqual(s); }
 
    friend INVENTOR_API bool               operator !=(const SbName &n1, const SbName &n2)
        { return n1.entry != n2.entry; }
 
  private:
    const SbNameEntry   *entry;         
};
 
#endif /* _SB_STRING_ */