/// For all string operations that the normalization does not set to None, /// and all non-string operations, /// the result is platform-dependent. /// This class is designed to process human-readable text, /// do not rely on the result. ///
////// In Linux and macOS, only en-US is supported, with a hard-coded set of date and time formats, /// and string operations only support None and IgnoreCase for normalization. ///
////// When there is a running task, queuing a new task will cancel all unexecuted queued tasks. /// When there is no running task, queuing a task will execute this task immediately. ///
////// Interface for streams. ///
////// Please notice that, even if you get a stream object, if [M:vl.stream.IStream.IsAvailable] returns false, all other methods cannot be used. ///
////// Not all methods are available for all types of streams. /// Feature testing functions must be called before calling other methods, if it is not sure that what kind of stream is being operated against: ///
//////
CodeAllocator;
typedef collections::ByteObjectMap::Allocator MapAllocator;
vuint8_t byte = 0;
vint code = -1;
Code* parent = 0;
vint size = 0;
collections::ByteObjectMap children;
};
}
class LzwBase : public Object
{
protected:
lzw::Code::CodeAllocator codeAllocator;
lzw::Code::MapAllocator mapAllocator;
lzw::Code* root;
vint eofIndex = -1;
vint nextIndex = 0;
vint indexBits = 1;
void UpdateIndexBits();
lzw::Code* CreateCode(lzw::Code* parent, vuint8_t byte);
LzwBase();
LzwBase(bool (&existingBytes)[256]);
~LzwBase();
};
/// An encoder to compress data using the Lzw algorithm.
///
/// You are not recommended to compress data more than 1 mega bytes at once using the encoder directly.
///
class LzwEncoder : public LzwBase, public EncoderBase
{
protected:
vuint8_t buffer[lzw::BufferSize];
vint bufferUsedBits = 0;
lzw::Code* prefix;
void Flush();
void WriteNumber(vint number, vint bitSize);
public:
/// Create an encoder.
LzwEncoder();
/// Create an encoder, specifying what bytes will never appear in the data to compress.
///
/// A filter array
/// If existingBytes[x] == true, it means x will possibly appear.
/// If existingBytes[x] == false, it means x will never appear.
///
///
/// The behavior is undefined, if existingBytes[x] == false, but byte x is actually in the data to compress.
///
LzwEncoder(bool (&existingBytes)[256]);
~LzwEncoder();
void Close()override;
vint Write(void* _buffer, vint _size)override;
};
/// An decoder to decompress data using the Lzw algorithm.
///
/// You are not recommended to compress data more than 1 mega bytes at once using the encoder directly.
///
class LzwDecoder :public LzwBase, public DecoderBase
{
protected:
collections::List dictionary;
lzw::Code* lastCode = 0;
vuint8_t inputBuffer[lzw::BufferSize];
vint inputBufferSize = 0;
vint inputBufferUsedBits = 0;
collections::Array outputBuffer;
vint outputBufferSize = 0;
vint outputBufferUsedBytes = 0;
bool ReadNumber(vint& number, vint bitSize);
void PrepareOutputBuffer(vint size);
void ExpandCodeToOutputBuffer(lzw::Code* code);
public:
/// Create a decoder.
LzwDecoder();
/// Create an encoder, specifying what bytes will never appear in the decompressed data.
///
/// A filter array
/// If existingBytes[x] == true, it means x will possibly appear.
/// If existingBytes[x] == false, it means x will never appear.
///
///
/// The array "existingBytes" should exactly match the one given to
LzwDecoder(bool (&existingBytes)[256]);
~LzwDecoder();
vint Read(void* _buffer, vint _size)override;
};
/***********************************************************************
Helper Functions
***********************************************************************/
/// Copy data from a readable input stream to a writable output stream.
/// Data copied in bytes.
/// The readable input stream.
/// The writable output stream.
extern vint CopyStream(stream::IStream& inputStream, stream::IStream& outputStream);
/// Compress data from a readable input stream to a writable output stream.
/// Data copied in bytes.
/// The readable input stream.
/// The writable output stream.
///
/// Data is compressed in multiple batches,
/// the is expected output stream to have data in multiple parts.
/// In each part, the first 4 bytes is the data before compression in bytes.
/// the rest is the compressed data.
///
/// Decompress data from a readable input stream (with compressed data) to a writable output stream (with uncompressed data).
/// Data copied in bytes.
/// The readable input stream.
/// The writable output stream.
///
/// Data is compressed in multiple batches,
/// the is expected input stream to have data in multiple parts.
/// In each part, the first 4 bytes is the data before compression in bytes.
/// the rest is the compressed data.
///
/// A writable stream that copy the written content to multiple output streams.
///
/// When writing happens, the boreadcast stream will only performance one write attempt to each output stream.
///
class BroadcastStream : public Object, public virtual IStream
{
typedef collections::List StreamList;
protected:
bool closed;
pos_t position;
StreamList streams;
public:
/// Create a boradcast stream.
BroadcastStream();
~BroadcastStream();
///
/// Get the list of output streams.
/// You can change this list to subscribe or unsubscribe.
///
/// The list of output streams.
StreamList& Targets();
bool CanRead()const;
bool CanWrite()const;
bool CanSeek()const;
bool CanPeek()const;
bool IsLimited()const;
bool IsAvailable()const;
void Close();
pos_t Position()const;
pos_t Size()const;
void Seek(pos_t _size);
void SeekFromBegin(pos_t _size);
void SeekFromEnd(pos_t _size);
vint Read(void* _buffer, vint _size);
vint Write(void* _buffer, vint _size);
vint Peek(void* _buffer, vint _size);
};
}
}
#endif
/***********************************************************************
.\STREAM\CACHESTREAM.H
***********************************************************************/
/***********************************************************************
Author: Zihan Chen (vczh)
Licensed under https://github.com/vczh-libraries/License
***********************************************************************/
#ifndef VCZH_STREAM_CACHESTREAM
#define VCZH_STREAM_CACHESTREAM
namespace vl
{
namespace stream
{
///
///
/// A potentially readable, peekable, writable, seekable and finite stream that creates on another stream.
/// Each feature is available if the target stream has the same feature.
///
///
/// When you read from the cache strema,
/// it will read a specified size of content from the target stream at once and cache,
/// reducing the number of operations on the target stream.
///
///
/// When you write to the cache stream,
/// it will cache all the data to write,
/// and write to the target stream after the cache is full,
/// reducing the number of operations on the target stream.
///
///
class CacheStream : public Object, public virtual IStream
{
protected:
IStream* target;
vint block;
pos_t start;
pos_t position;
char* buffer;
vint dirtyStart;
vint dirtyLength;
vint availableLength;
pos_t operatedSize;
void Flush();
void Load(pos_t _position);
vint InternalRead(void* _buffer, vint _size);
vint InternalWrite(void* _buffer, vint _size);
public:
/// Create a cache stream from a target stream.
/// The target stream.
/// Size of the cache.
CacheStream(IStream& _target, vint _block=65536);
~CacheStream();
bool CanRead()const;
bool CanWrite()const;
bool CanSeek()const;
bool CanPeek()const;
bool IsLimited()const;
bool IsAvailable()const;
void Close();
pos_t Position()const;
pos_t Size()const;
void Seek(pos_t _size);
void SeekFromBegin(pos_t _size);
void SeekFromEnd(pos_t _size);
vint Read(void* _buffer, vint _size);
vint Write(void* _buffer, vint _size);
vint Peek(void* _buffer, vint _size);
};
}
}
#endif
/***********************************************************************
.\STREAM\ENCODINGSTREAM.H
***********************************************************************/
/***********************************************************************
Author: Zihan Chen (vczh)
Licensed under https://github.com/vczh-libraries/License
***********************************************************************/
#ifndef VCZH_STREAM_ENCODINGSTREAM
#define VCZH_STREAM_ENCODINGSTREAM
namespace vl
{
namespace stream
{
/***********************************************************************
Encoding Related
***********************************************************************/
/// Encoder stream, a writable and potentially finite stream using [T:vl.stream.IEncoder] to transform content.
class EncoderStream : public virtual IStream
{
protected:
IStream* stream;
IEncoder* encoder;
pos_t position;
public:
/// Create en encoder stream.
/// The output stream to write.
/// The encoder to transform content.
EncoderStream(IStream& _stream, IEncoder& _encoder);
~EncoderStream();
bool CanRead()const;
bool CanWrite()const;
bool CanSeek()const;
bool CanPeek()const;
bool IsLimited()const;
bool IsAvailable()const;
void Close();
pos_t Position()const;
pos_t Size()const;
void Seek(pos_t _size);
void SeekFromBegin(pos_t _size);
void SeekFromEnd(pos_t _size);
vint Read(void* _buffer, vint _size);
vint Write(void* _buffer, vint _size);
vint Peek(void* _buffer, vint _size);
};
/// Decoder stream, a readable and potentially finite stream using [T:vl.stream.IDecoder] to transform content.
class DecoderStream : public virtual IStream
{
protected:
IStream* stream;
IDecoder* decoder;
pos_t position;
public:
/// Create a decoder stream.
/// The input stream to read.
/// The decoder to transform content.
DecoderStream(IStream& _stream, IDecoder& _decoder);
~DecoderStream();
bool CanRead()const;
bool CanWrite()const;
bool CanSeek()const;
bool CanPeek()const;
bool IsLimited()const;
bool IsAvailable()const;
void Close();
pos_t Position()const;
pos_t Size()const;
void Seek(pos_t _size);
void SeekFromBegin(pos_t _size);
void SeekFromEnd(pos_t _size);
vint Read(void* _buffer, vint _size);
vint Write(void* _buffer, vint _size);
vint Peek(void* _buffer, vint _size);
};
}
}
#endif
/***********************************************************************
.\STREAM\FILESTREAM.H
***********************************************************************/
/***********************************************************************
Author: Zihan Chen (vczh)
Licensed under https://github.com/vczh-libraries/License
***********************************************************************/
#ifndef VCZH_STREAM_FILESTREAM
#define VCZH_STREAM_FILESTREAM
#include
namespace vl
{
namespace stream
{
/// Platform-specific file stream implementation interface.
class IFileStreamImpl : public virtual Interface
{
public:
virtual bool Open() = 0;
virtual void Close() = 0;
virtual pos_t Position() const = 0;
virtual pos_t Size() const = 0;
virtual void Seek(pos_t _size) = 0;
virtual void SeekFromBegin(pos_t _size) = 0;
virtual void SeekFromEnd(pos_t _size) = 0;
virtual vint Read(void* _buffer, vint _size) = 0;
virtual vint Write(void* _buffer, vint _size) = 0;
virtual vint Peek(void* _buffer, vint _size) = 0;
};
/// A file stream. If the given file name is not working, the stream could be unavailable.
class FileStream : public Object, public virtual IStream
{
public:
/// Access to the file.
enum AccessRight
{
/// The file is opened to read, making this stream readable, seekable and finite.
ReadOnly,
/// The file is opened to write, making this stream writable.
WriteOnly,
/// The file is opened to both read and write, making this stream readable, seekable and writable.
ReadWrite
};
protected:
AccessRight accessRight;
Ptr impl;
public:
/// Create a file stream from a given file name.
/// The file to operate.
/// Expected operations on the file.
FileStream(const WString& fileName, AccessRight _accessRight);
~FileStream();
bool CanRead()const;
bool CanWrite()const;
bool CanSeek()const;
bool CanPeek()const;
bool IsLimited()const;
bool IsAvailable()const;
void Close();
pos_t Position()const;
pos_t Size()const;
void Seek(pos_t _size);
void SeekFromBegin(pos_t _size);
void SeekFromEnd(pos_t _size);
vint Read(void* _buffer, vint _size);
vint Write(void* _buffer, vint _size);
vint Peek(void* _buffer, vint _size);
};
}
}
#endif
/***********************************************************************
.\FILESYSTEM.H
***********************************************************************/
/***********************************************************************
Author: Zihan Chen (vczh)
Licensed under https://github.com/vczh-libraries/License
***********************************************************************/
#ifndef VCZH_FILESYSTEM
#define VCZH_FILESYSTEM
namespace vl
{
namespace filesystem
{
/// Absolute file path.
class FilePath : public Object
{
friend class LinuxFileSystemImpl;
friend class WindowsFileSystemImpl;
protected:
WString fullPath;
static void NormalizeDelimiters(collections::Array& buffer);
static void TrimLastDelimiter(WString& fullPath);
void Initialize();
static void GetPathComponents(WString path, collections::List& components);
static WString ComponentsToPath(const collections::List& components);
public:
/// Get the delimiter character used in a file path.
static wchar_t GetPathDelimiter();
/// Create a root path.
/// Create a file path.
/// Content of the file path. If it is a relative path, it will be converted to an absolute path.
FilePath(const WString& _filePath);
/// Create a file path.
/// Content of the file path. If it is a relative path, it will be converted to an absolute path.
FilePath(const wchar_t* _filePath);
/// Copy a file path.
/// The file path to copy.
FilePath(const FilePath& _filePath);
~FilePath() = default;
std::strong_ordering operator<=>(const FilePath& path)const { return fullPath <=> path.fullPath; }
bool operator==(const FilePath& path)const { return fullPath == path.fullPath; }
/// Concat an absolute path and a relative path.
/// The result absolute path.
/// The relative path to concat.
FilePath operator/(const WString& relativePath)const;
/// Test if the file path is a file.
/// Returns true if the file path is a file.
bool IsFile()const;
/// Test if the file path is a folder.
/// Returns true if the file path is a folder.
/// In Windows, a drive is also considered a folder.
bool IsFolder()const;
/// Test if the file path is a the root of all file system objects.
/// Returns true if the file path is the root of all file system objects.
bool IsRoot()const;
/// Get the last piece of names in the file path.
/// The last piece of names in the file path.
WString GetName()const;
/// Get the containing folder of this file path.
/// The containing folder.
FilePath GetFolder()const;
/// Get the content of the file path.
/// The content of the file path.
WString GetFullPath()const;
/// Calculate the relative path based on a specified referencing folder.
/// The relative path.
/// The referencing folder.
WString GetRelativePathFor(const FilePath& _filePath)const;
};
/// A file.
class File : public Object
{
private:
FilePath filePath;
public:
/// Create an empty reference. An empty reference does not refer to any file.
File() = default;
/// Create a reference to a specified file. The file is not required to exist.
/// The specified file.
File(const FilePath& _filePath);
~File() = default;
/// Get the file path of the file.
/// The file path.
const FilePath& GetFilePath()const;
/// Get the content of a text file with encoding testing.
/// Returns true if this operation succeeded.
/// Returns the content of the file.
/// Returns the encoding of the file.
/// Returns true if there is a BOM in the file.
bool ReadAllTextWithEncodingTesting(WString& text, stream::BomEncoder::Encoding& encoding, bool& containsBom);
/// Get the content of a text file. If there is no BOM in the file, the encoding is assumed to be aligned to the current code page.
/// The content of the file.
WString ReadAllTextByBom()const;
/// Get the content of a text file.
/// Returns true if this operation succeeded.
/// The content of the file.
bool ReadAllTextByBom(WString& text)const;
/// Get the content of a text file by lines.
/// Returns true if this operation succeeded.
/// The content of the file by lines.
///
/// Lines could be separated by either CRLF or LF.
/// A text file is not required to ends with CRLF.
/// If the last character of the file is LF,
/// the last line is the line before LF.
///
bool ReadAllLinesByBom(collections::List& lines)const;
/// Write text to the file.
/// Returns true if this operation succeeded.
/// The text to write.
/// Set to true to add a corresponding BOM at the beginning of the file according to the encoding, the default value is true.
/// The text encoding, the default encoding is UTF-16.
bool WriteAllText(const WString& text, bool bom = true, stream::BomEncoder::Encoding encoding = stream::BomEncoder::Utf16);
/// Write text to the file.
/// Returns true if this operation succeeded.
/// The text to write, with CRLF appended after all lines.
/// Set to true to add a corresponding BOM at the beginning of the file according to the encoding, the default value is true.
/// The text encoding, the default encoding is UTF-16.
bool WriteAllLines(collections::List& lines, bool bom = true, stream::BomEncoder::Encoding encoding = stream::BomEncoder::Utf16);
/// Test does the file exist or not.
/// Returns true if the file exists.
bool Exists()const;
/// Delete the file.
/// Returns true if this operation succeeded.
/// This function could return before the file is actually deleted.
bool Delete()const;
/// Rename the file.
/// Returns true if this operation succeeded.
/// The new file name.
bool Rename(const WString& newName)const;
};
/// A folder.
/// In Windows, a drive is also considered a folder.
class Folder : public Object
{
private:
FilePath filePath;
bool CreateNonRecursively()const;
bool DeleteNonRecursively()const;
public:
/// Create a reference to the root folder.
Folder() = default;
/// Create a reference to a specified folder. The folder is not required to exist.
/// The specified folder.
Folder(const FilePath& _filePath);
~Folder() = default;
/// Get the file path of the folder.
/// The file path.
const FilePath& GetFilePath()const;
/// Get all folders in this folder.
/// Returns true if this operation succeeded.
/// All folders.
/// In Windows, drives are considered sub folders in the root folder.
bool GetFolders(collections::List& folders)const;
/// Get all files in this folder.
/// Returns true if this operation succeeded.
/// All files.
bool GetFiles(collections::List& files)const;
/// Test does the folder exist or not.
/// Returns true if the folder exists.
bool Exists()const;
/// Create the folder.
/// Returns true if this operation succeeded.
/// Set to true to create all levels of containing folders if they do not exist.
///
/// This function could return before the folder is actually created.
/// If "recursively" is false, this function will only attempt to create the specified folder directly,
/// it fails if the containing folder does not exist.
///
bool Create(bool recursively)const;
/// Delete the folder.
/// Returns true if this operation succeeded.
/// Set to true to delete everything in the folder.
/// This function could return before the folder is actually deleted.
bool Delete(bool recursively)const;
/// Rename the folder.
/// Returns true if this operation succeeded.
/// The new folder name.
bool Rename(const WString& newName)const;
};
/// Platform-specific file system implementation interface.
class IFileSystemImpl : public virtual feature_injection::IFeatureImpl
{
public:
// FilePath operations
virtual wchar_t GetPathDelimiter() const = 0;
virtual const wchar_t* GetCompatibleDelimiters() const = 0;
virtual WString ConcatPath(const WString& fullPath, const WString& relativePath) const = 0;
virtual void Initialize(WString& fullPath) const = 0;
virtual bool IsFile(const WString& fullPath) const = 0;
virtual bool IsFolder(const WString& fullPath) const = 0;
virtual bool IsRoot(const WString& fullPath) const = 0;
virtual WString GetRelativePathFor(const WString& fromPath, const WString& toPath) const = 0;
// File operations
virtual bool FileDelete(const FilePath& filePath) const = 0;
virtual bool FileRename(const FilePath& filePath, const WString& newName) const = 0;
// Folder operations
virtual bool GetFolders(const FilePath& folderPath, collections::List& folders) const = 0;
virtual bool GetFiles(const FilePath& folderPath, collections::List& files) const = 0;
virtual bool CreateFolder(const FilePath& folderPath) const = 0;
virtual bool DeleteFolder(const FilePath& folderPath) const = 0;
virtual bool FolderRename(const FilePath& folderPath, const WString& newName) const = 0;
// Stream operations
virtual Ptr GetFileStreamImpl(const WString& fileName, stream::FileStream::AccessRight accessRight) const = 0;
};
extern void InjectFileSystemImpl(IFileSystemImpl* impl);
extern void EjectFileSystemImpl(IFileSystemImpl* impl);
}
}
#endif
/***********************************************************************
.\STREAM\MEMORYSTREAM.H
***********************************************************************/
/***********************************************************************
Author: Zihan Chen (vczh)
Licensed under https://github.com/vczh-libraries/License
***********************************************************************/
#ifndef VCZH_STREAM_MEMORYSTREAM
#define VCZH_STREAM_MEMORYSTREAM
namespace vl
{
namespace stream
{
/// A readable, peekable, writable and seekable stream that creates on a buffer.
class MemoryStream : public Object, public virtual IStream
{
protected:
vint block;
char* buffer;
vint size;
vint position;
vint capacity;
void PrepareSpace(vint totalSpace);
public:
/// Create a memory stream.
///
/// Size for each allocation.
/// When the allocated buffer is not big enough for writing,
/// the buffer will be rebuilt with an extension of "_block" in bytes.
///
MemoryStream(vint _block=65536);
~MemoryStream();
bool CanRead()const;
bool CanWrite()const;
bool CanSeek()const;
bool CanPeek()const;
bool IsLimited()const;
bool IsAvailable()const;
void Close();
pos_t Position()const;
pos_t Size()const;
void Seek(pos_t _size);
void SeekFromBegin(pos_t _size);
void SeekFromEnd(pos_t _size);
vint Read(void* _buffer, vint _size);
vint Write(void* _buffer, vint _size);
vint Peek(void* _buffer, vint _size);
void* GetInternalBuffer();
};
}
}
#endif
/***********************************************************************
.\STREAM\ACCESSOR.H
***********************************************************************/
/***********************************************************************
Author: Zihan Chen (vczh)
Licensed under https://github.com/vczh-libraries/License
***********************************************************************/
#ifndef VCZH_STREAM_ACCESSOR
#define VCZH_STREAM_ACCESSOR
namespace vl
{
namespace stream
{
/***********************************************************************
Text Related
***********************************************************************/
/// Text reader. All line breaks are normalized to CRLF regardless whatever in the input stream.
/// The character type.
template
class TextReader_ : public Object
{
public:
NOT_COPYABLE(TextReader_);
TextReader_() = default;
/// Test does the reader reach the end or not.
/// Returns true if the reader reaches the end.
virtual bool IsEnd()=0;
/// Read a single character.
/// The character.
virtual T ReadChar()=0;
/// Read a string of a specified size in characters.
/// The read string. It could be shorter than the expected length if the reader reaches the end.
/// Expected length of the string to read.
virtual ObjectString ReadString(vint length);
/// Read a string until a line breaks is reached.
/// The string without the line break. If the reader reaches the end, it returns an empty string.
virtual ObjectString ReadLine();
/// Read everying remain.
/// The read string.
virtual ObjectString ReadToEnd();
};
///