/////////////////////////////////////////////////////////////////////////////// 
// Copyright (C) 2002-2016, Open Design Alliance (the "Alliance"). 
// All rights reserved. 
// 
// This software and its documentation and related materials are owned by 
// the Alliance. The software may only be incorporated into application 
// programs owned by members of the Alliance, subject to a signed 
// Membership Agreement and Supplemental Software License Agreement with the
// Alliance. The structure and organization of this software are the valuable  
// trade secrets of the Alliance and its suppliers. The software is also 
// protected by copyright law and international treaty provisions. Application  
// programs incorporating this software must include the following statement 
// with their copyright notices:
//   
//   This application incorporates Teigha(R) software pursuant to a license 
//   agreement with Open Design Alliance.
//   Teigha(R) Copyright (C) 2002-2016 by Open Design Alliance. 
//   All rights reserved.
//
// By use of this software, its documentation or related materials, you 
// acknowledge and accept the above terms.
///////////////////////////////////////////////////////////////////////////////

// MemFileStreamImpl.h : implementation for the OdMemFileStreamImpl class.
//
//////////////////////////////////////////////////////////////////////

#if !defined(_MEMORYFILESTREAMIMPL_H_INCLUDED_)
#define _MEMORYFILESTREAMIMPL_H_INCLUDED_

#include "RxObjectImpl.h"
#include "MemoryStream.h"
#include "OdAlloc.h"

#ifdef OD_HAVE_UNISTD_FILE
#include <unistd.h>
#endif

#ifdef OD_HAVE_WINDOWS_STORAGE_FILE
#include <windows.storage.h>
#endif

#ifdef OD_HAVE_WRL_FILE
#include <wrl/client.h>
#include <wrl/wrappers/corewrappers.h>
#endif

//DD:EXPORT_ON

/** \details
    <group TD_Namespaces>
*/
namespace TmpFileHelper
{
#define TEMPFILE_PREFIX  "tx$"

  /** \details
    Returns the temporary file name.
  */
  static OdString getTempFile(OdDbBaseHostAppServices* pHostAppServices, const OdAnsiString& prefix = TEMPFILE_PREFIX)
  {
    OdString tmpDir = pHostAppServices->getTempPath();
#if defined(_WINRT)
    GUID result;
    if (CoCreateGuid(&result) < 0) 
        return OdString::kEmpty;
    tmpDir = tmpDir.format(L"%ls%llx%x%x.tmp", tmpDir.c_str(), result.Data1, result.Data2, result.Data3);

#elif defined(_WIN32)  // Win 32 + 64 bit
    OdChar tmpFile[MAX_PATH];
    ::GetTempFileName(tmpDir.c_str(), !prefix.isEmpty() ? OdString(prefix).c_str() : L"tmp", 0, tmpFile);
    if (odStrLen(tmpFile))
      tmpDir = OdString(tmpFile, (int)odStrLen(tmpFile));
#else
    char tmpFile[4096];  // sufficient for Win, Linux, Mac
    tmpFile[0] = 0;

    OdAnsiCharArray dstBuf;
    int lenStr = tmpDir.getLength();
    dstBuf.reserve(lenStr * 4); // UTF-8 can use up to 4 bytes per character
    OdCharMapper::unicodeToUtf8(tmpDir.c_str(), lenStr, dstBuf);
    strcat(tmpFile, (const char*)dstBuf.asArrayPtr());
    
    strcat(tmpFile, !prefix.isEmpty() ? prefix.c_str() : "tmp");
#ifdef OD_HAVE_MKSTEMPS_FUNC
    strcat(tmpFile, "XXXXXX.tmp");
    int fileDescriptor = mkstemps(tmpFile, 4);
#else
    strcat(tmpFile, "XXXXXX");
    int fileDescriptor = mkstemp(tmpFile);
#endif
    if (fileDescriptor == -1)
    {
      tmpFile[0] = 0;
    }
    else
      close(fileDescriptor);
    // Convert Utf8 back to Unicode
    OdAnsiString ansiTmpFile(tmpFile);
    OdCharArray buf;
    OdCharMapper::utf8ToUnicode(ansiTmpFile.c_str(), ansiTmpFile.getLength(), buf);
    tmpDir = OdString(buf.getPtr(), buf.size() - 1);
#endif
    return tmpDir;
  }

} // namespace

/*
same as OdMemoryStreamImpl, except that it uses a much larger PageSize, and a filled page
is swapped to an automatically created + associated temporary disk file;
the page data is then deleted, and if accessed, swapped-in from file again before accessing;
the PAGE's size should be at least 512 kB
*/

/** \details
  <group Other_Classes>

  Declares the page data.
*/
class PAGE
{
public:
  PAGE*    m_pNextPage;
  PAGE*    m_pPrevPage;
  OdUInt64 m_nPageStartAddr;
  OdUInt8* m_data;
  bool     m_modified;
  bool     m_savedToFile;
  OdUInt64 m_nFilePos;
};

/** \details

<group Other_Classes>
*/
class OdMemFileStreamDummyBase { };


/** \details
  <group Other_Classes>

  This class defines the interface for paged-memory file I/O objects.
*/
template <class TBase = OdMemFileStreamDummyBase>
class OdMemFileStreamImpl : public TBase
{
  friend class OdMemoryStream;   

  OdUInt64  m_numPages;
  PAGE*     m_pFirstPage;
  PAGE*     m_pCurrPage;
  PAGE*     m_pLastPage;

  /** \details
    <group Other_Classes>

     Helper class to swap in/out a PAGE from/to disk file.
  */
  class PageSwitcher
  {
    // the *singleton* data buffer

    OdArray<OdUInt8, OdMemoryAllocator<OdUInt8> >  m_dataBuffer;
    PAGE*          m_activePage;   
    OdString   m_sTmpFileName;
    OdStreamBufPtr m_pTmpFile;
    OdDbBaseHostAppServices* m_pHostAppServices;

    /** \details
      Releases the disk file. 
    */
    bool releaseDiskFile(bool deleteIt)
    {
      m_pTmpFile = NULL;
      if (deleteIt && !m_sTmpFileName.isEmpty())
        remove(m_sTmpFileName);
      m_sTmpFileName.empty();
      m_activePage = 0;
      return true;
    };

  public:
    /** \details
      Constructor creates the empty page switcher.
    */
    PageSwitcher()
      : m_activePage(NULL)
    {
    };

    /** \details
      Destructor deletes the buffer for page data and releases the disk file.
    */
    ~PageSwitcher()
    {
      setBufferSize(0);
      releaseDiskFile(true);
    };

    void setAppServices(OdDbBaseHostAppServices* pHostAppServices)
    {
      m_pHostAppServices = pHostAppServices;
    }

    /** \details
      Sets the buffer size for storing page data. 

      \param pageSize [in]  page size.
    */
    inline void  setBufferSize(OdUInt32 pageSize) { m_dataBuffer.resize(pageSize); };

    /** \details
      Returns the page data as an array of 8-bit codes.

      \param pPage [in]  pointer to the page data.
    */
    inline OdUInt8*  dataBuffer(PAGE* pPage) { return m_dataBuffer.asArrayPtr();};

    /** \details
      Returns the size of the page data.

      \param pPage [in]  pointer to the page data.
    */
    inline OdUInt32  dataSize(PAGE* pPage)   { return m_dataBuffer.length(); };

    /** \details
      Returns the current active page data. 
    */
    inline PAGE* activePage() const { return m_activePage; };

    /** \details
      Makes the page data as active.

      \param pPage [in]  pointer to the page data.
    */
    inline void  setActivePage(PAGE* pPage) { m_activePage = pPage; };

    /** \details
      Checks whether the page data is current and active, and returns True if the page data 
      is active or False if the page data is inactive.

      \param pPage [in]  pointer to the page data.
    */
    inline bool  isActivePage(PAGE* pPage) const { return (pPage == m_activePage); };

    /** \details
      Checks whether the page data is modified, and returns True if the page data 
      is modified or False if the page data is not changed.

      \param pPage [in]  pointer to the page data.
    */
    inline bool  isModified(PAGE* pPage) const { return pPage->m_modified; };

    /** \details
      Marks the page data as modified.

      \param pPage [in]  pointer to the page data.
      \param modified [in]  True if the page data is modified, False if the page data is not changed.
    */
    inline void  setModified(PAGE* pPage, bool modified) { pPage->m_modified = modified; };

    /** \details
      Checks whether the page data is saved, and returns True if the page data 
      is saved or False if the page data is unsaved.

      \param pPage [in]  pointer to the page data.
    */
    inline bool  isSaved(PAGE* pPage) const { return pPage->m_savedToFile; };

    /** \details
      Marks the page data as saved.

      \param pPage [in]  pointer to the page data.
      \param saved [in]  True if the page data is saved, False if the page data is unsaved.
    */
    inline void  setSaved(PAGE* pPage, bool saved) { pPage->m_savedToFile = saved; };

    /** \details
      Returns the file position of the page data.

      \param pPage [in]  pointer to the page data.
    */
    inline OdUInt64 filePosition(PAGE* pPage) const { return pPage->m_nFilePos; };

    /** \details
      Sets the file position of the page data.

      \param pPage [in]  pointer to the page data.
      \param seekPos [in]  position in the file.
    */
    inline void  setFilePosition(PAGE* pPage, OdUInt64 seekPos) { pPage->m_nFilePos = seekPos; };

    /** \details
      Initializes the page data.

      \param pPage [in]  pointer to the page data.
    */
    void initializePage(PAGE* pPage)
    {
      ODA_ASSERT(pPage);
      pPage->m_pPrevPage = 0;
      pPage->m_pNextPage = 0;
      pPage->m_data = dataBuffer(pPage);
      setModified(pPage, false);
      setSaved(pPage, false);
      setFilePosition(pPage, 0);
    };

    /** \details
      Gets the temporary disk file as a stream. 
    */
    OdStreamBufPtr& diskFile()
    {
      if (!m_pTmpFile.isNull())
        return m_pTmpFile;

      // determine temporary filename
      if (m_pHostAppServices)
      {
        m_sTmpFileName = TmpFileHelper::getTempFile(m_pHostAppServices);
        m_pTmpFile = odrxSystemServices()->createFile(m_sTmpFileName,
          (Oda::FileAccessMode)(Oda::kFileRead | Oda::kFileWrite),
          Oda::kShareDenyReadWrite,
          Oda::kCreateAlways);
        ODA_ASSERT(!m_pTmpFile.isNull());
        return m_pTmpFile;
      } 
      else
        throw OdError(eNullObjectPointer);
    };

    /** \details
      Saves the specified page data in the disk file and marks it as saved.
      Returns True if saving is successful.

      \param pPage [in]  pointer to the page data.
    */
    bool savePage(PAGE* pPage)
    {
      if (pPage && isSaved(pPage) && !isModified(pPage)) // no need to save here
        return true;

      if (!pPage || diskFile().isNull())
        return false;

      if (isSaved(pPage))
      {
        diskFile()->seek(filePosition(pPage), OdDb::kSeekFromStart);
      }
      else
      {
        diskFile()->seek(0, OdDb::kSeekFromEnd);
        setFilePosition(pPage, diskFile()->tell());
      }
      diskFile()->putBytes(dataBuffer(pPage), dataSize(pPage));

      setModified(pPage, false);
      setSaved(pPage, true);
      return true;
    };

    /** \details
      Loads the specified page data from the disk file and makes it active. 
      Returns True if loading is successful.

      \param pPage [in]  pointer to the page data.
    */
    bool loadPage(PAGE* pPage)
    {
      if (!pPage)
        return false;
      if (isActivePage(pPage) && !isModified(pPage)) // no need to (re-)load here
        return true;

      if (isSaved(pPage) && !diskFile().isNull())
      {
        diskFile()->seek(filePosition(pPage), OdDb::kSeekFromStart);
        diskFile()->getBytes(dataBuffer(pPage), dataSize(pPage));
      }

      setModified(pPage, false);
      setActivePage(pPage);
      return true;
    };

    /** \details
      Checks whether the page data can be ensured. 

      \param pPage [in]  pointer to the page data.
    */
    bool ensurePage(PAGE* pPage)
    {
      ODA_ASSERT(pPage);
      return isActivePage(pPage) ? true : switchToPage(pPage);
    };

    /** \details
      Switches to the page data. If the specified page data is not active, the 
      method saves the current active page data and loads the specified page data.
      Returns True if the page data is loaded successfully or is active.

      \param pPage [in]  pointer to the page data.
    */
    bool switchToPage(PAGE* pPage)
    {
      ODA_ASSERT(pPage);
      if (isActivePage(pPage))
        return true;
      savePage(activePage());
      return loadPage(pPage);
    };

    /** \details
      Rewinds the page data.

      \param pPage [in]  pointer to the page data.
    */
    bool rewind(PAGE* pPage)
    {
      ODA_ASSERT(pPage);
      // 'pPage' is loaded at next read/write access
      return isActivePage(pPage) ? true : savePage(activePage());
    }

    /** \details
      Truncates the page data.

      \param pPage [in]  pointer to the page data.
    */
    bool truncate(PAGE* pPage)
    {
      ODA_ASSERT(pPage);
      bool wasSaved = isSaved(pPage);
      setModified(pPage, false);
      setSaved(pPage, false);
      if (!wasSaved || diskFile().isNull())
      {
        return true;
      }

      diskFile()->seek(filePosition(pPage), OdDb::kSeekFromStart);
      diskFile()->truncate();
      return true;
    };
  }; // class PageSwitcher

  PageSwitcher m_pageSwitcher;

  /** \details
    Copies the file stream.
  */
  OdMemFileStreamImpl& operator= (const OdMemFileStreamImpl&) {return *this;}

protected:
  OdUInt64  m_nCurPos;
  OdUInt64  m_nEndPos;
  OdUInt32  m_nPageDataSize;

  /** \details
    Returns the page switcher.
  */
  inline PageSwitcher& pageSwitcher() { return m_pageSwitcher; };

  /** \details
    Returns the allocated memory size for all pages.
  */
  inline OdUInt64 allocated() const { return m_numPages * m_nPageDataSize; }
  inline OdUInt64 curPageNo() const { return (m_nCurPos / m_nPageDataSize); }
  inline OdUInt32 posInCurPage() const { return OdUInt32(m_nCurPos % m_nPageDataSize); }
  inline OdUInt32 leftInCurPage() const { return (m_pCurrPage ? m_nPageDataSize - posInCurPage() : 0); }

  /** \details
    Adds new page data.
  */
  void addPage();

  /** \details
    Finds the next page data.
  */
  void seekNextPage(bool bCreateNew = false);

  /** \details
    Finds the previous page data.
  */
  inline void seekPrevPage()
  {
    if(m_pCurrPage->m_pPrevPage)
    {
      m_nCurPos -= posInCurPage();
      m_nCurPos -= m_nPageDataSize;
      m_pCurrPage = m_pCurrPage->m_pPrevPage;
      pageSwitcher().switchToPage(m_pCurrPage);
    }
    else
      throw OdError(eEndOfFile);
  }

  inline OdUInt8* currPos() { return m_pCurrPage->m_data + posInCurPage(); }
  inline const OdUInt8* currPos() const { return m_pCurrPage->m_data + posInCurPage(); }

public:
  OdMemFileStreamImpl(OdUInt32 nPageDataSize = 0x00200000) // 2MB
    : m_numPages(0)
    , m_pFirstPage(0)
    , m_pCurrPage(0)
    , m_pLastPage(0)
    , m_nCurPos(0)
    , m_nEndPos(0)
    , m_nPageDataSize(0)
  {
    setPageDataSize(nPageDataSize);
    setAppServices(0);
  }

  void setAppServices(OdDbBaseHostAppServices* pHostAppServices)
  {
    pageSwitcher().setAppServices(pHostAppServices);
  }

  /** \details
    Returns the page data size.
  */
  OdUInt32 pageDataSize() const { return m_nPageDataSize; }

  /** \details
    Sets the page data size and buffer size for page switcher.

    \param nPageSize [in]  page data size.
  */
  void setPageDataSize(OdUInt32 nPageSize)
  {
    m_nPageDataSize = nPageSize;
    pageSwitcher().setBufferSize(nPageSize);
  }

  /** \details
    Reserves the specified number of bytes for the file memory stream object.
  */
  void reserve(OdUInt64 nSize)
  {
    while(nSize > allocated())
      addPage();
  }

  /** \details
    Returns the length in bytes of the file associated with this stream object.
  */
  OdUInt64 length() 
  {
    return m_nEndPos; 
  }

  /** \details
    Moves the current position of the file pointer for this stream object to the specified location.

    \param offset [in]  number of bytes
    \param seekType [in]  seek type
  */
  OdUInt64 seek(OdInt64 offset, OdDb::FilerSeekType whence);

  /** \details
    Returns the current position of the file pointer for this stream object.
  */
  OdUInt64 tell()
  {
    return m_nCurPos;
  }

  /** \details
    Checks whether the file pointer has reached the end of a file, and returns True if the  
    current position for this stream object is at the end of file.
  */
  bool isEof()
  {
    return (m_nCurPos>=m_nEndPos);
  }

  /** \details
    Returns the byte at the current position of the file pointer for this stream object and 
    increments the pointer.
  */
  OdUInt8 getByte();

  /** \details
    Returns the specified number of bytes, starting at the current position of the file pointer 
    for this stream object, and increments the pointer on the specified number of bytes.

    \param buffer [in]  pointer to the character buffer
    \param nLen [in]  number of bytes
  */
  void getBytes(void* buffer, OdUInt32 nLen);

  /** \details
    Writes the byte to the current position of the file pointer for this stream object, and 
    increments the pointer.

    \param val [in]  byte to be wrote
  */
  void putByte(OdUInt8 val);

  /** \details
    Writes the specified number of bytes, starting at the current position of the file pointer 
    for this stream object, and increments the pointer on the specified number of bytes.

    \param buffer [in]  pointer to the character buffer
    \param nLen [in]  number of bytes
  */
  void putBytes(const void* buffer, OdUInt32 nLen);

  //void copyDataTo(TBase* pDest, OdUInt32 nSrcStart = 0, OdUInt32 nSrcEnd = 0)
  //{
  //  TBase::copyDataTo(pDest, nSrcStart, nSrcEnd);
  //}

  /** \details
    Sets the current position of the file pointer for this stream object to zero.
  */
  void rewind()
  {
    m_nCurPos = 0;
    m_pCurrPage = m_pFirstPage;
    if(m_pCurrPage)
    {
      pageSwitcher().rewind(m_pCurrPage);
    }
  }

  /** \details
    Sets the length of the file associated with this stream object to zero.
  */
  void truncate()
  {
    if(m_pCurrPage)
    {
      pageSwitcher().truncate(m_pCurrPage);
      PAGE* pNext, *pCurr = m_pCurrPage->m_pNextPage;
      m_pCurrPage->m_pNextPage = 0;
      m_pLastPage = m_pCurrPage;
      m_nEndPos = m_nCurPos;
      while(pCurr)
      {
        pNext = pCurr->m_pNextPage;
        pCurr->m_data = 0;
        if (pageSwitcher().activePage() == pCurr)
        {
          pageSwitcher().setActivePage(0);
        }
        ::odrxFree(pCurr);
        --m_numPages;
        pCurr = pNext;
      }
    }
  }

  /** \details
    Destructor deletes stream object.
  */
  ~OdMemFileStreamImpl();
};

////////////////////////////////////////////////////////

template <class TBase>
OdMemFileStreamImpl<TBase>::~OdMemFileStreamImpl()
{
  PAGE* pNext, *pCurr = m_pFirstPage;
  while(pCurr)
  {
    pNext = pCurr->m_pNextPage;
    pCurr->m_data = 0;
    if (pageSwitcher().activePage() == pCurr)
    {
      int t=0;
    }
    ::odrxFree(pCurr);
    pCurr = pNext;
  }
  m_pFirstPage = 0;
}

template <class TBase>
void OdMemFileStreamImpl<TBase>::addPage()
{
  PAGE* pPage = (PAGE*)::odrxAlloc(sizeof(PAGE));
  if (!pPage)
    throw OdError(eOutOfMemory);

  pageSwitcher().initializePage(pPage);

  pPage->m_pPrevPage = m_pLastPage;
  if(m_pLastPage)
  {
    m_pLastPage->m_pNextPage = pPage;
    if(!m_pCurrPage)
    {
      m_pCurrPage = pPage;
      pageSwitcher().switchToPage(m_pCurrPage);
    }
    pPage->m_nPageStartAddr = pPage->m_pPrevPage->m_nPageStartAddr + m_nPageDataSize;
  }
  else
  {
    m_pFirstPage = m_pCurrPage = pPage;
    pPage->m_nPageStartAddr = 0;
    pageSwitcher().switchToPage(m_pCurrPage);
  }
  m_pLastPage = pPage;
  ++m_numPages;
}

template <class TBase>
void OdMemFileStreamImpl<TBase>::seekNextPage(bool bCreateNew)
{
  if(bCreateNew)
  {
    if(!m_pCurrPage)
    {
      addPage();
      return;
    }
    if(!m_pCurrPage->m_pNextPage)
      addPage();
  }
  if(m_pCurrPage->m_pNextPage)
  {
    m_pCurrPage = m_pCurrPage->m_pNextPage;
    m_nCurPos += leftInCurPage();
    pageSwitcher().switchToPage(m_pCurrPage);
  }
  else
    throw OdError(eEndOfFile);
}

template <class TBase>
OdUInt64 OdMemFileStreamImpl<TBase>::seek(OdInt64 offset, OdDb::FilerSeekType from)
{
  OdUInt64 nNewPos;
  switch(from)
  {
  case OdDb::kSeekFromEnd:
    nNewPos = m_nEndPos + offset;
    break;
  case OdDb::kSeekFromCurrent:
    nNewPos = m_nCurPos + offset;
    break;
  case OdDb::kSeekFromStart:
    if(!offset)
    {
      rewind();
      return 0;
    }
    nNewPos = offset;
    break;
  default:
    throw OdError(eInvalidInput);
    break;
  };

  if(nNewPos != m_nCurPos)
  {
    if (nNewPos > m_nEndPos)
      throw OdError( eEndOfFile );

    OdInt64 nFromEnd = m_nEndPos - nNewPos;

    bool bForward = false;
    bool bBack = false;
    if (m_pCurrPage)
    {
      if (nNewPos >= m_pCurrPage->m_nPageStartAddr)
      {
        bForward = true;
      }
      else
      {
        bBack = true;
      }
    }

    if (nFromEnd == 0)
    {
      m_pCurrPage = m_pLastPage;
      bForward = true;
    }
    else if (bForward)
    {
      if (nFromEnd < ((OdInt64)nNewPos - (OdInt64)m_pCurrPage->m_nPageStartAddr))
      {
        m_pCurrPage = m_pLastPage;
        bForward = false;
      }
    }
    else if (bBack)
    {
      if (nNewPos < (m_pCurrPage->m_nPageStartAddr - nNewPos))
      {
        m_pCurrPage = m_pFirstPage;
        bForward = true;
      }
    }
    else
    {
      if (nNewPos <= (OdUInt64)nFromEnd)
      {
        m_pCurrPage = m_pFirstPage;
        bForward = true;
      }
      else
      {
        m_pCurrPage = m_pLastPage;
      }
    }

    m_nCurPos = nNewPos;
    if (bForward)
    {
      nNewPos = nNewPos / m_nPageDataSize * m_nPageDataSize ;
      while(m_pCurrPage && m_pCurrPage->m_nPageStartAddr < nNewPos)
      {
        m_pCurrPage = m_pCurrPage->m_pNextPage;
      }
    }
    else
    {
      while(m_pCurrPage->m_nPageStartAddr > m_nCurPos)
      {
        m_pCurrPage = m_pCurrPage->m_pPrevPage;
      }
    }
    pageSwitcher().switchToPage(m_pCurrPage);
  }
  return m_nCurPos;
}

template <class TBase>
OdUInt8 OdMemFileStreamImpl<TBase>::getByte()
{
  OdUInt8 ret;
  if(m_nCurPos < m_nEndPos)
  {
    pageSwitcher().ensurePage(m_pCurrPage);
    OdUInt32 nPosInPage = posInCurPage();
    ret = m_pCurrPage->m_data[nPosInPage];
    ++m_nCurPos;
    if ((nPosInPage + 1) == m_nPageDataSize)
      m_pCurrPage = m_pCurrPage->m_pNextPage;
  }
  else
  {
    throw OdError(eEndOfFile);
  }
  return ret;
}

template <class TBase>
void OdMemFileStreamImpl<TBase>::getBytes(void* buffer, OdUInt32 nLen)
{
  if (nLen==0)
    return;

  OdUInt64 nNewPos = m_nCurPos + nLen;
  if(nNewPos <= m_nEndPos)
  {
    OdUInt8* pDest = (OdUInt8*)buffer;
    OdUInt32 nToCopy = odmin(leftInCurPage(), nLen);
    if(nToCopy)
    {
      pageSwitcher().ensurePage(m_pCurrPage);
      ::memcpy(pDest, currPos(), nToCopy);
      pDest += nToCopy;
      nLen -= nToCopy;
    }
    while(nLen)
    {
      seekNextPage();
      nToCopy = odmin(m_nPageDataSize, nLen);
      ::memcpy(pDest, m_pCurrPage->m_data, nToCopy);
      pDest += nToCopy;
      nLen -= nToCopy;
    }
    m_nCurPos = nNewPos;
    if(m_nCurPos && (m_nCurPos % m_nPageDataSize)==0)
      m_pCurrPage = m_pCurrPage->m_pNextPage;
  }
  else
  {
    throw OdError(eEndOfFile);
  }
}

template <class TBase>
void OdMemFileStreamImpl<TBase>::putByte(OdUInt8 val)
{
  if(!m_pCurrPage)
  {
    seekNextPage(true);
  }
  pageSwitcher().ensurePage(m_pCurrPage);
  pageSwitcher().setModified(m_pCurrPage, true);
  OdUInt64 nPosInPage = posInCurPage();
  m_pCurrPage->m_data[nPosInPage] = val;
  ++m_nCurPos;
  m_nEndPos = odmax(m_nCurPos, m_nEndPos);
  if ((nPosInPage + 1) == m_nPageDataSize)
  {
    m_pCurrPage = m_pCurrPage->m_pNextPage;
  }
}

template <class TBase>
void OdMemFileStreamImpl<TBase>::putBytes(const void* buffer, OdUInt32 nLen)
{
  if (nLen == 0)
  {
    return;
  }
  const OdUInt8* pSrc = (const OdUInt8*)buffer;
  OdUInt32 nToCopy = odmin(leftInCurPage(), nLen);
  if(nToCopy)
  {
    pageSwitcher().ensurePage(m_pCurrPage);
    pageSwitcher().setModified(m_pCurrPage, true);
    ::memcpy(currPos(), pSrc, nToCopy);
    pSrc += nToCopy;
    nLen -= nToCopy;
  }
  while(nLen)
  {
    seekNextPage(true);
    pageSwitcher().setModified(m_pCurrPage, true);
    nToCopy = odmin(m_nPageDataSize, nLen);
    ::memcpy(m_pCurrPage->m_data, pSrc, nToCopy);
    pSrc += nToCopy;
    nLen -= nToCopy;
  }
  m_nCurPos += nToCopy;
  if(m_nCurPos && (m_nCurPos % m_nPageDataSize)==0)
  {
    m_pCurrPage = m_pCurrPage->m_pNextPage;
  }
  m_nEndPos = odmax(m_nCurPos, m_nEndPos);
}

//DD:EXPORT_OFF

#endif // !defined(_MEMORYFILESTREAMIMPL_H_INCLUDED_)