407 lines
15 KiB
C++
407 lines
15 KiB
C++
// CkBinData.h: interface for the CkBinData class.
|
|
//
|
|
//////////////////////////////////////////////////////////////////////
|
|
|
|
// This header is generated for Chilkat 11.3.0
|
|
|
|
#define _CkVersion 11.3.0
|
|
|
|
#ifndef _CkBinData_H
|
|
#define _CkBinData_H
|
|
|
|
#include "chilkatDefs.h"
|
|
#include "CkString.h"
|
|
#include "CkMultiByteBase.h"
|
|
|
|
class CkByteData;
|
|
class CkStringBuilder;
|
|
|
|
|
|
|
|
#if !defined(__sun__) && !defined(__sun)
|
|
#pragma pack (push, 8)
|
|
#endif
|
|
|
|
|
|
#undef Copy
|
|
|
|
// CLASS: CkBinData
|
|
class CK_VISIBLE_PUBLIC CkBinData : public CkMultiByteBase
|
|
{
|
|
private:
|
|
|
|
// Don't allow assignment or copying these objects.
|
|
CkBinData(const CkBinData &);
|
|
CkBinData &operator=(const CkBinData &);
|
|
|
|
public:
|
|
CkBinData(void);
|
|
virtual ~CkBinData(void);
|
|
|
|
static CkBinData *createNew(void);
|
|
static CkBinData *createNew2(int progLang);
|
|
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);
|
|
|
|
const unsigned char *getBinaryDataPtr(void);
|
|
|
|
unsigned long getSize(void);
|
|
|
|
|
|
|
|
|
|
// BEGIN PUBLIC INTERFACE
|
|
|
|
// ----------------------
|
|
// Properties
|
|
// ----------------------
|
|
// The number of bytes contained within the object.
|
|
int get_NumBytes(void);
|
|
|
|
|
|
|
|
// ----------------------
|
|
// Methods
|
|
// ----------------------
|
|
// Appends the contents of another BinData to this object.
|
|
bool AppendBd(CkBinData &binData);
|
|
|
|
|
|
// Appends binary data to the current contents, if any.
|
|
bool AppendBinary(CkByteData &data);
|
|
|
|
|
|
// Appends the appropriate BOM (byte order mark), also known as a preamble , for
|
|
// the given charset. If the charset has no defined BOM, then nothing is appended. An
|
|
// application would typically call this to append the utf-8, utf-16, or utf-32
|
|
// BOM.
|
|
bool AppendBom(const char *charset);
|
|
|
|
|
|
// Appends a single byte. The byteValue should be a value from 0 to 255.
|
|
bool AppendByte(int byteValue);
|
|
|
|
|
|
// Appends a byte count followed by the string in the desired character encoding,
|
|
// such as utf-8 . The numCountBytes is the size in bytes of the integer to represent the
|
|
// byte count. If 0, then a minimal number of bytes is used. If bigEndian is true, the
|
|
// byte count is appended in big endian byte ordering, otherwise little-ending byte
|
|
// ordering. The str is the string to be appended. The charset is the character
|
|
// encoding, such as utf-8 , utf-16 , windows-1252 , etc.
|
|
bool AppendCountedString(int numCountBytes, bool bigEndian, const char *str, const char *charset);
|
|
|
|
|
|
// Appends binary data to the current contents.
|
|
bool AppendData(const void *data, int numBytes);
|
|
|
|
|
|
// Appends encoded binary data to the current data. The encoding may be Base64 ,
|
|
// modBase64 , base64Url , Base32 , Base58 , QP (for quoted-printable), URL (for
|
|
// url-encoding), Hex , or any of the encodings found at Chilkat Binary Encodings
|
|
// List.
|
|
//
|
|
// References:
|
|
// 1: https://www.chilkatsoft.com/binary_encodings.asp
|
|
bool AppendEncoded(const char *encData, const char *encoding);
|
|
|
|
|
|
// Decodes the contents of sb and appends the decoded bytes to this object. The
|
|
// encoding may be Base64 , modBase64 , base64Url , Base32 , Base58 , QP (for
|
|
// quoted-printable), URL (for url-encoding), Hex , or any of the encodings found
|
|
// at Chilkat Binary Encodings List.
|
|
//
|
|
// References:
|
|
// 1: https://www.chilkatsoft.com/binary_encodings.asp
|
|
bool AppendEncodedSb(CkStringBuilder &sb, const char *encoding);
|
|
|
|
|
|
// Appends a 16-bit integer (2 bytes). If littleEndian is true, then the integer bytes
|
|
// are appended in little-endian byte order, otherwise big-endian byte order is
|
|
// used.
|
|
bool AppendInt2(int value, bool littleEndian);
|
|
|
|
|
|
// Appends a 32-bit integer (4 bytes). If littleEndian is true, then the integer bytes
|
|
// are appended in little-endian byte order, otherwise big-endian byte order is
|
|
// used.
|
|
bool AppendInt4(int value, bool littleEndian);
|
|
|
|
|
|
// Appends a string to this object, padded to the fieldLen with NULL or SPACE chars. If
|
|
// padWithSpace is true, then SPACE chars are used and the string is not null-terminated.
|
|
// If fieldLen is false, then null bytes are used. The charset controls the byte
|
|
// representation to use, such as utf-8 .
|
|
//
|
|
// Note: This call will always append a total number of bytes equal to fieldLen. If the
|
|
// str is longer than fieldLen, the method returns false to indicate failure and
|
|
// nothing is appended.
|
|
//
|
|
bool AppendPadded(const char *str, const char *charset, bool padWithSpace, int fieldLen);
|
|
|
|
|
|
// Appends the contents of a StringBuilder to this object.
|
|
bool AppendSb(CkStringBuilder &sb, const char *charset);
|
|
|
|
|
|
// Appends a string to this object. (This does not append the BOM. If a BOM is
|
|
// required, the AppendBom method can be called to append the appropriate BOM.)
|
|
bool AppendString(const char *str, const char *charset);
|
|
|
|
|
|
// Does either 16-bit or 32-bit byte swapping of the entire contents. If size
|
|
// equals 16, then swaps in 2 bytes (e.g., 0x1234 → 0x3412). If size equals 32,
|
|
// then swaps 4 bytes (e.g., 0x12345678 → 0x78563412)
|
|
void ByteSwap(int size);
|
|
|
|
|
|
// This method converts the character encoding of an object's contents from one
|
|
// format to another, such as from Windows-1252 to UTF-8. The allOrNone parameter
|
|
// determines error handling for unrepresentable bytes. If allOrNone is true, the
|
|
// object's contents remain unchanged when errors occur. If false, error bytes
|
|
// are discarded. The method returns true if successful and false if errors
|
|
// occur.
|
|
bool CharsetConvert(const char *fromCharset, const char *toCharset, bool allOrNone);
|
|
|
|
|
|
// Clears the contents.
|
|
bool Clear(void);
|
|
|
|
|
|
// Return true if the contents of this object equals the contents of binData.
|
|
bool ContentsEqual(CkBinData &binData);
|
|
|
|
|
|
// Return the index where the first occurrence of str is found. Return -1 if not
|
|
// found. The startIdx indicates the byte index where the search begins. The charset
|
|
// specifies the byte representation of str that is to be searched. For example,
|
|
// it can be utf-8 , windows-1252 , ansi , utf-16 , etc.
|
|
int FindString(const char *str, int startIdx, const char *charset);
|
|
|
|
|
|
// Retrieves the binary data contained within the object.
|
|
bool GetBinary(CkByteData &outBytes);
|
|
|
|
|
|
// Retrieves a chunk of the binary data contained within the object.
|
|
bool GetBinaryChunk(int offset, int numBytes, CkByteData &outBytes);
|
|
|
|
|
|
// Returns the value of the byte at the given index. The returned value is an
|
|
// integer from 0 to 255.
|
|
int GetByte(int index);
|
|
|
|
|
|
// Retrieves the binary data contained within the object.
|
|
const void *GetData(void);
|
|
|
|
|
|
// Retrieves a chunk of the binary data contained within the object.
|
|
const void *GetDataChunk(int offset, int numBytes);
|
|
|
|
|
|
// Retrieves the binary data as an encoded string. The encoding may be Base64 ,
|
|
// modBase64 , base64Url , Base32 , Base58 , QP (for quoted-printable), URL (for
|
|
// url-encoding), Hex , or any of the encodings found at Chilkat Binary Encodings
|
|
// List.
|
|
//
|
|
// References:
|
|
// 1: https://www.chilkatsoft.com/binary_encodings.asp
|
|
bool GetEncoded(const char *encoding, CkString &outStr);
|
|
|
|
// Retrieves the binary data as an encoded string. The encoding may be Base64 ,
|
|
// modBase64 , base64Url , Base32 , Base58 , QP (for quoted-printable), URL (for
|
|
// url-encoding), Hex , or any of the encodings found at Chilkat Binary Encodings
|
|
// List.
|
|
//
|
|
// References:
|
|
// 1: https://www.chilkatsoft.com/binary_encodings.asp
|
|
const char *getEncoded(const char *encoding);
|
|
// Retrieves the binary data as an encoded string. The encoding may be Base64 ,
|
|
// modBase64 , base64Url , Base32 , Base58 , QP (for quoted-printable), URL (for
|
|
// url-encoding), Hex , or any of the encodings found at Chilkat Binary Encodings
|
|
// List.
|
|
//
|
|
// References:
|
|
// 1: https://www.chilkatsoft.com/binary_encodings.asp
|
|
const char *encoded(const char *encoding);
|
|
|
|
|
|
// Retrieves a chunk of the binary data and returns it in encoded form. The encoding
|
|
// may be Base64 , modBase64 , base64Url , Base32 , Base58 , QP (for
|
|
// quoted-printable), URL (for url-encoding), Hex , or any of the encodings found
|
|
// at Chilkat Binary Encodings List.
|
|
//
|
|
// References:
|
|
// 1: https://www.chilkatsoft.com/binary_encodings.asp
|
|
bool GetEncodedChunk(int offset, int numBytes, const char *encoding, CkString &outStr);
|
|
|
|
// Retrieves a chunk of the binary data and returns it in encoded form. The encoding
|
|
// may be Base64 , modBase64 , base64Url , Base32 , Base58 , QP (for
|
|
// quoted-printable), URL (for url-encoding), Hex , or any of the encodings found
|
|
// at Chilkat Binary Encodings List.
|
|
//
|
|
// References:
|
|
// 1: https://www.chilkatsoft.com/binary_encodings.asp
|
|
const char *getEncodedChunk(int offset, int numBytes, const char *encoding);
|
|
// Retrieves a chunk of the binary data and returns it in encoded form. The encoding
|
|
// may be Base64 , modBase64 , base64Url , Base32 , Base58 , QP (for
|
|
// quoted-printable), URL (for url-encoding), Hex , or any of the encodings found
|
|
// at Chilkat Binary Encodings List.
|
|
//
|
|
// References:
|
|
// 1: https://www.chilkatsoft.com/binary_encodings.asp
|
|
const char *encodedChunk(int offset, int numBytes, const char *encoding);
|
|
|
|
|
|
// Writes the encoded data to a StringBuilder. The encoding may be Base64 , modBase64 ,
|
|
// base64Url , Base32 , Base58 , QP (for quoted-printable), URL (for url-encoding),
|
|
// Hex , or any of the encodings found at Chilkat Binary Encodings List.
|
|
//
|
|
// References:
|
|
// 1: https://www.chilkatsoft.com/binary_encodings.asp
|
|
bool GetEncodedSb(const char *encoding, CkStringBuilder &sb);
|
|
|
|
|
|
// Returns the hash of the contents of this object. The algorithm is the hash algorithm,
|
|
// and can be sha1 , sha256 , sha384 , sha512 , sha3-224 , sha3-256 , sha3-384 ,
|
|
// sha3-512 , md2 , md5 , ripemd128 , ripemd160 , ripemd256 , or ripemd320 . The
|
|
// encoding can be base64 , modBase64 , base64Url , base32 , base58 , qp (for
|
|
// quoted-printable), url (for url-encoding), hex , hexLower , or any of the
|
|
// encodings found at Chilkat Binary Encodings List.
|
|
//
|
|
// References:
|
|
// 1: https://www.chilkatsoft.com/binary_encodings.asp
|
|
bool GetHash(const char *algorithm, const char *encoding, CkString &outStr);
|
|
|
|
// Returns the hash of the contents of this object. The algorithm is the hash algorithm,
|
|
// and can be sha1 , sha256 , sha384 , sha512 , sha3-224 , sha3-256 , sha3-384 ,
|
|
// sha3-512 , md2 , md5 , ripemd128 , ripemd160 , ripemd256 , or ripemd320 . The
|
|
// encoding can be base64 , modBase64 , base64Url , base32 , base58 , qp (for
|
|
// quoted-printable), url (for url-encoding), hex , hexLower , or any of the
|
|
// encodings found at Chilkat Binary Encodings List.
|
|
//
|
|
// References:
|
|
// 1: https://www.chilkatsoft.com/binary_encodings.asp
|
|
const char *getHash(const char *algorithm, const char *encoding);
|
|
// Returns the hash of the contents of this object. The algorithm is the hash algorithm,
|
|
// and can be sha1 , sha256 , sha384 , sha512 , sha3-224 , sha3-256 , sha3-384 ,
|
|
// sha3-512 , md2 , md5 , ripemd128 , ripemd160 , ripemd256 , or ripemd320 . The
|
|
// encoding can be base64 , modBase64 , base64Url , base32 , base58 , qp (for
|
|
// quoted-printable), url (for url-encoding), hex , hexLower , or any of the
|
|
// encodings found at Chilkat Binary Encodings List.
|
|
//
|
|
// References:
|
|
// 1: https://www.chilkatsoft.com/binary_encodings.asp
|
|
const char *hash(const char *algorithm, const char *encoding);
|
|
|
|
|
|
// Returns the value of the 16-bit signed integer stored in big-endian or
|
|
// little-endian byte ordering at the given index.
|
|
int GetInt2(int index, bool littleEndian);
|
|
|
|
|
|
// Returns the value of the 32-bit signed integer stored in big-endian or
|
|
// little-endian byte ordering at the given index.
|
|
int GetInt4(int index, bool littleEndian);
|
|
|
|
|
|
// Interprets the bytes according to charset and returns the string. The charset can be
|
|
// utf-8 , utf-16 , ansi , iso-8859-* , windows-125* , or any of the supported
|
|
// character encodings listed in the link below.
|
|
bool GetString(const char *charset, CkString &outStr);
|
|
|
|
// Interprets the bytes according to charset and returns the string. The charset can be
|
|
// utf-8 , utf-16 , ansi , iso-8859-* , windows-125* , or any of the supported
|
|
// character encodings listed in the link below.
|
|
const char *getString(const char *charset);
|
|
// Interprets the bytes according to charset and returns the string. The charset can be
|
|
// utf-8 , utf-16 , ansi , iso-8859-* , windows-125* , or any of the supported
|
|
// character encodings listed in the link below.
|
|
const char *string(const char *charset);
|
|
|
|
|
|
// Returns numBytes bytes starting at startIdx. The bytes are interpreted according to charset
|
|
// (for example, utf-8 , ansi , utf-16 , windows-1252 , etc.)
|
|
bool GetTextChunk(int startIdx, int numBytes, const char *charset, CkString &outStr);
|
|
|
|
// Returns numBytes bytes starting at startIdx. The bytes are interpreted according to charset
|
|
// (for example, utf-8 , ansi , utf-16 , windows-1252 , etc.)
|
|
const char *getTextChunk(int startIdx, int numBytes, const char *charset);
|
|
// Returns numBytes bytes starting at startIdx. The bytes are interpreted according to charset
|
|
// (for example, utf-8 , ansi , utf-16 , windows-1252 , etc.)
|
|
const char *textChunk(int startIdx, int numBytes, const char *charset);
|
|
|
|
|
|
// Returns the value of the 16-bit unsigned integer stored in big-endian or
|
|
// little-endian byte ordering at the given index.
|
|
unsigned long GetUInt2(int index, bool littleEndian);
|
|
|
|
|
|
// Returns the value of the 32-bit unsigned integer stored in big-endian or
|
|
// little-endian byte ordering at the given index.
|
|
unsigned long GetUInt4(int index, bool littleEndian);
|
|
|
|
|
|
// Returns true if this object contains valid utf-8 byte sequences. Any invalid
|
|
// byte sequence that is not valid utf-8 will cause this function to return
|
|
// false.
|
|
bool IsValidUtf8(void);
|
|
|
|
|
|
// Loads binary data and replaces the current contents, if any.
|
|
bool LoadBinary(CkByteData &data);
|
|
|
|
|
|
// Loads binary data from an encoded string, replacing the current contents, if
|
|
// any. The encoding may be Base64 , modBase64 , base64Url , Base32 , Base58 , QP (for
|
|
// quoted-printable), URL (for url-encoding), Hex , or any of the encodings found
|
|
// at Chilkat Binary Encodings List.
|
|
//
|
|
// References:
|
|
// 1: https://www.chilkatsoft.com/binary_encodings.asp
|
|
bool LoadEncoded(const char *encData, const char *encoding);
|
|
|
|
|
|
// Loads data from a file.
|
|
bool LoadFile(const char *path);
|
|
|
|
|
|
// Removes bytes having a specified value (0-255). For example, to remove all null
|
|
// bytes, pass 0 in value.
|
|
void RemoveByteVal(int value);
|
|
|
|
|
|
// Removes a chunk of bytes from the binary data.
|
|
bool RemoveChunk(int offset, int numBytes);
|
|
|
|
|
|
// Securely clears the contents by writing 0 bytes to the memory prior to
|
|
// deallocating the internal memory.
|
|
bool SecureClear(void);
|
|
|
|
|
|
// Appends the contents of this object to a file.
|
|
bool WriteAppendFile(const char *path);
|
|
|
|
|
|
// Writes the contents to a file.
|
|
bool WriteFile(const char *path);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// END PUBLIC INTERFACE
|
|
|
|
|
|
};
|
|
#if !defined(__sun__) && !defined(__sun)
|
|
#pragma pack (pop)
|
|
#endif
|
|
|
|
#endif
|