Line data    Source code

       1             : /******************************************************************************
       2             :  *
       3             :  * Purpose:  Implementation of the CLinkSegment class.
       4             :  *
       5             :  ******************************************************************************
       6             :  * Copyright (c) 2009
       7             :  * PCI Geomatics, 90 Allstate Parkway, Markham, Ontario, Canada.
       8             :  *
       9             :  * SPDX-License-Identifier: MIT
      10             :  ****************************************************************************/
      11             : 
      12             : #include "core/clinksegment.h"
      13             : #include "segment/cpcidsksegment.h"
      14             : #include "core/pcidsk_utils.h"
      15             : #include "pcidsk_exception.h"
      16             : 
      17             : #include <vector>
      18             : #include <string>
      19             : #include <cassert>
      20             : #include <cstring>
      21             : 
      22             : using namespace PCIDSK;
      23             : 
      24           0 : CLinkSegment::CLinkSegment(PCIDSKFile *fileIn,
      25             :                            int segmentIn,
      26           0 :                            const char *segment_pointer) :
      27             :     CPCIDSKSegment(fileIn, segmentIn, segment_pointer),
      28           0 :     loaded_(false), modified_(false)
      29             : {
      30           0 :     Load();
      31           0 : }
      32             : 
      33             : 
      34           0 : CLinkSegment::~CLinkSegment()
      35             : {
      36           0 : }
      37             : 
      38             : // Load the contents of the segment
      39           0 : void CLinkSegment::Load()
      40             : {
      41             :     // Check if we've already loaded the segment into memory
      42           0 :     if (loaded_) {
      43           0 :         return;
      44             :     }
      45             : 
      46           0 :     seg_data.SetSize(data_size < 1024 ? -1 : (int) (data_size - 1024));
      47             : 
      48           0 :     ReadFromFile(seg_data.buffer, 0, data_size - 1024);
      49             : 
      50           0 :     if (seg_data.buffer_size < 8)
      51             :     {
      52           0 :         path.clear();
      53           0 :         return;
      54             :     }
      55             : 
      56           0 :     if (!STARTS_WITH(seg_data.buffer, "SysLinkF"))
      57             :     {
      58           0 :         seg_data.Put("SysLinkF",0,8);
      59           0 :         return;
      60             :     }
      61             : 
      62           0 :     const char * pszEnd = seg_data.buffer + seg_data.buffer_size;
      63           0 :     const char * pszPathStart = seg_data.buffer + 8;
      64           0 :     const char * pszPathEnd = pszPathStart;
      65             : 
      66             :     // Find the end of the path.
      67           0 :     while (pszPathEnd < pszEnd && *pszPathEnd)
      68           0 :         ++pszPathEnd;
      69             : 
      70             :     // Remove trailing spaces.
      71           0 :     while (pszPathEnd > pszPathStart && *pszPathEnd == ' ')
      72           0 :         --pszPathEnd;
      73             : 
      74           0 :     path = std::string(pszPathStart, pszPathEnd);
      75             : 
      76             :     // We've now loaded the structure up with data. Mark it as being loaded
      77             :     // properly.
      78           0 :     loaded_ = true;
      79             : 
      80             : }
      81             : 
      82           0 : void CLinkSegment::Write(void)
      83             : {
      84             :     //We are not writing if nothing was loaded.
      85           0 :     if (!modified_) {
      86           0 :         return;
      87             :     }
      88             : 
      89           0 :     seg_data.Put("SysLinkF",0,8);
      90           0 :     seg_data.Put(path.c_str(), 8, static_cast<int>(path.size()), true);
      91             : 
      92           0 :     WriteToFile(seg_data.buffer, 0, data_size-1024);
      93           0 :     modified_ = false;
      94             : }
      95             : 
      96           0 : std::string CLinkSegment::GetPath(void) const
      97             : {
      98           0 :     return path;
      99             : }
     100             : 
     101           0 : void CLinkSegment::SetPath(const std::string& oPath)
     102             : {
     103           0 :     if(oPath.size() < 504)
     104             :     {
     105           0 :         path = oPath;
     106           0 :         modified_ = true;
     107             :     }
     108             :     else
     109             :     {
     110           0 :         return ThrowPCIDSKException("The size of the path cannot be"
     111           0 :                               " bigger than 504 characters.");
     112             :     }
     113             : }
     114             : 
     115           0 : void CLinkSegment::Synchronize()
     116             : {
     117           0 :     if(modified_)
     118             :     {
     119           0 :         this->Write();
     120             :     }
     121           0 : }
     122             :