![]() |
|
#include <tbytevector.h>
Collaboration diagram for TagLib::ByteVector:
Public Member Functions | |
ByteVector () | |
ByteVector (uint size, char value=0) | |
ByteVector (const ByteVector &v) | |
ByteVector (char c) | |
ByteVector (const char *data, uint length) | |
ByteVector (const char *data) | |
virtual | ~ByteVector () |
ByteVector & | setData (const char *data, uint length) |
ByteVector & | setData (const char *data) |
char * | data () |
const char * | data () const |
ByteVector | mid (uint index, uint length=0xffffffff) const |
char | at (uint index) const |
int | find (const ByteVector &pattern, uint offset=0, int byteAlign=1) const |
int | rfind (const ByteVector &pattern, uint offset=0, int byteAlign=1) const |
bool | containsAt (const ByteVector &pattern, uint offset, uint patternOffset=0, uint patternLength=0xffffffff) const |
bool | startsWith (const ByteVector &pattern) const |
bool | endsWith (const ByteVector &pattern) const |
ByteVector & | replace (const ByteVector &pattern, const ByteVector &with) |
int | endsWithPartialMatch (const ByteVector &pattern) const |
ByteVector & | append (const ByteVector &v) |
ByteVector & | clear () |
uint | size () const |
ByteVector & | resize (uint size, char padding=0) |
Iterator | begin () |
ConstIterator | begin () const |
Iterator | end () |
ConstIterator | end () const |
bool | isNull () const |
bool | isEmpty () const |
uint | checksum () const |
uint | toUInt (bool mostSignificantByteFirst=true) const |
short | toShort (bool mostSignificantByteFirst=true) const |
long long | toLongLong (bool mostSignificantByteFirst=true) const |
const char & | operator[] (int index) const |
char & | operator[] (int index) |
bool | operator== (const ByteVector &v) const |
bool | operator!= (const ByteVector &v) const |
bool | operator== (const char *s) const |
bool | operator!= (const char *s) const |
bool | operator< (const ByteVector &v) const |
bool | operator> (const ByteVector &v) const |
ByteVector | operator+ (const ByteVector &v) const |
ByteVector & | operator= (const ByteVector &v) |
ByteVector & | operator= (char c) |
ByteVector & | operator= (const char *data) |
Static Public Member Functions | |
ByteVector | fromUInt (uint value, bool mostSignificantByteFirst=true) |
ByteVector | fromShort (short value, bool mostSignificantByteFirst=true) |
ByteVector | fromLongLong (long long value, bool mostSignificantByteFirst=true) |
ByteVector | fromCString (const char *s, uint length=0xffffffff) |
Static Public Attributes | |
ByteVector | null |
Protected Member Functions | |
void | detach () |
Related Functions | |
(Note that these are not member functions.) | |
TAGLIB_EXPORT std::ostream & | operator<< (std::ostream &s, const TagLib::ByteVector &v) |
This class provides a byte vector with some methods that are useful for tagging purposes. Many of the search functions are tailored to what is useful for finding tag related paterns in a data array.
|
Constructs an empty byte vector. |
|
Construct a vector of size size with all values set to value by default. |
|
Contructs a byte vector that is a copy of v. |
|
Contructs a byte vector that contains c. |
|
Constructs a byte vector that copies data for up to length bytes. |
|
Constructs a byte vector that copies data up to the first null byte. The behavior is undefined if data is not null terminated. This is particularly useful for constructing byte arrays from string constants. |
|
Destroys this ByteVector instance. |
|
Appends v to the end of the ByteVector. |
|
This essentially performs the same as operator[](), but instead of causing a runtime error if the index is out of bounds, it will return a null byte. |
|
Returns a ConstIterator that points to the front of the vector. |
|
Returns an Iterator that points to the front of the vector. |
|
Returns a CRC checksum of the byte vector's data. |
|
Clears the data. |
|
Checks to see if the vector contains the pattern starting at position offset. Optionally, if you only want to search for part of the pattern you can specify an offset within the pattern to start from. Also, you can specify to only check for the first patternLength bytes of pattern with the patternLength argument. |
|
Returns a pointer to the internal data structure which may not be modified. |
|
Returns a pointer to the internal data structure.
|
|
|
|
Returns a ConstIterator that points to the back of the vector. |
|
Returns an Iterator that points to the back of the vector. |
|
Returns true if the vector ends with pattern. |
|
Checks for a partial match of pattern at the end of the vector. It returns the offset of the partial match within the vector, or -1 if the pattern is not found. This method is particularly useful when searching for patterns that start in one vector and end in another. When combined with startsWith() it can be used to find a pattern that overlaps two buffers.
|
|
Searches the ByteVector for pattern starting at offset and returns the offset. Returns -1 if the pattern was not found. If byteAlign is specified the pattern will only be matched if it starts on a byte divisible by byteAlign (starting from offset). |
|
Returns a ByteVector based on the CString s. |
|
Creates a 8 byte ByteVector based on value. If mostSignificantByteFirst is true, then this will operate left to right in building the ByteVector. For example if mostSignificantByteFirst is true then $00 00 00 01 == 0x0000000000000001 == 1, if false, $01 00 00 00 00 00 00 00 == 0x0100000000000000 == 1.
|
|
Creates a 2 byte ByteVector based on value. If mostSignificantByteFirst is true, then this will operate left to right in building the ByteVector. For example if mostSignificantByteFirst is true then $00 01 == 0x0001 == 1, if false, $01 00 == 0x0100 == 1.
|
|
Creates a 4 byte ByteVector based on value. If mostSignificantByteFirst is true, then this will operate left to right in building the ByteVector. For example if mostSignificantByteFirst is true then $00 00 00 01 == 0x00000001 == 1, if false, $01 00 00 00 == 0x01000000 == 1.
|
|
Returns true if the ByteVector is empty.
|
|
Returns true if the vector is null.
|
|
Returns a byte vector made up of the bytes starting at index and for length bytes. If length is not specified it will return the bytes from index to the end of the vector. |
|
Returns true if this ByteVector and the null terminated C string s do not contain the same data. |
|
Returns true if this ByteVector and v are not equal. |
|
Returns a vector that is v appended to this vector. |
|
Returns true if this ByteVector is less than v. The value of the vectors is determined by evaluating the character from left to right, and in the event one vector is a superset of the other, the size is used. |
|
Copies ByteVector v. |
|
Copies ByteVector v. |
|
Copies ByteVector v. |
|
Returns true if this ByteVector and the null terminated C string s contain the same data. |
|
Returns true if this ByteVector and v are equal. |
|
Returns true if this ByteVector is greater than v. |
|
Returns a reference to the byte at index. |
|
Returns a const refernence to the byte at index. |
|
Replaces pattern with with and returns a reference to the ByteVector after the operation. This does modify the vector. |
|
Resize the vector to size. If the vector is currently less than size, pad the remaining spaces with padding. Returns a reference to the resized vector. |
|
Searches the ByteVector for pattern starting from either the end of the vector or offset and returns the offset. Returns -1 if the pattern was not found. If byteAlign is specified the pattern will only be matched if it starts on a byte divisible by byteAlign (starting from offset). |
|
Sets the data for the byte array copies data up to the first null byte. The behavior is undefined if data is not null terminated. |
|
Sets the data for the byte array using the first length bytes of data |
|
Returns the size of the array. |
|
Returns true if the vector starts with pattern. |
|
Converts the first 8 bytes of the vector to a (signed) long long. If mostSignificantByteFirst is true this will operate left to right evaluating the integer. For example if mostSignificantByteFirst is true then $00 00 00 00 00 00 00 01 == 0x0000000000000001 == 1, if false, $01 00 00 00 00 00 00 00 == 0x0100000000000000 == 1.
|
|
Converts the first 2 bytes of the vector to a short. If mostSignificantByteFirst is true this will operate left to right evaluating the integer. For example if mostSignificantByteFirst is true then $00 $01 == 0x0001 == 1, if false, $01 00 == 0x01000000 == 1.
|
|
Converts the first 4 bytes of the vector to an unsigned integer. If mostSignificantByteFirst is true this will operate left to right evaluating the integer. For example if mostSignificantByteFirst is true then $00 $00 $00 $01 == 0x00000001 == 1, if false, $01 00 00 00 == 0x01000000 == 1.
|
|
Streams the ByteVector v to the output stream s. |
|
A static, empty ByteVector which is convenient and fast (since returning an empty or "null" value does not require instantiating a new ByteVector). |