Line data    Source code

       1             : /*******************************************************************************
       2             :  *  Project: libopencad
       3             :  *  Purpose: OpenSource CAD formats support library
       4             :  *  Author: Alexandr Borzykh, mush3d at gmail.com
       5             :  *  Author: Dmitry Baryshnikov, bishop.dev@gmail.com
       6             :  *  Language: C++
       7             :  *******************************************************************************
       8             :  *  The MIT License (MIT)
       9             :  *
      10             :  *  Copyright (c) 2016 Alexandr Borzykh
      11             :  *  Copyright (c) 2016 NextGIS, <info@nextgis.com>
      12             :  *
      13             :  * SPDX-License-Identifier: MIT
      14             :  *******************************************************************************/
      15             : #include "vsilfileio.h"
      16             : 
      17           9 : VSILFileIO::VSILFileIO(const char *pszFilePath)
      18           9 :     : CADFileIO(pszFilePath), m_oFileStream(nullptr)
      19             : {
      20           9 : }
      21             : 
      22          18 : VSILFileIO::~VSILFileIO()
      23             : {
      24           9 :     if (m_oFileStream)
      25           1 :         VSILFileIO::Close();
      26          18 : }
      27             : 
      28           0 : const char *VSILFileIO::ReadLine()
      29             : {
      30             :     // TODO: getline
      31           0 :     return nullptr;
      32             : }
      33             : 
      34           0 : bool VSILFileIO::Eof() const
      35             : {
      36           0 :     return VSIFEofL(m_oFileStream) || VSIFErrorL(m_oFileStream);
      37             : }
      38             : 
      39           9 : bool VSILFileIO::Open(int mode)
      40             : {
      41             :     // NOTE: now support only read mode
      42           9 :     if (mode & OpenMode::out)
      43           0 :         return false;
      44             : 
      45           9 :     std::string sOpenMode = "r";
      46           9 :     if (mode & OpenMode::binary)
      47           9 :         sOpenMode = "rb";
      48             : 
      49           9 :     m_oFileStream = VSIFOpenL(m_soFilePath.c_str(), sOpenMode.c_str());
      50             : 
      51           9 :     if (m_oFileStream != nullptr)
      52           9 :         m_bIsOpened = true;
      53             : 
      54           9 :     return m_bIsOpened;
      55             : }
      56             : 
      57           9 : bool VSILFileIO::Close()
      58             : {
      59           9 :     bool bRet = VSIFCloseL(m_oFileStream) == 0 ? true : false;
      60           9 :     m_oFileStream = nullptr;
      61           9 :     return bRet;
      62             : }
      63             : 
      64         458 : int VSILFileIO::Seek(long offset, CADFileIO::SeekOrigin origin)
      65             : {
      66         458 :     int nWhence = 0;
      67         458 :     switch (origin)
      68             :     {
      69           8 :         case SeekOrigin::CUR:
      70           8 :             nWhence = SEEK_CUR;
      71           8 :             break;
      72           0 :         case SeekOrigin::END:
      73           0 :             nWhence = SEEK_END;
      74           0 :             break;
      75         450 :         case SeekOrigin::BEG:
      76         450 :             nWhence = SEEK_SET;
      77         450 :             break;
      78             :     }
      79             : 
      80         458 :     return VSIFSeekL(m_oFileStream, offset, nWhence) == 0 ? 0 : 1;
      81             : }
      82             : 
      83           0 : long int VSILFileIO::Tell()
      84             : {
      85           0 :     return static_cast<long>(VSIFTellL(m_oFileStream));
      86             : }
      87             : 
      88         716 : size_t VSILFileIO::Read(void *ptr, size_t size)
      89             : {
      90         716 :     return VSIFReadL(static_cast<char *>(ptr), 1, size, m_oFileStream);
      91             : }
      92             : 
      93           0 : size_t VSILFileIO::Write(void * /*ptr*/, size_t /*size*/)
      94             : {
      95             :     // unsupported
      96           0 :     return 0;
      97             : }
      98             : 
      99          26 : void VSILFileIO::Rewind()
     100             : {
     101          26 :     VSIRewindL(m_oFileStream);
     102          26 : }