1
/***************************************************************************
2
copyright : (C) 2002 - 2008 by Scott Wheeler
3
email : wheeler@kde.org
4
***************************************************************************/
6
/***************************************************************************
7
* This library is free software; you can redistribute it and/or modify *
8
* it under the terms of the GNU Lesser General Public License version *
9
* 2.1 as published by the Free Software Foundation. *
11
* This library is distributed in the hope that it will be useful, but *
12
* WITHOUT ANY WARRANTY; without even the implied warranty of *
13
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU *
14
* Lesser General Public License for more details. *
16
* You should have received a copy of the GNU Lesser General Public *
17
* License along with this library; if not, write to the Free Software *
18
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 *
21
* Alternatively, this file is available under the Mozilla Public *
22
* License Version 1.1. You may obtain a copy of the License at *
23
* http://www.mozilla.org/MPL/ *
24
***************************************************************************/
26
#ifndef TAGLIB_BYTEVECTOR_H
27
#define TAGLIB_BYTEVECTOR_H
30
#include "taglib_export.h"
40
* This class provides a byte vector with some methods that are useful for
41
* tagging purposes. Many of the search functions are tailored to what is
42
* useful for finding tag related paterns in a data array.
45
class TAGLIB_EXPORT ByteVector
48
#ifndef DO_NOT_DOCUMENT
49
typedef std::vector<char>::iterator Iterator;
50
typedef std::vector<char>::const_iterator ConstIterator;
54
* Constructs an empty byte vector.
59
* Construct a vector of size \a size with all values set to \a value by
62
ByteVector(uint size, char value = 0);
65
* Contructs a byte vector that is a copy of \a v.
67
ByteVector(const ByteVector &v);
70
* Contructs a byte vector that contains \a c.
75
* Constructs a byte vector that copies \a data for up to \a length bytes.
77
ByteVector(const char *data, uint length);
80
* Constructs a byte vector that copies \a data up to the first null
81
* byte. The behavior is undefined if \a data is not null terminated.
82
* This is particularly useful for constructing byte arrays from string
85
ByteVector(const char *data);
88
* Destroys this ByteVector instance.
90
virtual ~ByteVector();
93
* Sets the data for the byte array using the first \a length bytes of \a data
95
ByteVector &setData(const char *data, uint length);
98
* Sets the data for the byte array copies \a data up to the first null
99
* byte. The behavior is undefined if \a data is not null terminated.
101
ByteVector &setData(const char *data);
104
* Returns a pointer to the internal data structure.
106
* \warning Care should be taken when modifying this data structure as it is
107
* easy to corrupt the ByteVector when doing so. Specifically, while the
108
* data may be changed, its length may not be.
113
* Returns a pointer to the internal data structure which may not be modified.
115
const char *data() const;
118
* Returns a byte vector made up of the bytes starting at \a index and
119
* for \a length bytes. If \a length is not specified it will return the bytes
120
* from \a index to the end of the vector.
122
ByteVector mid(uint index, uint length = 0xffffffff) const;
125
* This essentially performs the same as operator[](), but instead of causing
126
* a runtime error if the index is out of bounds, it will return a null byte.
128
char at(uint index) const;
131
* Searches the ByteVector for \a pattern starting at \a offset and returns
132
* the offset. Returns -1 if the pattern was not found. If \a byteAlign is
133
* specified the pattern will only be matched if it starts on a byte divisible
134
* by \a byteAlign (starting from \a offset).
136
int find(const ByteVector &pattern, uint offset = 0, int byteAlign = 1) const;
139
* Searches the ByteVector for \a pattern starting from either the end of the
140
* vector or \a offset and returns the offset. Returns -1 if the pattern was
141
* not found. If \a byteAlign is specified the pattern will only be matched
142
* if it starts on a byte divisible by \a byteAlign (starting from \a offset).
144
int rfind(const ByteVector &pattern, uint offset = 0, int byteAlign = 1) const;
147
* Checks to see if the vector contains the \a pattern starting at position
148
* \a offset. Optionally, if you only want to search for part of the pattern
149
* you can specify an offset within the pattern to start from. Also, you can
150
* specify to only check for the first \a patternLength bytes of \a pattern with
151
* the \a patternLength argument.
153
bool containsAt(const ByteVector &pattern, uint offset, uint patternOffset = 0, uint patternLength = 0xffffffff) const;
156
* Returns true if the vector starts with \a pattern.
158
bool startsWith(const ByteVector &pattern) const;
161
* Returns true if the vector ends with \a pattern.
163
bool endsWith(const ByteVector &pattern) const;
166
* Replaces \a pattern with \a with and returns a reference to the ByteVector
167
* after the operation. This \e does modify the vector.
169
ByteVector &replace(const ByteVector &pattern, const ByteVector &with);
172
* Checks for a partial match of \a pattern at the end of the vector. It
173
* returns the offset of the partial match within the vector, or -1 if the
174
* pattern is not found. This method is particularly useful when searching for
175
* patterns that start in one vector and end in another. When combined with
176
* startsWith() it can be used to find a pattern that overlaps two buffers.
178
* \note This will not match the complete pattern at the end of the string; use
179
* endsWith() for that.
181
int endsWithPartialMatch(const ByteVector &pattern) const;
184
* Appends \a v to the end of the ByteVector.
186
ByteVector &append(const ByteVector &v);
194
* Returns the size of the array.
199
* Resize the vector to \a size. If the vector is currently less than
200
* \a size, pad the remaining spaces with \a padding. Returns a reference
201
* to the resized vector.
203
ByteVector &resize(uint size, char padding = 0);
206
* Returns an Iterator that points to the front of the vector.
211
* Returns a ConstIterator that points to the front of the vector.
213
ConstIterator begin() const;
216
* Returns an Iterator that points to the back of the vector.
221
* Returns a ConstIterator that points to the back of the vector.
223
ConstIterator end() const;
226
* Returns true if the vector is null.
228
* \note A vector may be empty without being null.
234
* Returns true if the ByteVector is empty.
239
bool isEmpty() const;
242
* Returns a CRC checksum of the byte vector's data.
244
uint checksum() const;
247
* Converts the first 4 bytes of the vector to an unsigned integer.
249
* If \a mostSignificantByteFirst is true this will operate left to right
250
* evaluating the integer. For example if \a mostSignificantByteFirst is
251
* true then $00 $00 $00 $01 == 0x00000001 == 1, if false, $01 00 00 00 ==
256
uint toUInt(bool mostSignificantByteFirst = true) const;
259
* Converts the first 2 bytes of the vector to a short.
261
* If \a mostSignificantByteFirst is true this will operate left to right
262
* evaluating the integer. For example if \a mostSignificantByteFirst is
263
* true then $00 $01 == 0x0001 == 1, if false, $01 00 == 0x01000000 == 1.
267
short toShort(bool mostSignificantByteFirst = true) const;
270
* Converts the first 8 bytes of the vector to a (signed) long long.
272
* If \a mostSignificantByteFirst is true this will operate left to right
273
* evaluating the integer. For example if \a mostSignificantByteFirst is
274
* true then $00 00 00 00 00 00 00 01 == 0x0000000000000001 == 1,
275
* if false, $01 00 00 00 00 00 00 00 == 0x0100000000000000 == 1.
279
long long toLongLong(bool mostSignificantByteFirst = true) const;
282
* Creates a 4 byte ByteVector based on \a value. If
283
* \a mostSignificantByteFirst is true, then this will operate left to right
284
* in building the ByteVector. For example if \a mostSignificantByteFirst is
285
* true then $00 00 00 01 == 0x00000001 == 1, if false, $01 00 00 00 ==
290
static ByteVector fromUInt(uint value, bool mostSignificantByteFirst = true);
293
* Creates a 2 byte ByteVector based on \a value. If
294
* \a mostSignificantByteFirst is true, then this will operate left to right
295
* in building the ByteVector. For example if \a mostSignificantByteFirst is
296
* true then $00 01 == 0x0001 == 1, if false, $01 00 == 0x0100 == 1.
300
static ByteVector fromShort(short value, bool mostSignificantByteFirst = true);
303
* Creates a 8 byte ByteVector based on \a value. If
304
* \a mostSignificantByteFirst is true, then this will operate left to right
305
* in building the ByteVector. For example if \a mostSignificantByteFirst is
306
* true then $00 00 00 01 == 0x0000000000000001 == 1, if false,
307
* $01 00 00 00 00 00 00 00 == 0x0100000000000000 == 1.
311
static ByteVector fromLongLong(long long value, bool mostSignificantByteFirst = true);
314
* Returns a ByteVector based on the CString \a s.
316
static ByteVector fromCString(const char *s, uint length = 0xffffffff);
319
* Returns a const refernence to the byte at \a index.
321
const char &operator[](int index) const;
324
* Returns a reference to the byte at \a index.
326
char &operator[](int index);
329
* Returns true if this ByteVector and \a v are equal.
331
bool operator==(const ByteVector &v) const;
334
* Returns true if this ByteVector and \a v are not equal.
336
bool operator!=(const ByteVector &v) const;
339
* Returns true if this ByteVector and the null terminated C string \a s
340
* contain the same data.
342
bool operator==(const char *s) const;
345
* Returns true if this ByteVector and the null terminated C string \a s
346
* do not contain the same data.
348
bool operator!=(const char *s) const;
351
* Returns true if this ByteVector is less than \a v. The value of the
352
* vectors is determined by evaluating the character from left to right, and
353
* in the event one vector is a superset of the other, the size is used.
355
bool operator<(const ByteVector &v) const;
358
* Returns true if this ByteVector is greater than \a v.
360
bool operator>(const ByteVector &v) const;
363
* Returns a vector that is \a v appended to this vector.
365
ByteVector operator+(const ByteVector &v) const;
368
* Copies ByteVector \a v.
370
ByteVector &operator=(const ByteVector &v);
373
* Copies ByteVector \a v.
375
ByteVector &operator=(char c);
378
* Copies ByteVector \a v.
380
ByteVector &operator=(const char *data);
383
* A static, empty ByteVector which is convenient and fast (since returning
384
* an empty or "null" value does not require instantiating a new ByteVector).
386
static ByteVector null;
390
* If this ByteVector is being shared via implicit sharing, do a deep copy
391
* of the data and separate from the shared members. This should be called
392
* by all non-const subclass members.
397
class ByteVectorPrivate;
398
ByteVectorPrivate *d;
404
* \relates TagLib::ByteVector
405
* Streams the ByteVector \a v to the output stream \a s.
407
TAGLIB_EXPORT std::ostream &operator<<(std::ostream &s, const TagLib::ByteVector &v);
added
removed
Frameworks/taglib/taglib/taglib/toolkit/tbytevector.h
