MeVis/ThirdParty/Sources/Inventor/inventor/lib/database/include/Inventor/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>





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(SbBool 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);

    int                 operator !() const { return (string[0] == '\0'); }

    friend INVENTOR_API int             operator ==(const SbString &str, const char *s);

    friend INVENTOR_API int             operator ==(const char *s, const SbString &str)
        { return (str == s); }


    friend INVENTOR_API int             operator ==(const SbString &str1, const SbString &str2)
        { return (str1 == str2.string); }

    friend INVENTOR_API int             operator !=(const SbString &str, const char *s);

    friend INVENTOR_API int             operator !=(const char *s, const SbString &str)
        { return (str != s); }

    friend INVENTOR_API int             operator !=(const SbString &str1,
                                    const SbString &str2)
        { return (str1 != str2.string); }

    friend INVENTOR_API int             operator <(const SbString &str, const char *s);

    friend INVENTOR_API int             operator <(const char *s, const SbString &str)
        { return (str < s); }
    
    friend INVENTOR_API int             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:
    SbBool              isEmpty() const   { return (string[0] == '\0'); }

    SbBool              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 SbBool       isIdentStartChar(char c);

    static SbBool       isIdentChar(char c);

    static SbBool       isBaseNameStartChar(char c);

    static SbBool       isBaseNameChar(char c);

    int                 operator !() const   { return entry->isEmpty(); }

    friend INVENTOR_API int             operator ==(const SbName &n, const char *s)
        { return n.entry->isEqual(s); }

    friend INVENTOR_API int             operator ==(const char *s, const SbName &n)
        { return n.entry->isEqual(s); }

    friend INVENTOR_API int             operator ==(const SbName &n1, const SbName &n2)
        { return n1.entry == n2.entry; }

    friend INVENTOR_API int             operator !=(const SbName &n, const char *s)
        { return ! n.entry->isEqual(s); }

    friend INVENTOR_API int             operator !=(const char *s, const SbName &n)
        { return ! n.entry->isEqual(s); }

    friend INVENTOR_API int             operator !=(const SbName &n1, const SbName &n2)
        { return n1.entry != n2.entry; }

  private:
    const SbNameEntry   *entry;         
};

#endif /* _SB_STRING_ */