SoInput.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 the definition of the SoInput class.
 |
 |   Classes:
 |      SoInput, SoInputFile (internal)
 |
 |   Author(s)          : Paul S. Strauss
 |
 ______________  S I L I C O N   G R A P H I C S   I N C .  ____________
 _______________________________________________________________________
 */
 
#ifndef  _SO_INPUT_
#define  _SO_INPUT_
 
#include <Inventor/misc/SoBasic.h>
#include <Inventor/SbDict.h>
#include <Inventor/SbPList.h>
#include <Inventor/SbString.h>
#include <Inventor/SoDB.h>
 
class SoNode;
class SoPath;
class SoBase;
class SoDB;
class SbStringList;
 
 
SoINTERNAL struct SoInputFile {
    SbString            name;           
    SbString            fullName;       
    FILE                *fp;            
    void                *buffer;        
    char                *curBuf;        
    size_t              bufSize;        
    int                 lineNum;        
    bool                openedHere;     
    bool                binary;         
    bool                readHeader;     
    bool                headerOk;       
    SbDict              *refDict;       
    bool                borrowedDict;   
    float               ivVersion;      
    SbString            headerString;   
    SoDBHeaderCB        *postReadCB;    
    void                *CBData;        
 
    SoInputFile();                      
};
 
 
 
 
class INVENTOR_API SoInput {
 public:
 
    SoInput();
 
    ~SoInput();
 
    static void         addDirectoryFirst(const char *dirName);
    static void         addDirectoryLast(const char *dirName);
 
    static void         addEnvDirectoriesFirst(const char *envVarName);
    static void         addEnvDirectoriesLast(const char *envVarName);
 
    static void         removeDirectory(const char *dirName);
 
    static void         clearDirectories();
 
    static const SbStringList &getDirectories();
 
    void                setFilePointer(FILE *newFP);
 
    bool                openFile(const char *fileName,
                                 bool okIfNotFound = FALSE);
 
    bool                pushFile(const char *fileName);
 
    void                closeFile();
 
    bool                isValidFile();
 
    FILE *              getCurFile() const;
 
    const char *        getCurFileName() const;
 
    void                setBuffer(void *bufPointer, size_t bufSize);
 
    size_t              getNumBytesRead() const;
 
    SbString            getHeader();
 
    float               getIVVersion()  
        { return curFile->ivVersion; }
    
    
  SoEXTENDER public:
    bool                isBinary();
 
    bool                get(char &c);
 
    bool                getASCIIBuffer(char &c);
 
    bool                getASCIIFile(char &c);
 
    bool                readHex(uint32_t &l);
 
    bool                read(char           &c);
    bool                read(SbString       &s);
    bool                read(SbName         &n, bool validIdent = FALSE);
    bool                read(int            &i);
    bool                read(unsigned int   &i);
    bool                read(short          &s);
    bool                read(unsigned short &s);
    bool                read(float          &f);
    bool                read(double         &d);
    bool                readBinaryArray(unsigned char *c, int length);
    bool                readBinaryArray(int32_t *l, int length);
    bool                readBinaryArray(float *f, int length);
    bool                readBinaryArray(double *d, int length);
 
    bool                eof() const;
 
  SoINTERNAL public:
    static void         init();
 
    SoInput(SoInput *dictIn);
 
    void                getLocationString(SbString &string) const;
 
    void                putBack(char c);
    void                putBack(const char *string);
 
    void                addReference(const SbName &name, SoBase *base,
                                     bool addToGlobalDict = TRUE);
 
    void                removeReference(const SbName &name);
 
    SoBase *            findReference(const SbName &name) const;
 
  private:
    static SbStringList *directories;   
    SbPList             files;          
    struct SoInputFile  *curFile;       
    SbString            backBuf;        
    int                 backBufIndex;   
 
    void                *tmpBuffer;     
    char                *curTmpBuf;     
    size_t              tmpBufSize;     
 
    char                backupBuf[8];   
    bool                backupBufUsed;  
    
    void                setIVVersion(float version) 
        { curFile->ivVersion = version; }
 
    FILE *              findFile(const char *fileName,
                                 SbString &fullName) const;
 
    void                initFile(FILE *newFP, const char *fileName,
                                 SbString *fullName, bool openedHere,
                                 SbDict *refDict = NULL);
 
    bool                checkHeader();
 
    bool                fromBuffer() const
        { return (curFile->buffer != NULL); }
 
    bool                skipWhiteSpace();
 
    bool                popFile();
 
    size_t              freeBytesInBuf() const
        { return (curFile->bufSize -
                  (curFile->curBuf - (char *) curFile->buffer)); }
 
    bool                readInteger(int32_t &l);
    bool                readUnsignedInteger(uint32_t &l);
    bool                readReal(double &d);
 
    bool                readUnsignedIntegerString(char *str);
 
    int                 readDigits(char *string, uint32_t maxDigits = 0xffffffff);
    int                 readHexDigits(char *string);
 
    int                 readChar(char *string, char charToRead);
 
    bool                makeRoomInBuf(size_t nBytes);
 
    void                convertShort(char *from, short *s);
    void                convertInt32(char *from, int32_t *l);
    void                convertFloat(char *from, float *f);
    void                convertDouble(char *from, double *d);
    void                convertShortArray( char *from, short *to,
                             int len);
    void                convertInt32Array( char *from, int32_t *to,
                             int len);
    void                convertFloatArray( char *from, float *to,
                             int len);
    void                convertDoubleArray( char *from, double *to,
                             int len);
friend class SoBase;
friend class SoDB;
};
 
#endif /* _SO_INPUT_ */