Line data Source code
1 : /******************************************************************************
2 : *
3 : * Project: VSI Virtual File System
4 : * Purpose: Declarations for classes related to the virtual filesystem.
5 : * These would only be normally required by applications implementing
6 : * their own virtual file system classes which should be rare.
7 : * The class interface may be fragile through versions.
8 : * Author: Frank Warmerdam, warmerdam@pobox.com
9 : *
10 : ******************************************************************************
11 : * Copyright (c) 2005, Frank Warmerdam <warmerdam@pobox.com>
12 : * Copyright (c) 2010-2014, Even Rouault <even dot rouault at spatialys.com>
13 : *
14 : * SPDX-License-Identifier: MIT
15 : ****************************************************************************/
16 :
17 : #ifndef CPL_VSI_VIRTUAL_H_INCLUDED
18 : #define CPL_VSI_VIRTUAL_H_INCLUDED
19 :
20 : #include "cpl_progress.h"
21 : #include "cpl_vsi.h"
22 : #include "cpl_vsi_error.h"
23 : #include "cpl_string.h"
24 :
25 : #include <cstdint>
26 : #include <map>
27 : #include <memory>
28 : #include <mutex>
29 : #include <vector>
30 : #include <string>
31 :
32 : // To avoid aliasing to GetDiskFreeSpace to GetDiskFreeSpaceA on Windows
33 : #ifdef GetDiskFreeSpace
34 : #undef GetDiskFreeSpace
35 : #endif
36 :
37 : // To avoid aliasing to CopyFile to CopyFileA on Windows
38 : #ifdef CopyFile
39 : #undef CopyFile
40 : #endif
41 :
42 : /************************************************************************/
43 : /* VSIVirtualHandle */
44 : /************************************************************************/
45 :
46 : /** Virtual file handle */
47 : struct CPL_DLL VSIVirtualHandle
48 : {
49 : public:
50 : virtual int Seek(vsi_l_offset nOffset, int nWhence) = 0;
51 : virtual vsi_l_offset Tell() = 0;
52 : virtual size_t Read(void *pBuffer, size_t nSize, size_t nCount) = 0;
53 : virtual int ReadMultiRange(int nRanges, void **ppData,
54 : const vsi_l_offset *panOffsets,
55 : const size_t *panSizes);
56 :
57 : /** This method is called when code plans to access soon one or several
58 : * ranges in a file. Some file systems may be able to use this hint to
59 : * for example asynchronously start such requests.
60 : *
61 : * Offsets may be given in a non-increasing order, and may potentially
62 : * overlap.
63 : *
64 : * @param nRanges Size of the panOffsets and panSizes arrays.
65 : * @param panOffsets Array containing the start offset of each range.
66 : * @param panSizes Array containing the size (in bytes) of each range.
67 : * @since GDAL 3.7
68 : */
69 91 : virtual void AdviseRead(CPL_UNUSED int nRanges,
70 : CPL_UNUSED const vsi_l_offset *panOffsets,
71 : CPL_UNUSED const size_t *panSizes)
72 : {
73 91 : }
74 :
75 : /** Return the total maximum number of bytes that AdviseRead() can handle
76 : * at once.
77 : *
78 : * Some AdviseRead() implementations may give up if the sum of the values
79 : * in the panSizes[] array provided to AdviseRead() exceeds a limit.
80 : *
81 : * Callers might use that threshold to optimize the efficiency of
82 : * AdviseRead().
83 : *
84 : * A returned value of 0 indicates a unknown limit.
85 : * @since GDAL 3.9
86 : */
87 219 : virtual size_t GetAdviseReadTotalBytesLimit() const
88 : {
89 219 : return 0;
90 : }
91 :
92 : virtual size_t Write(const void *pBuffer, size_t nSize, size_t nCount) = 0;
93 :
94 : int Printf(CPL_FORMAT_STRING(const char *pszFormat), ...)
95 : CPL_PRINT_FUNC_FORMAT(2, 3);
96 :
97 : virtual void ClearErr() = 0;
98 :
99 : virtual int Eof() = 0;
100 :
101 : virtual int Error() = 0;
102 :
103 48419 : virtual int Flush()
104 : {
105 48419 : return 0;
106 : }
107 :
108 : virtual int Close() = 0;
109 : // Base implementation that only supports file extension.
110 : virtual int Truncate(vsi_l_offset nNewSize);
111 :
112 9 : virtual void *GetNativeFileDescriptor()
113 : {
114 9 : return nullptr;
115 : }
116 :
117 151 : virtual VSIRangeStatus GetRangeStatus(CPL_UNUSED vsi_l_offset nOffset,
118 : CPL_UNUSED vsi_l_offset nLength)
119 : {
120 151 : return VSI_RANGE_STATUS_UNKNOWN;
121 : }
122 :
123 : virtual bool HasPRead() const;
124 : virtual size_t PRead(void *pBuffer, size_t nSize,
125 : vsi_l_offset nOffset) const;
126 :
127 : /** Ask current operations to be interrupted.
128 : * Implementations must be thread-safe, as this will typically be called
129 : * from another thread than the active one for this file.
130 : */
131 5 : virtual void Interrupt()
132 : {
133 5 : }
134 :
135 : /** For a file created with CreateOnlyVisibleAtCloseTime(), ask for the
136 : * file to not be created at all (if possible)
137 : */
138 82 : virtual void CancelCreation()
139 : {
140 82 : }
141 :
142 : // NOTE: when adding new methods, besides the "actual" implementations,
143 : // also consider the VSICachedFile and VSIVirtualHandleOnlyVisibleAtCloseTime one.
144 :
145 336408 : virtual ~VSIVirtualHandle()
146 336408 : {
147 336408 : }
148 : };
149 :
150 : /************************************************************************/
151 : /* VSIVirtualHandleCloser */
152 : /************************************************************************/
153 :
154 : /** Helper close to use with a std:unique_ptr<VSIVirtualHandle>,
155 : * such as VSIVirtualHandleUniquePtr. */
156 : struct VSIVirtualHandleCloser
157 :
158 : {
159 : /** Operator () that closes and deletes the file handle. */
160 16354 : void operator()(VSIVirtualHandle *poHandle)
161 : {
162 16354 : if (poHandle)
163 : {
164 16336 : poHandle->Close();
165 16336 : delete poHandle;
166 : }
167 16354 : }
168 : };
169 :
170 : /** Unique pointer of VSIVirtualHandle that calls the Close() method */
171 : typedef std::unique_ptr<VSIVirtualHandle, VSIVirtualHandleCloser>
172 : VSIVirtualHandleUniquePtr;
173 :
174 : /************************************************************************/
175 : /* VSIProxyFileHandle */
176 : /************************************************************************/
177 :
178 : #ifndef DOXYGEN_SKIP
179 : class VSIProxyFileHandle /* non final */ : public VSIVirtualHandle
180 : {
181 : protected:
182 : VSIVirtualHandleUniquePtr m_nativeHandle{};
183 :
184 : public:
185 200 : explicit VSIProxyFileHandle(VSIVirtualHandleUniquePtr &&nativeHandle)
186 200 : : m_nativeHandle(std::move(nativeHandle))
187 : {
188 200 : }
189 :
190 894 : int Seek(vsi_l_offset nOffset, int nWhence) override
191 : {
192 894 : return m_nativeHandle->Seek(nOffset, nWhence);
193 : }
194 :
195 813 : vsi_l_offset Tell() override
196 : {
197 813 : return m_nativeHandle->Tell();
198 : }
199 :
200 1091 : size_t Read(void *pBuffer, size_t nSize, size_t nCount) override
201 : {
202 1091 : return m_nativeHandle->Read(pBuffer, nSize, nCount);
203 : }
204 :
205 0 : int ReadMultiRange(int nRanges, void **ppData,
206 : const vsi_l_offset *panOffsets,
207 : const size_t *panSizes) override
208 : {
209 0 : return m_nativeHandle->ReadMultiRange(nRanges, ppData, panOffsets,
210 0 : panSizes);
211 : }
212 :
213 0 : void AdviseRead(int nRanges, const vsi_l_offset *panOffsets,
214 : const size_t *panSizes) override
215 : {
216 0 : return m_nativeHandle->AdviseRead(nRanges, panOffsets, panSizes);
217 : }
218 :
219 0 : size_t GetAdviseReadTotalBytesLimit() const override
220 : {
221 0 : return m_nativeHandle->GetAdviseReadTotalBytesLimit();
222 : }
223 :
224 4806 : size_t Write(const void *pBuffer, size_t nSize, size_t nCount) override
225 : {
226 4806 : return m_nativeHandle->Write(pBuffer, nSize, nCount);
227 : }
228 :
229 0 : void ClearErr() override
230 : {
231 0 : return m_nativeHandle->ClearErr();
232 : }
233 :
234 0 : int Eof() override
235 : {
236 0 : return m_nativeHandle->Eof();
237 : }
238 :
239 0 : int Error() override
240 : {
241 0 : return m_nativeHandle->Error();
242 : }
243 :
244 2 : int Flush() override
245 : {
246 2 : return m_nativeHandle->Flush();
247 : }
248 :
249 200 : int Close() override
250 : {
251 200 : return m_nativeHandle->Close();
252 : }
253 :
254 0 : int Truncate(vsi_l_offset nNewSize) override
255 : {
256 0 : return m_nativeHandle->Truncate(nNewSize);
257 : }
258 :
259 0 : void *GetNativeFileDescriptor() override
260 : {
261 0 : return m_nativeHandle->GetNativeFileDescriptor();
262 : }
263 :
264 0 : VSIRangeStatus GetRangeStatus(vsi_l_offset nOffset,
265 : vsi_l_offset nLength) override
266 : {
267 0 : return m_nativeHandle->GetRangeStatus(nOffset, nLength);
268 : }
269 :
270 0 : bool HasPRead() const override
271 : {
272 0 : return m_nativeHandle->HasPRead();
273 : }
274 :
275 0 : size_t PRead(void *pBuffer, size_t nSize,
276 : vsi_l_offset nOffset) const override
277 : {
278 0 : return m_nativeHandle->PRead(pBuffer, nSize, nOffset);
279 : }
280 :
281 0 : void Interrupt() override
282 : {
283 0 : m_nativeHandle->Interrupt();
284 0 : }
285 :
286 : void CancelCreation() override;
287 : };
288 : #endif
289 :
290 : /************************************************************************/
291 : /* VSIFilesystemHandler */
292 : /************************************************************************/
293 :
294 : #ifndef DOXYGEN_SKIP
295 : class CPL_DLL VSIFilesystemHandler
296 : {
297 :
298 : public:
299 32511 : virtual ~VSIFilesystemHandler() = default;
300 :
301 : static VSIVirtualHandleUniquePtr
302 : OpenStatic(const char *pszFilename, const char *pszAccess,
303 : bool bSetError = false, CSLConstList papszOptions = nullptr);
304 :
305 : virtual VSIVirtualHandleUniquePtr
306 : Open(const char *pszFilename, const char *pszAccess, bool bSetError = false,
307 : CSLConstList papszOptions = nullptr) = 0;
308 :
309 : virtual VSIVirtualHandleUniquePtr
310 : CreateOnlyVisibleAtCloseTime(const char *pszFilename,
311 : bool bEmulationAllowed,
312 : CSLConstList papszOptions);
313 :
314 : virtual int Stat(const char *pszFilename, VSIStatBufL *pStatBuf,
315 : int nFlags) = 0;
316 :
317 2 : virtual int Unlink(const char *pszFilename)
318 : {
319 : (void)pszFilename;
320 2 : errno = ENOENT;
321 2 : return -1;
322 : }
323 :
324 : virtual int *UnlinkBatch(CSLConstList papszFiles);
325 :
326 0 : virtual int Mkdir(const char *pszDirname, long nMode)
327 : {
328 : (void)pszDirname;
329 : (void)nMode;
330 0 : errno = ENOENT;
331 0 : return -1;
332 : }
333 :
334 0 : virtual int Rmdir(const char *pszDirname)
335 : {
336 : (void)pszDirname;
337 0 : errno = ENOENT;
338 0 : return -1;
339 : }
340 :
341 : virtual int RmdirRecursive(const char *pszDirname);
342 :
343 5 : char **ReadDir(const char *pszDirname)
344 : {
345 5 : return ReadDirEx(pszDirname, 0);
346 : }
347 :
348 3 : virtual char **ReadDirEx(const char * /*pszDirname*/, int /* nMaxFiles */)
349 : {
350 3 : return nullptr;
351 : }
352 :
353 77333 : virtual char **SiblingFiles(const char * /*pszFilename*/)
354 : {
355 77333 : return nullptr;
356 : }
357 :
358 0 : virtual int Rename(const char *oldpath, const char *newpath,
359 : GDALProgressFunc pProgressFunc, void *pProgressData)
360 : {
361 : (void)oldpath;
362 : (void)newpath;
363 : (void)pProgressFunc;
364 : (void)pProgressData;
365 0 : errno = ENOENT;
366 0 : return -1;
367 : }
368 :
369 27913 : virtual int IsCaseSensitive(const char *pszFilename)
370 : {
371 : (void)pszFilename;
372 27913 : return TRUE;
373 : }
374 :
375 0 : virtual GIntBig GetDiskFreeSpace(const char * /* pszDirname */)
376 : {
377 0 : return -1;
378 : }
379 :
380 0 : virtual int SupportsSparseFiles(const char * /* pszPath */)
381 : {
382 0 : return FALSE;
383 : }
384 :
385 15382 : virtual int HasOptimizedReadMultiRange(const char * /* pszPath */)
386 : {
387 15382 : return FALSE;
388 : }
389 :
390 1 : virtual const char *GetActualURL(const char * /*pszFilename*/)
391 : {
392 1 : return nullptr;
393 : }
394 :
395 14 : virtual const char *GetOptions()
396 : {
397 14 : return nullptr;
398 : }
399 :
400 1 : virtual char *GetSignedURL(const char * /*pszFilename*/,
401 : CSLConstList /* papszOptions */)
402 : {
403 1 : return nullptr;
404 : }
405 :
406 : virtual bool Sync(const char *pszSource, const char *pszTarget,
407 : const char *const *papszOptions,
408 : GDALProgressFunc pProgressFunc, void *pProgressData,
409 : char ***ppapszOutputs);
410 :
411 : virtual int CopyFile(const char *pszSource, const char *pszTarget,
412 : VSILFILE *fpSource, vsi_l_offset nSourceSize,
413 : const char *const *papszOptions,
414 : GDALProgressFunc pProgressFunc, void *pProgressData);
415 :
416 : virtual int
417 : CopyFileRestartable(const char *pszSource, const char *pszTarget,
418 : const char *pszInputPayload, char **ppszOutputPayload,
419 : CSLConstList papszOptions,
420 : GDALProgressFunc pProgressFunc, void *pProgressData);
421 :
422 : virtual VSIDIR *OpenDir(const char *pszPath, int nRecurseDepth,
423 : const char *const *papszOptions);
424 :
425 : virtual char **GetFileMetadata(const char *pszFilename,
426 : const char *pszDomain,
427 : CSLConstList papszOptions);
428 :
429 : virtual bool SetFileMetadata(const char *pszFilename,
430 : CSLConstList papszMetadata,
431 : const char *pszDomain,
432 : CSLConstList papszOptions);
433 :
434 : virtual bool
435 : MultipartUploadGetCapabilities(int *pbNonSequentialUploadSupported,
436 : int *pbParallelUploadSupported,
437 : int *pbAbortSupported, size_t *pnMinPartSize,
438 : size_t *pnMaxPartSize, int *pnMaxPartCount);
439 :
440 : virtual char *MultipartUploadStart(const char *pszFilename,
441 : CSLConstList papszOptions);
442 :
443 : virtual char *MultipartUploadAddPart(const char *pszFilename,
444 : const char *pszUploadId,
445 : int nPartNumber,
446 : vsi_l_offset nFileOffset,
447 : const void *pData, size_t nDataLength,
448 : CSLConstList papszOptions);
449 :
450 : virtual bool
451 : MultipartUploadEnd(const char *pszFilename, const char *pszUploadId,
452 : size_t nPartIdsCount, const char *const *apszPartIds,
453 : vsi_l_offset nTotalSize, CSLConstList papszOptions);
454 :
455 : virtual bool MultipartUploadAbort(const char *pszFilename,
456 : const char *pszUploadId,
457 : CSLConstList papszOptions);
458 :
459 0 : virtual bool AbortPendingUploads(const char * /*pszFilename*/)
460 : {
461 0 : return true;
462 : }
463 :
464 : virtual std::string
465 26707 : GetStreamingFilename(const std::string &osFilename) const
466 : {
467 26707 : return osFilename;
468 : }
469 :
470 : virtual std::string
471 1521 : GetNonStreamingFilename(const std::string &osFilename) const
472 : {
473 1521 : return osFilename;
474 : }
475 :
476 : /** Return the canonical filename.
477 : *
478 : * May be implemented by case-insensitive filesystems
479 : * (currently Win32 and MacOSX)
480 : * to return the filename with its actual case (i.e. the one that would
481 : * be used when listing the content of the directory).
482 : */
483 : virtual std::string
484 252 : GetCanonicalFilename(const std::string &osFilename) const
485 : {
486 252 : return osFilename;
487 : }
488 :
489 107 : virtual bool IsLocal(const char * /* pszPath */) const
490 : {
491 107 : return true;
492 : }
493 :
494 5 : virtual bool IsArchive(const char * /* pszPath */) const
495 : {
496 5 : return false;
497 : }
498 :
499 48 : virtual bool SupportsSequentialWrite(const char * /* pszPath */,
500 : bool /* bAllowLocalTempFile */)
501 : {
502 48 : return true;
503 : }
504 :
505 304 : virtual bool SupportsRandomWrite(const char * /* pszPath */,
506 : bool /* bAllowLocalTempFile */)
507 : {
508 304 : return true;
509 : }
510 :
511 43 : virtual bool SupportsRead(const char * /* pszPath */)
512 : {
513 43 : return true;
514 : }
515 :
516 2 : virtual VSIFilesystemHandler *Duplicate(const char * /* pszPrefix */)
517 : {
518 2 : CPLError(CE_Failure, CPLE_NotSupported,
519 : "Duplicate() not supported on this file "
520 : "system");
521 2 : return nullptr;
522 : }
523 :
524 : /** Return the directory separator.
525 : *
526 : * Default is forward slash. The only exception currently is the Windows
527 : * file system which returns anti-slash, unless the specified path is of the
528 : * form "{drive_letter}:/{rest_of_the_path}".
529 : */
530 930054 : virtual const char *GetDirectorySeparator(CPL_UNUSED const char *pszPath)
531 : {
532 930054 : return "/";
533 : }
534 : };
535 : #endif /* #ifndef DOXYGEN_SKIP */
536 :
537 : /************************************************************************/
538 : /* VSIFileManager */
539 : /************************************************************************/
540 :
541 : #ifndef DOXYGEN_SKIP
542 : class CPL_DLL VSIFileManager
543 : {
544 : private:
545 : VSIFilesystemHandler *poDefaultHandler = nullptr;
546 : std::map<std::string, VSIFilesystemHandler *> oHandlers{};
547 :
548 : VSIFileManager();
549 :
550 : static VSIFileManager *Get();
551 :
552 : CPL_DISALLOW_COPY_ASSIGN(VSIFileManager)
553 :
554 : public:
555 : ~VSIFileManager();
556 :
557 : static VSIFilesystemHandler *GetHandler(const char *);
558 : static void InstallHandler(const std::string &osPrefix,
559 : VSIFilesystemHandler *);
560 : static void RemoveHandler(const std::string &osPrefix);
561 :
562 : static char **GetPrefixes();
563 : };
564 : #endif /* #ifndef DOXYGEN_SKIP */
565 :
566 : /************************************************************************/
567 : /* ==================================================================== */
568 : /* VSIArchiveFilesystemHandler */
569 : /* ==================================================================== */
570 : /************************************************************************/
571 :
572 : #ifndef DOXYGEN_SKIP
573 :
574 1551 : class VSIArchiveEntryFileOffset
575 : {
576 : public:
577 : virtual ~VSIArchiveEntryFileOffset();
578 : };
579 :
580 : class VSIArchiveEntry
581 : {
582 : public:
583 : std::string fileName{};
584 : vsi_l_offset uncompressed_size = 0;
585 : std::unique_ptr<VSIArchiveEntryFileOffset> file_pos{};
586 : bool bIsDir = false;
587 : GIntBig nModifiedTime = 0;
588 : };
589 :
590 75 : class VSIArchiveContent
591 : {
592 : public:
593 : time_t mTime = 0;
594 : vsi_l_offset nFileSize = 0;
595 : std::vector<VSIArchiveEntry> entries{};
596 :
597 : // Store list of child indices for each directory
598 : using DirectoryChildren = std::vector<int>;
599 :
600 : std::map<std::string, DirectoryChildren> dirIndex{};
601 :
602 225 : VSIArchiveContent() = default;
603 :
604 : ~VSIArchiveContent();
605 :
606 : private:
607 : CPL_DISALLOW_COPY_ASSIGN(VSIArchiveContent)
608 : };
609 :
610 5143 : class VSIArchiveReader
611 : {
612 : public:
613 : virtual ~VSIArchiveReader();
614 :
615 : virtual int GotoFirstFile() = 0;
616 : virtual int GotoNextFile() = 0;
617 : virtual VSIArchiveEntryFileOffset *GetFileOffset() = 0;
618 : virtual GUIntBig GetFileSize() = 0;
619 : virtual CPLString GetFileName() = 0;
620 : virtual GIntBig GetModifiedTime() = 0;
621 : virtual int GotoFileOffset(VSIArchiveEntryFileOffset *pOffset) = 0;
622 : };
623 :
624 5750 : class VSIArchiveFilesystemHandler /* non final */ : public VSIFilesystemHandler
625 : {
626 : CPL_DISALLOW_COPY_ASSIGN(VSIArchiveFilesystemHandler)
627 :
628 : bool FindFileInArchive(const char *archiveFilename,
629 : const char *fileInArchiveName,
630 : const VSIArchiveEntry **archiveEntry);
631 :
632 : protected:
633 : mutable std::recursive_mutex oMutex{};
634 :
635 : /* We use a cache that contains the list of files contained in a VSIArchive
636 : * file as */
637 : /* unarchive.c is quite inefficient in listing them. This speeds up access
638 : * to VSIArchive files */
639 : /* containing ~1000 files like a CADRG product */
640 : std::map<CPLString, std::unique_ptr<VSIArchiveContent>> oFileList{};
641 :
642 : virtual const char *GetPrefix() const = 0;
643 : virtual std::vector<CPLString> GetExtensions() const = 0;
644 : virtual std::unique_ptr<VSIArchiveReader>
645 : CreateReader(const char *pszArchiveFileName) = 0;
646 :
647 : public:
648 : VSIArchiveFilesystemHandler();
649 : ~VSIArchiveFilesystemHandler() override;
650 :
651 : int Stat(const char *pszFilename, VSIStatBufL *pStatBuf,
652 : int nFlags) override;
653 : char **ReadDirEx(const char *pszDirname, int nMaxFiles) override;
654 :
655 : virtual const VSIArchiveContent *
656 : GetContentOfArchive(const char *archiveFilename,
657 : VSIArchiveReader *poReader = nullptr);
658 : virtual char *SplitFilename(const char *pszFilename,
659 : CPLString &osFileInArchive,
660 : bool bCheckMainFileExists,
661 : bool bSetError) const;
662 : virtual std::unique_ptr<VSIArchiveReader>
663 : OpenArchiveFile(const char *archiveFilename, const char *fileInArchiveName);
664 :
665 : bool IsLocal(const char *pszPath) const override;
666 :
667 : bool IsArchive(const char *pszPath) const override;
668 :
669 0 : bool SupportsSequentialWrite(const char * /* pszPath */,
670 : bool /* bAllowLocalTempFile */) override
671 : {
672 0 : return false;
673 : }
674 :
675 0 : bool SupportsRandomWrite(const char * /* pszPath */,
676 : bool /* bAllowLocalTempFile */) override
677 : {
678 0 : return false;
679 : }
680 : };
681 :
682 : /************************************************************************/
683 : /* VSIDIR */
684 : /************************************************************************/
685 :
686 : struct CPL_DLL VSIDIR
687 : {
688 3534 : VSIDIR() = default;
689 : virtual ~VSIDIR();
690 :
691 : virtual const VSIDIREntry *NextDirEntry() = 0;
692 :
693 : private:
694 : VSIDIR(const VSIDIR &) = delete;
695 : VSIDIR &operator=(const VSIDIR &) = delete;
696 : };
697 :
698 : #endif /* #ifndef DOXYGEN_SKIP */
699 :
700 : VSIVirtualHandle CPL_DLL *
701 : VSICreateBufferedReaderHandle(VSIVirtualHandle *poBaseHandle);
702 : VSIVirtualHandle *
703 : VSICreateBufferedReaderHandle(VSIVirtualHandle *poBaseHandle,
704 : const GByte *pabyBeginningContent,
705 : vsi_l_offset nCheatFileSize);
706 : constexpr int VSI_CACHED_DEFAULT_CHUNK_SIZE = 32768;
707 : VSIVirtualHandle CPL_DLL *
708 : VSICreateCachedFile(VSIVirtualHandle *poBaseHandle,
709 : size_t nChunkSize = VSI_CACHED_DEFAULT_CHUNK_SIZE,
710 : size_t nCacheSize = 0);
711 :
712 : const int CPL_DEFLATE_TYPE_GZIP = 0;
713 : const int CPL_DEFLATE_TYPE_ZLIB = 1;
714 : const int CPL_DEFLATE_TYPE_RAW_DEFLATE = 2;
715 : VSIVirtualHandle CPL_DLL *VSICreateGZipWritable(VSIVirtualHandle *poBaseHandle,
716 : int nDeflateType,
717 : int bAutoCloseBaseHandle);
718 :
719 : VSIVirtualHandle *VSICreateGZipWritable(VSIVirtualHandle *poBaseHandle,
720 : int nDeflateType,
721 : bool bAutoCloseBaseHandle, int nThreads,
722 : size_t nChunkSize,
723 : size_t nSOZIPIndexEltSize,
724 : std::vector<uint8_t> *panSOZIPIndex);
725 :
726 : VSIVirtualHandle *
727 : VSICreateUploadOnCloseFile(VSIVirtualHandleUniquePtr &&poWritableHandle,
728 : VSIVirtualHandleUniquePtr &&poTmpFile,
729 : const std::string &osTmpFilename);
730 :
731 : #endif /* ndef CPL_VSI_VIRTUAL_H_INCLUDED */
|
