/* $NoKeywords: $ */ /* // // Copyright (c) 1993-2012 Robert McNeel & Associates. All rights reserved. // OpenNURBS, Rhinoceros, and Rhino3D are registered trademarks of Robert // McNeel & Associates. // // THIS SOFTWARE IS PROVIDED "AS IS" WITHOUT EXPRESS OR IMPLIED WARRANTY. // ALL IMPLIED WARRANTIES OF FITNESS FOR ANY PARTICULAR PURPOSE AND OF // MERCHANTABILITY ARE HEREBY DISCLAIMED. // // For complete openNURBS copyright information see . // //////////////////////////////////////////////////////////////// */ #if !defined(ON_ARCHIVE_INC_) #define ON_ARCHIVE_INC_ class ON_CLASS ON_FileStream { public: /* Description: Portable wrapper for C runtime fopen(). Parameters: filename - [in] mode - [in] Remarks: Use the ON_FileStream static functions for reading, writing, seeking, position finding with the FILE pointer returned by this function. */ static FILE* Open( const wchar_t* filename, const wchar_t* mode ); /* Description: Portable wrapper for C runtime fopen(). Parameters: filename - [in] mode - [in] Remarks: Use the ON_FileStream static functions for reading, writing, seeking, position finding with the FILE pointer returned by this function. */ static FILE* Open( const char* filename, const char* mode ); /* Description: Portable wrapper for C runtime fclose(). Parameters: fp - [in] FILE pointer returned by ON_FileStream::Open(). Returns: 0: successful -1: null fp parameter != 0: fclose() failure code */ static int Close( FILE* fp ); /* Description: Portable wrapper for C runtime ftell(). Parameters: fp - [in] FILE pointer returned by ON_FileStream::Open(). Returns: >= 0: current file position -1: an error occured */ static ON__INT64 CurrentPosition( FILE* fp ); /* Description: Portable wrapper for C runtime fseek(fp,offset,SEEK_CUR). Parameters: fp - [in] FILE pointer returned by ON_FileStream::Open(). offset - [in] */ static bool SeekFromCurrentPosition( FILE* fp, ON__INT64 offset ); /* Description: Portable wrapper for C runtime fseek(fp,offset,SEEK_SET). Parameters: fp - [in] FILE pointer returned by ON_FileStream::Open(). offset - [in] */ static bool SeekFromStart( FILE* fp, ON__INT64 offset ); /* Description: Portable wrapper for C runtime fseek(fp,offset,SEEK_END). Parameters: fp - [in] FILE pointer returned by ON_FileStream::Open(). offset - [in] */ static bool SeekFromEnd( FILE* fp, ON__INT64 offset ); /* Description: Portable wrapper for C runtime fseek(fp,offset,origin). Parameters: fp - [in] FILE pointer returned by ON_FileStream::Open(). offset - [in] origin - [in] SEEK_SET (0): seek from beginning of file. SEEK_CUR (1): seek from current position of file pointer. SEEK_END (2): seek from end of file. */ static bool Seek( FILE* fp, ON__INT64 offset, int orgin ); /* Description: Portable wrapper for C runtime fread(buffer,1,count,fp). Parameters: fp - [in] FILE pointer returned by ON_FileStream::Open() count - [in] number of bytes to read. buffer - [out] read bytes are stored in this buffer Returns: number of bytes read */ static ON__UINT64 Read( FILE* fp, ON__UINT64 count, void* buffer ); /* Description: Portable wrapper for C runtime fwrite(buffer,1,count,fp). Parameters: fp - [in] FILE pointer returned by ON_FileStream::Open() count - [in] number of bytes to write buffer - [in] data to be written Returns: number of bytes written. */ static ON__UINT64 Write( FILE* fp, ON__UINT64 count, const void* buffer ); /* Description: Portable wrapper for C runtime fflush(fp). Parameters: fp - [in] FILE pointer returned by ON_FileStream::Open(). Returns: true if flush was successful. False if an error occured. */ static bool Flush( FILE* fp ); /* Description: Portable wrapper for C runtime fstat(). Parameters: fp - [in] FILE pointer returned by ON_FileStream::Open(). file_size - [out] If file_size is not null, the the size of the file in bytes returned here file_creation_time - [out] If file_creation_time is not null, then the time the file was created is returned here as the number of seconds since midnight January 1, 1970. file_last_modified_time - [out] If file_last_modified_time is not null, then the time the file was last modified is returned here as the number of seconds since midnight January 1, 1970. Returns: true if the query was successful. False if an error occured. */ static bool GetFileInformation( FILE* fp, ON__UINT64* file_size, ON__UINT64* file_create_time, ON__UINT64* file_last_modified_time ); }; class ON_CLASS ON_FileIterator { public: ON_FileIterator(); ~ON_FileIterator(); void Destroy(); /* Description: Find the first matching file in the directory. Parameters: directory_name - [in] The directory to look in. file_name_filter - [in] If this paramter is null, then the iteration includes all names in the directory. The file name to search for. This parameter can include wildcard characters, such as an asterisk (*) or a question mark (?). For example, "\rootdir\subdir\*.*" will iterate all files in the \rootdir\subdir\ directory. Example: // Iterate through the files in a directory named "\rootdir\subdir" FILE* fp = 0; ON_FileIterator fit; const char* directory = "\\rootdir\\subdir"; for ( const wchar_t* filename = fit.FirstFile( directory, "*.3dm" ); 0 != filename; filename = fit.NextFile() ) { if ( fit.CurrentFileIsDirectory() ) continue; ON_String fullpath = directory; fullpath += '\\'; fullpath += filename; FILE* fp = ON_FileStream::Open(fullpath,"rb"); if ( 0 == fp ) { continue; } ... ON_FileStream::Close(fp); fp = 0; } } Returns: NULL if no matching files are present in the directory. */ const wchar_t* FirstFile( const wchar_t* directory_name, const wchar_t* file_name_filter ); const wchar_t* FirstFile( const char* directory_name, const char* file_name_filter ); /* Description: Find the next matching file in the directory. Returns: NULL if no more matching files are present in the directory. */ const wchar_t* NextFile(); const wchar_t* CurrentFileName() const; ON__UINT64 CurrentFileSize() const; /* Returns true if the current "file" is a directory. */ bool CurrentFileIsDirectory() const; /* Returns true if the current file or directory is hidden. This means its name begins with a '.' or it's Windows hidden attribute is true. */ bool CurrentFileIsHidden() const; bool GetCurrentFullPathFileName( ON_wString& filename ) const; /* Returns: File creation time in seconds since January 1, 1970 */ ON__UINT64 CurrentFileCreateTime() const; /* Returns: File last modified time in seconds since January 1, 1970 */ ON__UINT64 CurrentFileLastModifiedTime() const; /* Returns: File last access time in seconds since January 1, 1970 */ ON__UINT64 CurrentFileLastAccessTime() const; /* Returns: Number of matching files returned so far. */ ON__UINT64 Count() const; private: // Used by Windows ::Find ON__UINT64 m_count; ON_wString m_directory; #if defined(ON_COMPILER_MSC) ON__UINT32 m_file_attributes_mask; HANDLE m_h; WIN32_FIND_DATA m_fd; #else ON_wString m_ws_file_name_filter; ON_String m_utf8_file_name_filter; DIR* m_dir; struct dirent m_dirent; char m_dirent_name_buffer[NAME_MAX+1]; // < this field provide storage for m_dirent.d_name[] // information about the current file wchar_t m_current_name[1024]; ON__UINT64 m_current_file_attributes; // 1 = regular file, 2 = directory ON__UINT64 m_current_file_size; ON__UINT64 m_current_file_create_time; ON__UINT64 m_current_last_modified_time; ON__UINT64 m_current_last_access_time; #endif }; ///////////////////////////////////////////////////////////////////// // // ON_Buffer // typedef void (*ON_Buffer_ErrorHandler)(class ON_Buffer*); class ON_CLASS ON_Buffer { public: ON_Buffer(); ~ON_Buffer(); ON_Buffer(const ON_Buffer& src); ON_Buffer& operator=(const ON_Buffer& src); /* Description: Compare contents of buffers. Paramters: a - [in] b - [in] Returns: -1: a < b 0: a == b 1: a > b */ static int Compare( const ON_Buffer& a, const ON_Buffer& b ); void Destroy(); void EmergencyDestroy(); /* Returns: True if Size() == CurrentPosition(). Remarks: It is possible to seek beyond the end of the buffer. In this case, the current position will be past the end of the buffer and AtEnd() will return false. */ bool AtEnd() const; /* Returns: Number of bytes currently in the buffer. Remarks: It is possible to seek beyond the end of the buffer. In this case, the current position will be past the end of the buffer and CurrentPosition() will be greater than Size(). */ ON__UINT64 Size() const; /* Returns: 32-bit CRC of the buffer contents. Remarks: */ ON__UINT32 CRC32( ON__UINT32 current_remainder ) const; /* Returns: Current position in the buffer. Remarks: It is possible to seek beyond the end of the buffer. In this case, the current position will be past the end of the buffer and CurrentPosition() will be greater than Size(). */ ON__UINT64 CurrentPosition() const; /* Parameters: size - [in] number of bytes to write. buffer - [in] values to write. Returns: Number of bytes written buffer. */ ON__UINT64 Write( ON__UINT64 size, const void* buffer ); /* Parameters: size - [in] number of bytes to read. buffer - [out] read values are returned in buffer. Returns: Number of bytes read into buffer. For example, if CurrentPosition() <= Size() and size > (Size() - CurrentPosition()) and buffer is not null, then the value (Size() - CurrentPosition()) is returned. Remarks: If the size parameter is zero, then nothing is done. When CurrentPosition() <= Size(), attempts to read more than (Size() - CurrentPosition()) bytes do not generate an error. When CurrentPosition() > Size(), any attempt to read generates an error. */ ON__UINT64 Read( ON__UINT64 size, void* buffer ); enum { seek_from_beginning_of_file = 0, seek_from_current_position = 1, seek_from_end_of_file = 2 }; /* Parameters: offset - [in] number of bytes to seek from origin origin - [in] initial position. 0 (SEEK_SET) Seek from beginning of file. 1 (SEEK_CUR) Seek from current position. 2 (SEEK_END) Seek from end of file. Returns: True if successful. False if the seek would result in a file position before the beginning of the file. If false is returned, the current position is not changed. Remarks: Seeking beyond the end of the buffer is succeeds. Seeking before the beginning of the buffer fails. */ bool Seek( ON__INT64 offset, int origin ); /* Parameters: offset - [in] (>= 0) number of bytes to seek from the start of the buffer. Returns: True if successful. False if the seek would result in a file position before the beginning of the file. If false is returned, the current position is not changed. Remarks: Seeking beyond the end of the buffer is succeeds. Seeking before the beginning of the buffer fails. */ bool SeekFromStart( ON__INT64 offset ); /* Parameters: offset - [in] number of bytes to seek from the current position. Returns: True if successful. False if the seek would result in a file position before the beginning of the file. If false is returned, the current position is not changed. Remarks: Seeking beyond the end of the buffer is succeeds. Seeking before the beginning of the buffer fails. */ bool SeekFromCurrentPosition( ON__INT64 offset ); /* Parameters: offset - [in] number of bytes to seek from the end fo the buffer. Returns: True if successful. False if the seek would result in a file position before the beginning of the file. If false is returned, the current position is not changed. Remarks: Seeking beyond the end of the buffer is succeeds. Seeking before the beginning of the buffer fails. */ bool SeekFromEnd( ON__INT64 offset ); /* Parameters: buffer_size - [in] new size of buffer. Returns: True if successful. Remarks: The current position is not changed and may be beyond the end of the file. Use Seek to set the current position after calling ChangeSize(). */ bool ChangeSize( ON__UINT64 buffer_size ); /* Description: Return unused memory to heap. Remarks: Call this function after creating an ON_Buffer that will persist for and extended amount of time. There are never more than 16 pages of unsued memory (16*4096 bytes on most computers) in an ON_Buffer. Compact() can be called at any time, but calling Compact() the then writing at the end of the buffer is not an efficient use of time or memory. */ bool Compact(); /* Returns True if the ON_Buffer is valid. */ bool IsValid( const ON_TextLog* text_log ) const; /* Returns: Value that identifies most recent error. 0: no error 1: attempt to seek to a negative position */ ON__UINT32 LastError() const; void ClearLastError(); ON_Buffer_ErrorHandler ErrorHandler() const; void SetErrorHandler(ON_Buffer_ErrorHandler error_handler); /* Description: Use WriteToBinaryArchive() to save an entire ON_Buffer inside a binary archive. Use ReadFromBinaryArchive() to retrieve the ON_Buffer from the ON_BinaryArchive. */ bool WriteToBinaryArchive( ON_BinaryArchive& ) const; /* Description: Use ReadFromBinaryArchive() to retrieve an entire ON_Buffer that was written using WriteToBinaryArchive(). */ bool ReadFromBinaryArchive( ON_BinaryArchive& ); /* Description: Compress this buffer Parameters: compressed_buffer - [out] (The reference can be *this) Example: // compress a buffer in place ON_Buffer buffer; buffer = ...; if ( !buffer.Compress(buffer) ) { // compression failed } else { // buffer is now compressed } Returns: True if successful. False if failed. */ bool Compress( ON_Buffer& compressed_buffer ) const; /* Description: Uncompress this buffer which must have been compressed using ON_Buffer::Compress(). Parameters: uncompressed_buffer - [out] (The reference can be *this) Example: // silly example that compresses and then uncompresses a buffer in place // to show how to call the functions. ON_Buffer buffer; buffer = ...; // buffer is in it uncompressed form if ( buffer.Compress(buffer) ) { // buffer is now compressed if ( buffer.Uncompress(buffer) ) { // buffer is uncompressed again. } } Returns: True if successful. False if failed. */ bool Uncompress( ON_Buffer& uncompressed_buffer ) const; private: ON__UINT64 m_buffer_size; // total number of bytes in the buffer ON__UINT64 m_current_position; struct ON_BUFFER_SEGMENT* m_first_segment; struct ON_BUFFER_SEGMENT* m_last_segment; struct ON_BUFFER_SEGMENT* m_current_segment; bool SetCurrentSegment(bool); void Copy( const ON_Buffer& ); ON_MEMORY_POOL* m_heap; ON_Buffer_ErrorHandler m_error_handler; ON__UINT32 m_last_error; unsigned char m_reserved[12]; }; ///////////////////////////////////////////////////////////////////// // // ON_BinaryArchive // virtual class for CPU independent serialization // // ON_BinaryFile // simple class for CPU independent binary file I/O // includes optional CRC support // class ON_Object; class ON_Group; class ON_Font; class ON_DimStyle; class ON_Arc; class ON_ObjectAttributes; class ON_InstanceDefinition; class ON_HatchPattern; class ON_Linetype; struct ON_3DM_CHUNK { std::size_t m_offset; // In read or write_using_fseek mode, this is the // file position of first byte after chunk's length. // In write_using_buffer mode, this of the m_buffer[] // position of first byte after chunk's length. unsigned int m_typecode; int m_value; int m_do_length; // true if chunk is a long chunk with length ON__UINT16 m_do_crc16; // 16 bit CRC using CCITT polynomial ON__UINT16 m_crc16; ON__UINT32 m_do_crc32; // 32 bit CRC ON__UINT32 m_crc32; }; struct ON_3DM_BIG_CHUNK { ON__UINT64 m_big_offset; // In read or write_using_fseek mode, this is the // file position of first byte after chunk's length. // In write_using_buffer mode, this of the m_buffer[] // position of first byte after chunk's length. ON__UINT64 Length() const; // 0 for short chunks ON__INT64 m_big_value; ON__UINT32 m_typecode; ON__UINT8 m_bLongChunk; // true if chunk is a long chunk and m_big_value is a length. ON__UINT8 m_reserved1; ON__UINT8 m_reserved2; ON__UINT8 m_reserved3; // CRC settings ON__UINT8 m_do_crc16; // true (1) if we are calculating 16 bit CRC ON__UINT8 m_do_crc32; // true (1) if we are calculating 32 bit CRC ON__UINT16 m_crc16; // current 16 bit CRC value ON__UINT32 m_crc32; // current 32 bit CRC value }; bool ON_IsLongChunkTypecode(ON__UINT32 typecode); bool ON_IsShortChunkTypecode(ON__UINT32 typecode); #if defined(ON_DLL_TEMPLATE) // This stuff is here because of a limitation in the way Microsoft // handles templates and DLLs. See Microsoft's knowledge base // article ID Q168958 for details. #pragma warning( push ) #pragma warning( disable : 4231 ) ON_DLL_TEMPLATE template class ON_CLASS ON_SimpleArray; ON_DLL_TEMPLATE template class ON_CLASS ON_SimpleArray; #pragma warning( pop ) #endif class ON_Light; class ON_Bitmap; class ON_TextureMapping; class ON_Material; class ON_Layer; class ON_3dmProperties; class ON_3dmSettings; class ON_3dmObjectAttributes; class ON_3dmGoo; class ON_BinaryArchive; // Used int ON_3dmProperties::Read() to set ON_BinaryArchive.m_3dm_opennurbs_version // Do not call directly. void ON_SetBinaryArchiveOpenNURBSVersion(ON_BinaryArchive&,int); class ON_CLASS ON_BinaryArchive // use for generic serialization of binary data { public: ON_BinaryArchive( ON::archive_mode ); virtual ~ON_BinaryArchive(); virtual std::size_t CurrentPosition( // current offset (in bytes) into archive ( like ftell() ) ) const = 0; virtual bool SeekFromCurrentPosition( // seek from current position ( like fseek( ,SEEK_CUR) ) int // byte offset ( >= -CurrentPostion() ) ) = 0; virtual bool SeekFromStart( // seek from current position ( like fseek( ,SEEK_SET) ) std::size_t // byte offset ( >= 0 ) ) = 0; virtual bool AtEnd() const = 0; // true if at end of file bool BigSeekFromStart( ON__UINT64 offset ); bool BigSeekForward( ON__UINT64 offset ); bool BigSeekBackward( ON__UINT64 offset ); bool BigSeekFromCurrentPosition( ON__INT64 offset ); /* Description: Tool for swapping bytes when doing I/O on using big endian CPUs. Remarks: 3dm files are always saved with little endian byte order. See Also: ON_BinaryArchive::Endian */ static bool ToggleByteOrder( int, // number of elements int, // size of element (2,4, or 8) const void*, // source buffer void* // destination buffer (can be same a source buffer) ); static const char* TypecodeName( unsigned int tcode ); static char* ON_TypecodeParse( unsigned int tcode, char* typecode_name, std::size_t max_length ); bool ReadMode() const; // true if reading is permitted bool WriteMode() const; // true if writing is permitted /* Returns: Endian-ness of the cpu reading this file. Remarks: 3dm files are alwasy saved with little endian byte order. */ ON::endian Endian() const; // endian-ness of cpu int BadCRCCount() const; // number of chunks read with bad CRC bool ReadByte( std::size_t, void* ); // must fail if mode is not read or readwrite bool WriteByte( std::size_t, const void* ); // must fail if mode is not write or readwrite /* Description: Expert user function that uses Read() to load a buffer. Paramters: sizeof_buffer - [in] number of bytes to attempt to read. buffer - [out] read bytes are stored in this buffer Returns: Number of bytes actually read, which may be less than sizeof_buffer if the end of file is encountered. */ ON__UINT64 ReadBuffer( ON__UINT64 sizeof_buffer, void* buffer ); /* Description: Expert user function to control CRC calculation while reading and writing. Typically this is used when seeking around and reading/writing information in non-serial order. Parameters: bEnable - [in] Returns: Current state of CRC calculation. Use the returned value to restore the CRC calculation setting after you are finished doing your fancy pants expert IO. */ bool EnableCRCCalculation( bool bEnable ); // ReadCompressedBuffer()/WriteCompressedBuffer() use zlib 1.1.3 // to inflate/deflate the data buffer. // Care must be used to get an endian independent file. // See ON_Mesh::Read()/ON_Mesh::Write() for an example of an endian // independent use of compression. See also ToggleByteOrder() and Endian(). // // To read data archived by WriteCompressedBuffer( sizeof_buffer, buffer ) // do something like: // // std::size_t sizeof_buffer = 0; // ReadCompressedBufferSize(&sizeof_buffer); // buffer = something with sizeof_buffer bytes. // int bFailedCRC = false; // bool ok = ReadCompressedBuffer( sizeof_buffer, buffer, &bFailedCRC ); // /* Description: Red the size of a compressed buffer. Parameters: sizeof__outbuffer - [out] size of the uncompressed buffer in bytes Returns: True if read was successful. */ bool ReadCompressedBufferSize( std::size_t* sizeof__outbuffer ); /* Description: Read compressed information from an archive and uncompress it. Parameters: sizeof__outbuffer - [in] size of the uncompressed buffer in bytes outbuffer - [out] uncompressed buffer returned here bFailedCRC - [out] true if cyclic redundancy check fails on uncompressed buffer Example: std::size_t sizeof_buffer = 0; ReadCompressedBufferSize(&sizeof_buffer); buffer = ...; // something with sizeof_buffer bytes. int bFailedCRC = false; bool ok = ReadCompressedBuffer( sizeof_buffer, buffer, &bFailedCRC ); Returns: True if read was successful. You need to check the value of bFailedCRC to see if the information that was read is valid. */ bool ReadCompressedBuffer( std::size_t sizeof__outbuffer, void* outbuffer, int* bFailedCRC ); /* Description: Compress buffer and write the compressed information to the archive. Parameters: sizeof__inbuffer - [in] size of the uncompressed buffer in bytes inbuffer - [in] uncompressed buffer Returns: True if write was successful. */ bool WriteCompressedBuffer( std::size_t sizeof__inbuffer, const void* inbuffer ); bool ReadBool( bool* ); bool ReadChar( // Read an array of 8 bit chars std::size_t, // number of chars to read char* ); bool ReadChar( // Read an array of 8 bit unsigned chars std::size_t, // number of unsigned chars to read unsigned char* ); bool ReadChar( // Read a single 8 bit char char* ); bool ReadChar( // Read a single 8 bit unsigned char unsigned char* ); bool ReadShort( // Read an array of 16 bit shorts std::size_t, // number of shorts to read short* ); bool ReadShort( // Read an array of 16 bit unsigned shorts std::size_t, // number of shorts to read unsigned short* ); bool ReadShort( // Read a single 16 bit short short* ); bool ReadShort( // Read a single 16 bit unsigned short unsigned short* ); bool ReadInt( // Read an array of 32 bit integers std::size_t, // number of ints to read int* ); bool ReadInt( // Read an array of 32 bit integers std::size_t, // number of ints to read unsigned int* ); bool ReadInt( // Read a single 32 bit integer int* ); bool ReadInt( // Read a single 32 bit unsigned integer unsigned int* ); bool ReadBigInt( // Read an array of 64 bit integers std::size_t, // number of ints to read ON__INT64* ); bool ReadBigInt( // Read an array of 64 bit integers std::size_t, // number of ints to read ON__UINT64* ); bool ReadBigInt( // Read a single 64 bit integer ON__INT64* ); bool ReadBigInt( // Read a single 64 bit unsigned integer ON__UINT64* ); bool ReadLong( // Read an array of 32 bit integers std::size_t, // number of ints to read long* ); bool ReadLong( // Read an array of 32 bit integers std::size_t, // number of ints to read unsigned long* ); bool ReadLong( // Read a single 32 bit integer long* ); bool ReadLong( // Read a single 32 bit unsigned integer unsigned long* ); bool ReadSize( // Read a single std::size_t std::size_t* ); bool ReadBigSize( std::size_t* ); // 64 bits bool ReadBigTime( time_t* ); // UCT seconds since 1 January 1970 (64 bits) bool ReadFloat( // Read an array of floats std::size_t, // number of floats float* ); bool ReadFloat( // Read a single float float* ); bool ReadDouble( // Read an array of IEEE doubles std::size_t, // number of doubles double* ); bool ReadDouble( // Read a single double double* ); bool ReadColor( ON_Color& ); bool ReadPoint ( ON_2dPoint& ); bool ReadPoint ( ON_3dPoint& ); bool ReadPoint ( ON_4dPoint& ); bool ReadVector ( ON_2dVector& ); bool ReadVector ( ON_3dVector& ); bool ReadBoundingBox(ON_BoundingBox&); bool ReadXform(ON_Xform&); bool ReadPlaneEquation(ON_PlaneEquation&); bool ReadPlane(ON_Plane&); bool ReadLine(ON_Line&); bool ReadArc(ON_Arc&); bool ReadCircle(ON_Circle&); bool ReadInterval( ON_Interval& ); bool ReadUuid( ON_UUID& ); bool ReadDisplayMaterialRef( ON_DisplayMaterialRef& ); bool ReadLinetypeSegment( ON_LinetypeSegment& ); // All times are stored in coordinated universal time // ( a.k.a GMT, UTC ). Use ANSI C time() and gmtime() calls. bool ReadTime( struct tm& ); /* Parameters: str_array_count - [out] Number of elements in the string array. All ON_BinaryArchive string WriteString() functions write a null terminator to the file and the null terminator is included in the count. This means that if a string has a non-zero element, then str_array_count >= 2. Remarks: Modify your code to use ReadStringUTF8ElementCount() when reading UTF-8 encoded strings and ReadStringUTF16ElementCount() when reading UTF-16 encoded strings. */ ON_DEPRECATED bool ReadStringSize( std::size_t* str_array_count ); /* Parameters: string_utf8_element_count - [out] Number of bytes in the string array. All ON_BinaryArchive string WriteString() functions write a null terminator to the file and the null terminator is included in string_element_count. This means that if opennurbs wrote the string, either string_element_count = 0 or string_element_count >= 2. */ bool ReadStringUTF8ElementCount( std::size_t* string_utf8_element_count ); /* Parameters: string_utf16_element_count - [out] Number of elements in the string array. All ON_BinaryArchive string WriteString() functions write a null terminator to the file and the null terminator is included in string_element_count. This means that if opennurbs wrote the string, either string_element_count = 0 or string_element_count >= 2. */ bool ReadStringUTF16ElementCount( std::size_t* string_utf16_element_count ); /* Parameters: str_array_count - [in] Number of char elements in str_array[], including the null terminator. The value of str_array_count is returned by ReadCharStringElementCount(). str_array - [in/out] Pass in an array with at least str_array_count elements. If true is returned and str_array_count > 0, then str_array[str_array_count-1] = 0. All strings with char elements written by Rhino are UTF-8 encoded unicode strings. */ bool ReadString( std::size_t str_array_count, char* str_array ); /* Parameters: str_array_count - [in] Number of unsignd char elements in str_array[], including the null terminator. The value of str_array_count is returned by ReadCharStringElementCount(). str_array - [in/out] Pass in an array with at least str_array_count elements. If true is returned and str_array_count > 0, then str_array[str_array_count-1] = 0. All strings with unsigned char elements written by Rhino are UTF-8 encoded unicode strings. */ bool ReadString( std::size_t str_array_count, unsigned char* str_array ); /* Parameters: str_array_count - [in] Number of unsigned short elements in str_array[], including the null terminator. The value of str_array_count is returned by ReadWideCharStringElementCount(). str_array - [in/out] Pass in an array with at least str_array_count elements. If true is returned and str_array_count > 0, then str_array[str_array_count-1] = 0. All strings with unsigned short elements written by Rhino are UTF-16 encoded unicode strings. */ bool ReadString( std::size_t str_array_count, unsigned short* str_array ); bool ReadString( ON_String& sUTF8 ); bool ReadString( ON_wString& s ); bool ReadComponentIndex( ON_COMPONENT_INDEX& ); bool ReadArray( ON_SimpleArray& ); bool ReadArray( ON_SimpleArray& ); bool ReadArray( ON_SimpleArray& ); bool ReadArray( ON_SimpleArray& ); bool ReadArray( ON_SimpleArray& ); bool ReadArray( ON_SimpleArray& ); bool ReadArray( ON_SimpleArray& ); bool ReadArray( ON_SimpleArray& ); bool ReadArray( ON_SimpleArray& ); bool ReadArray( ON_SimpleArray& ); bool ReadArray( ON_SimpleArray& ); bool ReadArray( ON_SimpleArray& ); bool ReadArray( ON_SimpleArray& ); bool ReadArray( ON_SimpleArray& ); bool ReadArray( ON_SimpleArray& ); bool ReadArray( ON_SimpleArray& ); bool ReadArray( ON_SimpleArray& ); bool ReadArray( ON_SimpleArray& ); bool ReadArray( ON_SimpleArray& ); bool ReadArray( ON_SimpleArray& ); bool ReadArray( ON_SimpleArray& ); bool ReadArray( ON_ClassArray& ); bool ReadArray( ON_ClassArray& ); bool ReadArray( ON_SimpleArray& ); bool ReadArray( ON_SimpleArray& ); bool ReadArray( ON_SimpleArray& ); bool ReadArray( ON_ClassArray& ); bool ReadArray( ON_ClassArray& ); bool ReadArray( ON_ClassArray& ); bool ReadArray( ON_SimpleArray& ); bool ReadArray( ON_SimpleArray& ); bool ReadArray( ON_ObjectArray& ); bool ReadArray( ON_SimpleArray& ); bool WriteBool( bool ); bool WriteChar( // Write an array of 8 bit chars std::size_t, // number of chars to write const char* ); bool WriteChar( // Write an array of 8 bit unsigned chars std::size_t, // number of unsigned chars to write const unsigned char* ); bool WriteChar( // Write a single 8 bit char char ); bool WriteChar( // Write a single 8 bit unsigned char unsigned char ); bool WriteShort( // Write an array of 16 bit shorts std::size_t, // number of shorts to write const short* ); bool WriteShort( // Write an array of 16 bit unsigned shorts std::size_t, // number of shorts to write const unsigned short* ); bool WriteShort( // Write a single 16 bit short short ); bool WriteShort( // Write a single 16 bit unsigned short unsigned short ); bool WriteInt( // Write an array of 32 bit integers std::size_t, // number of ints to write const int* ); bool WriteInt( // Write an array of 32 bit integers std::size_t, // number of ints to write const unsigned int* ); bool WriteInt( // Write a single 32 bit integer int ); bool WriteInt( // Write a single 32 bit unsigned integer unsigned int ); bool WriteBigInt( // Write an array of 64 bit integers std::size_t, // number of ints to write const ON__INT64* ); bool WriteBigInt( // Write an array of 64 bit integers std::size_t, // number of ints to write const ON__UINT64* ); bool WriteBigInt( // Write a single 64 bit integer ON__INT64 ); bool WriteBigInt( // Write a single 64 bit unsigned integer ON__UINT64 ); bool WriteLong( // Write an array of 32 bit integers std::size_t, // number of ints to write const long* ); bool WriteLong( // Write an array of 32 bit integers std::size_t, // number of ints to write const unsigned long* ); bool WriteLong( // Write a single 32 bit integer long ); bool WriteLong( // Write a single 32 bit unsigned integer unsigned long ); bool WriteSize( // Write a single std::size_t std::size_t ); bool WriteBigSize( std::size_t ); // 64 bits bool WriteBigTime( time_t ); // UCT seconds since 1 January 1970 (64 bits) bool WriteFloat( // Write a number of IEEE floats std::size_t, // number of doubles const float* ); bool WriteFloat( // Write a single float float ); bool WriteDouble( // Write a single double std::size_t, const double* ); bool WriteDouble( // Write a single double double ); bool WriteColor ( const ON_Color& ); bool WritePoint ( const ON_2dPoint& ); bool WritePoint ( const ON_3dPoint& ); bool WritePoint ( const ON_4dPoint& ); bool WriteVector ( const ON_2dVector& ); bool WriteVector ( const ON_3dVector& ); bool WriteBoundingBox(const ON_BoundingBox&); bool WriteXform(const ON_Xform&); bool WritePlaneEquation(const ON_PlaneEquation&); bool WritePlane(const ON_Plane&); bool WriteLine(const ON_Line&); bool WriteArc(const ON_Arc&); bool WriteCircle(const ON_Circle&); bool WriteInterval( const ON_Interval& ); bool WriteUuid( const ON_UUID& ); bool WriteDisplayMaterialRef( const ON_DisplayMaterialRef& ); bool WriteLinetypeSegment( const ON_LinetypeSegment& ); // All times are stored in universal coordinated time // ( a.k.a GMT, UCT ). Use ANSI C time() and gmtime() calls. bool WriteTime( const struct tm& ); /* Parameters: sUTF8 - [in] A null terminated UTF-8 encoded unicode string. Remarks: To read a string written with WriteString(const char*), call ReadStringUTF8ElementCount(&string_utf8_element_count) to get the number of char elements written in the file, obtain a buffer with at least string_utf8_element_count char elements and then call ReadString(string_utf8_element_count,buffer) to read the char elements. If 0 == sUTF8 or 0 == SUTF8[0], a 4 byte int with value = 0 is written, otherwise a 4 byte int with value = strlen + 1 is written, followed by the string, followed by the null terminator. */ bool WriteString( const char* sUTF8 ); /* Parameters: sUTF8 - [in] A null terminated UTF-8 encoded unicode string. Remarks: To read a string written with WriteString(const unsigned char*), call ReadStringUTF8ElementCount(&string_utf8_element_count) to get the number of unsigned char elements written in the file, obtain a buffer with at least string_utf8_element_count unsigned char elements and then call ReadString(string_utf8_element_count,buffer) to read the unsigned charelements. If 0 == sUTF8 or 0 == SUTF8[0], a 4 byte int with value = 0 is written, otherwise a 4 byte int with value = strlen + 1 is written, followed by the string, followed by the null terminator. */ bool WriteString( const unsigned char* sUTF8 ); /* Parameters: sUTF16 - [in] A null terminated UTF-16 encoded unicode string. Remarks: To read a string written with WriteString(const unsigned short*), call ReadStringUTF16ElementCount(&string_utf16_element_count) to get the number of unsigned short elements written in the file, obtain a buffer with at least string_utf16_element_count unsigned short elements and then call ReadString(string_utf16_element_count,buffer) to read the unsigned short elements. If 0 == sUTF8 or 0 == SUTF8[0], a 4 byte int with value = 0 is written, otherwise a 4 byte int with value = strlen + 1 is written, followed by the string, followed by the null terminator. */ bool WriteString( const unsigned short* sUTF16 ); bool WriteString( const ON_String& sUTF8 ); bool WriteString( const ON_wString& s); bool WriteComponentIndex( const ON_COMPONENT_INDEX& ); bool WriteArray( const ON_SimpleArray& ); bool WriteArray( const ON_SimpleArray& ); bool WriteArray( const ON_SimpleArray& ); bool WriteArray( const ON_SimpleArray& ); bool WriteArray( const ON_SimpleArray& ); bool WriteArray( const ON_SimpleArray& ); bool WriteArray( const ON_SimpleArray& ); bool WriteArray( const ON_SimpleArray& ); bool WriteArray( const ON_SimpleArray& ); bool WriteArray( const ON_SimpleArray& ); bool WriteArray( const ON_SimpleArray& ); bool WriteArray( const ON_SimpleArray& ); bool WriteArray( const ON_SimpleArray& ); bool WriteArray( const ON_SimpleArray& ); bool WriteArray( const ON_SimpleArray& ); bool WriteArray( const ON_SimpleArray& ); bool WriteArray( const ON_SimpleArray& ); bool WriteArray( const ON_SimpleArray& ); bool WriteArray( const ON_SimpleArray& ); bool WriteArray( const ON_SimpleArray& ); bool WriteArray( const ON_SimpleArray& ); bool WriteArray( const ON_ClassArray& ); bool WriteArray( const ON_ClassArray& ); bool WriteArray( const ON_SimpleArray& ); bool WriteArray( const ON_SimpleArray& ); bool WriteArray( const ON_SimpleArray& ); bool WriteArray( const ON_ClassArray& ); bool WriteArray( const ON_ClassArray& ); bool WriteArray( const ON_ClassArray& ); bool WriteArray( const ON_SimpleArray& ); bool WriteArray( const ON_SimpleArray& ); bool WriteArray( int count, const class ON_Layer* ); bool WriteArray( int count, const class ON_Layer*const* ); ///////////////////////////////////////////////////// // // Read/Write classes derived from ON_Object // /* Description: Reads and object from a 3dm archive; Parameters: ppObject - [out] object is allocated and a pointer to the allocated object is returned as *ppObject; Returns: 0: failure - unable to read object because of file IO problems 1: success 3: unable to read object because it's UUID is not registered this could happen in cases where old code is attempting to read new objects. */ int ReadObject( ON_Object** ppObject ); /* Description: Reads and object from a 3dm archive. Parameters: object - [in] The value of object.ON_ClassId()->Uuid() must exactly match the class uuid in of the next object in the archive. Returns: 0: failure - unable to read object because of file IO problems. 1: success 2: unable to read object because the class id in the archive did not match pObject->ClassId. */ int ReadObject( ON_Object& object ); bool WriteObject( const ON_Object* ); // writes object definition bool WriteObject( const ON_Object& ); // writes object definition /////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////// // // 3DM Interface - ignore if not reading/writing a 3DM file // this is here so that the infrastructure // for writing 3dm archives is available for // any type of serialization device. // bool EnableSave3dmRenderMeshes( ON_BOOL32 = true ); // returns previous state bool Save3dmRenderMeshes() const; bool EnableSave3dmAnalysisMeshes( ON_BOOL32 = true ); // returns previous state bool Save3dmAnalysisMeshes() const; bool EnableSaveUserData( ON_BOOL32 = true ); // returns previous state bool SaveUserData() const; /* Returns: 50 (The Rhino 5.0 opennurbs file version.) This is the value of version to pass to ON_BinaryArchive functions like Write3dmStartSection() when you want to use the the current opennurbs version number and you do not want to have to update your code when this version number changes. */ static int CurrentArchiveVersion(); /////////////////////////////////////////////////////////////////// // Step 1: REQUIRED - Write/Read Start Section // /* Parameters: version - [in] 0, 2, 3, 4, 5 or 50 (5 is treated as 50) If version is 0, then the value of ON_BinaryArchive::CurrentArchiveVersion() is used. Use either 0 or the value of ON_BinaryArchive::CurrentArchiveVersion() for the version parameter when you want your code to write the most up to date file version. sStartSectionComment - [in] NULL or ASCII string with application name, et cetera. This information is primarily used when debugging files that contain problems. McNeel and Associates stores application name, application version, compile date, and the OS in use when file was written. */ bool Write3dmStartSection( int version, const char* sStartSectionComment ); /* Parameters: version - [out] .3dm file version (2, 3, 4, 5 or 50) sStartSectionComment - [out] string passed to Write3dmStartSection() */ bool Read3dmStartSection( int* version, ON_String& sStartSectionComment ); /////////////////////////////////////////////////////////////////// // Step 2: REQUIRED - Write/Read properties table // bool Write3dmProperties( const ON_3dmProperties& ); bool Read3dmProperties( ON_3dmProperties& ); /////////////////////////////////////////////////////////////////// // Step 3: REQUIRED - Write/Read settings table // bool Write3dmSettings( const ON_3dmSettings& ); bool Read3dmSettings( ON_3dmSettings& ); /////////////////////////////////////////////////////////////////// // Step 4: REQUIRED - Write/Read bitmap table (it can be empty) // bool BeginWrite3dmBitmapTable(); bool Write3dmBitmap( const ON_Bitmap& ); bool EndWrite3dmBitmapTable(); bool BeginRead3dmBitmapTable(); int Read3dmBitmap( // returns 0 at end of light table // 1 bitmap successfully read ON_Bitmap** // bitmap returned here ); bool EndRead3dmBitmapTable(); /////////////////////////////////////////////////////////////////// // Step 5: REQUIRED - Write/Read render material table (it can be empty) // bool BeginWrite3dmTextureMappingTable(); bool Write3dmTextureMapping( const ON_TextureMapping& ); bool EndWrite3dmTextureMappingTable(); bool BeginRead3dmTextureMappingTable(); int Read3dmTextureMapping( // returns 0 at end of table ON_TextureMapping** // layer returned here ); bool EndRead3dmTextureMappingTable(); /////////////////////////////////////////////////////////////////// // Step 6: REQUIRED - Write/Read render material table (it can be empty) // bool BeginWrite3dmMaterialTable(); bool Write3dmMaterial( const ON_Material& ); bool EndWrite3dmMaterialTable(); bool BeginRead3dmMaterialTable(); int Read3dmMaterial( // returns 0 at end of table ON_Material** // layer returned here ); bool EndRead3dmMaterialTable(); /////////////////////////////////////////////////////////////////// // Step 7: REQUIRED - Write/Read linetype table (it can be empty) // bool BeginWrite3dmLinetypeTable(); bool Write3dmLinetype( const ON_Linetype&); bool EndWrite3dmLinetypeTable(); bool BeginRead3dmLinetypeTable(); int Read3dmLinetype(ON_Linetype**); bool EndRead3dmLinetypeTable(); /////////////////////////////////////////////////////////////////// // Step 8: REQUIRED - Write/Read layer table (it can be empty) // bool BeginWrite3dmLayerTable(); bool Write3dmLayer( const ON_Layer& ); bool EndWrite3dmLayerTable(); bool BeginRead3dmLayerTable(); int Read3dmLayer( // returns 0 at end of table ON_Layer** // layer returned here ); bool EndRead3dmLayerTable(); /////////////////////////////////////////////////////////////////// // Step 9: REQUIRED - Write/Read group table (it can be empty) // bool BeginWrite3dmGroupTable(); bool Write3dmGroup( const ON_Group& ); bool EndWrite3dmGroupTable(); bool BeginRead3dmGroupTable(); // Description: // Reads groups from group table. If the group definition is // read, a group is created by calling new ON_Group(), // initialized with values stored in the archive, and // returned. // // Parameters: // ppGroup - If the group definition is // read, a group is created by calling new ON_Group(), // initialized with values stored in the archive, and // a pointer to the new group is returned in *ppGroup. // // Returns: // // @untitled table // 0 at the end of the group table // 1 group definition was successfully read // -1 archive is corrupt at this point // // Example: // Calls to Read3dmGroup need to be bracketed by calls // to BeginRead3dmGroupTable() / EndRead3dmGroupTable(). // // archive.BeginRead3dmGroupTable(); // ON_Group* pGroup; // int rc = 1; // while(rc==1) // { // // pGroup = 0; // archive.Read3dmGroup(&pGroup); // if ( pGroup ) // do something with pGroup // } // // archive.EndRead3dmGroupTable(); // int Read3dmGroup( ON_Group** // ppGroup ); bool EndRead3dmGroupTable(); /////////////////////////////////////////////////////////////////// // Step 10: REQUIRED - Write/Read font table (it can be empty) // bool BeginWrite3dmFontTable(); bool Write3dmFont( const ON_Font& ); bool EndWrite3dmFontTable(); bool BeginRead3dmFontTable(); // Description: // Reads fonts from font table. If the font definition is // read, a font is created by calling new ON_Font(), // initialized with values stored in the archive, and // returned. // // Parameters: // ppFont - If the font definition is // read, a font is created by calling new ON_Font(), // initialized with values stored in the archive, and // a pointer to the new font is returned in *ppFont. // // Returns: // // @untitled table // 0 at the end of the font table // 1 font definition was successfully read // -1 archive is corrupt at this point // // Example: // Calls to Read3dmFont need to be bracketed by calls // to BeginRead3dmFontTable() / EndRead3dmFontTable(). // // archive.BeginRead3dmFontTable(); // int rc = 1; // ON_Font* pFont; // while(rc==1) // { // // pFont = 0; // archive.Read3dmFont(&pFont); // if ( pFont ) // do something with pFont // } // // archive.EndRead3dmFontTable(); // int Read3dmFont( ON_Font** // ppFont ); bool EndRead3dmFontTable(); /////////////////////////////////////////////////////////////////// // Step 11: REQUIRED - Write/Read dimstyle table (it can be empty) // bool BeginWrite3dmDimStyleTable(); bool Write3dmDimStyle( const ON_DimStyle& ); bool EndWrite3dmDimStyleTable(); bool BeginRead3dmDimStyleTable(); // Description: // Reads annotation dimension styles from dimension style table. // If the dimension style definition is read, // a dimension style is created by calling new ON_DimStyle(), // initialized with values stored in the archive, and // returned. // // Parameters: // ppDimStyle - If the dimstyle definition is // read, a dimstyle is created by calling new ON_DimStyle(), // initialized with values stored in the archive, and // a pointer to the new dimstyle is returned in *ppDimStyle. // // Returns: // // @untitled table // 0 at the end of the dimension style table // 1 dimension style definition was successfully read // -1 archive is corrupt at this point // // Example: // Calls to Read3dmDimStyle need to be bracketed by calls // to BeginRead3dmDimStyleTable() / EndRead3dmDimStyleTable(). // // archive.BeginRead3dmDimStyleTable(); // int rc = 1; // ON_DimStyle* pDimStyle; // while(rc==1) // { // // pDimStyle = 0; // archive.Read3dmDimStyle(&pDimStyle); // if ( pDimStyle ) // do something with pDimStyle // } // // archive.EndRead3dmDimStyleTable(); // int Read3dmDimStyle( ON_DimStyle** // ppDimStyle ); bool EndRead3dmDimStyleTable(); /////////////////////////////////////////////////////////////////// // Step 12: REQUIRED - Write/Read render light table (it can be empty) // bool BeginWrite3dmLightTable(); bool Write3dmLight( const ON_Light&, const ON_3dmObjectAttributes* // optional ); bool EndWrite3dmLightTable(); bool BeginRead3dmLightTable(); int Read3dmLight( // returns 0 at end of light table // 1 light successfully read // -1 if file is corrupt ON_Light**, // light returned here ON_3dmObjectAttributes* // optional - if NOT NULL, object attributes are // returned here ); bool EndRead3dmLightTable(); /////////////////////////////////////////////////////////////////// // Step 13: REQUIRED - Write/Read hatch pattern table (it can be empty) // bool BeginWrite3dmHatchPatternTable(); bool Write3dmHatchPattern( const ON_HatchPattern&); bool EndWrite3dmHatchPatternTable(); bool BeginRead3dmHatchPatternTable(); int Read3dmHatchPattern(ON_HatchPattern**); bool EndRead3dmHatchPatternTable(); /////////////////////////////////////////////////////////////////// // Step 14: REQUIRED - Write/Read instance definition table (it can be empty) // bool BeginWrite3dmInstanceDefinitionTable(); bool Write3dmInstanceDefinition( const ON_InstanceDefinition& ); bool EndWrite3dmInstanceDefinitionTable(); bool BeginRead3dmInstanceDefinitionTable(); /* Description: Reads instance definitions from instance defintion table. Parameters: ppInstanceDefinition - If an instance defintion is read, an instance defintion is created by calling new ON_InstanceDefinition(), initialized with values stored in the archive, and a pointer to the new instance defintion is returned in *ppInstanceDefinition. Returns: @untitled table 0 at the end of the instance defintion table 1 instance defintion was successfully read -1 archive is corrupt at this point Example: Calls to Read3dmInstanceDefinition need to be bracketed by calls to BeginRead3dmInstanceDefinitionTable() / EndRead3dmInstanceDefinitionTable(). archive.BeginRead3dmInstanceDefinitionTable(); int rc = 1; ON_InstanceDefinition* pInstanceDefinition; while(rc==1) { pInstanceDefinition = 0; archive.Read3dmInstanceDefinition(&pInstanceDefinition); if ( pInstanceDefinition ) do something with pInstanceDefinition } archive.EndRead3dmInstanceDefinitionTable(); */ int Read3dmInstanceDefinition( ON_InstanceDefinition** // ppInstanceDefinition ); bool EndRead3dmInstanceDefinitionTable(); /////////////////////////////////////////////////////////////////// // Step 15: REQUIRED - Write/Read geometry and annotation table (it can be empty) // bool BeginWrite3dmObjectTable(); bool Write3dmObject( const ON_Object&, const ON_3dmObjectAttributes* // optional ); bool EndWrite3dmObjectTable(); bool BeginRead3dmObjectTable(); int Read3dmObject( // returns 0 at end of object table // 1 if object is read // 2 if object is skipped because it does not match filter // -1 if file is corrupt ON_Object**, // object returned here (NULL if skipped) ON_3dmObjectAttributes*, // optional - if NOT NULL, object attributes are // returned here unsigned int = 0 // optional filter made by setting ON::object_type bits ); // returns NULL at end of object table bool EndRead3dmObjectTable(); /////////////////////////////////////////////////////////////////// // Step 16: REQUIRED - Write/Read history record table (it can be empty) // bool BeginWrite3dmHistoryRecordTable(); bool Write3dmHistoryRecord( const class ON_HistoryRecord& ); bool EndWrite3dmHistoryRecordTable(); bool BeginRead3dmHistoryRecordTable(); /* Returns: 0 at end of object table 1 if object is read -1 if file is corrupt */ int Read3dmHistoryRecord( class ON_HistoryRecord*& ); bool EndRead3dmHistoryRecordTable(); /////////////////////////////////////////////////////////////////// // Step 17: OPTIONAL - Write/Read 0 or more user tables // /* Description: Write the user table header information that must precede the user table information written by a plug-in. Parameters: plugin_id - [in] bSavingGoo - [in] Set to false if a plug-in will be used to write the user table. Set to true if a user table written by a missing plug-in is being resaved. In this case, goo_3dm_version and goo_opennurbs_version must also be set. In practice, you should use Write3dmAnonymousUserTableRecord() to handle writing "goo" and use this function only when the plug-in in present. goo_3dm_version - [in] If bSavingGoo is false, this parameter must be zero and ON_BinaryArchive::Archive3dmVersion() will be used. If bSavingGoo is true, this parameter must be the version of the 3dm archive (1,2,3,4,5,50,...) the plug-in code used to write the user table. goo_opennurbs_version - [in] If bSavingGoo is false, this parameter must be zero and ON_BinaryArchive::ArchiveOpenNURBSVersion() will be used. If bSavingGoo is true, this parameter must be the version of the opennurbs (YYYYMMDDN) the plug-in code used to write the user table. Returns: True if the the user information can be written. False if user informtion should not be written. */ bool BeginWrite3dmUserTable( const ON_UUID& plugin_id, bool bSavingGoo, int goo_3dm_version, int goo_opennurbs_version ); bool EndWrite3dmUserTable(); /* Description: If Read3dmAnaonymousUserTable() was used to read ON_3dmGoo because a plug-in was not present, then use Write3dmAnonymousUserTableRecord() to put than information back into the archive. Write3dmAnonymousUserTableRecord() writes the entire record. Do NOT call BeginWrite3dmUserTable() / EndWrite3dmUserTable() when using Write3dmAnonymousUserTableRecord(). Parameters: plugin_id - [in] goo_version - [in] The version of the archive (1,2,3,4,5,50,...) that was used when the plug-in wrote the user table. goo_opennurbs_version - [in] The version of opennurbs ( YYYMMDDN ) that was used when the plug-in wrote the user table. goo - [in] Returns: True if the goo was written or skipped because it could not be robustly saved. False if a catastrophic IO error occured. */ bool Write3dmAnonymousUserTableRecord( const ON_UUID& plugin_id, int goo_3dm_version, int goo_opennurbs_version, const ON_3dmGoo& goo ); // OBSOLETE - use BeginWrite3dmUserTable(plugin_id, bSavingGoo, 3dm_version, opennurbs_version ) ON_DEPRECATED bool BeginWrite3dmUserTable( const ON_UUID& ); // OBSOLETE - use Write3dmAnonymousUserTableRecord(plugin_id, ..., goo) ON_DEPRECATED bool Write3dmAnonymousUserTable( const ON_3dmGoo& ); /* Parameters: plugin_id - [out] id of plug-in that wrote the user table bLastSavedAsGoo - [out] True if this table was saved into this archive as goo because the plug-in was not present at the time of the save. archive_3dm_version - [out] Version of the archive the plug-in wrote to. When bLastSavedAsGoo is true, this number can be different from Archive3dmVersion(). archive_opennurbs_version - [out] Version of opennurbs the plug-in used to write the archive. When bLastSavedAsGoo is true, this number can be different from ArchiveOpenNURBSVersion(). Returns: False when there are no more user tables or an IO error occurs. */ bool BeginRead3dmUserTable( ON_UUID& plugin_id, bool* bLastSavedAsGoo, int* archive_3dm_version, int* archive_opennurbs_version ); /* Description: If the plug-in that wrote the user table is not present and you need to read and resave the user table, then use Read3dmAnonymousUserTable() to load the information into "goo". If you do not need to resave the information, then simply call EndRead3dmUserTable() to skip over this table. */ bool Read3dmAnonymousUserTable( int archive_3dm_version, int archive_opennurbs_version, ON_3dmGoo& goo ); bool EndRead3dmUserTable(); // OBSOLETE - use BeginRead3dmUserTable( plugin_id, bLastSavedAsGoo, archive_3dm_version, ... ) ON_DEPRECATED bool BeginRead3dmUserTable( ON_UUID& ); // OBSOLETE - use Read3dmAnonymousUserTable( archive_3dm_version, archive_opennurbs_version, goo ) ON_DEPRECATED bool Read3dmAnonymousUserTable( ON_3dmGoo& ); /////////////////////////////////////////////////////////////////// // Step 18: REQUIRED when writing / OPTIONAL when reading // Write end of file marker. This information is primarily // used when debugging files to make sure the end of the file // hasn't been cut off. // // Description: // Writes a TCODE_ENDOFFILE chunk that contains the number // of bytes in the archive. // // Returns: // true if successful, false if unable to write to archive. bool Write3dmEndMark(); // Description: // Checks for a TCODE_ENDOFFILE chunk at the current position. // If it finds one, it reads it and returns the number // of bytes in the archive. Comparing this number with // the current file position can help detect files that // have been damaged by loosing sections. // // Parameters: // sizeof_archive - [out] number of bytes written to archive // // Returns: // true if successful, false if unable to find or read // a TCODE_ENDOFFILE chunk. bool Read3dmEndMark( std::size_t* // sizeof_archive ); /////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////// // Low level tools to Write/Read chunks. See opennurbs_3dm.h for details // about the structure of chunks. Every chunk must begin with a // call to BeginWrite/ReadChunk(). // If BeginWriteChunk()/BeginReadChunk() returns true, then // you must call EndWrite/ReadChunk() or cease using the archive. // Description: // Writes a chunk header containing 4 byte typecode and value. // // Parameters: // typecode - [in] a TCODE_* number from opennurbs_3dm.h // value - [in] if (typecode&TCODE_SHORT) is nonzero, then // this is the value to be saved. Othewise, pass // a zero and the EndWrite3dmChunk() call will // store the length of the chunk. // // Returns: // true if write was successful. bool BeginWrite3dmChunk( unsigned int, // typecode int // value ); bool BeginWrite3dmBigChunk( ON__UINT32 typecode, ON__INT64 value ); /* Description: Begins writing a chunk. Parameters: tcode - [in] chunk's typecode from opennurbs_3dm.h. This cannot be a short tcode. major_version - [in] ( >= 1) minor_version - [in] ( >= 0 ) Returns: True if input was valid and chunk was started. In this case You must call EndWrite3dmChunk(), even if something goes wrong while you attempt to write the contents of the chunk. False if input was not valid or the write failed. */ bool BeginWrite3dmChunk( unsigned int tcode, int major_version, int minor_version ); // updates length in chunk header bool EndWrite3dmChunk(); bool Write3dmGoo( const ON_3dmGoo& ); // call to write "goo" // OBSOLETE - Use BeginRead3dmBigChunk() ON_DEPRECATED bool BeginRead3dmChunk( unsigned int*, // typecode from opennurbs_3dm.h int* // value ); // When the end of the 3dm file is reached, BeginReadChunk() will // return true with a typecode of TCODE_ENDOFFILE. bool BeginRead3dmBigChunk( unsigned int*, // typecode from opennurbs_3dm.h ON__INT64* // value ); /* Description: Begins reading a chunk that must be in the archive at this location. Parameters: expected_tcode - [in] chunk's typecode from opennurbs_3dm.h major_version - [out] minor_version - [out] Returns: True if beginning of the chunk was read. In this case You must call EndRead3dmChunk(), even if something goes wrong while you attempt to read the interior of the chunk. False if the chunk did not exist at the current location in the file. */ bool BeginRead3dmChunk( unsigned int expected_tcode, int* major_version, int* minor_version ); /* Description: Calling this will skip rest of stuff in chunk if it was only partially read. Parameters: bSupressPartiallyReadChunkWarning - [in] Generally, a call to ON_WARNING is made when a chunk is partially read. If bSupressPartiallyReadChunkWarning is true, then no warning is issued for partially read chunks. */ bool EndRead3dmChunk(); bool EndRead3dmChunk(bool bSupressPartiallyReadChunkWarning); /////////////////////////////////////////////////////////////////// // // Tools for dictionary IO (used in .NET) // /* Description: Begins writing a dictionary. Parameters: dictionary_id - [in] version - [in] It is suggested that you use YYYYMMDD as the version number. dictionary_name - [in] You may pass NULL. Remarks: Begins a new chunk with tcode TCODE_DICTIONARY and then writes a TCODE_DICTIONARY_ID chunk containing the id, version and name. After calling this function, you may either write entries by calling BeginWriteDictionaryEntry(); write entry definition... EndWriteDictionaryEntry(); or you may finish writing the dictionay by calling EndWriteDictionary(); */ bool BeginWriteDictionary( ON_UUID dictionary_id, unsigned int version, const wchar_t* dictionary_name ); /* Description: Begins writing a dictionary entry. Parameters: de_type - [in] entry_name - [in] Returns: true Entry header was written and you must call EndWriteDictionary() after writing the entry data. false Failed to write entry header. Do not call EndWriteDictionary(). Remarks: Begins a new chunk with tcode TCODE_DICTIONARY_ENTRY, then writes the int, and then writes the string. */ bool EndWriteDictionary(); /* Description: Begins writing a dictionary entry. Parameters: de_type - [in] entry_name - [in] Returns: true Entry header was written and you must call EndWriteDictionary() after writing the entry data. false Failed to write entry header. Do not call EndWriteDictionary(). Remarks: Begins a new chunk with tcode TCODE_DICTIONARY_ENTRY, then writes the int, and then writes the string. */ bool BeginWriteDictionaryEntry( int de_type, const wchar_t* entry_name ); bool EndWriteDictionaryEntry(); bool BeginReadDictionary( ON_UUID* dictionary_id, unsigned int* version, ON_wString& dictionary_name ); bool EndReadDictionary(); /* Description: Begin reading a dictionary entry. Parameters: de_type - [out] entry_name - [out] Returns: 0: serious IO error 1: success read information and then call EndReadDictionaryEntry() 2: at end of dictionary */ int BeginReadDictionaryEntry( int* de_type, ON_wString& entry_name ); bool EndReadDictionaryEntry(); bool Read3dmGoo( ON_3dmGoo& ); // Call to read "goo" // OBSOLETE - Use PeekAt3dmBigChunkType() ON_DEPRECATED bool PeekAt3dmChunkType( // does not change file position unsigned int*, // typecode from opennurbs_3dm.h int* // value ); bool PeekAt3dmBigChunkType( // does not change file position ON__UINT32* typecode, ON__INT64* big_value ); bool Seek3dmChunkFromStart( // beginning at the start of the active chunk, search portion of // archive included in active chunk for the start of a subchunk // with the specified type. // if true is returned, then the position is set so the next call to // BeginRead3dmChunk() will read a chunk with the specified typecode unsigned int // typecode from opennurbs_3dm.h ); bool Seek3dmChunkFromCurrentPosition( // beginning at the current position, search portion of archive // included in active chunk for the start of a subchunk with the // specified type. // if true is returned, then the position is set so the next call to // BeginRead3dmChunk() will read a chunk with the specified typecode unsigned int // typecode from opennurbs_3dm.h ); // A chunk version is a single byte that encodes a major.minor // version number. Useful when creating I/O code for 3dm chunks // that may change in the future. Increment the minor version // number if new information is added to the end of the chunk. // Increment the major version if the format of the chunk changes // in some other way. bool Write3dmChunkVersion( int, // major // 0 to 15 int // minor // 0 to 16 ); bool Read3dmChunkVersion( int*, // major // 0 to 15 int* // minor // 0 to 16 ); /* Description: Low level tool to writes user data attached to the object. This function should never be called directly. Parameters: object - [in] Returns: True if successful. */ bool WriteObjectUserData( const ON_Object& object ); /* Description: Low level tool to read user data and attach it to the object. This function should never be called directly. Parameters: object - [in/out] Returns: True if successful. */ bool ReadObjectUserData( ON_Object& object ); /* Description: If a 3dm archive is being read or written, then this is the version of the 3dm archive format (1, 2, 3, 4 or 5). Returns: @untitle table 0 a 3dm archive is not being read/written 1 a version 1 3dm archive is being read/written 2 a version 2 3dm archive is being read/written 3 a version 3 3dm archive is being read/written 4 a version 4 3dm archive is being read/written 5 an old version 5 3dm archive is being read 50 a version 5 3dm archive is being read/written See Also: ON_BinaryArchive::ArchiveOpenNURBSVersion */ int Archive3dmVersion() const; /* Description: If a 3dm archive is being read, then this is the version of openNURBS that was used to write the archive. This value is only available after ON_BinaryArchive::Read3dmProperties is called. See Also: ON_BinaryArchive::Archive3dmVersion ON_BinaryArchive::Read3dmProperties Returns: Version of openNURBS used to write the archive. The openNURBS version is the value returned by ON::Version. See Also: ON::Version ON_BinaryArchive::Read3dmProperties ON_BinaryArchive::Archive3dmVersion Remarks: This value is rarely needed. You probably want to use ON_BinaryArchive::Archive3dmVersion. */ int ArchiveOpenNURBSVersion() const; /* Description: When a 3dm archive is saved from an MFC application that supports Windows linking/embedding, the first 5kb to 1mb of the file contains information that is put there by MFC. ArchiveStartOffset() returns the offset into the file where the 3dm archive actually begins. The call to ON_BinaryArchive::Read3dmStartSection() calculates this offset and stores the value in m_3dm_start_section_offset. Returns: Offset into the binary "file" where the actual 3dm archive begins. Remarks: Generally, this value can be ignored. This function is a diagnostice tool that is used to analyzed damaged files. */ std::size_t ArchiveStartOffset() const; enum table_type { no_active_table = 0, properties_table, settings_table, bitmap_table, texture_mapping_table, material_table, linetype_table, layer_table, light_table, object_table, group_table, font_table, dimstyle_table, hatchpattern_table, instance_definition_table, historyrecord_table, user_table }; /* Description: Expert user function for reading damaged files. Parameters: chunk - [out] current chunk. Returns: Level of the chunk or 0 if there is no current chunk. */ int GetCurrentChunk(ON_3DM_CHUNK& chunk) const; int GetCurrentChunk(ON_3DM_BIG_CHUNK& big_chunk) const; /* Description: Expert user function for reading damaged files. The search starts at the beginning of the file. Parameters: tcode_table - [in] typecode of the table tcode_record - [in] typecode of the record class_uuid - [in] id of the opennurbs class in the record min_length_data - [in] minimum size of the opennurbs class data Returns: True if the table start is found. In this case the current position of the archive is at the start of the table and the standared BeginRead3dm...Table() function can be used. False if the table start is not found. */ bool FindTableInDamagedArchive( unsigned int tcode_table, unsigned int tcode_record, ON_UUID class_uuid, int min_length_data ); /* Description: Expert user function for studying contents of a file. The primary use is as an aid to help dig through files that have been damaged (bad disks, transmission errors, etc.) If an error is found, a line that begins with the word "ERROR" is printed. Parameters: text_log - [in] place to print informtion recursion_depth - [in] simply a counter to aid in debugging. Returns: 0 if something went wrong, otherwise the typecode of the chunk that was just studied. */ unsigned int Dump3dmChunk( ON_TextLog& text_log, int recursion_depth = 0 ); protected: /* Description: Works like the C runtrim fread(). Returns: actual number of bytes read (like fread()) */ virtual std::size_t Read( std::size_t, void* ) = 0; /* Description: Works like the C runtrim fwrite(). Returns: actual number of bytes written (like fwrite()) */ virtual std::size_t Write( std::size_t, const void* ) = 0; /* Description: Force Write() to flush any buffered data to physical archive. Returns: True if successful or if there is nothing to flush. False if information could not be flushed. */ virtual bool Flush() = 0; /* Applications (like Rhino) override this function to load plug-ins Description: When ON_BinaryArchive::ReadObject() encounters userdata and the user data class id is not present, LoadUserDataApplication is called to load the application that created user data. Returns: 0 - could not load the application 1 - successfully loaded the application 2 - the application was already loaded */ virtual int LoadUserDataApplication( ON_UUID /*application_id*/ ) { return 0; } bool SetArchive3dmVersion(int); private: // 16 bit integer IO bool WriteInt8( std::size_t, const ON__INT8* ); bool ReadInt8( std::size_t, ON__INT8* ); // 16 bit integer IO bool WriteInt16( std::size_t, const ON__INT16* ); bool ReadInt16( std::size_t, ON__INT16* ); // 32 bit integer IO bool WriteInt32( std::size_t, const ON__INT32* ); bool ReadInt32( std::size_t, ON__INT32* ); // 64 bit integer IO bool WriteInt64( std::size_t, const ON__INT64* ); bool ReadInt64( std::size_t, ON__INT64* ); bool BeginWrite3dmTable( unsigned int // tcode ); bool EndWrite3dmTable( unsigned int // tcode ); bool BeginRead3dmTable( unsigned int // tcode ); bool EndRead3dmTable( unsigned int // tcode ); bool Read3dmV1Layer( ON_Layer*& ); int Read3dmV1Light( // returns 0 at end of light table // 1 light successfully read // -1 if file is corrupt ON_Light**, // light returned here ON_3dmObjectAttributes* // optional - if NOT NULL, object attributes are // returned here ); int Read3dmV1Material( ON_Material** ); int Read3dmV1Object( // returns 0 at end of object table // 1 if object is read // 2 if object is skipped because it does not match filter // -1 if file is corrupt ON_Object**, // object returned here (NULL if skipped) ON_3dmObjectAttributes*, // optional - if NOT NULL, object attributes are // returned here unsigned int = 0 // optional filter made by setting ON::object_type bits ); // returns NULL at end of object table bool Read3dmV1AttributesOrMaterial( ON_3dmObjectAttributes*, // attributes, ON_Material*, // material, ON_BOOL32&, // bHaveMat unsigned int, // end_mark_tcode class ON__3dmV1_XDATA* = 0 // v1 "xdata" ); bool Read3dmV1String( ON_String& ); int Read3dmV1LayerIndex( const char* ) const; public: // helpers for reading V1 objects bool ReadV1_TCODE_RH_POINT(ON_Object**,ON_3dmObjectAttributes*); bool ReadV1_TCODE_MESH_OBJECT(ON_Object**,ON_3dmObjectAttributes*); bool ReadV1_TCODE_LEGACY_CRV(ON_Object**,ON_3dmObjectAttributes*); bool ReadV1_TCODE_LEGACY_FAC(ON_Object**,ON_3dmObjectAttributes*); bool ReadV1_TCODE_LEGACY_SHL(ON_Object**,ON_3dmObjectAttributes*); bool ReadV1_TCODE_RHINOIO_OBJECT_NURBS_CURVE(ON_Object**,ON_3dmObjectAttributes*); bool ReadV1_TCODE_RHINOIO_OBJECT_NURBS_SURFACE(ON_Object**,ON_3dmObjectAttributes*); bool ReadV1_TCODE_RHINOIO_OBJECT_BREP(ON_Object**,ON_3dmObjectAttributes*); bool ReadV1_TCODE_ANNOTATION(unsigned int,ON_Object**,ON_3dmObjectAttributes*); private: ON::archive_mode Mode() const; // current read/write mode void UpdateCRC( std::size_t, const void* ); int ReadObjectHelper(ON_Object**); int m_3dm_version; int m_3dm_v1_layer_index; int m_3dm_v1_material_index; // The bits in m_error_message_mask are used to mask errors // when we know we are doing something that may generate an // error. // // bit 0x00000001 // V1 files do not have a table structure and are read using // multiple passes and there are valid situations where a // 4 byte read is attempted at the end of a file. // // bit 0x00000002 // Some v1 files do not have an end mark. When reading // these v1 files bit 0x02 is set. // // bit 0x00000004 // Requested read may go beyond end of file. // One situation where this happens is when a table is not at the // expected location in a file, unsigned int m_error_message_mask; protected: unsigned int ErrorMessageMask() const; /* Paramters: sizeof_request - [in] value of count parameter passed to virtual Read() function. sizeof_read - [in] number of bytes actually read by the virtual Read() function. Returns: True if a call to Read() is permitted to ask for more bytes than are left in the file. This value varies as the file is read and must be checked at each failure. */ bool MaskReadError( ON__UINT64 sizeof_request, ON__UINT64 sizeof_read ) const; private: // When a 3DM archive is read, m_3dm_opennurbs_version records the version of // OpenNURBS used to create the archive. Otherwise, m_3dm_opennurbs_version // is zero. // // Read3dmProperties() sets this to the version of OpenNURBS that was // used to write file file. If the file was created using a version // of OpenNURBS before 200012210, this number will be zero. // // Write3dmProperties() stores the value returned by ON::Version() in // the archive's properties table. friend void ON_SetBinaryArchiveOpenNURBSVersion(ON_BinaryArchive&,int); int m_3dm_opennurbs_version; // When a 3dm archive is saved from an MFC application that supports // Windows linking/embedding, the first 5kb to 1mb of the file contains // information that is put there by MFC. m_3dm_start_section_offset // records the offset into the file where the 3dm archive actually begins. std::size_t m_3dm_start_section_offset; table_type m_active_table; table_type TableTypeFromTypecode( unsigned int ); // table type from tcode ON_SimpleArray m_chunk; // stack of chunks bool PushBigChunk( ON__UINT32 typecode, ON__INT64 value ); bool WriteChunkTypecode( ON__UINT32 ); bool ReadChunkTypecode( ON__UINT32* ); bool WriteChunkValue( ON__UINT32 typecode, ON__INT64 ); bool WriteChunkLength( ON__UINT64 ); bool ReadChunkValue( ON__UINT32 typecode, ON__INT64* value64 ); bool FindMisplacedTable( ON__UINT64 filelength, const ON__UINT32 table_tocde, const ON__UINT32 table_record_record, const ON_UUID class_uuid, const ON__UINT64 min_length_data ); bool ReadObjectUserDataAnonymousChunk( const ON__UINT64 length_TCODE_ANONYMOUS_CHUNK, const int archive_3dm_version, const int archive_opennurbs_version, class ON_UserData* ud ); public: std::size_t SizeofChunkLength() const; private: bool WriteEOFSizeOfFile( ON__UINT64 ); bool ReadEOFSizeOfFile( ON__UINT64* ); bool m_bDoChunkCRC; // true if active chunk crc status should be checked // and updated. int m_bad_CRC_count; // number of chunks that have a bad crc private: // compressed buffer I/O uses zlib 1.1.3 inflate()/deflate() struct { ON::archive_mode mode; // ON::read = read and inflate, ON::write = deflate and write enum { sizeof_x_buffer = 16384 }; unsigned char buffer[sizeof_x_buffer]; z_stream strm; } m_zlib; // returns number of bytes written std::size_t WriteDeflate( std::size_t, // sizeof uncompressed input data const void* // uncompressed input data ); bool ReadInflate( std::size_t, // sizeof uncompressed input data void* // buffer to hold uncompressed data ); bool CompressionInit(); void CompressionEnd(); private: // endian-ness of the cpu reading this file. // 3dm files are alwasy saved with little endian byte order. ON::endian m_endian; ON::archive_mode m_mode; // 3dm write options bool m_bSaveUserData; // true to save user data (increases file size) bool m_bSavePreviewImage; // true to save 200x200 preview bitmap (increases file size) bool m_bEmbedTextureBitmaps; // true to embed texture, bump, trace, and wallpaper bitmaps (increases file size) bool m_bSaveRenderMeshes; // true to save meshes used to render B-rep objects (increases file size) bool m_bSaveAnalysisMeshes; // true to save meshes used in surface analysis (increases file size) // ids of plug-ins that support saving older (V3) versions // of user data. This information is filled in from the // list of plug-ins passed in whenteh settings are saved. ON_SimpleArray< ON_UUID > m_V3_plugin_id_list; struct ON__3dmV1LayerIndex* m_V1_layer_list; // prohibit default construction, copy construction, and operator= ON_BinaryArchive(); ON_BinaryArchive( const ON_BinaryArchive& ); // no implementation ON_BinaryArchive& operator=( const ON_BinaryArchive& ); // no implementation }; class ON_CLASS ON_3dmGoo { // used to store goo public: ON_3dmGoo(); ~ON_3dmGoo(); ON_3dmGoo( const ON_3dmGoo& ); ON_3dmGoo& operator=( const ON_3dmGoo& ); void Dump(ON_TextLog&) const; unsigned int m_typecode; int m_value; unsigned char* m_goo; ON_3dmGoo* m_next_goo; ON_3dmGoo* m_prev_goo; }; class ON_CLASS ON_BinaryFile : public ON_BinaryArchive { public: ON_BinaryFile( ON::archive_mode ); /* Description: Create an ON_BinaryArchive that reads/writes from an ordinary file. Parameters: mode - [in] fp - [in] If a file is being read, fp is the pointer returned from ON_FileStream::Open(...,"rb"). If a file is being written, fp is the pointer returned from ON_FileStream::Open(...,"wb"). */ ON_BinaryFile( ON::archive_mode, FILE* fp ); virtual ~ON_BinaryFile(); // ON_BinaryArchive overrides std::size_t CurrentPosition() const; bool SeekFromCurrentPosition(int); bool SeekFromStart(std::size_t); bool AtEnd() const; // fseek from end (since the file has an end) bool SeekFromEnd( int ); ////////// // To use custom memory buffering instead of relying // on fread()/fwrite()'s build in buffering, call // EnableMemoryBuffer() with the buffer size immediately // after constructing the ON_BinaryFile. There appear // to be enough bugs in existing Windows NT/2000 NETWORK // I/O that using this hack will speed up I/O by factors // of 10 to 100. void EnableMemoryBuffer( int=16384 // capacity of memory buffer ); protected: std::size_t Read( std::size_t, void* ); std::size_t Write( std::size_t, const void* ); bool Flush(); private: // Implementation FILE* m_fp; // if m_memory_buffer_capacity is zero, then Write() uses // fwrite() directly. If m_memory_buffer_capacity is // greater than zero, then Write() buffers its results // into m_memory_buffer. This is provided to work around // bugs in some networks that result in extremely slow // performance when seeking is used. std::size_t m_memory_buffer_capacity; std::size_t m_memory_buffer_size; std::size_t m_memory_buffer_ptr; unsigned char* m_memory_buffer; private: // prohibit default construction, copy construction, and operator= ON_BinaryFile( ); // no implementation ON_BinaryFile( const ON_BinaryFile& ); // no implementation ON_BinaryFile& operator=( const ON_BinaryFile& ); // no implementation }; class ON_CLASS ON_BinaryArchiveBuffer : public ON_BinaryArchive { public: /* Description: Create an ON_BinaryArchive that reads/writes from an ON_Buffer. Parameters: mode - [in] buffer - [in] Remarks: If a non-null buffer is specifed, then do not call SetBuffer() */ ON_BinaryArchiveBuffer( ON::archive_mode, ON_Buffer* buffer ); virtual ~ON_BinaryArchiveBuffer(); /* Description: If the ON_BinaryArchiveBuffer class is created with the constructor that has a single "mode" parameter, then use SetBuffer() to specify the buffer to read/write from before using the ON_BinaryArchiveBuffer. Parameters: buffer - [in] Returns: True if the buffer is set. Once the buffer is set it cannot be changed. */ bool SetBuffer( ON_Buffer* buffer ); /* Returns: Buffer being read/written. */ ON_Buffer* Buffer() const; // virtual ON_BinaryArchive overrides std::size_t CurrentPosition() const; bool SeekFromCurrentPosition(int); bool SeekFromStart(std::size_t); bool AtEnd() const; bool SeekFromEnd( ON__INT64 ); protected: std::size_t Read( std::size_t, void* ); std::size_t Write( std::size_t, const void* ); bool Flush(); private: // Buffer being read/written. ON_Buffer* m_buffer; private: // prohibit use - you should specify a buffer. ON_BinaryArchiveBuffer( ON::archive_mode ); private: // prohibit default construction, copy construction, and operator= ON_BinaryArchiveBuffer( ); // no implementation ON_BinaryArchiveBuffer( const ON_BinaryArchiveBuffer& ); // no implementation ON_BinaryArchiveBuffer& operator=( const ON_BinaryArchiveBuffer& ); // no implementation }; class ON_CLASS ON_Read3dmBufferArchive : public ON_BinaryArchive { public: /* Description: Construct an ON_BinaryArchive for reading information from a memory buffer. Parameters: sizeof_buffer - [in] size of buffer in bytes (>0) buffer - [in] memory buffer containing binary archive bCopyBuffer - [in] true - copy the input buffer. Useful when the buffer may be destroyed while this class is still in use. false - Do not copy the input buffer. In this case you are responsible for making certain the input buffer is valid while this class is in use. archive_3dm_version - [in] (1,2,3,4 or 5) archive_opennurbs_version - [in] YYYYMMDDn */ ON_Read3dmBufferArchive( std::size_t sizeof_buffer, const void* buffer, bool bCopyBuffer, int archive_3dm_version, int archive_opennurbs_version ); ~ON_Read3dmBufferArchive(); /* Returns: value of m_sizeof_buffer */ std::size_t SizeOfBuffer() const; /* Returns: value of m_buffer */ const void* Buffer() const; // ON_BinaryArchive overrides std::size_t CurrentPosition() const; bool SeekFromCurrentPosition(int); bool SeekFromStart(std::size_t); bool AtEnd() const; protected: // ON_BinaryArchive overrides std::size_t Read( std::size_t, void* ); // return actual number of bytes read (like fread()) std::size_t Write( std::size_t, const void* ); bool Flush(); private: void* m_p; const unsigned char* m_buffer; std::size_t m_sizeof_buffer; std::size_t m_buffer_position; ON__INT_PTR m_reserved1; ON__INT_PTR m_reserved2; ON__INT_PTR m_reserved3; ON__INT_PTR m_reserved4; private: // prohibit use - no implementation ON_Read3dmBufferArchive(); ON_Read3dmBufferArchive( const ON_Read3dmBufferArchive& ); ON_Read3dmBufferArchive& operator=(const ON_Read3dmBufferArchive&); }; class ON_CLASS ON_Write3dmBufferArchive : public ON_BinaryArchive { public: /* Description: Construct an ON_BinaryArchive for writing information to a memory buffer. Parameters: initial_sizeof_buffer - [in] initial size of buffer in bytes (>=0) If you are unable to estimate the size you will need, pass in zero. max_sizeof_buffer - [in] maximum size of buffer in bytes (>=0) If max_sizeof_buffer > 0 and the amount of information saved requires a buffer larger than this size, then writing fails. If max_sizeof_buffer <= 0, then no buffer size limits are enforced. archive_3dm_version - [in] (0, ,2,3,4 or 50) Pass 0 or ON_BinaryArchive::CurrentArchiveVersion() to write the version of opennurbs archives used by lastest version of Rhino. archive_opennurbs_version - [in] YYYYMMDDn */ ON_Write3dmBufferArchive( std::size_t initial_sizeof_buffer, std::size_t max_sizeof_buffer, int archive_3dm_version, int archive_opennurbs_version ); ~ON_Write3dmBufferArchive(); /* Returns: Size of the archive in bytes. */ std::size_t SizeOfArchive() const; /* Returns: value of m_sizeof_buffer */ std::size_t SizeOfBuffer() const; /* Returns: value of m_buffer. SizeOfArchive() reports the number of bytes written to this buffer. SizeOfBuffer() reports the number of bytes allocated in this buffer. */ const void* Buffer() const; /* Returns: The pointer to the buffer and sets all members on this archive back to zero. The caller is responsible for calling onfree() on the pointer when finished with the buffer. */ void* HarvestBuffer(); // ON_BinaryArchive overrides std::size_t CurrentPosition() const; bool SeekFromCurrentPosition(int); bool SeekFromStart(std::size_t); bool AtEnd() const; protected: // ON_BinaryArchive overrides std::size_t Read( std::size_t, void* ); std::size_t Write( std::size_t, const void* ); // return actual number of bytes written (like fwrite()) bool Flush(); private: void AllocBuffer(std::size_t); void* m_p; unsigned char* m_buffer; std::size_t m_sizeof_buffer; const std::size_t m_max_sizeof_buffer; std::size_t m_sizeof_archive; std::size_t m_buffer_position; ON__INT_PTR m_reserved1; ON__INT_PTR m_reserved2; ON__INT_PTR m_reserved3; ON__INT_PTR m_reserved4; private: // prohibit use - no implementation ON_Write3dmBufferArchive(); ON_Write3dmBufferArchive( const ON_Write3dmBufferArchive& ); ON_Write3dmBufferArchive& operator=(const ON_Write3dmBufferArchive&); }; /* Description: Create a simple archive that contains a single geometric object. Parameters: archive - [in] destination archive. version - [in] (0, 2, 3, 4, or 50) format version.archive version number. Version 2 format can be read by Rhino 2 and Rhino 3. Version 3 format can be read by Rhino 3. Pass 0 or ON_BinaryArchive::CurrentArchiveVersion() to write the latest version of archives supported by Rhino. object - [in] object to be saved in the archive's object table. This is typically some type of ON_Curve, ON_Surface, ON_Mesh, or ON_Brep. Returns: @untitled table true archive successfully written. false archive not successfully written. Example: const char* filename = "myfile.3dm"; FILE* fp = ON::OpenFile( filename, "wb" ); ON_BinaryFile file( fp, ON::write3dm ); ON_BOOL32 ok = ON_WriteArchive( archive, geometry ); ON::CloseFile( fp ); Remarks: The object table in the archive will contain a single object. */ ON_DECL bool ON_WriteOneObjectArchive( ON_BinaryArchive& archive, int version, const ON_Object& object ); #endif