MeVis/ThirdParty/Sources/Inventor/inventor/lib/database/include/Inventor/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;        
    SbBool              openedHere;     
    SbBool              binary;         
    SbBool              readHeader;     
    SbBool              headerOk;       
    SbDict              *refDict;       
    SbBool              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);

    SbBool              openFile(const char *fileName,
                                 SbBool okIfNotFound = FALSE);

    SbBool              pushFile(const char *fileName);

    void                closeFile();

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

    SbBool              get(char &c);

    SbBool              getASCIIBuffer(char &c);

    SbBool              getASCIIFile(char &c);

    SbBool              readHex(uint32_t &l);

    SbBool              read(char           &c);
    SbBool              read(SbString       &s);
    SbBool              read(SbName         &n, SbBool validIdent = FALSE);
    SbBool              read(int            &i);
    SbBool              read(unsigned int   &i);
    SbBool              read(short          &s);
    SbBool              read(unsigned short &s);
    SbBool              read(float          &f);
    SbBool              read(double         &d);
    SbBool              readBinaryArray(unsigned char *c, int length);
    SbBool              readBinaryArray(int32_t *l, int length);
    SbBool              readBinaryArray(float *f, int length);
    SbBool              readBinaryArray(double *d, int length);

    SbBool              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,
                                     SbBool 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];   

    SbBool              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, SbBool openedHere,
                                 SbDict *refDict = NULL);

    SbBool              checkHeader();

    SbBool              fromBuffer() const
        { return (curFile->buffer != NULL); }

    SbBool              skipWhiteSpace();

    SbBool              popFile();

    size_t              freeBytesInBuf() const
        { return (curFile->bufSize -
                  (curFile->curBuf - (char *) curFile->buffer)); }

    SbBool              readInteger(int32_t &l);
    SbBool              readUnsignedInteger(uint32_t &l);
    SbBool              readReal(double &d);

    SbBool              readUnsignedIntegerString(char *str);

    int                 readDigits(char *string, uint32_t maxDigits = 0xffffffff);
    int                 readHexDigits(char *string);

    int                 readChar(char *string, char charToRead);

    SbBool              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, register short *to,
                             register int len);
    void                convertInt32Array( char *from, register int32_t *to,
                             register int len);
    void                convertFloatArray( char *from, register float *to,
                             register int len);
    void                convertDoubleArray( char *from, register double *to,
                             register int len);
friend class SoBase;
friend class SoDB;
};

#endif /* _SO_INPUT_ */