577 lines
26 KiB
C++
577 lines
26 KiB
C++
// CkFileAccessW.h: interface for the CkFileAccessW class.
|
|
//
|
|
//////////////////////////////////////////////////////////////////////
|
|
|
|
// This header is generated for Chilkat 11.3.0
|
|
|
|
#ifndef _CkFileAccessW_H
|
|
#define _CkFileAccessW_H
|
|
|
|
#include "chilkatDefs.h"
|
|
#include "CkString.h"
|
|
#include "CkWideCharBase.h"
|
|
|
|
class CkBinDataW;
|
|
class CkStringBuilderW;
|
|
class CkByteData;
|
|
class CkDateTimeW;
|
|
|
|
|
|
|
|
#if !defined(__sun__) && !defined(__sun)
|
|
#pragma pack (push, 8)
|
|
#endif
|
|
|
|
|
|
// CLASS: CkFileAccessW
|
|
class CK_VISIBLE_PUBLIC CkFileAccessW : public CkWideCharBase
|
|
{
|
|
|
|
|
|
private:
|
|
|
|
// Don't allow assignment or copying these objects.
|
|
CkFileAccessW(const CkFileAccessW &);
|
|
CkFileAccessW &operator=(const CkFileAccessW &);
|
|
|
|
public:
|
|
CkFileAccessW(void);
|
|
virtual ~CkFileAccessW(void);
|
|
|
|
|
|
|
|
static CkFileAccessW *createNew(void);
|
|
|
|
|
|
|
|
void CK_VISIBLE_PRIVATE inject(void *impl);
|
|
|
|
// May be called when finished with the object to free/dispose of any
|
|
// internal resources held by the object.
|
|
void dispose(void);
|
|
|
|
|
|
|
|
// BEGIN PUBLIC INTERFACE
|
|
|
|
// ----------------------
|
|
// Properties
|
|
// ----------------------
|
|
// The current working directory of the calling process.
|
|
void get_CurrentDir(CkString &str);
|
|
// The current working directory of the calling process.
|
|
const wchar_t *currentDir(void);
|
|
|
|
// Returns true if the current open file is at the end-of-file.
|
|
bool get_EndOfFile(void);
|
|
|
|
// This property is set by the following methods: FileOpen, OpenForRead,
|
|
// OpenForWrite, OpenForReadWrite, and OpenForAppend. It provides an error code
|
|
// indicating the failure reason. Possible values are:
|
|
//
|
|
// 1. 0>
|
|
// 2. Success (No error)
|
|
// 3. Access denied.
|
|
// 4. File not found.
|
|
// 5. General (non-specific) open error.
|
|
// 6. File aleady exists.
|
|
// 7. Path refers to a directory and the access requested involves writing.
|
|
// 8. Too many symbolic links were encountered in resolving path.
|
|
// 9. The process already has the maximum number of files open.
|
|
// 10. Pathname is too long.
|
|
// 11. The system limit on the total number of open files has been reached.
|
|
// 12. Pathname refers to a device special file and no corresponding device
|
|
// exists.
|
|
// 13. Insufficient kernel memory was available.
|
|
// 14. Pathname was to be created but the device containing pathname has no
|
|
// room for the new file.
|
|
// 15. A component used as a directory in pathname is not, in fact, a
|
|
// directory.
|
|
// 16. Pathname refers to a regular file, too large to be opened (this would be
|
|
// a limitation of the underlying operating system, not a limitation imposed by
|
|
// Chilkat).
|
|
// 17. Pathname refers to a file on a read-only filesystem and write access was
|
|
// requested.
|
|
//
|
|
int get_FileOpenError(void);
|
|
|
|
// The error message text associated with the FileOpenError code.
|
|
void get_FileOpenErrorMsg(CkString &str);
|
|
// The error message text associated with the FileOpenError code.
|
|
const wchar_t *fileOpenErrorMsg(void);
|
|
|
|
// Note: This property only applies for applications running on Windows.
|
|
//
|
|
// If true, then the following methods open files for exclusive-access:
|
|
// OpenForAppend, OpenForRead, OpenForReadWrite, OpenForWrite. When a file is
|
|
// opened for exclusive access, it is locked so that no other process may open the
|
|
// file. When the file is closed, the lock is released.
|
|
//
|
|
// The default value of this property is false.
|
|
//
|
|
bool get_LockFileOnOpen(void);
|
|
// Note: This property only applies for applications running on Windows.
|
|
//
|
|
// If true, then the following methods open files for exclusive-access:
|
|
// OpenForAppend, OpenForRead, OpenForReadWrite, OpenForWrite. When a file is
|
|
// opened for exclusive access, it is locked so that no other process may open the
|
|
// file. When the file is closed, the lock is released.
|
|
//
|
|
// The default value of this property is false.
|
|
//
|
|
void put_LockFileOnOpen(bool newVal);
|
|
|
|
|
|
|
|
// ----------------------
|
|
// Methods
|
|
// ----------------------
|
|
// Appends a string using the ANSI character encoding to the currently open file.
|
|
bool AppendAnsi(const wchar_t *text);
|
|
|
|
// Appends the contents of bd to the currently open file.
|
|
bool AppendBd(CkBinDataW &bd);
|
|
|
|
// Appends the contents of sb using the character encoding (such as utf-8 )
|
|
// specified by charset to the currently open file.
|
|
bool AppendSb(CkStringBuilderW &sb, const wchar_t *charset);
|
|
|
|
// Appends a string using the character encoding specified by str to the currently
|
|
// open file.
|
|
bool AppendText(const wchar_t *str, const wchar_t *charset);
|
|
|
|
// Appends the 2-byte Unicode BOM (little endian) to the currently open file.
|
|
bool AppendUnicodeBOM(void);
|
|
|
|
// Appends the 3-byte utf-8 BOM to the currently open file.
|
|
bool AppendUtf8BOM(void);
|
|
|
|
// Same as DirEnsureExists, except the argument is a file path (the last part of
|
|
// the path is a filename and not a directory). Creates all missing directories
|
|
// such that filePath may be created.
|
|
bool DirAutoCreate(const wchar_t *filePath);
|
|
|
|
// Creates a new directory specified by dirPath.
|
|
bool DirCreate(const wchar_t *dirPath);
|
|
|
|
// Deletes the directory specified by dirPath. It is only possible to delete a
|
|
// directory if it contains no files or subdirectories.
|
|
bool DirDelete(const wchar_t *dirPath);
|
|
|
|
// Creates all directories necessary such that the entire dirPath exists.
|
|
bool DirEnsureExists(const wchar_t *dirPath);
|
|
|
|
// Returns true if the dirPath exists.
|
|
bool DirExists(const wchar_t *dirPath);
|
|
|
|
// Closes the currently open file.
|
|
void FileClose(void);
|
|
|
|
// Compares the contents of two files and returns true if they are equal and
|
|
// otherwise returns false. The actual contents of the files are only compared if
|
|
// the sizes are equal. The files are not entirely loaded into memory. Instead,
|
|
// they are compared chunk by chunk. This allows for any size files to be compared,
|
|
// regardless of the memory capacity of the computer.
|
|
bool FileContentsEqual(const wchar_t *filePath1, const wchar_t *filePath2);
|
|
|
|
// Copys existingFilepath to newFilepath. If failIfExists is true and newFilepath already exists, then an error is
|
|
// returned.
|
|
bool FileCopy(const wchar_t *existingFilepath, const wchar_t *newFilepath, bool failIfExists);
|
|
|
|
// Deletes the file specified by filePath.
|
|
bool FileDelete(const wchar_t *filePath);
|
|
|
|
// Returns true if filePath exists, otherwise returns false.
|
|
bool FileExists(const wchar_t *filePath);
|
|
|
|
// Returns 1 if the path exists, 0 if the path does not exist, and -1 if unable to
|
|
// check because of directory permissions or some other error that prevents the
|
|
// ability to obtain the information.
|
|
int FileExists3(const wchar_t *path);
|
|
|
|
// This method should only be called on Windows operating systems. It's arguments
|
|
// are similar to the Windows Platform SDK function named CreateFile. For Linux,
|
|
// MAC OS X, and other operating system, use the OpenForRead, OpenForWrite,
|
|
// OpenForReadWrite, and OpenForAppend methods.
|
|
//
|
|
// Opens a file for reading or writing. The arguments mirror the Windows CreateFile
|
|
// function:Access Modes:
|
|
// GENERIC_READ (0x80000000)
|
|
// GENERIC_WRITE (0x40000000)
|
|
//
|
|
// Share Modes:
|
|
// FILE_SHARE_READ(0x00000001)
|
|
// FILE_SHARE_WRITE(0x00000002)
|
|
//
|
|
// Create Dispositions
|
|
// CREATE_NEW 1
|
|
// CREATE_ALWAYS 2
|
|
// OPEN_EXISTING 3
|
|
// OPEN_ALWAYS 4
|
|
// TRUNCATE_EXISTING 5
|
|
//
|
|
// // Attributes:
|
|
// FILE_ATTRIBUTE_READONLY 0x00000001
|
|
// FILE_ATTRIBUTE_HIDDEN 0x00000002
|
|
// FILE_ATTRIBUTE_SYSTEM 0x00000004
|
|
// FILE_ATTRIBUTE_DIRECTORY 0x00000010
|
|
// FILE_ATTRIBUTE_ARCHIVE 0x00000020
|
|
// FILE_ATTRIBUTE_NORMAL 0x00000080
|
|
// FILE_ATTRIBUTE_TEMPORARY 0x00000100
|
|
//
|
|
bool FileOpen(const wchar_t *filePath, unsigned long accessMode, unsigned long shareMode, unsigned long createDisposition, unsigned long attributes);
|
|
|
|
// Reads bytes from the currently open file. maxNumBytes specifies the maximum number of
|
|
// bytes to read. Returns an empty byte array on error.
|
|
bool FileRead(int maxNumBytes, CkByteData &outBytes);
|
|
|
|
// Reads bytes from the currently open file. maxNumBytes specifies the maximum number of
|
|
// bytes to read. Appends the bytes to the binData.
|
|
bool FileReadBd(int maxNumBytes, CkBinDataW &binData);
|
|
|
|
// Renames a file from existingFilepath to newFilepath.
|
|
bool FileRename(const wchar_t *existingFilepath, const wchar_t *newFilepath);
|
|
|
|
// Sets the file pointer for the currently open file. The offset is an offset in
|
|
// bytes from the origin. The origin can be one of the following:0 = Offset is from beginning of file.
|
|
// 1 = Offset is from current position of file pointer.
|
|
// 2 = Offset is from the end-of-file (offset may be negative).
|
|
bool FileSeek(int offset, int origin);
|
|
|
|
// Returns the size, in bytes, of a file. Returns -1 for failure.
|
|
//
|
|
// Note: This method returns a signed 32-bit integer, which is not large enough to
|
|
// handle files greater than 2GB in size. To handle larger files, call FileSizeStr
|
|
// instead, or call FileSize64. The FileSize64 method was added in Chilkat
|
|
// v9.5.0.88.
|
|
//
|
|
int FileSize(const wchar_t *filePath);
|
|
|
|
// Returns the size, in bytes, of a file. Returns -1 for failure.
|
|
__int64 FileSize64(const wchar_t *filePath);
|
|
|
|
// Returns the size of the file in decimal string format.
|
|
bool FileSizeStr(const wchar_t *filePath, CkString &outStr);
|
|
// Returns the size of the file in decimal string format.
|
|
const wchar_t *fileSizeStr(const wchar_t *filePath);
|
|
|
|
// Examines the file at path and returns one of the following values:
|
|
//
|
|
// -1 = Unable to check because of directory permissions or some error preventing
|
|
// the ability to obtain the information.
|
|
// 0 = File does not exist.
|
|
// 1 = Regular file.
|
|
// 2 = Directory.
|
|
// 3 = Symbolic link.
|
|
// 4 = Windows Shortcut.
|
|
// 99 = Something else.
|
|
//
|
|
// Additional file types may be added in the future as needed.
|
|
//
|
|
int FileType(const wchar_t *path);
|
|
|
|
// Writes bytes to the currently open file.
|
|
bool FileWrite(CkByteData &data);
|
|
|
|
// Writes bytes to the currently open file.
|
|
bool FileWrite2(const void *pByteData, unsigned long szByteData);
|
|
|
|
// Writes the contents of binData to the currently open file. To specify the entire
|
|
// contents of binData, set both offset and numBytes equal to 0. To write all remaining data
|
|
// starting at offset, then set numBytes equal to 0.
|
|
bool FileWriteBd(CkBinDataW &binData, int offset, int numBytes);
|
|
|
|
// This is purely a utility/convenience method -- initially created to help with
|
|
// block file uploads to Azure Blob storage. It generates a block ID string that is
|
|
// the decimal representation of the index in length chars, and then encoded according
|
|
// to encoding (which can be an encoding such as base64 , hex , ascii , etc.) For
|
|
// example, if index = 8, length = 12, and encoding = base64 , then the string 00000012 is
|
|
// returned base64 encoded.
|
|
bool GenBlockId(int index, int length, const wchar_t *encoding, CkString &outStr);
|
|
// This is purely a utility/convenience method -- initially created to help with
|
|
// block file uploads to Azure Blob storage. It generates a block ID string that is
|
|
// the decimal representation of the index in length chars, and then encoded according
|
|
// to encoding (which can be an encoding such as base64 , hex , ascii , etc.) For
|
|
// example, if index = 8, length = 12, and encoding = base64 , then the string 00000012 is
|
|
// returned base64 encoded.
|
|
const wchar_t *genBlockId(int index, int length, const wchar_t *encoding);
|
|
|
|
// Returns the directory information for the specified path string.GetDirectoryName('C:\MyDir\MySubDir\myfile.ext') returns 'C:\MyDir\MySubDir\'
|
|
// GetDirectoryName('C:\MyDir\MySubDir') returns 'C:\MyDir\'
|
|
// GetDirectoryName('C:\MyDir\') returns 'C:\MyDir\'
|
|
// GetDirectoryName('C:\MyDir') returns 'C:\'
|
|
// GetDirectoryName('C:\') returns 'C:\'
|
|
bool GetDirectoryName(const wchar_t *path, CkString &outStr);
|
|
// Returns the directory information for the specified path string.GetDirectoryName('C:\MyDir\MySubDir\myfile.ext') returns 'C:\MyDir\MySubDir\'
|
|
// GetDirectoryName('C:\MyDir\MySubDir') returns 'C:\MyDir\'
|
|
// GetDirectoryName('C:\MyDir\') returns 'C:\MyDir\'
|
|
// GetDirectoryName('C:\MyDir') returns 'C:\'
|
|
// GetDirectoryName('C:\') returns 'C:\'
|
|
const wchar_t *getDirectoryName(const wchar_t *path);
|
|
// Returns the directory information for the specified path string.GetDirectoryName('C:\MyDir\MySubDir\myfile.ext') returns 'C:\MyDir\MySubDir\'
|
|
// GetDirectoryName('C:\MyDir\MySubDir') returns 'C:\MyDir\'
|
|
// GetDirectoryName('C:\MyDir\') returns 'C:\MyDir\'
|
|
// GetDirectoryName('C:\MyDir') returns 'C:\'
|
|
// GetDirectoryName('C:\') returns 'C:\'
|
|
const wchar_t *directoryName(const wchar_t *path);
|
|
|
|
// Returns the extension of the specified path string.GetExtension('C:\mydir.old\myfile.ext') returns '.ext'
|
|
// GetExtension('C:\mydir.old\') returns ''
|
|
bool GetExtension(const wchar_t *path, CkString &outStr);
|
|
// Returns the extension of the specified path string.GetExtension('C:\mydir.old\myfile.ext') returns '.ext'
|
|
// GetExtension('C:\mydir.old\') returns ''
|
|
const wchar_t *getExtension(const wchar_t *path);
|
|
// Returns the extension of the specified path string.GetExtension('C:\mydir.old\myfile.ext') returns '.ext'
|
|
// GetExtension('C:\mydir.old\') returns ''
|
|
const wchar_t *extension(const wchar_t *path);
|
|
|
|
// Returns the file name and extension of the specified path string.GetFileName('C:\mydir\myfile.ext') returns 'myfile.ext'
|
|
// GetFileName('C:\mydir\') returns ''
|
|
bool GetFileName(const wchar_t *path, CkString &outStr);
|
|
// Returns the file name and extension of the specified path string.GetFileName('C:\mydir\myfile.ext') returns 'myfile.ext'
|
|
// GetFileName('C:\mydir\') returns ''
|
|
const wchar_t *getFileName(const wchar_t *path);
|
|
// Returns the file name and extension of the specified path string.GetFileName('C:\mydir\myfile.ext') returns 'myfile.ext'
|
|
// GetFileName('C:\mydir\') returns ''
|
|
const wchar_t *fileName(const wchar_t *path);
|
|
|
|
// Returns the file name of the specified path string without the extension.GetFileNameWithoutExtension('C:\mydir\myfile.ext') returns 'myfile'
|
|
// GetFileNameWithoutExtension('C:\mydir\') returns ''
|
|
bool GetFileNameWithoutExtension(const wchar_t *path, CkString &outStr);
|
|
// Returns the file name of the specified path string without the extension.GetFileNameWithoutExtension('C:\mydir\myfile.ext') returns 'myfile'
|
|
// GetFileNameWithoutExtension('C:\mydir\') returns ''
|
|
const wchar_t *getFileNameWithoutExtension(const wchar_t *path);
|
|
// Returns the file name of the specified path string without the extension.GetFileNameWithoutExtension('C:\mydir\myfile.ext') returns 'myfile'
|
|
// GetFileNameWithoutExtension('C:\mydir\') returns ''
|
|
const wchar_t *fileNameWithoutExtension(const wchar_t *path);
|
|
|
|
// Applications should instead call GetFileTimeStr .
|
|
//
|
|
// Gets one of the following date/times for a file:0: Last-modified
|
|
// 1: Last-access
|
|
// 2: Creation
|
|
// The path argument indicates which time to return. The values can be 0, 1, or 2.
|
|
//
|
|
// Note: Linux filesystems do not keep a file's creation date/time. In such a case,
|
|
// this method will return the last-modified time.
|
|
//
|
|
// The caller is responsible for deleting the object returned by this method.
|
|
CkDateTimeW *GetFileTime(const wchar_t *path, int which);
|
|
|
|
// Returns one of the following times for a file:0: Last-modified
|
|
// 1: Last-access
|
|
// 2: Creation
|
|
// The path argument indicates which time to return. The values can be 0, 1, or 2.
|
|
//
|
|
// Note: Linux filesystems do not keep a file's creation date/time. In such a case,
|
|
// this method will return the last-modified time.
|
|
//
|
|
// The time is returned in the ISO 8601 timestamp format: YYYY-MM-DDTHH:MM:SSZ.
|
|
//
|
|
bool GetFileTimeStr(const wchar_t *path, int which, CkString &outStr);
|
|
// Returns one of the following times for a file:0: Last-modified
|
|
// 1: Last-access
|
|
// 2: Creation
|
|
// The path argument indicates which time to return. The values can be 0, 1, or 2.
|
|
//
|
|
// Note: Linux filesystems do not keep a file's creation date/time. In such a case,
|
|
// this method will return the last-modified time.
|
|
//
|
|
// The time is returned in the ISO 8601 timestamp format: YYYY-MM-DDTHH:MM:SSZ.
|
|
//
|
|
const wchar_t *getFileTimeStr(const wchar_t *path, int which);
|
|
// Returns one of the following times for a file:0: Last-modified
|
|
// 1: Last-access
|
|
// 2: Creation
|
|
// The path argument indicates which time to return. The values can be 0, 1, or 2.
|
|
//
|
|
// Note: Linux filesystems do not keep a file's creation date/time. In such a case,
|
|
// this method will return the last-modified time.
|
|
//
|
|
// The time is returned in the ISO 8601 timestamp format: YYYY-MM-DDTHH:MM:SSZ.
|
|
//
|
|
const wchar_t *fileTimeStr(const wchar_t *path, int which);
|
|
|
|
// Applications should instead call GetFileTimeStr .
|
|
//
|
|
// Gets the last-modified date/time for a file. The accuracy of the last-modified
|
|
// data is to the number of seconds.
|
|
//
|
|
// The caller is responsible for deleting the object returned by this method.
|
|
CkDateTimeW *GetLastModified(const wchar_t *path);
|
|
|
|
// Returns the number of blocks in the currently open file. The number of bytes per
|
|
// block is specified by blockSize. The number of blocks is the file size divided by the
|
|
// blockSize, plus 1 if the file size is not evenly divisible by blockSize. For example, if
|
|
// the currently open file is 60500 bytes, and if the blockSize is 1000 bytes, then this
|
|
// method returns a count of 61 blocks.
|
|
//
|
|
// Returns -1 if no file is open. Return 0 if the file is completely empty (0
|
|
// bytes).
|
|
//
|
|
int GetNumBlocks(int blockSize);
|
|
|
|
// Creates a temporary filepath of the form dirPath\prefix_xxxx.TMP Where xxxx are
|
|
// random alpha-numeric chars. The returned filepath is guaranteed to not already
|
|
// exist.
|
|
bool GetTempFilename(const wchar_t *dirPath, const wchar_t *prefix, CkString &outStr);
|
|
// Creates a temporary filepath of the form dirPath\prefix_xxxx.TMP Where xxxx are
|
|
// random alpha-numeric chars. The returned filepath is guaranteed to not already
|
|
// exist.
|
|
const wchar_t *getTempFilename(const wchar_t *dirPath, const wchar_t *prefix);
|
|
// Creates a temporary filepath of the form dirPath\prefix_xxxx.TMP Where xxxx are
|
|
// random alpha-numeric chars. The returned filepath is guaranteed to not already
|
|
// exist.
|
|
const wchar_t *tempFilename(const wchar_t *dirPath, const wchar_t *prefix);
|
|
|
|
// Opens a file for appending. If filePath did not already exists, it is created. When
|
|
// an existing file is opened with this method, the contents will not be
|
|
// overwritten and the file pointer is positioned at the end of the file.
|
|
//
|
|
// If the open/create failed, then error information will be available in the
|
|
// FileOpenError and FileOpenErrorMsg properties.
|
|
//
|
|
bool OpenForAppend(const wchar_t *filePath);
|
|
|
|
// Opens a file for reading. The file may contain any type of data (binary or text)
|
|
// and it must already exist. If the open failed, then error information will be
|
|
// available in the FileOpenError and FileOpenErrorMsg properties.
|
|
bool OpenForRead(const wchar_t *filePath);
|
|
|
|
// Opens a file for reading/writing. If filePath did not already exists, it is created.
|
|
// When an existing file is opened with this method, the contents will not be
|
|
// overwritten, but the file pointer is positioned at the beginning of the file.
|
|
//
|
|
// If the open/create failed, then error information will be available in the
|
|
// FileOpenError and FileOpenErrorMsg properties.
|
|
//
|
|
bool OpenForReadWrite(const wchar_t *filePath);
|
|
|
|
// Opens a file for writing. If filePath did not already exists, it is created. When an
|
|
// existing file is opened with this method, the contents will be overwritten. (For
|
|
// example, calling OpenForWrite on an existing file and then immediately closing
|
|
// the file will result in an empty file.) If the open/create failed, then error
|
|
// information will be available in the FileOpenError and FileOpenErrorMsg
|
|
// properties.
|
|
bool OpenForWrite(const wchar_t *filePath);
|
|
|
|
// Reads the entire contents of a binary file and returns it as an encoded string
|
|
// (using an encoding such as Base64, Hex, etc.) The encoding may be one of the
|
|
// following strings: base64, hex, qp, or url.
|
|
bool ReadBinaryToEncoded(const wchar_t *filePath, const wchar_t *encoding, CkString &outStr);
|
|
// Reads the entire contents of a binary file and returns it as an encoded string
|
|
// (using an encoding such as Base64, Hex, etc.) The encoding may be one of the
|
|
// following strings: base64, hex, qp, or url.
|
|
const wchar_t *readBinaryToEncoded(const wchar_t *filePath, const wchar_t *encoding);
|
|
|
|
// Reads the Nth block of a file, where the size of each block is specified by
|
|
// blockSize. The first block is at blockIndex 0. If the block to be read is the last in the
|
|
// file and there is not enough data to fill an entire block, then the partial
|
|
// block is returned.
|
|
bool ReadBlock(int blockIndex, int blockSize, CkByteData &outBytes);
|
|
|
|
// Reads the Nth block of a file, where the size of each block is specified by
|
|
// blockSize. The first block is at blockIndex 0. If the block to be read is the last in the
|
|
// file and there is not enough data to fill an entire block, then the partial
|
|
// block is returned. The file data is appended to the contents of bd.
|
|
bool ReadBlockBd(int blockIndex, int blockSize, CkBinDataW &bd);
|
|
|
|
// Reads the entire contents of a binary file and returns the data.
|
|
bool ReadEntireFile(const wchar_t *filePath, CkByteData &outBytes);
|
|
|
|
// Reads the entire contents of a text file, interprets the bytes according to the
|
|
// character encoding specified by charset, and returns the text file as a string.
|
|
bool ReadEntireTextFile(const wchar_t *filePath, const wchar_t *charset, CkString &outStrFileContents);
|
|
// Reads the entire contents of a text file, interprets the bytes according to the
|
|
// character encoding specified by charset, and returns the text file as a string.
|
|
const wchar_t *readEntireTextFile(const wchar_t *filePath, const wchar_t *charset);
|
|
|
|
// Scans the currently open file (opened by calling OpenForRead) for the next chunk
|
|
// of text delimited by beginMarker and endMarker. The matched text, including the beginMarker and
|
|
// endMarker are appended to sb. The bytes of the text file are interpreted according
|
|
// to charset. If startAtBeginning equals true, then scanning begins at the start of the file.
|
|
// Otherwise scanning begins starting at the byte following the last matched
|
|
// fragment.
|
|
//
|
|
// The return value of this function is:
|
|
// 0: No match was found.
|
|
// 1: Found the next matching fragment and appended to sb.
|
|
// -1: Error reading the file.
|
|
//
|
|
// To support a common need for use with XML files, the beginMarker is XML tag aware . If
|
|
// the beginMarker is a string such as "<abc>", then it will also match "<abc ", where a
|
|
// whitespace char follows the tag. This is to handle cases where some XML tags
|
|
// have attributes and others do not.
|
|
//
|
|
int ReadNextFragment(bool startAtBeginning, const wchar_t *beginMarker, const wchar_t *endMarker, const wchar_t *charset, CkStringBuilderW &sb);
|
|
|
|
// Reassembles a file previously split by the SplitFile method.
|
|
bool ReassembleFile(const wchar_t *partsDirPath, const wchar_t *partPrefix, const wchar_t *partExtension, const wchar_t *reassembledFilename);
|
|
|
|
// Replaces all occurrences of existingString with replacementString in a file. The character encoding,
|
|
// such as utf-8, ansi, etc. is specified by charset.
|
|
int ReplaceStrings(const wchar_t *filePath, const wchar_t *charset, const wchar_t *existingString, const wchar_t *replacementString);
|
|
|
|
// Sets the current working directory for the calling process to dirPath.
|
|
bool SetCurrentDir(const wchar_t *dirPath);
|
|
|
|
// Sets the create date/time, the last-access date/time, and the last-modified
|
|
// date/time for a file. For non-Windows filesystems where create times are not
|
|
// implemented, the createTime is ignored.
|
|
bool SetFileTimes(const wchar_t *filePath, CkDateTimeW &createTime, CkDateTimeW &lastAccessTime, CkDateTimeW &lastModTime);
|
|
|
|
// Sets the last-modified date/time for a file.
|
|
bool SetLastModified(const wchar_t *filePath, CkDateTimeW &lastModified);
|
|
|
|
// Splits a file into chunks. To reassemble a split file, see the ReassembleFile
|
|
// method. Please refer to the example below:
|
|
bool SplitFile(const wchar_t *fileToSplit, const wchar_t *partPrefix, const wchar_t *partExtension, int partSize, const wchar_t *destDir);
|
|
|
|
// Creates a symbolic link.
|
|
//
|
|
// Note: On Windows systems, this is not the same as creating a shortcut. A Windows
|
|
// symbolic link and a Windows shortcut are two different things. Shortcut files
|
|
// are common on Windows, but not symbolic links. Creating a symbolic link requires
|
|
// a special privilege, unless running as administrator. To be able to create
|
|
// symbolic links, your user account or group needs to be listed in secpol.msc →
|
|
// Security Settings → Local Policies → User Rights Assignment → Create symbolic
|
|
// links. However the special setting is not needed when running within the
|
|
// development environment, such as from Visual Studio.
|
|
//
|
|
bool SymlinkCreate(const wchar_t *targetPath, const wchar_t *linkPath);
|
|
|
|
// Returns the full pathname of the file at the end of the linkPath. Also handles
|
|
// Windows shortcut files by returning the absolute path of the target.
|
|
bool SymlinkTarget(const wchar_t *linkPath, CkString &outStr);
|
|
// Returns the full pathname of the file at the end of the linkPath. Also handles
|
|
// Windows shortcut files by returning the absolute path of the target.
|
|
const wchar_t *symlinkTarget(const wchar_t *linkPath);
|
|
|
|
// Deletes an entire directory tree (all files and sub-directories).
|
|
bool TreeDelete(const wchar_t *path);
|
|
|
|
// Truncates the currently open file at the current file position.
|
|
bool Truncate(void);
|
|
|
|
// Opens/creates filePath, writes fileData, and closes the file.
|
|
bool WriteEntireFile(const wchar_t *filePath, CkByteData &fileData);
|
|
|
|
// Opens filePath, writes textData using the character encoding specified by charset, and
|
|
// closes the file. If includedPreamble is true and the charset is Unicode or utf-8, then the
|
|
// BOM is included at the beginning of the file.
|
|
bool WriteEntireTextFile(const wchar_t *filePath, const wchar_t *textData, const wchar_t *charset, bool includedPreamble);
|
|
|
|
|
|
|
|
|
|
|
|
// END PUBLIC INTERFACE
|
|
|
|
|
|
};
|
|
#if !defined(__sun__) && !defined(__sun)
|
|
#pragma pack (pop)
|
|
#endif
|
|
|
|
#endif
|