Changeset 13547

Timestamp:

01/18/08 17:01:29 (6 months ago)

Author:

warmerdam

Message:

To use dwg/dxf support gdal interface should be updated.
Switch/redefine OdChar?* to OdString?&, OdUInt32 to OdUInt64
in ogr_dwg.h, odfilebuf.h/cpp (#1459).

Files:

• spike/dxfdwg/OdFileBuf.cpp (modified) (14 diffs)
• spike/dxfdwg/OdFileBuf.h (modified) (8 diffs)
• spike/dxfdwg/ogr_dwg.h (modified) (6 diffs)
• spike/dxfdwg/ogrwritabledwgdatasource.cpp (modified) (1 diff)

spike/dxfdwg/OdFileBuf.cpp

@@ +1 @@
+
+#if (defined(WIN32) || defined(WIN64)) && !defined(_WIN32_WCE)
+
+#define ODA_NON_TRACING   // Comment it to have trace
+
+#pragma warning(disable: 4290)
+
+#if defined(_MSC_VER)
+#include <windows.h>
+#endif
+
+#include "OdaCommon.h"
+#include "OdFileBuf.h"
+#include "OdString.h"
+
+
+void OdBaseFileBuf::open(const OdString& wszFileName, Oda::FileShareMode nShareMode, Oda::FileAccessMode nDesiredAccess, Oda::FileCreationDisposition nCreationDisposition)
+{
+        close();
+        ODA_TRACE(DD_T("open('%ls', 0x%x, 0x%x, %d)"), wszFileName.c_str(), nDesiredAccess, nShareMode, nCreationDisposition);
+
+        // Check file name passed
+  if( wszFileName.isEmpty() ) throw OdError(eNoFileName);
+        
+        DWORD dwAccess = 0, dwAttr = 0;
+        if( nDesiredAccess & Oda::kFileRead )
+        {
+                dwAccess |= GENERIC_READ;
+                dwAttr |= FILE_FLAG_RANDOM_ACCESS;
+        }
+        if( nDesiredAccess & Oda::kFileWrite )
+        {
+                dwAccess |= GENERIC_WRITE;
+                dwAttr |= FILE_ATTRIBUTE_NORMAL;
+        }
+
+        DWORD dwShare = 0;
+        if( nShareMode != Oda::kShareDenyRead && nShareMode != Oda::kShareDenyReadWrite )
+        {
+                dwShare |= FILE_SHARE_READ;
+        }
+        if( nShareMode != Oda::kShareDenyWrite && nShareMode != Oda::kShareDenyReadWrite )
+        {
+                dwShare |= FILE_SHARE_WRITE;
+        }
+
+        DWORD dwDisposition = 0;
+        switch( nCreationDisposition )
+        {
+                case Oda::kCreateNew:
+                        dwDisposition = CREATE_NEW;
+                        break;
+                case Oda::kCreateAlways:
+                        dwDisposition = CREATE_ALWAYS;
+                        break;
+                case Oda::kOpenExisting:
+                        dwDisposition = OPEN_EXISTING;
+                        break;
+                case Oda::kOpenAlways:
+                        dwDisposition = OPEN_ALWAYS;
+                        break;
+                case Oda::kTruncateExisting:
+                        dwDisposition = TRUNCATE_EXISTING;
+                        break;
+        }
+
+  OdString sFileName = wszFileName;
+  m_hFile =     ::CreateFileW(wszFileName, dwAccess, dwShare, NULL, dwDisposition, dwAttr, NULL);
+
+        if( m_hFile == INVALID_HANDLE_VALUE )
+        {
+    ODA_TRACE1("open() can't open file, GetLastError = %x", ::GetLastError());
+                throw OdError_FileException(eCantOpenFile, sFileName);
+        }
+        else
+        {
+                m_sFileName = sFileName;
+                m_iFileShare = nShareMode;
+        }
+
+        //ATLTRACE("OdBaseFileBuf::open(%hs)\n", m_sFileName.c_str());
+}
+
+void OdBaseFileBuf::close()
+{
+        if( m_hFile != INVALID_HANDLE_VALUE )
+        {
+                ODA_TRACE(DD_T("close()"));
+                // Flush buffer if writing was done
+                if( m_bFileWritten ) ::FlushFileBuffers(m_hFile);
+                ::CloseHandle(m_hFile);
+                m_hFile = INVALID_HANDLE_VALUE;
+        }
+        m_sFileName.empty();
+        m_iFileShare = 0;
+        m_bFileWritten = false;
+  m_bError = false;
+}
+
+OdUInt64 OdBaseFileBuf::length()
+{
+        ODA_TRACE(DD_T("length()"));
+        return ::GetFileSize(m_hFile, NULL);
+}
+
+#if !defined(INVALID_SET_FILE_POINTER) // for _MSC_VER <= 1200
+#define INVALID_SET_FILE_POINTER ((DWORD)-1)
+#endif
+
+OdUInt64 OdBaseFileBuf::seek(OdInt64 offset, OdDb::FilerSeekType whence)
+{
+        ODA_TRACE(DD_T("seek(%d, %d)"), offset, whence);
+
+        DWORD dwMethod = 0;
+        switch( whence )
+        {
+                case OdDb::kSeekFromStart:
+                        dwMethod = FILE_BEGIN;
+                        break;
+                case OdDb::kSeekFromCurrent:
+                        dwMethod = FILE_CURRENT;
+                        break;
+                case OdDb::kSeekFromEnd:
+                        dwMethod = FILE_END;
+                        break;
+        }
+
+  LARGE_INTEGER li;
+  li.QuadPart = offset;
+  li.LowPart = ::SetFilePointer(m_hFile, li.LowPart, &li.HighPart, dwMethod);
+  if (li.LowPart == INVALID_SET_FILE_POINTER && ::GetLastError() != NO_ERROR)
+  {
+    li.QuadPart = -1;
+    throw OdError_FileException(eFileInternalErr, m_sFileName);
+  }
+  return li.QuadPart;
+}
+
+OdUInt64 OdBaseFileBuf::tell()
+{
+        ODA_TRACE(DD_T("tell()"));
+        return ::SetFilePointer(m_hFile, 0, NULL, FILE_CURRENT);
+}
+
+bool OdBaseFileBuf::isEof()
+{
+        ODA_TRACE(DD_T("isEof()"));
+        return (::GetFileSize(m_hFile, NULL) == ::SetFilePointer(m_hFile, 0, NULL, FILE_CURRENT));
+}
+
+OdUInt8 OdBaseFileBuf::getByte()
+{
+        ODA_TRACE(DD_T("getByte()"));
+
+        DWORD dwBytes = 0;
+        OdUInt8 b = 0;
+        if( !::ReadFile(m_hFile, &b, 1, &dwBytes, NULL) )
+        {
+                ODA_TRACE(DD_T("getByte() can't read byte due to read error"));
+                throw OdError_FileException(eFileInternalErr, m_sFileName);
+        }
+        if( dwBytes == 0 )
+        {
+                ODA_TRACE(DD_T("getByte() can't read byte due to end-of-file"));
+                throw OdError_FileException(eEndOfFile, m_sFileName);
+        }
+        
+        return b;
+}
+
+void OdBaseFileBuf::getBytes(void* buffer, OdUInt32 nLen)
+{
+        ODA_TRACE(DD_T("getBytes(%p, %u)"), buffer, nLen);
+
+        DWORD dwBytes = 0;
+        if( !::ReadFile(m_hFile, buffer, nLen, &dwBytes, NULL) )
+        {
+                ODA_TRACE(DD_T("getBytes() can't read byte due to read error"));
+                throw OdError_FileException(eFileInternalErr, m_sFileName);
+        }
+        if( dwBytes < nLen )
+        {
+                ODA_TRACE(DD_T("getBytes() read only %u bytes due to end-of-file"), dwBytes);
+                throw OdError_FileException(eEndOfFile, m_sFileName);
+        }
+}
+
+void OdBaseFileBuf::putByte(OdUInt8 val)
+{
+        ODA_TRACE(DD_T("putByte(0x%x)"), val);
+
+        DWORD dwBytes = 0;
+        BYTE b = val;
+        if( !::WriteFile(m_hFile, &b, 1, &dwBytes, NULL) || dwBytes != 1 )
+        {
+                ODA_TRACE(DD_T("putByte() can't write byte"));
+                throwOdError(OdError_FileException(eFileWriteError, m_sFileName));
+        }
+        m_bFileWritten = true;
+}
+
+void OdBaseFileBuf::putBytes(const void* buffer, OdUInt32 nLen)
+{
+        ODA_TRACE(DD_T("putBytes(%p, %u)"), buffer, nLen);
+
+        DWORD dwBytes = 0;
+        if( !::WriteFile(m_hFile, buffer, nLen, &dwBytes, NULL) || dwBytes != nLen )
+        {
+                ODA_TRACE(DD_T("putBytes() can't write bytes"));
+                throwOdError(OdError_FileException(eFileWriteError, m_sFileName));
+        }
+        m_bFileWritten = true;
+}
+
+void OdBaseFileBuf::truncate()
+{
+        ODA_TRACE(DD_T("truncate()"));
+        if( !::SetEndOfFile(m_hFile) )
+        {
+                ODA_TRACE(DD_T("truncate() failed"));
+                throw OdError_FileException(eFileInternalErr, m_sFileName);
+        }
+}
+
+// Current method behavior description (so required behavior isn't documented in DWGDirect yet):
+//  - Move source stream to nSrcStart position
+//  - Read (nSrcEnd-nSrcStart) bytes from source stream to temporary buffer
+//  - Write buffer to target stream
+//  - Set source stream to nSrcEnd position
+void OdBaseFileBuf::copyDataTo(OdStreamBuf* pDest, OdUInt64 nSrcStart, OdUInt64 nSrcEnd)
+{
+        ODA_TRACE(DD_T("copyDataTo(%p, %u, %u)"), pDest, nSrcStart, nSrcEnd);
+
+  if(nSrcStart==0 && nSrcEnd==0)
+  {
+    nSrcStart = tell();
+    nSrcEnd = length(); 
+  }
+
+  // Do nothing if incorrect positions passed
+        if( nSrcEnd <= nSrcStart ) return;
+
+        // Remember current position to restore on error
+        OdUInt64 nPos = tell();
+        if( nPos != nSrcStart )
+        {
+                // Move to start position
+                if( seek(nSrcStart, OdDb::kSeekFromStart) != nSrcStart )
+                {
+                        ODA_TRACE(DD_T("copyDataTo() can't move to start position"));
+                        throw OdError_FileException(eEndOfFile, m_sFileName);
+                }
+        }
+
+        // Allocate temporary buffer
+        OdUInt32 nLen = OdUInt32(nSrcEnd - nSrcStart);
+        
+        HLOCAL hBuf = ::LocalAlloc(LHND, nLen);
+        if( hBuf == NULL )
+        {
+                ODA_TRACE(DD_T("copyDataTo() can't allocate temporary buffer"));
+                seek(nPos, OdDb::kSeekFromStart);
+                throw OdError_FileException(eOutOfMemory, m_sFileName);
+        }
+
+        void* pBuf = ::LocalLock(hBuf);
+        if( pBuf == NULL )
+        {
+                ODA_TRACE(DD_T("copyDataTo() can't access to temporary buffer"));
+                ::LocalFree(hBuf);
+                seek(nPos, OdDb::kSeekFromStart);
+                throw OdError_FileException(eOutOfMemory, m_sFileName);
+        }
+
+        // Read to buffer (current position will be set to nSrcEnd after)
+        getBytes(pBuf, nLen);
+        //seek(nPos, OdDb::kSeekFromStart);
+
+        // Write to destination
+        pDest->putBytes(pBuf, nLen);
+
+        ::LocalUnlock(hBuf);
+        ::LocalFree(hBuf);
+}
+
+
+OdWrFileBuf::OdWrFileBuf() : m_nBufferedSize(0)
+{
+}
+
+OdWrFileBuf::~OdWrFileBuf() 
+{ 
+  close(); 
+}
+
+#ifndef DD_UNICODE
+void OdWrFileBuf::open(const OdChar* szFileName, Oda::FileShareMode nShareMode, Oda::FileAccessMode nDesiredAccess, Oda::FileCreationDisposition nCreationDisposition)
+{
+  OdWString wsStr = OdStringToWideChar(szFileName);
+  if (wsStr.isEmpty())
+    throw OdError(eNoFileName);
+
+  OdBaseFileBuf::open(wsStr.c_str(), nShareMode, nDesiredAccess, nCreationDisposition);
+}
+#endif
+
+#ifndef DD_UNICODE
+void OdWrFileBuf::open(const OdCharW* wszFileName, Oda::FileShareMode nShareMode, Oda::FileAccessMode nDesiredAccess, Oda::FileCreationDisposition nCreationDisposition)
+#else
+void OdWrFileBuf::open(const OdString& wszFileName, Oda::FileShareMode nShareMode, Oda::FileAccessMode nDesiredAccess, Oda::FileCreationDisposition nCreationDisposition)
+#endif
+{
+  if (nDesiredAccess == Oda::kFileRead)
+    throw OdError_FileException(eCantOpenFile, m_sFileName);
+
+  OdBaseFileBuf::open(wszFileName, nShareMode, nDesiredAccess, nCreationDisposition);
+}
+
+#ifndef DD_UNICODE
+void OdRdFileBuf::open(const OdChar* szFileName, Oda::FileShareMode nShareMode, Oda::FileAccessMode nDesiredAccess, Oda::FileCreationDisposition nCreationDisposition)
+{
+  OdWString wsStr = OdStringToWideChar(szFileName);
+  if (wsStr.isEmpty())
+    throw OdError(eNoFileName);
+
+  open(wsStr.c_str(), nShareMode, nDesiredAccess, nCreationDisposition);
+}
+void OdRdFileBuf::open(const OdCharW* wszFileName, Oda::FileShareMode nShareMode, Oda::FileAccessMode nDesiredAccess, Oda::FileCreationDisposition nCreationDisposition)
+#else
+void OdRdFileBuf::open(const OdString& wszFileName, Oda::FileShareMode nShareMode, Oda::FileAccessMode nDesiredAccess, Oda::FileCreationDisposition nCreationDisposition)
+#endif
+{
+  if (nDesiredAccess & Oda::kFileWrite)
+    throw OdError_FileException(eCantOpenFile, m_sFileName);
+
+  OdBaseFileBuf::open(wszFileName, nShareMode, nDesiredAccess, nCreationDisposition);
+
+        // Test open mode and file attributes to use fast mapping buffer instead of plain one
+        if( nCreationDisposition == Oda::kOpenExisting || nCreationDisposition == Oda::kOpenAlways )
+        {
+                // Reject compressed and other special files
+                // TODO Perhaps reject remote files also
+                DWORD dwAttr =
+#ifdef DD_UNICODE
+                        ::GetFileAttributesW(wszFileName);
+#else
+                        ::GetFileAttributesA(OdWideCharToString((LPCWSTR)wszFileName));
+#endif //DD_UNICODE
+                if( dwAttr != INVALID_FILE_SIZE/*INVALID_FILE_ATTRIBUTES*/ &&
+                        !(dwAttr & (FILE_ATTRIBUTE_DIRECTORY|FILE_ATTRIBUTE_ENCRYPTED|
+                        FILE_ATTRIBUTE_SPARSE_FILE|FILE_ATTRIBUTE_REPARSE_POINT|
+                        FILE_ATTRIBUTE_COMPRESSED|FILE_ATTRIBUTE_OFFLINE)) )
+                {
+                        try
+                        {
+        // Remember actual file size
+        m_ulSize.LowPart = ::GetFileSize(m_hFile, &m_ulSize.HighPart);
+
+        DWORD dwProtect = PAGE_READONLY, dwAccess = FILE_MAP_READ;
+        if( nDesiredAccess & Oda::kFileWrite )
+        {
+                dwProtect = PAGE_READWRITE;
+                dwAccess = FILE_MAP_WRITE;
+        }
+
+        // Map file into memory
+        m_hFileMap = ::CreateFileMapping(m_hFile, NULL, dwProtect, 0, 0, NULL);
+        if( m_hFileMap == INVALID_HANDLE_VALUE ) throw OdError_FileException(eCantOpenFile, m_sFileName);
+
+        m_pFileMap = ::MapViewOfFile(m_hFileMap, dwAccess, 0, 0, 0);
+        if( !m_pFileMap ) throw OdError_FileException(eCantOpenFile, m_sFileName);
+                        }
+                        catch( ... )
+                        {
+                                // Fall down to plain buffer use
+                                // disable cache
+                        }
+                }
+        }
+}
+
+OdRdFileBuf::OdRdFileBuf()
+{
+        m_hFileMap = INVALID_HANDLE_VALUE;
+        m_pFileMap = NULL;
+        m_ulSize.QuadPart = 0;
+        m_ulPos.QuadPart = 0;
+}
+
+void OdRdFileBuf::close()
+{
+        if( m_pFileMap )
+        {
+                ::UnmapViewOfFile(m_pFileMap);
+                m_pFileMap = NULL;
+        }
+        if( m_hFileMap != INVALID_HANDLE_VALUE )
+        {
+                ::CloseHandle(m_hFileMap);
+                m_hFileMap = INVALID_HANDLE_VALUE;
+        }
+        m_ulSize.QuadPart = 0;
+        m_ulPos.QuadPart = 0;
+
+        OdBaseFileBuf::close();
+}
+
+OdUInt64 OdRdFileBuf::length()
+{
+  return memBufferUsed() ? OdUInt64(m_ulSize.QuadPart) : OdBaseFileBuf::length();
+}
+
+OdUInt64 OdRdFileBuf::seek(OdInt64 offset, OdDb::FilerSeekType whence)
+{
+  if (!memBufferUsed())
+    return OdBaseFileBuf::seek(offset, whence);
+
+        switch( whence )
+        {
+                case OdDb::kSeekFromStart:
+                        if( offset < 0 || offset > (OdInt64)m_ulSize.QuadPart ) throw OdError_FileException(eFileInternalErr, m_sFileName);
+                        m_ulPos.QuadPart = offset;
+                        break;
+                case OdDb::kSeekFromCurrent:
+                        if( (m_ulPos.QuadPart + offset) < 0 || (m_ulPos.QuadPart + offset) > m_ulSize.QuadPart ) throw OdError_FileException(eFileInternalErr, m_sFileName);
+                        m_ulPos.QuadPart += offset;
+                        break;
+                case OdDb::kSeekFromEnd:
+                        if( offset > 0 || -offset > (OdInt64)m_ulSize.QuadPart ) throw OdError_FileException(eFileInternalErr, m_sFileName);
+                        m_ulPos.QuadPart = m_ulSize.QuadPart + offset;
+                        break;
+        }
+
+        return m_ulPos.QuadPart;
+}
+
+OdUInt64 OdRdFileBuf::tell()
+{
+  if (!memBufferUsed())
+    return OdBaseFileBuf::tell();
+
+        return OdUInt64(m_ulPos.QuadPart);
+}
+
+bool OdRdFileBuf::isEof()
+{
+  if (!memBufferUsed())
+    return OdBaseFileBuf::isEof();
+
+  return (m_ulPos.QuadPart == m_ulSize.QuadPart);
+}
+
+OdUInt8 OdRdFileBuf::getByte()
+{
+  if (!memBufferUsed())
+    return OdBaseFileBuf::getByte();
+
+  if( m_ulPos.QuadPart >= m_ulSize.QuadPart ) throw OdError_FileException(eEndOfFile, m_sFileName);
+
+        return ((OdUInt8*)m_pFileMap)[m_ulPos.QuadPart++];
+}
+
+void OdRdFileBuf::getBytes(void* buffer, OdUInt32 nLen)
+{
+  if (!memBufferUsed())
+  {
+    OdBaseFileBuf::getBytes(buffer, nLen);
+    return;
+  }
+
+  if( (m_ulPos.QuadPart + nLen) > m_ulSize.QuadPart ) throw OdError_FileException(eEndOfFile, m_sFileName);
+
+        ::CopyMemory(buffer, ((OdUInt8*)m_pFileMap) + m_ulPos.QuadPart, nLen);
+
+        m_ulPos.QuadPart += nLen;
+}
+
+void OdRdFileBuf::putByte(OdUInt8 val)
+{
+  if (!memBufferUsed())
+  {
+    OdBaseFileBuf::putByte(val);
+    return;
+  }
+
+  if( m_ulPos.QuadPart > m_ulSize.QuadPart ) throw OdError_FileException(eFileWriteError, m_sFileName);
+
+        ((OdUInt8*)m_pFileMap)[m_ulPos.QuadPart++] = val;
+
+        // TODO? m_bFileWritten = true;
+}
+
+void OdRdFileBuf::putBytes(const void* buffer, OdUInt32 nLen)
+{
+  if (!memBufferUsed())
+  {
+    OdBaseFileBuf::putBytes(buffer, nLen);
+    return;
+  }
+
+  if( (m_ulPos.QuadPart + nLen) > m_ulSize.QuadPart ) throw OdError_FileException(eFileWriteError, m_sFileName);
+
+        ::CopyMemory(((OdUInt8*)m_pFileMap) + m_ulPos.QuadPart, buffer, nLen);
+
+        m_ulPos.QuadPart += nLen;
+
+        // TODO? m_bFileWritten = true;
+}
+
+void OdRdFileBuf::truncate()
+{
+  if (!memBufferUsed())
+  {
+    OdBaseFileBuf::truncate();
+    return;
+  }
+
+  throw OdError_FileException(eFileWriteError, m_sFileName);
+}
+
+// Current method behavior description (so required behavior isn't documented in DWGDirect yet):
+//  - Move source stream to nSrcStart position
+//  - Read (nSrcEnd-nSrcStart) bytes from source stream to temporary buffer
+//  - Write buffer to target stream
+//  - Set source stream to nSrcEnd position
+void OdRdFileBuf::copyDataTo(OdStreamBuf* pDest, OdUInt64 nSrcStart, OdUInt64 nSrcEnd)
+{
+  if (!memBufferUsed())
+  {
+    OdBaseFileBuf::copyDataTo(pDest, nSrcStart, nSrcEnd);
+    return;
+  }
+
+  if( !pDest ) throw OdError_FileException(eNullObjectPointer, m_sFileName);
+
+  if(nSrcStart==0 && nSrcEnd==0)
+  {
+    nSrcStart = tell();
+    nSrcEnd = length(); 
+  }
+
+  // Do nothing if incorrect positions passed
+        if( nSrcEnd <= nSrcStart ) return;
+
+        if( nSrcEnd > m_ulSize.QuadPart ) throw OdError_FileException(eEndOfFile, m_sFileName);
+
+        pDest->putBytes(((OdUInt8*)m_pFileMap) + nSrcStart, OdUInt32(nSrcEnd - nSrcStart));
+}
+
+OdUInt64 OdWrFileBuf::seek(OdInt64 offset, OdDb::FilerSeekType whence)
+{
+  flush();
+  return OdBaseFileBuf::seek(offset, whence);
+}
+
+ void OdWrFileBuf::putByte(OdUInt8 val)
+{
+  if ( m_nBufferedSize == WRITING_BUFFER_LENGTH )
+  {
+    flush();
+  }
+  m_pBuffer[m_nBufferedSize++] = val;
+}
+
+void OdWrFileBuf::putBytes(const void* buffer, OdUInt32 nLen)
+{
+  if (nLen > WRITING_BUFFER_LENGTH)
+  {
+    flush();
+    OdBaseFileBuf::putBytes(buffer, nLen);
+    return;
+  }
+  if ( m_nBufferedSize + nLen > WRITING_BUFFER_LENGTH )
+  {
+    flush();
+  }
+  memcpy(m_pBuffer + m_nBufferedSize, buffer, nLen);
+  m_nBufferedSize += nLen;
+}
+
+OdUInt64 OdWrFileBuf::tell()
+{
+  return OdBaseFileBuf::tell() + m_nBufferedSize;
+}
+
+void OdWrFileBuf::close()
+{
+  if (!errorModeEnabled()) 
+  // to prevent second exception in putBytes. cr 3861
+  {
+    flush();
+  }
+  OdBaseFileBuf::close();
+}
+
+OdUInt8 OdWrFileBuf::getByte()
+{
+  flush();
+  return OdBaseFileBuf::getByte();
+}
+void OdWrFileBuf::getBytes(void* buffer, OdUInt32 nLen)
+{
+  flush();
+  OdBaseFileBuf::getBytes(buffer,nLen);
+}
+void OdWrFileBuf::copyDataTo(OdStreamBuf* pDest, OdUInt64 nSrcStart, OdUInt64 nSrcEnd)
+{
+  flush();
+  OdBaseFileBuf::copyDataTo(pDest, nSrcStart,nSrcEnd);
+}
+
+OdUInt64 OdWrFileBuf::length()
+{
+  OdUInt64 l = OdBaseFileBuf::length();
+  OdUInt64 pos = OdBaseFileBuf::tell();
+  if ( pos + m_nBufferedSize > l )
+  {
+    return pos + m_nBufferedSize;
+  }
+  else  
+  {
+    return l;
+  }
+}
+
+#else // #ifdef WIN32
+
-#include <stdlib.h>
-#include "OdaCommon.h"
@@ -33 +660 @@
-#endif
-
-Char *path, const char *
-
-path, 
+String& fileName, const OdString& 
+
+(const char*)fileName, (const char*)
-  if (m_fp)
-  {
-    setvbuf(m_fp, 0, _IOFBF, 8192);
-path
+fileName
-  }
-  else
-path
+fileName
-}
-
@@ -49 +676 @@
-OdWrFileBuf::OdWrFileBuf()
-    : m_position(ERR_VAL)
-
+
+
-
-OdWrFileBuf::~OdWrFileBuf()
@@ -58 +686 @@
-
-void OdWrFileBuf::open(
-Char*
+String&
-  Oda::FileShareMode /*shMode*/, 
-  Oda::FileAccessMode /*nDesiredAccess*/, 
-  Oda::FileCreationDisposition /*nCreationDisposition*/)
-{
-"wb"
+DD_T("wb")
-
-  //if (shMode == Oda::kShareDenyReadWrite)
@@ -69 +697 @@
-  m_position = 0;
-  m_length = 0;
-"wb"
+sMode
-  return;
-}
@@ -79 +707 @@
-}
-
-32
+64
-{
-  return m_length;
-}
-
-
-
+
-{
-  switch (whence) {
@@ -103 +730 @@
-}
-
-32
+64
-{
-  return m_position;
@@ -184 +811 @@
-
-void OdRdFileBuf::open(
-Char *
+String&
-  Oda::FileShareMode shMode,
-  Oda::FileAccessMode /*nDesiredAccess*/, 
@@ -192 +819 @@
-
-  if (shMode == Oda::kShareDenyWrite || shMode == Oda::kShareDenyReadWrite)
-"r+b"
+DD_T("r+b")
-  else 
-"rb"
-
-.c_str()
+DD_T("rb")
+
+
-
-  // Get file length
-32
+64
-        fseek(m_fp, 0L, 2);
-        m_length = ftell(m_fp);
@@ -315 +942 @@
-}
-
-32
+64
-{
-  return m_length;
@@ -321 +948 @@
-
-
-32 OdRdFileBuf::seek(OdInt32
+64 OdRdFileBuf::seek(OdInt64
-{
-  int bytestoadvance;
@@ -340 +967 @@
-  // from here on assume whence is 0
-  // if it's not in the area we're holding, seek to it
-32(offset) < m_BufPos || OdUInt32
+64(offset) < m_BufPos || OdUInt64
-  {
-    m_BufPos=offset & m_PosMask;
@@ -357 +984 @@
-}
-
-32
+64
-{
-  return (m_BufPos + (m_pNextChar - m_pCurBuf));
@@ -413 +1040 @@
-  }
-}
+ 
+#endif // #ifdef WIN32
+

spike/dxfdwg/OdFileBuf.h

@@ -1 +1 @@
-#ifndef ODFILEBUF_DEFINED
-#define ODFILEBUF_DEFINED
+
+#if (defined(WIN32) || defined(WIN64)) && !defined(_WIN32_WCE)
+
+#include "OdStreamBuf.h"
+#include "RxObjectImpl.h"
+#include "OdString.h"
+#include "DbSystemServices.h"
+
+#define DD_UNICODE
+
+class OdBaseFileBuf;
+
+/** Remarks:
+  This template class is a specialization of the OdSmartPtr class for OdBaseFileBuf object pointers.
+*/
+typedef OdSmartPtr<OdBaseFileBuf> OdBaseFileBufPtr;
+
+/** Description:
+  This class is the base file I/O class.
+  Library:
+  Source *code* provided.
+  {group:ExServices_Classes}
+*/
+class OdBaseFileBuf: public OdRxObjectImpl<OdStreamBuf>
+{
+private:
+  bool m_bError;
+protected:
+  inline void enableErrorMode(bool bEnable = true) 
+  { 
+    m_bError = bEnable; 
+  }
+
+  inline bool errorModeEnabled() 
+  { 
+    return m_bError; 
+  }
+
+  inline void throwOdError(const OdError &pError)
+  {
+    enableErrorMode(true);
+    throw pError;
+  }
+
+protected:
+  HANDLE    m_hFile;
+  OdString  m_sFileName;
+  int       m_iFileShare;
+  bool      m_bFileWritten;
+
+  OdBaseFileBuf()
+  {
+    m_hFile = INVALID_HANDLE_VALUE;
+    m_iFileShare = 0;
+    m_bFileWritten = false;
+    m_bError = false;
+  }
+
+public:
+  /** Description:
+    Opens the specified file with this StreamBuf object.
+    Arguments:
+    filename (I) Filename.
+    shareMode (I) Share mode.
+    accessMode (I) Access mode.
+    creationDisposition (I) Creation disposition.
+  */
+  virtual void open(const OdString& filename,
+    Oda::FileShareMode shareMode,
+    Oda::FileAccessMode accessMode,
+    Oda::FileCreationDisposition creationDisposition);
+#ifndef DD_UNICODE  
+  virtual void open(const OdCharW* filename,
+    Oda::FileShareMode shareMode,
+    Oda::FileAccessMode accessMode,
+    Oda::FileCreationDisposition creationDisposition);
+#endif
+
+  /** Description:
+    Closes the file opened by this StreamBuf object.
+  */
+  virtual void close();
+
+  /** Description:
+    Returns the name of the file associated with this StreamBuf object.
+  */
+  virtual OdString fileName() { return m_sFileName; }
+
+  /** Description:
+    Returns the share mode of this StreamBuf object.
+  */
+  virtual OdUInt32 getShareMode() { return OdUInt32(m_iFileShare); }
+  
+  /** Description:
+    Returns the *length* in bytes of the file associated with
+    this StreamBuf object.
+  */
+  virtual OdUInt64 length();
+  
+  /** Description:
+    Moves the current position of the file pointer for
+    this StreamBuf object to the specified location.
+
+    Arguments:
+    offset (I) Number of *bytes*.
+    seekType (I) Seek type.
+    
+    Remarks:
+    seekType must be one of the following:
+    
+    @table
+    Name                    Value       Description.
+    OdDb::kSeekFromStart    SEEK_SET    Start of file.
+    OdDb::kSeekFromCurrent  SEEK_CUR    Current position of file pointer.
+    OdDb::kSeekFromEnd      SEEK_END    End of file.
+  */
+  virtual OdUInt64 seek(OdInt64 offset, OdDb::FilerSeekType seekType);
+
+  /** Description:
+    Returns the current position of the file pointer for
+    this StreamBuf object.
+  */
+  virtual OdUInt64 tell();
+
+  /** Description:
+    Returns true if and only if the current position of the file pointer for
+    this StreamBuf object is at the end of file.
+  */
+  virtual bool isEof();
+
+  /** Description:
+    Returns the byte at the current position of the file pointer
+    for this StreamBuf object, and increments the pointer.
+  */
+  virtual OdUInt8 getByte();
+
+  /** Description:
+    Returns the specified number of bytes, starting at the current position of the file pointer
+    for this StreamBuf object, and increments the pointer by numBytes.
+    Arguments:
+    buffer (I) Character *buffer*.
+    numBytes (I) Number of *bytes*.
+  */
+  virtual void getBytes(void* buffer, OdUInt32 numBytes);
+
+  /** Description:
+    Writes the byte to the current position of the file pointer
+    for this StreamBuf object, and increments the pointer.
+    Arguments:
+    value (I) Byte to write. 
+  */
+  virtual void putByte(OdUInt8 value);
+
+  /** Description:
+    Writes the specified number of bytes, starting at the current position of the file pointer
+    for this StreamBuf object, and increments the pointer by numBytes.
+    Arguments:
+    buffer (I) Character *buffer*.
+    numBytes (I) Number of *bytes*.
+  */
+  virtual void putBytes(const void* buffer, OdUInt32 numBytes);
+
+  /** Description:
+    Sets the *length* of the file associated with
+    this StreamBuf object to zero.
+  */
+  virtual void truncate();
+
+   /** Description:
+    Copies the specified bytes from this StreamBuf object to the specified StreamBuf object.
+    Arguments:
+    pDestination (I) Pointer to the StreamBuf object to receive the *data*.
+    sourceStart (I) Starting position of the file pointer of this StreamBuf object.
+    sourceEnd (I) Ending position of the file pointer of this StreamBuf object.
+    Remarks:
+    Bytes are copied from sourceStart to sourceEnd inclusive.
+  */
+ virtual void copyDataTo(OdStreamBuf* pDestination, OdUInt64 sourceStart, OdUInt64 sourceEnd);
+};
+
+class OdRdFileBuf;
+
+/** Remarks:
+  This template class is a specialization of the OdSmartPtr class for OdRdFileBuf object pointers.
+*/
+typedef OdSmartPtr<OdRdFileBuf> OdRdFileBufPtr;
+
+/** Description:
+  This class implements file input.
+  Library:
+  Source *code* provided.
+  {group:ExServices_Classes}
+*/
+class OdRdFileBuf : public OdBaseFileBuf
+{
+  OdRdFileBuf(const OdRdFileBuf& source);
+  OdRdFileBuf& operator = (const OdRdFileBuf& source);
+
+protected:
+  HANDLE      m_hFileMap;
+  LPVOID      m_pFileMap;
+  ULARGE_INTEGER  m_ulSize;
+  ULARGE_INTEGER  m_ulPos;
+
+  /** { Secret } */
+  inline bool memBufferUsed() const { return m_pFileMap != 0; }
+
+public:
+  OdRdFileBuf(const OdString& filename) 
+  { 
+    m_hFileMap = INVALID_HANDLE_VALUE;
+    m_pFileMap = NULL;
+    m_ulSize.QuadPart = 0;
+    m_ulPos.QuadPart = 0;
+
+    open(filename); 
+  }
+
+  /** Description:
+    Arguments:
+    filename (I) Filename.
+    shareMode (I) Share mode.
+    accessMode (I) Access mode.
+    creationDisposition (I) Creation disposition.
+    Remarks:
+    Opens filename if specified.
+  */
+  OdRdFileBuf(
+    const OdString& filename, 
+    Oda::FileShareMode shareMode, 
+    Oda::FileAccessMode accessMode,
+    Oda::FileCreationDisposition creationDisposition)
+  { 
+    m_hFileMap = INVALID_HANDLE_VALUE;
+    m_pFileMap = NULL;
+    m_ulSize.QuadPart = 0;
+    m_ulPos.QuadPart = 0;
+
+    open(filename, shareMode, accessMode, creationDisposition); 
+  }
+
+  OdRdFileBuf();
+
+  ~OdRdFileBuf() { close(); }
+
+  /** 
+    Arguments:
+    filename (I) Filename.
+    shareMode (I) Share mode.
+    accessMode (I) Access mode.
+    creationDisposition (I) Creation disposition.
+    Remarks:
+    Opens filename if specified.
+  */
+  static OdRdFileBufPtr createObject()
+  {
+    return OdRdFileBufPtr(new OdRdFileBuf(), kOdRxObjAttach);
+  }
+
+  static OdRdFileBufPtr createObject(
+    const OdString& filename, 
+    Oda::FileShareMode shareMode = Oda::kShareDenyWrite,
+    Oda::FileAccessMode accessMode = Oda::kFileRead,
+    Oda::FileCreationDisposition creationDisposition = Oda::kOpenExisting)
+  {
+    return OdRdFileBufPtr(new OdRdFileBuf(filename, shareMode, accessMode, creationDisposition), kOdRxObjAttach);
+  }
+
+  virtual void open(const OdString& filename,
+    Oda::FileShareMode shareMode = Oda::kShareDenyWrite,
+    Oda::FileAccessMode accessMode = Oda::kFileRead,
+    Oda::FileCreationDisposition creationDisposition = Oda::kOpenExisting);
+#ifndef DD_UNICODE  
+  virtual void open(const OdCharW* filename,
+    Oda::FileShareMode shareMode = Oda::kShareDenyWrite,
+    Oda::FileAccessMode accessMode = Oda::kFileRead,
+    Oda::FileCreationDisposition creationDisposition = Oda::kOpenExisting);
+#endif
+
+  virtual void close();
+
+  virtual OdUInt64 length();
+  virtual OdUInt64 seek(OdInt64 offset, OdDb::FilerSeekType seekType);
+  virtual OdUInt64 tell();
+  virtual bool isEof();
+  virtual OdUInt8 getByte();
+  virtual void getBytes(void* buffer, OdUInt32 numBytes);
+  virtual void putByte(OdUInt8 value);
+  virtual void putBytes(const void* buffer, OdUInt32 numBytes);
+  virtual void truncate();
+
+  virtual void copyDataTo(OdStreamBuf* pDestination, OdUInt64 sourceStart, OdUInt64 sourceEnd);
+};
+
+#define WRITING_BUFFER_LENGTH 1024*8
+class OdWrFileBuf;
+
+/** Remarks:
+  This template class is a specialization of the OdSmartPtr class for OdWrFileBuf object pointers.
+*/
+typedef OdSmartPtr<OdWrFileBuf> OdWrFileBufPtr;
+
+/** Description:
+  This class implements file output.
+  Library:
+  Source *code* provided.
+  {group:ExServices_Classes}
+*/
+class OdWrFileBuf : public OdBaseFileBuf
+{
+  OdWrFileBuf(const OdWrFileBuf& source);
+  OdWrFileBuf& operator = (const OdWrFileBuf& source);
+  OdUInt8 m_pBuffer[WRITING_BUFFER_LENGTH];
+  OdUInt32 m_nBufferedSize;
+  inline void flush()
+  {
+    if ( m_nBufferedSize == 0 )
+      return;
+    OdBaseFileBuf::putBytes(m_pBuffer, m_nBufferedSize);
+    m_nBufferedSize = 0;
+  }
+
+public:
+
+  /** Description:
+    Arguments:
+    filename (I) Filename.
+    shareMode (I) Share mode.
+    accessMode (I) Access mode.
+    creationDisposition (I) Creation disposition.
+    Remarks:
+    Opens filename if specified.
+  */
+  OdWrFileBuf(const OdString& filename):m_nBufferedSize(0) { open(filename); }
+  OdWrFileBuf(
+    const OdString& filename, 
+    Oda::FileShareMode shareMode,
+    Oda::FileAccessMode accessMode,
+    Oda::FileCreationDisposition creationDisposition):m_nBufferedSize(0)
+  { 
+    open(filename, shareMode, accessMode, creationDisposition); 
+  }
+
+  OdWrFileBuf();
+
+  ~OdWrFileBuf();
+
+  /**
+    Arguments: