Miam-Player  0.8.0
A nice music player
TagLib::ByteVector Class Reference

A byte vector. More...

#include <tbytevector.h>

Public Types

typedef std::vector< char >::iterator Iterator
 
typedef std::vector< char >::const_iterator ConstIterator
 
typedef std::vector< char >::reverse_iterator ReverseIterator
 
typedef std::vector< char >::const_reverse_iterator ConstReverseIterator
 

Public Member Functions

 ByteVector ()
 Constructs an empty byte vector. More...
 
 ByteVector (unsigned int size, char value=0)
 Construct a vector of size size with all values set to value by default. More...
 
 ByteVector (const ByteVector &v)
 Constructs a byte vector that is a copy of v. More...
 
 ByteVector (const ByteVector &v, unsigned int offset, unsigned int length)
 Constructs a byte vector that is a copy of v. More...
 
 ByteVector (char c)
 Constructs a byte vector that contains c. More...
 
 ByteVector (const char *data, unsigned int length)
 Constructs a byte vector that copies data for up to length bytes. More...
 
 ByteVector (const char *data)
 Constructs a byte vector that copies data up to the first null byte. More...
 
virtual ~ByteVector ()
 Destroys this ByteVector instance. More...
 
ByteVectorsetData (const char *data, unsigned int length)
 Sets the data for the byte array using the first length bytes of data. More...
 
ByteVectorsetData (const char *data)
 Sets the data for the byte array copies data up to the first null byte. More...
 
char * data ()
 Returns a pointer to the internal data structure. More...
 
const char * data () const
 Returns a pointer to the internal data structure which may not be modified. More...
 
ByteVector mid (unsigned int index, unsigned int length=0xffffffff) const
 Returns a byte vector made up of the bytes starting at index and for length bytes. More...
 
char at (unsigned int index) const
 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. More...
 
int find (const ByteVector &pattern, unsigned int offset=0, int byteAlign=1) const
 Searches the ByteVector for pattern starting at offset and returns the offset. More...
 
int find (char c, unsigned int offset=0, int byteAlign=1) const
 Searches the char for c starting at offset and returns the offset. More...
 
int rfind (const ByteVector &pattern, unsigned int offset=0, int byteAlign=1) const
 Searches the ByteVector for pattern starting from either the end of the vector or offset and returns the offset. More...
 
bool containsAt (const ByteVector &pattern, unsigned int offset, unsigned int patternOffset=0, unsigned int patternLength=0xffffffff) const
 Checks to see if the vector contains the pattern starting at position offset. More...
 
bool startsWith (const ByteVector &pattern) const
 Returns true if the vector starts with pattern. More...
 
bool endsWith (const ByteVector &pattern) const
 Returns true if the vector ends with pattern. More...
 
ByteVectorreplace (char oldByte, char newByte)
 Replaces oldByte with newByte and returns a reference to the ByteVector after the operation. More...
 
ByteVectorreplace (const ByteVector &pattern, const ByteVector &with)
 Replaces pattern with with and returns a reference to the ByteVector after the operation. More...
 
int endsWithPartialMatch (const ByteVector &pattern) const
 Checks for a partial match of pattern at the end of the vector. More...
 
ByteVectorappend (const ByteVector &v)
 Appends v to the end of the ByteVector. More...
 
ByteVectorappend (char c)
 Appends c to the end of the ByteVector. More...
 
ByteVectorclear ()
 Clears the data. More...
 
unsigned int size () const
 Returns the size of the array. More...
 
ByteVectorresize (unsigned int size, char padding=0)
 Resize the vector to size. More...
 
Iterator begin ()
 Returns an Iterator that points to the front of the vector. More...
 
ConstIterator begin () const
 Returns a ConstIterator that points to the front of the vector. More...
 
Iterator end ()
 Returns an Iterator that points to the back of the vector. More...
 
ConstIterator end () const
 Returns a ConstIterator that points to the back of the vector. More...
 
ReverseIterator rbegin ()
 Returns a ReverseIterator that points to the front of the vector. More...
 
ConstReverseIterator rbegin () const
 Returns a ConstReverseIterator that points to the front of the vector. More...
 
ReverseIterator rend ()
 Returns a ReverseIterator that points to the back of the vector. More...
 
ConstReverseIterator rend () const
 Returns a ConstReverseIterator that points to the back of the vector. More...
 
bool isNull () const
 Returns true if the vector is null. More...
 
bool isEmpty () const
 Returns true if the ByteVector is empty. More...
 
unsigned int checksum () const
 Returns a CRC checksum of the byte vector's data. More...
 
unsigned int toUInt (bool mostSignificantByteFirst=true) const
 Converts the first 4 bytes of the vector to an unsigned integer. More...
 
unsigned int toUInt (unsigned int offset, bool mostSignificantByteFirst=true) const
 Converts the 4 bytes at offset of the vector to an unsigned integer. More...
 
unsigned int toUInt (unsigned int offset, unsigned int length, bool mostSignificantByteFirst=true) const
 Converts the length bytes at offset of the vector to an unsigned integer. More...
 
short toShort (bool mostSignificantByteFirst=true) const
 Converts the first 2 bytes of the vector to a (signed) short. More...
 
short toShort (unsigned int offset, bool mostSignificantByteFirst=true) const
 Converts the 2 bytes at offset of the vector to a (signed) short. More...
 
unsigned short toUShort (bool mostSignificantByteFirst=true) const
 Converts the first 2 bytes of the vector to a unsigned short. More...
 
unsigned short toUShort (unsigned int offset, bool mostSignificantByteFirst=true) const
 Converts the 2 bytes at offset of the vector to a unsigned short. More...
 
long long toLongLong (bool mostSignificantByteFirst=true) const
 Converts the first 8 bytes of the vector to a (signed) long long. More...
 
long long toLongLong (unsigned int offset, bool mostSignificantByteFirst=true) const
 Converts the 8 bytes at offset of the vector to a (signed) long long. More...
 
float toFloat32LE (size_t offset) const
 
float toFloat32BE (size_t offset) const
 
double toFloat64LE (size_t offset) const
 
double toFloat64BE (size_t offset) const
 
long double toFloat80LE (size_t offset) const
 
long double toFloat80BE (size_t offset) const
 
const char & operator[] (int index) const
 Returns a const reference to the byte at index. More...
 
char & operator[] (int index)
 Returns a reference to the byte at index. More...
 
bool operator== (const ByteVector &v) const
 Returns true if this ByteVector and v are equal. More...
 
bool operator!= (const ByteVector &v) const
 Returns true if this ByteVector and v are not equal. More...
 
bool operator== (const char *s) const
 Returns true if this ByteVector and the null terminated C string s contain the same data. More...
 
bool operator!= (const char *s) const
 Returns true if this ByteVector and the null terminated C string s do not contain the same data. More...
 
bool operator< (const ByteVector &v) const
 Returns true if this ByteVector is less than v. More...
 
bool operator> (const ByteVector &v) const
 Returns true if this ByteVector is greater than v. More...
 
ByteVector operator+ (const ByteVector &v) const
 Returns a vector that is v appended to this vector. More...
 
ByteVectoroperator= (const ByteVector &v)
 Copies ByteVector v. More...
 
ByteVectoroperator= (char c)
 Copies a byte c. More...
 
ByteVectoroperator= (const char *data)
 Copies data up to the first null byte. More...
 
void swap (ByteVector &v)
 Exchanges the content of the ByteVector by the content of v. More...
 
ByteVector toHex () const
 Returns a hex-encoded copy of the byte vector. More...
 
ByteVector toBase64 () const
 Returns a base64 encoded copy of the byte vector. More...
 

Static Public Member Functions

static ByteVector fromUInt (unsigned int value, bool mostSignificantByteFirst=true)
 Creates a 4 byte ByteVector based on value. More...
 
static ByteVector fromShort (short value, bool mostSignificantByteFirst=true)
 Creates a 2 byte ByteVector based on value. More...
 
static ByteVector fromLongLong (long long value, bool mostSignificantByteFirst=true)
 Creates a 8 byte ByteVector based on value. More...
 
static ByteVector fromFloat32LE (float value)
 Creates a 4 byte ByteVector based on value as an IEEE754 32-bit little-endian floating point number. More...
 
static ByteVector fromFloat32BE (float value)
 Creates a 4 byte ByteVector based on value as an IEEE754 32-bit big-endian floating point number. More...
 
static ByteVector fromFloat64LE (double value)
 Creates a 8 byte ByteVector based on value as an IEEE754 64-bit little-endian floating point number. More...
 
static ByteVector fromFloat64BE (double value)
 Creates a 8 byte ByteVector based on value as an IEEE754 64-bit big-endian floating point number. More...
 
static ByteVector fromCString (const char *s, unsigned int length=0xffffffff)
 Returns a ByteVector based on the CString s. More...
 
static ByteVector fromBase64 (const ByteVector &)
 Decodes the base64 encoded byte vector. More...
 

Static Public Attributes

static ByteVector null
 A static, empty ByteVector which is convenient and fast (since returning an empty or "null" value does not require instantiating a new ByteVector). More...
 

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)
 

Detailed Description

A byte vector.

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 patterns in a data array.

Member Typedef Documentation

◆ ConstIterator

typedef std::vector<char>::const_iterator TagLib::ByteVector::ConstIterator

◆ ConstReverseIterator

typedef std::vector<char>::const_reverse_iterator TagLib::ByteVector::ConstReverseIterator

◆ Iterator

typedef std::vector<char>::iterator TagLib::ByteVector::Iterator

◆ ReverseIterator

typedef std::vector<char>::reverse_iterator TagLib::ByteVector::ReverseIterator

Constructor & Destructor Documentation

◆ ByteVector() [1/7]

TagLib::ByteVector::ByteVector ( )

Constructs an empty byte vector.

◆ ByteVector() [2/7]

TagLib::ByteVector::ByteVector ( unsigned int  size,
char  value = 0 
)

Construct a vector of size size with all values set to value by default.

◆ ByteVector() [3/7]

TagLib::ByteVector::ByteVector ( const ByteVector v)

Constructs a byte vector that is a copy of v.

◆ ByteVector() [4/7]

TagLib::ByteVector::ByteVector ( const ByteVector v,
unsigned int  offset,
unsigned int  length 
)

Constructs a byte vector that is a copy of v.

◆ ByteVector() [5/7]

TagLib::ByteVector::ByteVector ( char  c)

Constructs a byte vector that contains c.

◆ ByteVector() [6/7]

TagLib::ByteVector::ByteVector ( const char *  data,
unsigned int  length 
)

Constructs a byte vector that copies data for up to length bytes.

◆ ByteVector() [7/7]

TagLib::ByteVector::ByteVector ( const char *  data)

Constructs a byte vector that copies data up to the first null byte.

This is particularly useful for constructing byte arrays from string constants.

Warning
The behavior is undefined if data is not null terminated.

◆ ~ByteVector()

virtual TagLib::ByteVector::~ByteVector ( )
virtual

Destroys this ByteVector instance.

Member Function Documentation

◆ append() [1/2]

ByteVector& TagLib::ByteVector::append ( const ByteVector v)

Appends v to the end of the ByteVector.

◆ append() [2/2]

ByteVector& TagLib::ByteVector::append ( char  c)

Appends c to the end of the ByteVector.

◆ at()

char TagLib::ByteVector::at ( unsigned int  index) const

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.

◆ begin() [1/2]

Iterator TagLib::ByteVector::begin ( )

Returns an Iterator that points to the front of the vector.

◆ begin() [2/2]

ConstIterator TagLib::ByteVector::begin ( ) const

Returns a ConstIterator that points to the front of the vector.

◆ checksum()

unsigned int TagLib::ByteVector::checksum ( ) const

Returns a CRC checksum of the byte vector's data.

Note
This uses an uncommon variant of CRC32 specializes in Ogg.

◆ clear()

ByteVector& TagLib::ByteVector::clear ( )

Clears the data.

◆ containsAt()

bool TagLib::ByteVector::containsAt ( const ByteVector pattern,
unsigned int  offset,
unsigned int  patternOffset = 0,
unsigned int  patternLength = 0xffffffff 
) const

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.

◆ data() [1/2]

char* TagLib::ByteVector::data ( )

Returns a pointer to the internal data structure.

Warning
Care should be taken when modifying this data structure as it is easy to corrupt the ByteVector when doing so. Specifically, while the data may be changed, its length may not be.

◆ data() [2/2]

const char* TagLib::ByteVector::data ( ) const

Returns a pointer to the internal data structure which may not be modified.

◆ detach()

void TagLib::ByteVector::detach ( )
protected

◆ end() [1/2]

Iterator TagLib::ByteVector::end ( )

Returns an Iterator that points to the back of the vector.

◆ end() [2/2]

ConstIterator TagLib::ByteVector::end ( ) const

Returns a ConstIterator that points to the back of the vector.

◆ endsWith()

bool TagLib::ByteVector::endsWith ( const ByteVector pattern) const

Returns true if the vector ends with pattern.

◆ endsWithPartialMatch()

int TagLib::ByteVector::endsWithPartialMatch ( const ByteVector pattern) const

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.

Note
This will not match the complete pattern at the end of the string; use endsWith() for that.

◆ find() [1/2]

int TagLib::ByteVector::find ( const ByteVector pattern,
unsigned int  offset = 0,
int  byteAlign = 1 
) const

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).

◆ find() [2/2]

int TagLib::ByteVector::find ( char  c,
unsigned int  offset = 0,
int  byteAlign = 1 
) const

Searches the char for c 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).

◆ fromBase64()

static ByteVector TagLib::ByteVector::fromBase64 ( const ByteVector )
static

Decodes the base64 encoded byte vector.

◆ fromCString()

static ByteVector TagLib::ByteVector::fromCString ( const char *  s,
unsigned int  length = 0xffffffff 
)
static

Returns a ByteVector based on the CString s.

◆ fromFloat32BE()

static ByteVector TagLib::ByteVector::fromFloat32BE ( float  value)
static

Creates a 4 byte ByteVector based on value as an IEEE754 32-bit big-endian floating point number.

See also
fromFloat32LE()

◆ fromFloat32LE()

static ByteVector TagLib::ByteVector::fromFloat32LE ( float  value)
static

Creates a 4 byte ByteVector based on value as an IEEE754 32-bit little-endian floating point number.

See also
fromFloat32BE()

◆ fromFloat64BE()

static ByteVector TagLib::ByteVector::fromFloat64BE ( double  value)
static

Creates a 8 byte ByteVector based on value as an IEEE754 64-bit big-endian floating point number.

See also
fromFloat64LE()

◆ fromFloat64LE()

static ByteVector TagLib::ByteVector::fromFloat64LE ( double  value)
static

Creates a 8 byte ByteVector based on value as an IEEE754 64-bit little-endian floating point number.

See also
fromFloat64BE()

◆ fromLongLong()

static ByteVector TagLib::ByteVector::fromLongLong ( long long  value,
bool  mostSignificantByteFirst = true 
)
static

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.

See also
toLongLong()

◆ fromShort()

static ByteVector TagLib::ByteVector::fromShort ( short  value,
bool  mostSignificantByteFirst = true 
)
static

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.

See also
toShort()

◆ fromUInt()

static ByteVector TagLib::ByteVector::fromUInt ( unsigned int  value,
bool  mostSignificantByteFirst = true 
)
static

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.

See also
toUInt()

◆ isEmpty()

bool TagLib::ByteVector::isEmpty ( ) const

Returns true if the ByteVector is empty.

See also
size()
isNull()

◆ isNull()

bool TagLib::ByteVector::isNull ( ) const

Returns true if the vector is null.

Note
A vector may be empty without being null. So do not use this method to check if the vector is empty.
See also
isEmpty()
Deprecated:

◆ mid()

ByteVector TagLib::ByteVector::mid ( unsigned int  index,
unsigned int  length = 0xffffffff 
) const

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.

◆ operator!=() [1/2]

bool TagLib::ByteVector::operator!= ( const ByteVector v) const

Returns true if this ByteVector and v are not equal.

◆ operator!=() [2/2]

bool TagLib::ByteVector::operator!= ( const char *  s) const

Returns true if this ByteVector and the null terminated C string s do not contain the same data.

◆ operator+()

ByteVector TagLib::ByteVector::operator+ ( const ByteVector v) const

Returns a vector that is v appended to this vector.

◆ operator<()

bool TagLib::ByteVector::operator< ( const ByteVector v) const

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.

◆ operator=() [1/3]

ByteVector& TagLib::ByteVector::operator= ( const ByteVector v)

Copies ByteVector v.

◆ operator=() [2/3]

ByteVector& TagLib::ByteVector::operator= ( char  c)

Copies a byte c.

◆ operator=() [3/3]

ByteVector& TagLib::ByteVector::operator= ( const char *  data)

Copies data up to the first null byte.

Warning
The behavior is undefined if data is not null terminated.

◆ operator==() [1/2]

bool TagLib::ByteVector::operator== ( const ByteVector v) const

Returns true if this ByteVector and v are equal.

◆ operator==() [2/2]

bool TagLib::ByteVector::operator== ( const char *  s) const

Returns true if this ByteVector and the null terminated C string s contain the same data.

◆ operator>()

bool TagLib::ByteVector::operator> ( const ByteVector v) const

Returns true if this ByteVector is greater than v.

◆ operator[]() [1/2]

const char& TagLib::ByteVector::operator[] ( int  index) const

Returns a const reference to the byte at index.

◆ operator[]() [2/2]

char& TagLib::ByteVector::operator[] ( int  index)

Returns a reference to the byte at index.

◆ rbegin() [1/2]

ReverseIterator TagLib::ByteVector::rbegin ( )

Returns a ReverseIterator that points to the front of the vector.

◆ rbegin() [2/2]

ConstReverseIterator TagLib::ByteVector::rbegin ( ) const

Returns a ConstReverseIterator that points to the front of the vector.

◆ rend() [1/2]

ReverseIterator TagLib::ByteVector::rend ( )

Returns a ReverseIterator that points to the back of the vector.

◆ rend() [2/2]

ConstReverseIterator TagLib::ByteVector::rend ( ) const

Returns a ConstReverseIterator that points to the back of the vector.

◆ replace() [1/2]

ByteVector& TagLib::ByteVector::replace ( char  oldByte,
char  newByte 
)

Replaces oldByte with newByte and returns a reference to the ByteVector after the operation.

This does modify the vector.

◆ replace() [2/2]

ByteVector& TagLib::ByteVector::replace ( const ByteVector pattern,
const ByteVector with 
)

Replaces pattern with with and returns a reference to the ByteVector after the operation.

This does modify the vector.

◆ resize()

ByteVector& TagLib::ByteVector::resize ( unsigned int  size,
char  padding = 0 
)

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.

◆ rfind()

int TagLib::ByteVector::rfind ( const ByteVector pattern,
unsigned int  offset = 0,
int  byteAlign = 1 
) const

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).

◆ setData() [1/2]

ByteVector& TagLib::ByteVector::setData ( const char *  data,
unsigned int  length 
)

Sets the data for the byte array using the first length bytes of data.

◆ setData() [2/2]

ByteVector& TagLib::ByteVector::setData ( const char *  data)

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.

◆ size()

unsigned int TagLib::ByteVector::size ( ) const

Returns the size of the array.

◆ startsWith()

bool TagLib::ByteVector::startsWith ( const ByteVector pattern) const

Returns true if the vector starts with pattern.

◆ swap()

void TagLib::ByteVector::swap ( ByteVector v)

Exchanges the content of the ByteVector by the content of v.

◆ toBase64()

ByteVector TagLib::ByteVector::toBase64 ( ) const

Returns a base64 encoded copy of the byte vector.

◆ toFloat32BE()

float TagLib::ByteVector::toFloat32BE ( size_t  offset) const

◆ toFloat32LE()

float TagLib::ByteVector::toFloat32LE ( size_t  offset) const

◆ toFloat64BE()

double TagLib::ByteVector::toFloat64BE ( size_t  offset) const

◆ toFloat64LE()

double TagLib::ByteVector::toFloat64LE ( size_t  offset) const

◆ toFloat80BE()

long double TagLib::ByteVector::toFloat80BE ( size_t  offset) const

◆ toFloat80LE()

long double TagLib::ByteVector::toFloat80LE ( size_t  offset) const

◆ toHex()

ByteVector TagLib::ByteVector::toHex ( ) const

Returns a hex-encoded copy of the byte vector.

◆ toLongLong() [1/2]

long long TagLib::ByteVector::toLongLong ( bool  mostSignificantByteFirst = true) const

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.

See also
fromUInt()

◆ toLongLong() [2/2]

long long TagLib::ByteVector::toLongLong ( unsigned int  offset,
bool  mostSignificantByteFirst = true 
) const

Converts the 8 bytes at offset 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.

See also
fromUInt()

◆ toShort() [1/2]

short TagLib::ByteVector::toShort ( bool  mostSignificantByteFirst = true) const

Converts the first 2 bytes of the vector to a (signed) 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.

See also
fromShort()

◆ toShort() [2/2]

short TagLib::ByteVector::toShort ( unsigned int  offset,
bool  mostSignificantByteFirst = true 
) const

Converts the 2 bytes at offset of the vector to a (signed) 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.

See also
fromShort()

◆ toUInt() [1/3]

unsigned int TagLib::ByteVector::toUInt ( bool  mostSignificantByteFirst = true) const

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.

See also
fromUInt()

◆ toUInt() [2/3]

unsigned int TagLib::ByteVector::toUInt ( unsigned int  offset,
bool  mostSignificantByteFirst = true 
) const

Converts the 4 bytes at offset 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.

See also
fromUInt()

◆ toUInt() [3/3]

unsigned int TagLib::ByteVector::toUInt ( unsigned int  offset,
unsigned int  length,
bool  mostSignificantByteFirst = true 
) const

Converts the length bytes at offset of the vector to an unsigned integer.

If length is larger than 4, the excess is ignored.

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.

See also
fromUInt()

◆ toUShort() [1/2]

unsigned short TagLib::ByteVector::toUShort ( bool  mostSignificantByteFirst = true) const

Converts the first 2 bytes of the vector to a unsigned 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.

See also
fromShort()

◆ toUShort() [2/2]

unsigned short TagLib::ByteVector::toUShort ( unsigned int  offset,
bool  mostSignificantByteFirst = true 
) const

Converts the 2 bytes at offset of the vector to a unsigned 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.

See also
fromShort()

Friends And Related Function Documentation

◆ operator<<()

TAGLIB_EXPORT std::ostream & operator<< ( std::ostream &  s,
const TagLib::ByteVector v 
)
related

Streams the ByteVector v to the output stream s.

Member Data Documentation

◆ null

ByteVector TagLib::ByteVector::null
static

A static, empty ByteVector which is convenient and fast (since returning an empty or "null" value does not require instantiating a new ByteVector).

Warning
Do not modify this variable. It will mess up the internal state of TagLib.
Deprecated:

The documentation for this class was generated from the following file: