/*
* ReAppenders.cpp
- *
+ *
* License: Public Domain
* You can use and modify this file without any restriction.
* Do what you want.
* @param append <code>true</code>the buffer will not truncated before storage
* @return <code>buffer</code> (for chaining)
*/
-ReByteBuffer& ReMemoryAppender::join(ReByteBuffer& buffer, bool append) {
- ReByteBuffer current;
+ReByteArray& ReMemoryAppender::join(ReByteArray& buffer, bool append) {
+ ReByteArray current;
if (!append)
buffer.setLength(0);
for (int ix = count() - 1; ix >= 0; ix--) {
* @param message the logging message to store
*/
void ReSlaveAppender::say(ReLogger* logger, const char* message) {
- ReByteBuffer buffer(logger->standardPrefix(m_charPrefix));
+ ReByteArray buffer(logger->standardPrefix(m_charPrefix));
buffer.append(message == NULL ? logger->asCString() : message);
m_masterLogger->say(logger->currentMode(), 0, buffer.str());
}
/*
* ReAppenders.hpp
- *
+ *
* License: Public Domain
* You can use and modify this file without any restriction.
* Do what you want.
ReMemoryAppender(int maxLines);
~ReMemoryAppender();
public:
- ReByteBuffer& join(ReByteBuffer& buffer, bool append = false);
+ ReByteArray& join(ReByteArray& buffer, bool append = false);
virtual void say(ReLogger* logger, const char* message);
protected:
int m_maxLines;
/*
* ReBaseUtils.cpp
- *
+ *
* License: Public Domain
* You can use and modify this file without any restriction.
* Do what you want.
/*
* ReBaseUtils.hpp
- *
+ *
* License: Public Domain
* You can use and modify this file without any restriction.
* Do what you want.
--- /dev/null
+/*
+ * ReByteArray.cpp
+ *
+ * License: Public Domain
+ * You can use and modify this file without any restriction.
+ * Do what you want.
+ * No warranties and disclaimer of any damages.
+ * You also can use this license: http://www.wtfpl.net
+ * The latest sources: https://github.com/republib
+ */
+
+#include "base/rebase.hpp"
+
+#ifdef __linux__
+extern void* memcpy(void* dest, const void* src, size_t n);
+extern void* memmove(void* dest, const void* src, size_t n);
+extern int _memcmp (const void* s1, const void* s2, size_t n);
+extern int _snprintf(char* s, size_t maxlen, const char* format, ...);
+#endif
+
+/** @brief Constructor.
+ *
+ * @param delta If a new storage must be allocated the size
+ * is incremented by at least this count of bytes
+ */
+ReByteArray::ReByteArray(size_t delta) :
+ // m_primaryBuffer
+ m_delta(delta),
+ m_buffer(m_primaryBuffer),
+ m_length(0),
+ m_capacity(sizeof m_primaryBuffer - 1),
+ m_reallocation(0) {
+ m_buffer[0] = '\0';
+}
+/** @brief Constructor.
+ *
+ * @param source the instance to copy (C string)
+ */
+ReByteArray::ReByteArray(const char* source) :
+ // m_primaryBuffer
+ m_delta(PRIMARY_BUFFER_SIZE),
+ m_buffer(m_primaryBuffer),
+ m_length(0),
+ m_capacity(sizeof m_primaryBuffer),
+ m_reallocation(0) {
+ m_buffer[0] = '\0';
+ if (source != NULL)
+ append(source);
+}
+
+/** @brief Constructor.
+ *
+ * @param source The byte sequence to copy
+ * @param sourceLength length of <code>source</code>
+ */
+ReByteArray::ReByteArray(const Byte* source, size_t sourceLength) :
+ // m_primaryBuffer
+ m_delta(PRIMARY_BUFFER_SIZE),
+ m_buffer(m_primaryBuffer),
+ m_length(0),
+ m_capacity(sizeof m_primaryBuffer - 1),
+ m_reallocation(0) {
+ m_buffer[0] = '\0';
+ append(source, sourceLength);
+}
+
+/** @brief Destructor.
+ *
+ */
+ReByteArray::~ReByteArray() {
+ if (m_buffer != m_primaryBuffer)
+ delete[] m_buffer;
+ m_buffer = NULL;
+ m_capacity = 0;
+ m_length = 0;
+}
+/** @brief Copy constructor.
+ *
+ * @param source the instance to copy
+ */
+ReByteArray::ReByteArray(const ReByteArray& source) :
+ // m_primaryBuffer
+ m_delta(source.delta()),
+ m_buffer(m_primaryBuffer),
+ m_length(0),
+ m_capacity(sizeof m_primaryBuffer),
+ m_reallocation(0) {
+ append(source.buffer(), source.length());
+}
+
+/** @brief The assignment operator.
+ *
+ * @param source the instance to copy
+ *
+ * @return the instance itself
+ */
+ReByteArray& ReByteArray::operator =(const ReByteArray& source) {
+ m_delta = source.delta();
+ set(source.buffer(), source.length());
+ return *this;
+}
+
+/** @brief Appends a byte sequence at the end of the buffer.
+ *
+ * If the space is not enough it will be allocated.
+ *
+ * <pre><code>Example:
+ * ReByteBuffer buf;
+ * assert(4 == buf.append("abc", 3).append("x").getLength());
+ * </code></pre>
+ *
+ * @param source the sequence to append
+ * @param length the length of the sequence
+ *
+ * @return *this (for chaining)
+ */
+ReByteArray& ReByteArray::append(const Byte* source, size_t length) {
+ if (source != NULL) {
+ if (length == (size_t) -1)
+ length = strlen(source);
+ ensureSize(m_length + length);
+ memcpy((void*) (m_buffer + m_length), source, length);
+ m_length += length;
+ m_buffer[m_length] = '\0';
+ }
+ return *this;
+}
+/** @brief Appends the content of another <code>ReByteBuffer</code> instance at the end of the buffer.
+ *
+ * If the space is not enough it will be allocated.
+ *
+ * <pre><code>Example:
+ * ReByteBuffer name; name.append("mydoc");
+ * ReByteBuffer ext; ext.append(".txt");
+ * name.append(ext);
+ * assert("mydoc.txt", name.getBuffer());
+ * </code></pre>
+ *
+ * @return *this (for chaining)
+ */
+ReByteArray& ReByteArray::append(const ReByteArray& source) {
+ return append(source.str(), source.length());
+}
+
+/** @brief Appends a floaating point number at the end of the buffer.
+ *
+ * If the space is not enough it will be allocated.
+ *
+ * <pre><code>Example:
+ * ReByteBuffer buf; buf.append("amount: ").append(377 / 100.0, "%5.2f");
+ * assert("amount: 3.77", buf.str());
+ * </code></pre>
+ *
+ * @return *this (for chaining)
+ */
+ReByteArray& ReByteArray::append(double value, const char* format) {
+ char buffer[256];
+
+ _snprintf(buffer, sizeof buffer, format, value);
+ append(buffer, -1);
+ return *this;
+}
+
+/**
+ * Appends a string with minimal/maximal length.
+ *
+ * If the length is greater than the maximal length the string will be cutted
+ * (in the middle) and a separator will set at the cut.
+ *
+ * <pre>Example:
+ * <code>buffer.appendFix("sammy2", -1, 5, 5, "*").appendFix("x", 1, 99, -3);
+ * </code>
+ * Buffer contains: "sa*y2 x"
+ * </pre>
+ *
+ * @param data data to append
+ * @param length length of <code>data</code>. -1: <code>strlen(data)</code>
+ * @param maxLength the stored length is at most this value
+ * @param minLength if the length is smaller padding characters will be added<br>
+ * < 0: padding is done at the top
+ * @param separator NULL or the string used at the separaration point
+ * @param padding character used for padding (see <code>minLength</code>)
+ * @return <code>*this</code> (for chaining)
+ */
+ReByteArray& ReByteArray::appendFix(const char* data, size_t length,
+ int maxLength, int minLength, const char* separator, char padding) {
+ if (length == (size_t) -1)
+ length = strlen(data);
+ if ((int) length < abs(minLength)) {
+ ensureSize(m_length + abs(minLength));
+ if (minLength < 0)
+ appendChar(padding, -minLength - length);
+ append(data, length);
+ if (minLength > 0)
+ appendChar(padding, minLength - length);
+ } else if ((int) length > maxLength) {
+ ensureSize(m_length + maxLength);
+ int sepLength = separator == NULL ? 0 : strlen(separator);
+ int lengthPart1 = (maxLength - sepLength + 1) / 2;
+ int lengthPart2 = maxLength - sepLength - lengthPart1;
+ append(data, lengthPart1);
+ if (sepLength > 0)
+ append(separator, sepLength);
+ append(data + length - lengthPart2, lengthPart2);
+ } else {
+ append(data, length);
+ }
+ return *this;
+}
+
+/**
+ * Appends data as string or as binary (hexdump).
+ *
+ * If data contains non ASCII char the data will be treated as binary.
+ *
+ * @param data the data to append
+ * @param length -1 (<code>strlen()</code>) or the length of data
+ * @param maxLength the maximal count of appended chars
+ * @return <code>*this</code> (chaining)
+ */
+ReByteArray& ReByteArray::appendDump(const char* data, size_t length,
+ int maxLength) {
+ if (length == size_t(-1)) {
+ length = strlen(data);
+ }
+ if ((int) length > maxLength)
+ length = maxLength;
+ // test if text or binary:
+ bool isBinary = false;
+ unsigned char cc;
+ for (size_t ii = 0; ii < length; ii++) {
+ if ((cc = (unsigned char) data[ii]) > 126
+ || (cc < ' ' && cc != '\n' && cc != '\r' && cc != '\t')) {
+ isBinary = true;
+ break;
+ }
+ }
+ if (!isBinary)
+ append(data, length);
+ else
+ appendHexDump(data, min(length, maxLength / 5)).reduceLength();
+ return *this;
+}
+/**
+ * Appends a hexadecimal dump of a memory array.
+ *
+ * <pre>Example:
+ * <code>buffer.appendHex("01234567890abcde", -1, 0x10, 16, "%0x8x", 1, -1, " | ");
+ * </code>
+ * Buffer contains:
+ * 00000010 30 31 32 33 34 35 36 37 38 39 30 61 62 63 64 65 | 01234567890abcde
+ * </pre>
+ *
+ * @param data data to dump
+ * @param length length of <code>data</code>. -1: <code>strlen(data)</code>
+ * @param offset a format which is used to append a preceeding position
+ * of source. NULL: no offset is appended
+ * @param bytesPerLine number of bytes in one line. If length is greater more
+ * lines are appended
+ * @param offsetFormat NULL or the sprintf format of the offset, e.g. "0x04x "
+ * @param withAscii <code>true</code>: the data is interpreted as ASCII too
+ * @param groupWidth behind <code>groupWidth</code> hex bytes a ' ' is appended
+ * @param gapBehind behind <code>gapBehind</code> hex bytes a ' ' is appended<br>
+ * -1: <code>bytePerLine / 2</code>
+ * @param separator NULL or a string between hex area and ASCII area
+ * @return <code>*this</code> (for chaining)
+ */
+ReByteArray& ReByteArray::appendHexDump(const char* data, size_t length,
+ int offset, int bytesPerLine, const char* offsetFormat, bool withAscii,
+ int groupWidth, int gapBehind, const char* separator) {
+ if (length == (size_t) -1)
+ length = strlen(data);
+ if (gapBehind < 0)
+ gapBehind = bytesPerLine / 2;
+ ensureSize(32);
+ int offsetLength = 0;
+ if (offsetFormat != NULL) {
+ _snprintf(m_buffer, 31, offsetFormat, offset + length);
+ offsetLength = strlen(m_buffer);
+ }
+ ensureSize(
+ (length + bytesPerLine - 1) / bytesPerLine
+ * (4 + offsetLength
+ + (gapBehind <= 0 ? 0 : bytesPerLine / gapBehind + 1)
+ + (separator == NULL ? 0 : strlen(separator)) + 1));
+ while (length > 0) {
+ if (offsetFormat != NULL)
+ appendInt(offset, offsetFormat);
+ int ix;
+ for (ix = 0; ix < bytesPerLine; ix++) {
+ if (ix < (int) length)
+ appendInt((unsigned char) data[ix], "%02x");
+ else
+ append(" ");
+ if (ix < bytesPerLine - 1
+ && (groupWidth == 1 || ix % groupWidth == groupWidth - 1))
+ appendChar(' ');
+ if (ix < bytesPerLine - 1 && gapBehind > 0
+ && (gapBehind == 1 || ix % gapBehind == gapBehind - 1))
+ appendChar(' ');
+ }
+ if (withAscii) {
+ if (separator != NULL)
+ append(separator, -1);
+ char cc;
+ for (ix = 0; ix < bytesPerLine; ix++) {
+ if (ix < (int) length)
+ appendInt((cc = data[ix]) < ' ' || cc > 127 ? '.' : cc,
+ "%c");
+ else
+ append(" ");
+ if (ix < bytesPerLine - 1 && gapBehind > 0
+ && (gapBehind == 1 || ix % gapBehind == gapBehind - 1))
+ append(" ", 1);
+ }
+ appendChar('\n');
+ length =
+ length <= (size_t) bytesPerLine ? 0 : length - bytesPerLine;
+ data += bytesPerLine;
+ offset += bytesPerLine;
+ }
+ }
+ return *this;
+}
+
+/** @brief Appends an integer as string at the end of the buffer.
+ *
+ * If the space is not enough it will be allocated.
+ *
+ * <pre><code>Example:
+ * ReByteBuffer buf; buf.appendInt(33, "%-4d");
+ * assert(strcmp("33 ", buf.str()) == 0);
+ * </code></pre>
+ *
+ * @param number the number to append
+ * @param format the format of the number used by <code>sprintf()</code>
+ *
+ * @return *this (for chaining)
+ */
+ReByteArray& ReByteArray::appendInt(int number, const char* format) {
+ char buffer[128];
+
+ _snprintf(buffer, sizeof buffer, format, number);
+ append(buffer, -1);
+ return *this;
+}
+
+/** @brief Appends an integer as string at the end of the buffer.
+ *
+ * If the space is not enough it will be allocated.
+ *
+ * <pre><code>Example:
+ * ReByteBuffer buf; buf.appendInt(33U, "%x");
+ * assert(strcmp("21 ", buf.str()) == 0);
+ * </code></pre>
+ *
+ * @param number the number to append
+ * @param format the format of the number used by <code>sprintf()</code>
+ *
+ * @return *this (for chaining)
+ */
+ReByteArray& ReByteArray::appendInt(unsigned int number, const char* format) {
+ char buffer[128];
+
+ _snprintf(buffer, sizeof buffer, format, number);
+ append(buffer, -1);
+ return *this;
+}
+
+/** @brief Appends an integer as string at the end of the buffer.
+ *
+ * If the space is not enough it will be allocated.
+ *
+ * <pre><code>Example:
+ * ReByteBuffer buf; buf.appendInt(12345678901ll, "%12d");
+ * assert(strcmp(" 12345678901", buf.str()) == 0);
+ * </code></pre>
+ *
+ * @param number the number to append
+ * @param format the format of the number used by <code>sprintf()</code>
+ *
+ * @return *this (for chaining)
+ */
+ReByteArray& ReByteArray::appendInt(int64_t number, const char* format) {
+ char buffer[256];
+
+ _snprintf(buffer, sizeof buffer, format, number);
+ append(buffer, -1);
+ return *this;
+}
+
+/** @brief Appends an integer as string at the end of the buffer.
+ *
+ * If the space is not enough it will be allocated.
+ *
+ * <pre><code>Example:
+ * ReByteBuffer buf; buf.appendInt((uint64_t) 0x12345678901ll, "%12x");
+ * assert(strcmp(" 12345678901", buf.str()) == 0);
+ * </code></pre>
+ *
+ * @param number the number to append
+ * @param format the format of the number used by <code>sprintf()</code>
+ *
+ * @return *this (for chaining)
+ */
+ReByteArray& ReByteArray::appendInt(uint64_t number, const char* format) {
+ char buffer[256];
+
+ _snprintf(buffer, sizeof buffer, format, number);
+ append(buffer, -1);
+ return *this;
+}
+
+/** @brief Appends a time (given in milli seconds) as 'dd:HH:MM.mmm'.
+ *
+ * @param time the time (duration) in msec
+ * @param minLength > 5: seconds will be 2 digits (preceeding '0' if needed)<br>
+ * > 6: at least MM:SS.sss<br>
+ * > 9: at least HH:MM:SS.sss<br>
+ * > 12: at least dd:HH:MM:SS.sss<br>
+ * @return <code>buffer</code> (for chaining)
+ */
+ReByteArray& ReByteArray::appendMilliSec(int time, int minLength) {
+ int days = time / (24 * 3600 * 1000LL);
+ time %= 24 * 3600 * 1000;
+ int expectedLength = days > 0 ? 12 : 0;
+ int hours = time / (3600 * 1000);
+ time %= 3600 * 1000;
+ if (hours > 0 && expectedLength == 0)
+ expectedLength = 9;
+ int minutes = time / (60 * 1000);
+ time %= 60 * 1000;
+ if (minutes > 0 && expectedLength == 0)
+ expectedLength = 5;
+ int minimum = minLength > expectedLength ? minLength : expectedLength;
+ int sec = time / 1000;
+ int msec = time % 1000;
+ static const char* stdFormat = "%02d";
+ if (days > 0 || minimum > 12)
+ appendInt(days).append(":");
+ if (hours > 0 || minimum > 9)
+ appendInt(hours, stdFormat).append(":");
+ if (minutes > 0 || minimum > 6)
+ appendInt(minutes, stdFormat).append(":");
+ appendInt(sec, sec > 10 || minimum > 5 ? stdFormat : "%d").append(".");
+ appendInt(msec, "%03d");
+ return *this;
+}
+
+/** @brief Appends a time (given in milli seconds) as 'dd:HH:MM.mmm'.
+ *
+ * @param time the time (duration) in msec
+ * @param minLength > 3: seconds will be 2 digits (preceeding '0' if needed)<br>
+ * > 4: at least MM:SS.sss<br>
+ * > 7: at least HH:MM:SS.sss<br>
+ * > 10: at least dd:HH:MM:SS<br>
+ * @return <code>buffer</code> (for chaining)
+ */
+ReByteArray& ReByteArray::appendTime(int time, int minLength) {
+ int days = time / (24 * 3600);
+ time %= 24 * 3600;
+ int expectedLength = days > 0 ? 10 : 0;
+ int hours = time / 3600;
+ time %= 3600;
+ if (hours > 0 && expectedLength == 0)
+ expectedLength = 7;
+ int minutes = time / 60;
+ time %= 60;
+ if (minutes > 0 && expectedLength == 0)
+ expectedLength = 3;
+ int minimum = minLength > expectedLength ? minLength : expectedLength;
+ int sec = time;
+ static const char* stdFormat = "%02d";
+ if (days > 0 || minimum > 10)
+ appendInt(days).append(":");
+ if (hours > 0 || minimum > 7)
+ appendInt(hours, stdFormat).append(":");
+ if (minutes > 0 || minimum > 4)
+ appendInt(minutes, stdFormat).append(":");
+ appendInt(sec, sec > 10 || minimum > 3 ? stdFormat : "%d");
+ return *this;
+}
+
+/** Converts a subsequence into an integer.
+ *
+ * The number may be a decimal or a hexadecimal number. Hex numbers start with 0x.
+ * <pre><code>Example:
+ * ReByteBuffer buf;
+ * buf.set("abc123", 6);
+ * assert(12 == buf.atoi(3, 3 + 2));
+ * </code></pre>
+ *
+ * @param start the first index to convert
+ * @param end -1: all found digits will be converted
+ * Otherwise: the maximal number of digits to convert
+ */
+int ReByteArray::atoi(size_t start, int end) const {
+ int rc = 0;
+ if (start < m_length) {
+ if (end < 0)
+ end = m_length;
+ char cc;
+ if (m_buffer[start] == '0' && tolower(m_buffer[start + 1]) == 'x') {
+ // Hexadecimal number:
+ start += 2;
+ while (start < (size_t) end && (cc = m_buffer[start++]) >= '0'
+ && isxdigit(cc))
+ rc = rc * 16 + (cc <= '9' ? cc - '0' : toupper(cc) - 'A' + 10);
+ } else {
+ // Decimal number:
+ while (start < (size_t) end && (cc = m_buffer[start++]) >= '0'
+ && cc <= '9')
+ rc = rc * 10 + cc - '0';
+ }
+ }
+ return rc;
+}
+
+/**
+ * Counts the occurrencies of a given byte sequence.
+ *
+ * @param toCount the byte sequence to count
+ * @param lengthOfToCount -1: length is <code>strlen(toCount)</count><br>
+ * otherwise: length of <code>toCount</count>
+ */
+int ReByteArray::count(const char* toCount, size_t lengthToCount) {
+ int rc = 0;
+ size_t start = 0;
+ if (lengthToCount == (size_t) -1)
+ lengthToCount = strlen(toCount);
+ while ((start = indexOf(toCount, lengthToCount, start)) != (size_t) -1) {
+ rc++;
+ start += lengthToCount;
+ }
+ return rc;
+}
+
+/**
+ * Tests whether the buffer ends with a given a byte sequence.
+ *
+ * @param tail the byte sequence to test
+ * @param tailLength -1: <code>strlen(tail)</code><br>
+ * otherwise: the length of <code>tail</code>
+ * @param ignoreCase <code>true</code>: the comparison is case insensitive<br>
+ * <code>false</code>: the comparison is case sensitive<br>
+ * @return <code>true</code>: the buffer ends with <code>tail</code><br>
+ * <code>false</code>: otherwise
+ */
+bool ReByteArray::endsWith(const Byte* tail, size_t tailLength,
+ bool ignoreCase) const {
+ bool rc = tail != NULL;
+ if (rc) {
+ if (tailLength == (size_t) -1)
+ tailLength = strlen(tail);
+ rc = indexOf(tail, tailLength, m_length - tailLength, m_length,
+ ignoreCase) >= 0;
+ }
+ return rc;
+}
+
+/** @brief Ensures that there is enough space.
+ *
+ * If not it will be allocated and the old value will be copied.
+ *
+ * A new allocation will be use at least <code>m_delta</code> bytes.
+ * The allocated space is incremented by one because of the ending '\\0'.
+ *
+ * @param size the size will be at least this value
+ */
+void ReByteArray::ensureSize(size_t size) {
+ if (m_capacity < size) {
+ int delta =
+ m_delta > 0 ? m_delta :
+ (int) m_capacity < -m_delta / 2 ? (int) 2 * m_capacity : -m_delta;
+ if (int(size - m_capacity) < delta)
+ size = m_capacity + delta;
+ // Think for the ending '\0':
+ Byte* buffer = new Byte[size + 1];
+ assert(buffer != NULL);
+ if (m_length > 0)
+ memcpy(buffer, m_buffer, m_length);
+ buffer[m_length] = '\0';
+ if (m_buffer != m_primaryBuffer)
+ delete[] m_buffer;
+ m_buffer = buffer;
+ m_capacity = size;
+ m_reallocation++;
+ }
+}
+/**
+ * @brief Fills a part of the buffer with a given character.
+ *
+ * @param filler the byte which is used as filler
+ * @param start the first index to fill. <code>0 <= start < m_length</code>
+ * @param end the index behind the last filled position. May be behind m_length
+ * @return the instance itself (vor chaining)
+ */
+ReByteArray& ReByteArray::fill(Byte filler, int start, int end) {
+ if (end == -1)
+ end = m_length;
+ if (start >= 0 && start < end) {
+ if (end > (int) m_length)
+ setLength(end);
+ memset(m_buffer + start, filler, end - start);
+ }
+ return *this;
+}
+
+/** @brief Checks for the index of the first different byte.
+ *
+ * @param source source to inspect
+ * @param length -1 or the length of <code>source</code>
+ * @param start the first index to inspect
+ * @param ignoreCase <code>true</code>: the comparison is case insensitive
+ * @return -1: both byte sequences are equal<br>
+ * otherwise: the index of the first difference
+ */
+int ReByteArray::firstDifference(const Byte* source, size_t length, int start,
+ bool ignoreCase) {
+ int rc = -1;
+ if (start < 0)
+ rc = 0;
+ else if (start < (int) m_length) {
+ if (length == (size_t) -1)
+ length = strlen(source);
+ int count = length > m_length - start ? m_length - start : length;
+ const Byte* ptr = m_buffer + start;
+ for (int ix = 0; rc < 0 && ix < count; ix++) {
+ if ((!ignoreCase && *ptr++ != *source++)
+ || (ignoreCase && (tolower(*ptr++) != tolower(*source++))))
+ rc = start + ix;
+ }
+ if (rc < 0 && length > m_length - start)
+ rc = start + count;
+ }
+ return rc;
+}
+
+/** @brief Searches for a byte sequence in the internal buffer.
+ *
+ * Finds the first occurrence of a byte sequence in a given range.
+ *
+ * <pre><code>Example:
+ * ReByteBuffer buf;
+ * buf.set("12abc123", 8);
+ * assert(5 == buf.indexOf("12", -1, 3));
+ * </code></pre>
+ *
+ * @param toFind the sequence to find
+ * @param toFindLength Length of <code>toFind</code>,
+ * If -1 the <code>strlen(toFind)</code> will be taken
+ * @param start the search respects the indices in the range [start, end[
+ * @param end -1: no upper limit to search<br>
+ * otherwise: the first index above the search range
+ * @param ignoreCase <code>true</code>: case insensitive search<br>
+ * <code>true</code>: case sensitive search
+ * @return -1: the sequence could not be found.
+ * Otherwise: the index of <code>toFind</code> in the internal buffer
+ */
+int ReByteArray::indexOf(const Byte* toFind, size_t toFindLength, int start,
+ int end, bool ignoreCase) const {
+ if (toFindLength == (size_t) -1)
+ toFindLength = strlen(toFind);
+ int rc = -1;
+ if (end < 0 || end > (int) m_length)
+ end = m_length;
+ if (start >= 0 && start <= int(m_length - toFindLength)
+ && end >= (int) toFindLength && end <= (int) m_length) {
+ while (rc < 0 && start <= int(end - toFindLength)) {
+ if (ignoreCase ?
+ _memicmp((void*) toFind, (void*) (m_buffer + start),
+ toFindLength) == 0 :
+ _memcmp(toFind, m_buffer + start, toFindLength) == 0)
+ rc = start;
+ else
+ start++;
+ }
+ }
+ return rc;
+}
+/**
+ * Tests whether the instance is a prefix of a given string.
+ *
+ * @param source the string to inspect
+ * @param length the length of the string<br>
+ * -1: <code>strlen(source)</code>
+ * @param ignoreCase <code>true</code>: the test is case insensitive
+ * @param minLength the substring (instance) must have at least this length
+ * for a positive test
+ * @return <code>true</code>the instance is a prefix of the <code>source</code>
+ * and the length is at least <code>minLength</code> bytes
+ */
+bool ReByteArray::isPrefixOf(const char* source, size_t length,
+ bool ignoreCase, int minLength) {
+ if (length == (size_t) -1)
+ length = strlen(source);
+ bool rc = length >= m_length && m_length <= length;
+ if (rc)
+ rc = equals(source, m_length, ignoreCase);
+ return rc;
+}
+
+/** @brief Searches revers for a byte sequence in the internal buffer.
+ *
+ * Finds the last occurrence of a byte sequence in a given range.
+ *
+ * <pre><code>Example:
+ * ReByteBuffer buf;
+ * buf.set("12abc123", 8);
+ * assert(5 == buf.rindexOf("12", -1, 3));
+ * </code></pre>
+ *
+ * @param toFind the sequence to find
+ * @param toFindLength length of <code>toFind</code>.
+ * If -1 the <code>strlen(toFind)</code> will be taken
+ * @param start the search respects the indices in the range [start, end[
+ * @param end -1: no upper limit to search<br>
+ * otherwise: the first index above the search range
+ * @param ignoreCase <code>true</code>: case insensitive search<br>
+ * <code>true</code>: case sensitive search
+ * @return -1: the sequence could not be found.
+ * Otherwise: the index of <code>toFind</code> in the internal buffer
+ */
+int ReByteArray::rindexOf(const Byte* toFind, size_t toFindLength, int start,
+ int end, bool ignoreCase) const {
+ if (toFindLength == (size_t) -1)
+ toFindLength = strlen(toFind);
+ int rc = -1;
+ if (end < 0 || end > (int) m_length)
+ end = m_length;
+ if (start >= 0 && start <= int(m_length - toFindLength)
+ && end >= (int) toFindLength && end <= (int) m_length) {
+ int current = end - toFindLength;
+ while (current >= start) {
+ if (ignoreCase ?
+ _strnicmp(toFind, m_buffer + current, toFindLength) != 0 :
+ _memcmp(toFind, m_buffer + current, toFindLength) != 0)
+ current--;
+ else {
+ rc = current;
+ break;
+ }
+ }
+ }
+ return rc;
+}
+/** @brief Replaces all occurrences of <code>toFind</code> with <code>replacement</code>.
+ *
+ * A single replacement can be done with <code>splice()</code>.
+ *
+ * <pre><code>Example:
+ * ReByteBuffer buf;
+ * buf.set("12abc123", 8);
+ * buf.replaceAll("12", -1, "XYZ", -1);
+ * assert(strcmp("XYZabcXYZ3", buf.str()) == 0);
+ * </code></pre>
+ *
+ * @param toFind the substring which will be replaced
+ * @param toFindLength the length of <code>toFind</code>. -1: <code>strlen()</code> will be used
+ * @param replacement the replacement
+ * @param replacementLength the length of <code>replacement</code>. -1: <code>strlen()</code> will be used
+ * @param start the first index to inspect
+ */
+ReByteArray& ReByteArray::replaceAll(const Byte* toFind, size_t toFindLength,
+ const Byte* replacement, size_t replacementLength, int start) {
+ if (toFindLength == size_t(-1))
+ toFindLength = strlen(toFind);
+ if (replacementLength == size_t(-1))
+ replacementLength = strlen(replacement);
+
+ while ((start = indexOf(toFind, toFindLength, start)) != -1) {
+ splice(start, toFindLength, replacement, replacementLength);
+ start += replacementLength;
+ }
+ return *this;
+}
+
+/** @brief Sets the increment used to increase the capacity.
+ *
+ * @param delta > 0: reservation allocates at least this amount of bytes<br>
+ * 0: delta is set to a default value<br>
+ * < 0: the current capacity will be doubled until <code>- delta</code>
+ */
+void ReByteArray::setDelta(int delta) {
+ m_delta = delta == 0 ? PRIMARY_BUFFER_SIZE : delta;
+}
+
+/** @brief Sets the length to a given value.
+ *
+ * The new length is greater than the current size the buffer will reallocated.
+ *
+ * <pre><code>Example:
+ * ReByteBuffer buf;
+ * buf.set("123", 3);
+ * buf.setLength(5);
+ * assert(strcmp("123", buf.str()) == 0);
+ * assert(5 == buf.getLength());
+ * </code></pre>
+ *
+ * @param length the new length
+ *
+ * @return *this (for chaining)
+ */
+ReByteArray& ReByteArray::setLength(size_t length) {
+ ensureSize(length);
+ m_length = length;
+ m_buffer[length] = '\0';
+ return *this;
+}
+/** @brief Sets the length to a given value and fills the new allocated part of the buffer with a given value.
+ *
+ * The new length is greater than the current size the buffer will reallocated.
+ *
+ * <pre><code>Example:
+ * ReByteBuffer buf;
+ * buf.set("123", 3);
+ * buf.setLengthAndFill(5, 'X');
+ * assert(strcmp("123XX", buf.str()) == 0);
+ * </code></pre>
+ *
+ * @param length the new length
+ * @param filler if the new length is greater than the current length the space
+ * will be filled with this value
+ * @return *this (for chaining)
+ */
+ReByteArray& ReByteArray::setLengthAndFillOut(size_t length, Byte filler) {
+ ensureSize(length);
+ if (length > m_length)
+ memset(m_buffer + m_length, filler, length - m_length);
+ m_length = length;
+ m_buffer[length] = '\0';
+ return *this;
+}
+/** @brief Cuts a sequence from the internal buffer and inserts another.
+ *
+ * This function implies a pure insertion and pure deletion of a subsequence.
+ *
+ * <pre><code>Example:
+ * ReByteBuffer buf;
+ * buf.set("12345", 5);
+ * buf.splice(2, 2, "XYZ", 3);
+ * assert(strcmp("12XYZ5", buf.str()) == 0);
+ * </code></pre>
+ *
+ * @param ix the index where the cut/insertion takes place
+ * @param replacedLength the number of deleted bytes. If 0 a pure insertion will be done
+ * @param source the sequence to insert. May be NULL (for pure deletion)
+ * @param length the length of the inserted sequence<br>
+ * 0: a pure deletion will be done<br>
+ * -1: <code>strlen(source)</code> will be taken
+ *
+ * @return true: Success. false: <code>ix</code> out of range
+ */
+bool ReByteArray::splice(size_t ix, size_t replacedLength,
+ const ReByteArray::Byte* source, size_t length) {
+ bool rc;
+ if (ix < 0 || ix > m_length)
+ rc = false;
+ else {
+ rc = true;
+
+ if (source == NULL)
+ length = 0;
+ if (length == (size_t) -1)
+ length = strlen(source);
+ if (ix + replacedLength > m_length)
+ replacedLength = m_length - ix;
+
+ ensureSize(m_length + length - replacedLength);
+
+ Byte* start = m_buffer + ix;
+ Byte* tail = start + replacedLength;
+ size_t lengthTail = m_length - ix - replacedLength;
+
+ if (length <= replacedLength) {
+ // The sequence will not be longer:
+ if (length > 0)
+ memcpy(start, source, length);
+ if (length < replacedLength) {
+ memmove(start + length, tail, lengthTail);
+ }
+ } else {
+ // The sequence will be longer:
+ memmove(start + length, tail, lengthTail);
+ memcpy(start, source, length);
+ }
+ m_length += length - replacedLength;
+ m_buffer[m_length] = '\0';
+ }
+ return rc;
+}
+/**
+ * Tests whether the buffer starts with a given a byte sequence.
+ *
+ * @param head the byte sequence to test
+ * @param headLength -1: <code>strlen(tail)</code><br>
+ * otherwise: the length of <code>tail</code>
+ * @param ignoreCase <code>true</code>: the comparison is case insensitive<br>
+ * <code>false</code>: the comparison is case sensitive<br>
+ * @return <code>true</code>: the buffer starts with <code>head</code><br>
+ * <code>false</code>: otherwise
+ */
+bool ReByteArray::startsWith(const Byte* head, size_t headLength,
+ const bool ignoreCase) const {
+ bool rc = head != NULL;
+ if (rc) {
+ if (headLength == (size_t) -1)
+ headLength = strlen(head);
+ rc = indexOf(head, headLength, 0, headLength, ignoreCase) == 0;
+ }
+ return rc;
+}
+
+/**
+ * Appends the status data of the instance onto the buffer.
+ *
+ * @param buffer OUT: the space for the data report
+ * @param prefix NULL or a prefix of the output
+ * @return <code>buffer.str()</code> (for chaining)
+ */
+const char* ReByteArray::status(ReByteArray& buffer,
+ const char* prefix) const {
+ if (prefix != NULL)
+ buffer.append(prefix);
+ buffer.append("capacity:").appendInt(m_capacity).append(" length: ")
+ .appendInt(m_length).append(" realloc: ").appendInt(m_reallocation)
+ .append("\n");
+ return buffer.str();
+}
+
--- /dev/null
+/*
+ * ReByteArray.hpp
+ *
+ * License: Public Domain
+ * You can use and modify this file without any restriction.
+ * Do what you want.
+ * No warranties and disclaimer of any damages.
+ * You also can use this license: http://www.wtfpl.net
+ * The latest sources: https://github.com/republib
+ */
+
+#ifndef REBYTEBUFFER_H_
+#define REBYTEBUFFER_H_
+
+#define PRIMARY_BUFFER_SIZE 513
+/** @brief An efficient dynamic memory buffer.
+ *
+ * Implements a very efficient dynamic byte sequence.
+ * <p>
+ * <strong>Note:</strong><br>
+ * It is guaranteed that the sequence is terminated by a '\\0' like C strings.
+ * This end marker is outside the visible buffer.<br/>
+ * Technically: <br/>
+ * <code>ReByteBuffer buf; assert(buf.getBuffer()[buf.getLength()] == '\\0');</code>
+ * </p>
+ * <p>This class can be used as a poor man's string class.
+ * </p>
+ * <p>Very effizient:
+ * <ul>
+ * <li>Every instance contains an array (512 Bytes),
+ * which is used if not more space is needed.
+ * In many cases there is no need of heap allocation (new or malloc().</li>
+ * <li>Many of the methods are written as inlines.</li>
+ * </ul>
+ * </p>
+ */
+class ReByteArray {
+public:
+ typedef char Byte;
+public:
+ ReByteArray(size_t delta = PRIMARY_BUFFER_SIZE);
+ ReByteArray(const char* source);
+ ReByteArray(const Byte* source, size_t sourceLength);
+ virtual ~ReByteArray();
+ ReByteArray(const ReByteArray& source);
+ ReByteArray& operator =(const ReByteArray& source);
+public:
+ ReByteArray& append(const Byte* source, size_t length = -1);
+ ReByteArray& append(const ReByteArray& source);
+ ReByteArray& append(double, const char* format = "%f");
+ /** Appends a 8 bit value in an architecture independent way.
+ * @param value integer to append
+ * @return <code>*this</code> (for chaining)
+ */
+ inline ReByteArray& appendBits8(int value) {
+ setLength(m_length + 1);
+ m_buffer[m_length - 1] = (char) value;
+ return *this;
+ }
+ /** Appends a 16 bit value in an architecture independent way.
+ * @param value integer to append
+ * @return <code>*this</code> (for chaining)
+ */
+ inline ReByteArray& appendBits16(int value) {
+ setLength(m_length + 2);
+ m_buffer[m_length - 2] = char(value >> 8);
+ m_buffer[m_length - 1] = char(value);
+ return *this;
+ }
+ /** Appends a 24 bit value in an architecture independent way.
+ * @param value integer to append
+ * @return <code>*this</code> (for chaining)
+ */
+ inline ReByteArray& appendBits24(int value) {
+ setLength(m_length + 3);
+ m_buffer[m_length - 3] = char(value >> 16);
+ m_buffer[m_length - 2] = char(value >> 8);
+ m_buffer[m_length - 1] = char(value);
+ return *this;
+ }
+ /** Appends a 24 bit value in an architecture independent way.
+ * @param value integer to append
+ * @return <code>*this</code> (for chaining)
+ */
+ inline ReByteArray& appendBits32(int value) {
+ setLength(m_length + 4);
+ m_buffer[m_length - 4] = char(value >> 24);
+ m_buffer[m_length - 3] = char(value >> 16);
+ m_buffer[m_length - 2] = char(value >> 8);
+ m_buffer[m_length - 1] = char(value);
+ return *this;
+ }
+ /** Appends a 64 bit value in an architecture independent way.
+ * @param value integer to append
+ * @return <code>*this</code> (for chaining)
+ */
+ inline ReByteArray& appendBits64(int64_t value) {
+ setLength(m_length + 8);
+ m_buffer[m_length - 8] = char(value >> 56);
+ m_buffer[m_length - 7] = char(value >> 48);
+ m_buffer[m_length - 6] = char(value >> 40);
+ m_buffer[m_length - 5] = char(value >> 32);
+ m_buffer[m_length - 4] = char(value >> 24);
+ m_buffer[m_length - 3] = char(value >> 16);
+ m_buffer[m_length - 2] = char(value >> 8);
+ m_buffer[m_length - 1] = char(value);
+ return *this;
+ }
+ /** Appends a character.
+ * @param aChar character to append
+ * @return <code>*this</code> (for chaining)
+ */
+ inline ReByteArray& appendChar(char aChar) {
+ setLength(m_length + 1);
+ m_buffer[m_length - 1] = aChar;
+ return *this;
+ }
+ /** Appends a character at least one time.
+ * @param aChar character to append
+ * @param count number of times to append
+ * @return <code>*this</code> (for chaining)
+ */
+ inline ReByteArray& appendChar(char aChar, int count) {
+ if (count > 0) {
+ size_t oldLength = m_length;
+ setLength(m_length + count);
+ memset(m_buffer + oldLength, aChar, count);
+ }
+ return *this;
+ }
+ ReByteArray& appendFix(const char* data, size_t length, int maxLength,
+ int minLength = 0, const char* separator = "*", char padding = ' ');
+ ReByteArray& appendDump(const char* data, size_t length = -1,
+ int maxLength = 80);
+ ReByteArray& appendHexDump(const char* data, size_t length = -1,
+ int offset = 0, int bytePerLine = 16, const char* offsetFormat =
+ "%04x: ", bool withAscii = true, int groupWidth = 1, int gapBehind =
+ -1, const char* separator = " | ");
+ ReByteArray& appendInt(int number, const char* format = "%d");
+ ReByteArray& appendInt(unsigned int number, const char* format = "%d");
+ ReByteArray& appendInt(int64_t number, const char* format = "%lld");
+ ReByteArray& appendInt(uint64_t number, const char* format = "%lld");
+ ReByteArray& appendMilliSec(int time, int minLength = 5);
+ ReByteArray& appendTime(int time, int minLength = 1);
+ /** @brief Returns the n-th byte of the internal buffer.
+ * @param index The index of the wanted byte.
+ * @return 0: Wrong index. Otherwise: The byte from the wanted position.
+ */
+ inline Byte at(size_t index) const {
+ return index >= m_length ? 0 : m_buffer[index];
+ }
+ int atoi(size_t start = 0, int end = -1) const;
+ /** @brief Returns the buffer (permitting modifying).
+ * @return The internal used buffer.
+ */
+ inline Byte* buffer() const {
+ return m_buffer;
+ }
+ /**@brief Returns the current size of the internal buffer.
+ * @return The current size of the internal buffer.
+ */
+ inline size_t capacity() const {
+ return m_capacity;
+ }
+ /**@brief Sets the length to 0.
+ * @return the instance (for chaining)
+ */
+ ReByteArray& clear(){
+ m_length = 0;
+ m_buffer[0] = '\0';
+ return *this;
+ }
+ /** @brief Returns a immutable C string.
+ * @return a pointer to the buffer content
+ */
+ const char* constData() const{
+ return reinterpret_cast<const char*>(m_buffer);
+ }
+ /**@brief Returns the minimum allocation unit.
+ * @return The minimum of bytes to allocate.
+ */
+ inline size_t delta() const {
+ return m_delta;
+ }
+ /** @brief Tests whether a given character is part of the content.
+ * @param cc character to test
+ * @return <code>true</code>: <code>part</code> is a part of the content
+ */
+ inline bool contains(char cc) const {
+ return indexOf(cc) >= 0;
+ }
+ /** @brief Tests whether a c string is part of the content.
+ * @param part array to test
+ * @return <code>true</code>: <code>part</code> is a part of the content
+ */
+ inline bool contains(const char* part) const{
+ return indexOf(part, -1) >= 0;
+ }
+ /** @brief Tests whether a byte array is part of the instance's content.
+ * @param part array to test
+ * @return <code>true</code>: <code>part</code> is a part of the content
+ */
+ inline bool contains(const ReByteArray& part) const{
+ return indexOf(part.constData(), part.length()) >= 0;
+ }
+ int count(const char* toCount, size_t lengthToCount = -1);
+ /** @brief Returns whether the byte array is empty.
+ * @return <code>true</code>: the byte array is empty (the length is 0)
+ */
+ inline bool empty() const {
+ return m_length == 0;
+ }
+ bool endsWith(const Byte* tail, size_t tailLength = -1, bool ignoreCase =
+ false) const;
+ /** @brief Test whether a given character is the end of the instance's content.
+ * @param tail the array to test
+ * @param ignoreCase <code>true</code>: the comparison is case insensitive
+ * @return <code>true</code>: <code>tail</code> is found at the end
+ */
+ inline
+ bool endsWith(char tail, bool ignoreCase = false) const{
+ return m_length > 0 && tolower(tail) == tolower(m_buffer[m_length-1]);
+ }
+ /** @brief Test whether a given byte array is the end of the instance's content.
+ * @param tail the array to test
+ * @param ignoreCase <code>true</code>: the comparison is case insensitive
+ * @return <code>true</code>: <code>tail</code> is found at the end
+ */
+ inline
+ bool endsWith(const ReByteArray& tail, bool ignoreCase = false) const{
+ return endsWith((const Byte*) tail.str(), (size_t) tail.length(), ignoreCase);
+ }
+ void ensureSize(size_t size);
+ /** After the call the last character is the given.
+ * @param aChar the character which will be the last
+ * @return <code>*this</code> (for chaining)
+ */
+ inline
+ ReByteArray& ensureLastChar(char aChar) {
+ if (lastChar() != aChar)
+ appendChar(aChar);
+ return *this;
+ }
+ /** @brief Tests whether another instance is equal to this instance.
+ * @param data string to compare
+ * @param length length of <code>data</code>. If -1: <code>strlen(data)</code>
+ * @param ignoreCase <code>true</code>: case insensitive comparison
+ * @return <code>true</code>: the buffer's contents are equal
+ */
+ inline
+ bool equals(const char* data, size_t length = (size_t) -1,
+ bool ignoreCase = false) const {
+ if (length == (size_t) -1)
+ length = strlen(data);
+ bool rc = length == m_length
+ && ((!ignoreCase && _memcmp(data, m_buffer, length) == 0)
+ || (ignoreCase && _strnicmp(data, m_buffer, length) == 0));
+ return rc;
+ }
+ /** @brief Tests whether another instance is equal to this instance.
+ * @param buffer the buffer to compare
+ * @param ignoreCase <code>true</code>: case insensitive comparison
+ * @return <code>true</code>: the buffer's contents are equal
+ */
+ inline
+ bool equals(const ReByteArray& buffer, bool ignoreCase = false) const {
+ bool rc = buffer.length() == m_length
+ && ((!ignoreCase && _memcmp(buffer.str(), m_buffer, m_length) == 0)
+ || (ignoreCase
+ && _strnicmp(buffer.str(), m_buffer, m_length) == 0));
+ return rc;
+ }
+ ReByteArray& fill(Byte filler = 0, int start = 0, int end = -1);
+ int firstDifference(const Byte* source, size_t length, int start = 0,
+ bool ignoreCase = false);
+ /** @brief Finds the index of the first occurrence of a given byte.
+ * @param toFind This byte will be searched.
+ * @param start The first index for searching.
+ * @return -1: not found. Otherwise: The index of the first occurrence.
+ */
+ inline
+ int indexOf(Byte toFind, int start = 0) const {
+ while ((size_t) start < m_length)
+ if (m_buffer[start++] == toFind)
+ return start - 1;
+ return -1;
+ }
+ int indexOf(const Byte* toFind, size_t toFindLength, int start = 0,
+ int end = -1, bool ignoreCase = false) const;
+ /** @brief Inserts a byte sequence.
+ * @param ix The position in the internal buffer for the insertion.
+ * @param source The sequence to insert.
+ * @param length The length of the inserted sequence.
+ *
+ * @return true: Success. false: <code>ix</code> out of range.
+ */
+ inline
+ bool insert(size_t ix, const Byte* source, size_t length) {
+ return splice(ix, 0, source, length);
+ }
+ bool isPrefixOf(const char* source, size_t length = -1, bool ignoreCase =
+ false, int minLength = 0);
+ /** Returns the last character.
+ * @return '\0': empty buffer<br>
+ * otherwise: the last character
+ */
+ inline
+ char lastChar() const {
+ return m_length == 0 ? '\0' : m_buffer[m_length - 1];
+ }
+ /**@brief Returns the length of the buffer (the count of used bytes).
+ * @return The count of the allocated bytes in the internal buffer.
+ */
+ inline size_t length() const {
+ return m_length;
+ }
+ /** Sets the length to a lower value.
+ * @param decrement the count to reduce the length
+ * @return The count of the allocated bytes in the internal buffer.
+ */
+ inline ReByteArray& reduceLength(int decrement = 1) {
+ if (decrement > 0 && m_length > 0) {
+ if (decrement > (int) m_length)
+ decrement = m_length;
+ setLength(m_length - decrement);
+ }
+ return *this;
+ }
+ /** @brief Cuts a sequence from the internal buffer.
+ *
+ * @param ix The index where the cut/insertion takes place.
+ * @param deletedLength The number of deleted bytes.
+ * This value may be larger than the existing bytes.
+ *
+ * @return true: Success. false: <code>ix</code> out of range.
+ */
+ inline
+ bool remove(size_t ix, size_t deletedLength) {
+ return splice(ix, deletedLength, NULL, 0);
+ }
+ /** Replaces a given character by another.
+ * @param toFind the character which will be replaced
+ * @param replacement the replacement character
+ * @param start only characters behind this index will be replaced
+ * @return *this (for chaining)
+ */
+ inline
+ ReByteArray& replace(char toFind, char replacement, int start = 0){
+ return replaceAll(reinterpret_cast<const Byte*>(&toFind), 1,
+ reinterpret_cast<const Byte*>(&replacement), 1, start);
+ }
+ ReByteArray& replaceAll(const Byte* toFind, size_t toFindLength,
+ const Byte* replacement, size_t replacementLength, int start = 0);
+ /** Removes an unwanted character at the end.
+ * @param aChar character to remove
+ * @return <code>*this</code> (for chaining)
+ */
+ inline ReByteArray& removeLastChar(char aChar) {
+ if (m_length > 0 && m_buffer[m_length - 1] == aChar)
+ setLength(m_length - 1);
+ return *this;
+ }
+ /** @brief Finds the index of the last occurrence of a given byte (reverse index of).
+ * @param toFind This byte will be searched.
+ * @param start The first index for searching. If < 0: relative to the end.
+ * @return -1: not found. Otherwise: The index of the last occurrence.
+ */
+ inline
+ int rindexOf(Byte toFind, int start = -1) const {
+ if (start < 0)
+ start = m_length + start;
+ while (start >= 0)
+ if (m_buffer[start--] == toFind)
+ return start + 1;
+ return -1;
+ }
+ int rindexOf(const Byte* toFind, size_t toFindLength, int start = 0,
+ int end = -1, bool ignoreCase = false) const;
+ /** @brief Sets the content of the buffer by copying a byte sequence.
+ * @param source The byte sequence to copy.
+ * @param length The length of <code>source</code>.
+ * @return *this (for chaining).
+ */
+ inline ReByteArray& set(const Byte* source, size_t length) {
+ return setLength(0).append(source, length);
+ }
+ /** @brief Sets the content of the buffer by copying a byte sequence.
+ * @param source the source to copy.
+ * @return *this (for chaining).
+ */
+ inline ReByteArray& set(const ReByteArray& source) {
+ return setLength(0).append(source);
+ }
+ void setDelta(int delta);
+ ReByteArray& setLength(size_t length);
+ ReByteArray& setLengthAndFillOut(size_t length, Byte filler = 0);
+ bool splice(size_t ix, size_t replacedLength, const Byte* source,
+ size_t length);
+ bool startsWith(const Byte* head, size_t headLength = -1,
+ const bool ignoreCase = false) const;
+ const char* status(ReByteArray& buffer, const char* prefix = NULL) const;
+ /** @brief Returns the buffer content as C string.
+ * This is exactly the same result as from <code>getBuffer()</code>.
+ * @return The internal used buffer.
+ */
+ inline
+ const char* str() const {
+ return (const char*) m_buffer;
+ }
+protected:
+ //@ If the needed space is small enough this buffer will be used.
+ char m_primaryBuffer[PRIMARY_BUFFER_SIZE];
+ // The minimum difference between old and new size after a new allocation.
+ int m_delta;
+ //@ The internal buffer. Points to <code>m_primaryBuffer</code> if the space is small enough.
+ char* m_buffer;
+ //@ The used bytes in <code>m_buffer</code>.
+ size_t m_length;
+ //@ The size of <code>m_buffer</code>.
+ size_t m_capacity;
+ //@ number of reallocation in ensureSize()
+ int m_reallocation;
+};
+
+#endif /* REBYTEBUFFER_H_ */
+++ /dev/null
-/*
- * ReByteBuffer.cpp
- *
- * License: Public Domain
- * You can use and modify this file without any restriction.
- * Do what you want.
- * No warranties and disclaimer of any damages.
- * You also can use this license: http://www.wtfpl.net
- * The latest sources: https://github.com/republib
- */
-
-#include "base/rebase.hpp"
-
-#ifdef __linux__
-extern void* memcpy(void* dest, const void* src, size_t n);
-extern void* memmove(void* dest, const void* src, size_t n);
-extern int _memcmp (const void* s1, const void* s2, size_t n);
-extern int _snprintf(char* s, size_t maxlen, const char* format, ...);
-#endif
-
-/** @brief Constructor.
- *
- * @param delta If a new storage must be allocated the size
- * is incremented by at least this count of bytes
- */
-ReByteBuffer::ReByteBuffer(size_t delta) :
- m_delta(delta),
- // m_primaryBuffer
- m_buffer(m_primaryBuffer),
- m_length(0),
- m_capacity(sizeof m_primaryBuffer - 1),
- m_reallocation(0) {
- m_buffer[0] = '\0';
-}
-/** @brief Constructor.
- *
- * @param source the instance to copy (C string)
- */
-ReByteBuffer::ReByteBuffer(const char* source) :
- m_delta(PRIMARY_BUFFER_SIZE),
- // m_primaryBuffer
- m_buffer(m_primaryBuffer),
- m_length(0),
- m_capacity(sizeof m_primaryBuffer),
- m_reallocation(0) {
- m_buffer[0] = '\0';
- if (source != NULL)
- append(source);
-}
-
-/** @brief Constructor.
- *
- * @param source The byte sequence to copy
- * @param sourceLength length of <code>source</code>
- */
-ReByteBuffer::ReByteBuffer(const Byte* source, size_t sourceLength) :
- m_delta(PRIMARY_BUFFER_SIZE),
- // m_primaryBuffer
- m_buffer(m_primaryBuffer),
- m_length(0),
- m_capacity(sizeof m_primaryBuffer - 1),
- m_reallocation(0) {
- m_buffer[0] = '\0';
- append(source, sourceLength);
-}
-
-/** @brief Destructor.
- *
- */
-ReByteBuffer::~ReByteBuffer() {
- if (m_buffer != m_primaryBuffer)
- delete[] m_buffer;
- m_buffer = NULL;
- m_capacity = 0;
- m_length = 0;
-}
-/** @brief Copy constructor.
- *
- * @param source the instance to copy
- */
-ReByteBuffer::ReByteBuffer(const ReByteBuffer& source) :
- m_delta(source.delta()),
- // m_primaryBuffer
- m_buffer(m_primaryBuffer),
- m_length(0),
- m_capacity(sizeof m_primaryBuffer),
- m_reallocation(0) {
- append(source.buffer(), source.length());
-}
-
-/** @brief The assignment operator.
- *
- * @param source the instance to copy
- *
- * @return the instance itself
- */
-ReByteBuffer& ReByteBuffer::operator =(const ReByteBuffer& source) {
- m_delta = source.delta();
- set(source.buffer(), source.length());
- return *this;
-}
-
-/** @brief Appends a byte sequence at the end of the buffer.
- *
- * If the space is not enough it will be allocated.
- *
- * <pre><code>Example:
- * ReByteBuffer buf;
- * assert(4 == buf.append("abc", 3).append("x").getLength());
- * </code></pre>
- *
- * @param source the sequence to append
- * @param length the length of the sequence
- *
- * @return *this (for chaining)
- */
-ReByteBuffer& ReByteBuffer::append(const Byte* source, size_t length) {
- if (source != NULL) {
- if (length == (size_t) -1)
- length = strlen(source);
- ensureSize(m_length + length);
- memcpy((void*) (m_buffer + m_length), source, length);
- m_length += length;
- m_buffer[m_length] = '\0';
- }
- return *this;
-}
-/** @brief Appends the content of another <code>ReByteBuffer</code> instance at the end of the buffer.
- *
- * If the space is not enough it will be allocated.
- *
- * <pre><code>Example:
- * ReByteBuffer name; name.append("mydoc");
- * ReByteBuffer ext; ext.append(".txt");
- * name.append(ext);
- * assert("mydoc.txt", name.getBuffer());
- * </code></pre>
- *
- * @return *this (for chaining)
- */
-ReByteBuffer& ReByteBuffer::append(const ReByteBuffer& source) {
- return append(source.str(), source.length());
-}
-
-/** @brief Appends a floaating point number at the end of the buffer.
- *
- * If the space is not enough it will be allocated.
- *
- * <pre><code>Example:
- * ReByteBuffer buf; buf.append("amount: ").append(377 / 100.0, "%5.2f");
- * assert("amount: 3.77", buf.str());
- * </code></pre>
- *
- * @return *this (for chaining)
- */
-ReByteBuffer& ReByteBuffer::append(double value, const char* format) {
- char buffer[256];
-
- _snprintf(buffer, sizeof buffer, format, value);
- append(buffer, -1);
- return *this;
-}
-
-/**
- * Appends a string with minimal/maximal length.
- *
- * If the length is greater than the maximal length the string will be cutted
- * (in the middle) and a separator will set at the cut.
- *
- * <pre>Example:
- * <code>buffer.appendFix("sammy2", -1, 5, 5, "*").appendFix("x", 1, 99, -3);
- * </code>
- * Buffer contains: "sa*y2 x"
- * </pre>
- *
- * @param data data to append
- * @param length length of <code>data</code>. -1: <code>strlen(data)</code>
- * @param maxLength the stored length is at most this value
- * @param minLength if the length is smaller padding characters will be added<br>
- * < 0: padding is done at the top
- * @param separator NULL or the string used at the separaration point
- * @param padding character used for padding (see <code>minLength</code>)
- * @return <code>*this</code> (for chaining)
- */
-ReByteBuffer& ReByteBuffer::appendFix(const char* data, size_t length,
- int maxLength, int minLength, const char* separator, char padding) {
- if (length == (size_t) -1)
- length = strlen(data);
- if ((int) length < abs(minLength)) {
- ensureSize(m_length + abs(minLength));
- if (minLength < 0)
- appendChar(padding, -minLength - length);
- append(data, length);
- if (minLength > 0)
- appendChar(padding, minLength - length);
- } else if ((int) length > maxLength) {
- ensureSize(m_length + maxLength);
- int sepLength = separator == NULL ? 0 : strlen(separator);
- int lengthPart1 = (maxLength - sepLength + 1) / 2;
- int lengthPart2 = maxLength - sepLength - lengthPart1;
- append(data, lengthPart1);
- if (sepLength > 0)
- append(separator, sepLength);
- append(data + length - lengthPart2, lengthPart2);
- } else {
- append(data, length);
- }
- return *this;
-}
-
-/**
- * Appends data as string or as binary (hexdump).
- *
- * If data contains non ASCII char the data will be treated as binary.
- *
- * @param data the data to append
- * @param length -1 (<code>strlen()</code>) or the length of data
- * @param maxLength the maximal count of appended chars
- * @return <code>*this</code> (chaining)
- */
-ReByteBuffer& ReByteBuffer::appendDump(const char* data, size_t length,
- int maxLength) {
- if (length == size_t(-1)) {
- length = strlen(data);
- }
- if ((int) length > maxLength)
- length = maxLength;
- // test if text or binary:
- bool isBinary = false;
- unsigned char cc;
- for (size_t ii = 0; ii < length; ii++) {
- if ((cc = (unsigned char) data[ii]) > 126
- || (cc < ' ' && cc != '\n' && cc != '\r' && cc != '\t')) {
- isBinary = true;
- break;
- }
- }
- if (!isBinary)
- append(data, length);
- else
- appendHexDump(data, min(length, maxLength / 5)).reduceLength();
- return *this;
-}
-/**
- * Appends a hexadecimal dump of a memory array.
- *
- * <pre>Example:
- * <code>buffer.appendHex("01234567890abcde", -1, 0x10, 16, "%0x8x", 1, -1, " | ");
- * </code>
- * Buffer contains:
- * 00000010 30 31 32 33 34 35 36 37 38 39 30 61 62 63 64 65 | 01234567890abcde
- * </pre>
- *
- * @param data data to dump
- * @param length length of <code>data</code>. -1: <code>strlen(data)</code>
- * @param offset a format which is used to append a preceeding position
- * of source. NULL: no offset is appended
- * @param bytesPerLine number of bytes in one line. If length is greater more
- * lines are appended
- * @param offsetFormat NULL or the sprintf format of the offset, e.g. "0x04x "
- * @param withAscii <code>true</code>: the data is interpreted as ASCII too
- * @param groupWidth behind <code>groupWidth</code> hex bytes a ' ' is appended
- * @param gapBehind behind <code>gapBehind</code> hex bytes a ' ' is appended<br>
- * -1: <code>bytePerLine / 2</code>
- * @param separator NULL or a string between hex area and ASCII area
- * @return <code>*this</code> (for chaining)
- */
-ReByteBuffer& ReByteBuffer::appendHexDump(const char* data, size_t length,
- int offset, int bytesPerLine, const char* offsetFormat, bool withAscii,
- int groupWidth, int gapBehind, const char* separator) {
- if (length == (size_t) -1)
- length = strlen(data);
- if (gapBehind < 0)
- gapBehind = bytesPerLine / 2;
- ensureSize(32);
- int offsetLength = 0;
- if (offsetFormat != NULL) {
- _snprintf(m_buffer, 31, offsetFormat, offset + length);
- offsetLength = strlen(m_buffer);
- }
- ensureSize(
- (length + bytesPerLine - 1) / bytesPerLine
- * (4 + offsetLength
- + (gapBehind <= 0 ? 0 : bytesPerLine / gapBehind + 1)
- + (separator == NULL ? 0 : strlen(separator)) + 1));
- while (length > 0) {
- if (offsetFormat != NULL)
- appendInt(offset, offsetFormat);
- int ix;
- for (ix = 0; ix < bytesPerLine; ix++) {
- if (ix < (int) length)
- appendInt((unsigned char) data[ix], "%02x");
- else
- append(" ");
- if (ix < bytesPerLine - 1
- && (groupWidth == 1 || ix % groupWidth == groupWidth - 1))
- appendChar(' ');
- if (ix < bytesPerLine - 1 && gapBehind > 0
- && (gapBehind == 1 || ix % gapBehind == gapBehind - 1))
- appendChar(' ');
- }
- if (withAscii) {
- if (separator != NULL)
- append(separator, -1);
- char cc;
- for (ix = 0; ix < bytesPerLine; ix++) {
- if (ix < (int) length)
- appendInt((cc = data[ix]) < ' ' || cc > 127 ? '.' : cc,
- "%c");
- else
- append(" ");
- if (ix < bytesPerLine - 1 && gapBehind > 0
- && (gapBehind == 1 || ix % gapBehind == gapBehind - 1))
- append(" ", 1);
- }
- appendChar('\n');
- length =
- length <= (size_t) bytesPerLine ? 0 : length - bytesPerLine;
- data += bytesPerLine;
- offset += bytesPerLine;
- }
- }
- return *this;
-}
-
-/** @brief Appends an integer as string at the end of the buffer.
- *
- * If the space is not enough it will be allocated.
- *
- * <pre><code>Example:
- * ReByteBuffer buf; buf.appendInt(33, "%-4d");
- * assert(strcmp("33 ", buf.str()) == 0);
- * </code></pre>
- *
- * @param number the number to append
- * @param format the format of the number used by <code>sprintf()</code>
- *
- * @return *this (for chaining)
- */
-ReByteBuffer& ReByteBuffer::appendInt(int number, const char* format) {
- char buffer[128];
-
- _snprintf(buffer, sizeof buffer, format, number);
- append(buffer, -1);
- return *this;
-}
-
-/** @brief Appends an integer as string at the end of the buffer.
- *
- * If the space is not enough it will be allocated.
- *
- * <pre><code>Example:
- * ReByteBuffer buf; buf.appendInt(33U, "%x");
- * assert(strcmp("21 ", buf.str()) == 0);
- * </code></pre>
- *
- * @param number the number to append
- * @param format the format of the number used by <code>sprintf()</code>
- *
- * @return *this (for chaining)
- */
-ReByteBuffer& ReByteBuffer::appendInt(unsigned int number, const char* format) {
- char buffer[128];
-
- _snprintf(buffer, sizeof buffer, format, number);
- append(buffer, -1);
- return *this;
-}
-
-/** @brief Appends an integer as string at the end of the buffer.
- *
- * If the space is not enough it will be allocated.
- *
- * <pre><code>Example:
- * ReByteBuffer buf; buf.appendInt(12345678901ll, "%12d");
- * assert(strcmp(" 12345678901", buf.str()) == 0);
- * </code></pre>
- *
- * @param number the number to append
- * @param format the format of the number used by <code>sprintf()</code>
- *
- * @return *this (for chaining)
- */
-ReByteBuffer& ReByteBuffer::appendInt(int64_t number, const char* format) {
- char buffer[256];
-
- _snprintf(buffer, sizeof buffer, format, number);
- append(buffer, -1);
- return *this;
-}
-
-/** @brief Appends an integer as string at the end of the buffer.
- *
- * If the space is not enough it will be allocated.
- *
- * <pre><code>Example:
- * ReByteBuffer buf; buf.appendInt((uint64_t) 0x12345678901ll, "%12x");
- * assert(strcmp(" 12345678901", buf.str()) == 0);
- * </code></pre>
- *
- * @param number the number to append
- * @param format the format of the number used by <code>sprintf()</code>
- *
- * @return *this (for chaining)
- */
-ReByteBuffer& ReByteBuffer::appendInt(uint64_t number, const char* format) {
- char buffer[256];
-
- _snprintf(buffer, sizeof buffer, format, number);
- append(buffer, -1);
- return *this;
-}
-
-/** @brief Appends a time (given in milli seconds) as 'dd:HH:MM.mmm'.
- *
- * @param time the time (duration) in msec
- * @param minLength > 5: seconds will be 2 digits (preceeding '0' if needed)<br>
- * > 6: at least MM:SS.sss<br>
- * > 9: at least HH:MM:SS.sss<br>
- * > 12: at least dd:HH:MM:SS.sss<br>
- * @return <code>buffer</code> (for chaining)
- */
-ReByteBuffer& ReByteBuffer::appendMilliSec(int time, int minLength) {
- int days = time / (24 * 3600 * 1000LL);
- time %= 24 * 3600 * 1000;
- int expectedLength = days > 0 ? 12 : 0;
- int hours = time / (3600 * 1000);
- time %= 3600 * 1000;
- if (hours > 0 && expectedLength == 0)
- expectedLength = 9;
- int minutes = time / (60 * 1000);
- time %= 60 * 1000;
- if (minutes > 0 && expectedLength == 0)
- expectedLength = 5;
- int minimum = minLength > expectedLength ? minLength : expectedLength;
- int sec = time / 1000;
- int msec = time % 1000;
- static const char* stdFormat = "%02d";
- if (days > 0 || minimum > 12)
- appendInt(days).append(":");
- if (hours > 0 || minimum > 9)
- appendInt(hours, stdFormat).append(":");
- if (minutes > 0 || minimum > 6)
- appendInt(minutes, stdFormat).append(":");
- appendInt(sec, sec > 10 || minimum > 5 ? stdFormat : "%d").append(".");
- appendInt(msec, "%03d");
- return *this;
-}
-
-/** @brief Appends a time (given in milli seconds) as 'dd:HH:MM.mmm'.
- *
- * @param time the time (duration) in msec
- * @param minLength > 3: seconds will be 2 digits (preceeding '0' if needed)<br>
- * > 4: at least MM:SS.sss<br>
- * > 7: at least HH:MM:SS.sss<br>
- * > 10: at least dd:HH:MM:SS<br>
- * @return <code>buffer</code> (for chaining)
- */
-ReByteBuffer& ReByteBuffer::appendTime(int time, int minLength) {
- int days = time / (24 * 3600);
- time %= 24 * 3600;
- int expectedLength = days > 0 ? 10 : 0;
- int hours = time / 3600;
- time %= 3600;
- if (hours > 0 && expectedLength == 0)
- expectedLength = 7;
- int minutes = time / 60;
- time %= 60;
- if (minutes > 0 && expectedLength == 0)
- expectedLength = 3;
- int minimum = minLength > expectedLength ? minLength : expectedLength;
- int sec = time;
- static const char* stdFormat = "%02d";
- if (days > 0 || minimum > 10)
- appendInt(days).append(":");
- if (hours > 0 || minimum > 7)
- appendInt(hours, stdFormat).append(":");
- if (minutes > 0 || minimum > 4)
- appendInt(minutes, stdFormat).append(":");
- appendInt(sec, sec > 10 || minimum > 3 ? stdFormat : "%d");
- return *this;
-}
-
-/** Converts a subsequence into an integer.
- *
- * The number may be a decimal or a hexadecimal number. Hex numbers start with 0x.
- * <pre><code>Example:
- * ReByteBuffer buf;
- * buf.set("abc123", 6);
- * assert(12 == buf.atoi(3, 3 + 2));
- * </code></pre>
- *
- * @param start the first index to convert
- * @param end -1: all found digits will be converted
- * Otherwise: the maximal number of digits to convert
- */
-int ReByteBuffer::atoi(size_t start, int end) const {
- int rc = 0;
- if (start < m_length) {
- if (end < 0)
- end = m_length;
- char cc;
- if (m_buffer[start] == '0' && tolower(m_buffer[start + 1]) == 'x') {
- // Hexadecimal number:
- start += 2;
- while (start < (size_t) end && (cc = m_buffer[start++]) >= '0'
- && isxdigit(cc))
- rc = rc * 16 + (cc <= '9' ? cc - '0' : toupper(cc) - 'A' + 10);
- } else {
- // Decimal number:
- while (start < (size_t) end && (cc = m_buffer[start++]) >= '0'
- && cc <= '9')
- rc = rc * 10 + cc - '0';
- }
- }
- return rc;
-}
-
-/**
- * Counts the occurrencies of a given byte sequence.
- *
- * @param toCount the byte sequence to count
- * @param lengthOfToCount -1: length is <code>strlen(toCount)</count><br>
- * otherwise: length of <code>toCount</count>
- */
-int ReByteBuffer::count(const char* toCount, size_t lengthToCount) {
- int rc = 0;
- size_t start = 0;
- if (lengthToCount == (size_t) -1)
- lengthToCount = strlen(toCount);
- while ((start = indexOf(toCount, lengthToCount, start)) != (size_t) -1) {
- rc++;
- start += lengthToCount;
- }
- return rc;
-}
-
-/**
- * Tests whether the buffer ends with a given a byte sequence.
- *
- * @param tail the byte sequence to test
- * @param tailLength -1: <code>strlen(tail)</code><br>
- * otherwise: the length of <code>tail</code>
- * @param ignoreCase <code>true</code>: the comparison is case insensitive<br>
- * <code>false</code>: the comparison is case sensitive<br>
- * @return <code>true</code>: the buffer ends with <code>tail</code><br>
- * <code>false</code>: otherwise
- */
-bool ReByteBuffer::endsWith(const Byte* tail, size_t tailLength,
- bool ignoreCase) const {
- bool rc = tail != NULL;
- if (rc) {
- if (tailLength == (size_t) -1)
- tailLength = strlen(tail);
- rc = indexOf(tail, tailLength, m_length - tailLength, m_length,
- ignoreCase) >= 0;
- }
- return rc;
-}
-
-/** @brief Ensures that there is enough space.
- *
- * If not it will be allocated and the old value will be copied.
- *
- * A new allocation will be use at least <code>m_delta</code> bytes.
- * The allocated space is incremented by one because of the ending '\\0'.
- *
- * @param size the size will be at least this value
- */
-void ReByteBuffer::ensureSize(size_t size) {
- if (m_capacity < size) {
- int delta =
- m_delta > 0 ? m_delta :
- (int) m_capacity < -m_delta / 2 ? (int) 2 * m_capacity : -m_delta;
- if (int(size - m_capacity) < delta)
- size = m_capacity + delta;
- // Think for the ending '\0':
- Byte* buffer = new Byte[size + 1];
- assert(buffer != NULL);
- if (m_length > 0)
- memcpy(buffer, m_buffer, m_length);
- buffer[m_length] = '\0';
- if (m_buffer != m_primaryBuffer)
- delete[] m_buffer;
- m_buffer = buffer;
- m_capacity = size;
- m_reallocation++;
- }
-}
-/**
- * @brief Fills a part of the buffer with a given character.
- *
- * @param filler the byte which is used as filler
- * @param start the first index to fill. <code>0 <= start < m_length</code>
- * @param end the index behind the last filled position. May be behind m_length
- * @return the instance itself (vor chaining)
- */
-ReByteBuffer& ReByteBuffer::fill(Byte filler, int start, int end) {
- if (end == -1)
- end = m_length;
- if (start >= 0 && start < end) {
- if (end > (int) m_length)
- setLength(end);
- memset(m_buffer + start, filler, end - start);
- }
- return *this;
-}
-
-/** @brief Checks for the index of the first different byte.
- *
- * @param source source to inspect
- * @param length -1 or the length of <code>source</code>
- * @param start the first index to inspect
- * @param ignoreCase <code>true</code>: the comparison is case insensitive
- * @return -1: both byte sequences are equal<br>
- * otherwise: the index of the first difference
- */
-int ReByteBuffer::firstDifference(const Byte* source, size_t length, int start,
- bool ignoreCase) {
- int rc = -1;
- if (start < 0)
- rc = 0;
- else if (start < (int) m_length) {
- if (length == (size_t) -1)
- length = strlen(source);
- int count = length > m_length - start ? m_length - start : length;
- const Byte* ptr = m_buffer + start;
- for (int ix = 0; rc < 0 && ix < count; ix++) {
- if ((!ignoreCase && *ptr++ != *source++)
- || (ignoreCase && (tolower(*ptr++) != tolower(*source++))))
- rc = start + ix;
- }
- if (rc < 0 && length > m_length - start)
- rc = start + count;
- }
- return rc;
-}
-
-/** @brief Searches for a byte sequence in the internal buffer.
- *
- * Finds the first occurrence of a byte sequence in a given range.
- *
- * <pre><code>Example:
- * ReByteBuffer buf;
- * buf.set("12abc123", 8);
- * assert(5 == buf.indexOf("12", -1, 3));
- * </code></pre>
- *
- * @param toFind the sequence to find
- * @param toFindLength Length of <code>toFind</code>,
- * If -1 the <code>strlen(toFind)</code> will be taken
- * @param start the search respects the indices in the range [start, end[
- * @param end -1: no upper limit to search<br>
- * otherwise: the first index above the search range
- * @param ignoreCase <code>true</code>: case insensitive search<br>
- * <code>true</code>: case sensitive search
- * @return -1: the sequence could not be found.
- * Otherwise: the index of <code>toFind</code> in the internal buffer
- */
-int ReByteBuffer::indexOf(const Byte* toFind, size_t toFindLength, int start,
- int end, bool ignoreCase) const {
- if (toFindLength == (size_t) -1)
- toFindLength = strlen(toFind);
- int rc = -1;
- if (end < 0 || end > (int) m_length)
- end = m_length;
- if (start >= 0 && start <= int(m_length - toFindLength)
- && end >= (int) toFindLength && end <= (int) m_length) {
- while (rc < 0 && start <= int(end - toFindLength)) {
- if (ignoreCase ?
- _memicmp((void*) toFind, (void*) (m_buffer + start),
- toFindLength) == 0 :
- _memcmp(toFind, m_buffer + start, toFindLength) == 0)
- rc = start;
- else
- start++;
- }
- }
- return rc;
-}
-/**
- * Tests whether the instance is a prefix of a given string.
- *
- * @param source the string to inspect
- * @param length the length of the string<br>
- * -1: <code>strlen(source)</code>
- * @param ignoreCase <code>true</code>: the test is case insensitive
- * @param minLength the substring (instance) must have at least this length
- * for a positive test
- * @return <code>true</code>the instance is a prefix of the <code>source</code>
- * and the length is at least <code>minLength</code> bytes
- */
-bool ReByteBuffer::isPrefixOf(const char* source, size_t length,
- bool ignoreCase, int minLength) {
- if (length == (size_t) -1)
- length = strlen(source);
- bool rc = length >= m_length && m_length <= length;
- if (rc)
- rc = equals(source, m_length, ignoreCase);
- return rc;
-}
-
-/** @brief Searches revers for a byte sequence in the internal buffer.
- *
- * Finds the last occurrence of a byte sequence in a given range.
- *
- * <pre><code>Example:
- * ReByteBuffer buf;
- * buf.set("12abc123", 8);
- * assert(5 == buf.rindexOf("12", -1, 3));
- * </code></pre>
- *
- * @param toFind the sequence to find
- * @param toFindLength length of <code>toFind</code>.
- * If -1 the <code>strlen(toFind)</code> will be taken
- * @param start the search respects the indices in the range [start, end[
- * @param end -1: no upper limit to search<br>
- * otherwise: the first index above the search range
- * @param ignoreCase <code>true</code>: case insensitive search<br>
- * <code>true</code>: case sensitive search
- * @return -1: the sequence could not be found.
- * Otherwise: the index of <code>toFind</code> in the internal buffer
- */
-int ReByteBuffer::rindexOf(const Byte* toFind, size_t toFindLength, int start,
- int end, bool ignoreCase) const {
- if (toFindLength == (size_t) -1)
- toFindLength = strlen(toFind);
- int rc = -1;
- if (end < 0 || end > (int) m_length)
- end = m_length;
- if (start >= 0 && start <= int(m_length - toFindLength)
- && end >= (int) toFindLength && end <= (int) m_length) {
- int current = end - toFindLength;
- while (current >= start) {
- if (ignoreCase ?
- _strnicmp(toFind, m_buffer + current, toFindLength) != 0 :
- _memcmp(toFind, m_buffer + current, toFindLength) != 0)
- current--;
- else {
- rc = current;
- break;
- }
- }
- }
- return rc;
-}
-/** @brief Replaces all occurrences of <code>toFind</code> with <code>replacement</code>.
- *
- * A single replacement can be done with <code>splice()</code>.
- *
- * <pre><code>Example:
- * ReByteBuffer buf;
- * buf.set("12abc123", 8);
- * buf.replaceAll("12", -1, "XYZ", -1);
- * assert(strcmp("XYZabcXYZ3", buf.str()) == 0);
- * </code></pre>
- *
- * @param toFind the substring which will be replaced
- * @param toFindLength the length of <code>toFind</code>. -1: <code>strlen()</code> will be used
- * @param replacement the replacement
- * @param replacementLength the length of <code>replacement</code>. -1: <code>strlen()</code> will be used
- * @param start the first index to inspect
- */
-ReByteBuffer& ReByteBuffer::replaceAll(const Byte* toFind, size_t toFindLength,
- const Byte* replacement, size_t replacementLength, int start) {
- if (toFindLength == size_t(-1))
- toFindLength = strlen(toFind);
- if (replacementLength == size_t(-1))
- replacementLength = strlen(replacement);
-
- while ((start = indexOf(toFind, toFindLength, start)) != -1) {
- splice(start, toFindLength, replacement, replacementLength);
- start += replacementLength;
- }
- return *this;
-}
-
-/** @brief Sets the increment used to increase the capacity.
- *
- * @param delta > 0: reservation allocates at least this amount of bytes<br>
- * 0: delta is set to a default value<br>
- * < 0: the current capacity will be doubled until <code>- delta</code>
- */
-void ReByteBuffer::setDelta(int delta) {
- m_delta = delta == 0 ? PRIMARY_BUFFER_SIZE : delta;
-}
-
-/** @brief Sets the length to a given value.
- *
- * The new length is greater than the current size the buffer will reallocated.
- *
- * <pre><code>Example:
- * ReByteBuffer buf;
- * buf.set("123", 3);
- * buf.setLength(5);
- * assert(strcmp("123", buf.str()) == 0);
- * assert(5 == buf.getLength());
- * </code></pre>
- *
- * @param length the new length
- *
- * @return *this (for chaining)
- */
-ReByteBuffer& ReByteBuffer::setLength(size_t length) {
- ensureSize(length);
- m_length = length;
- m_buffer[length] = '\0';
- return *this;
-}
-/** @brief Sets the length to a given value and fills the new allocated part of the buffer with a given value.
- *
- * The new length is greater than the current size the buffer will reallocated.
- *
- * <pre><code>Example:
- * ReByteBuffer buf;
- * buf.set("123", 3);
- * buf.setLengthAndFill(5, 'X');
- * assert(strcmp("123XX", buf.str()) == 0);
- * </code></pre>
- *
- * @param length the new length
- * @param filler if the new length is greater than the current length the space
- * will be filled with this value
- * @return *this (for chaining)
- */
-ReByteBuffer& ReByteBuffer::setLengthAndFillOut(size_t length, Byte filler) {
- ensureSize(length);
- if (length > m_length)
- memset(m_buffer + m_length, filler, length - m_length);
- m_length = length;
- m_buffer[length] = '\0';
- return *this;
-}
-/** @brief Cuts a sequence from the internal buffer and inserts another.
- *
- * This function implies a pure insertion and pure deletion of a subsequence.
- *
- * <pre><code>Example:
- * ReByteBuffer buf;
- * buf.set("12345", 5);
- * buf.splice(2, 2, "XYZ", 3);
- * assert(strcmp("12XYZ5", buf.str()) == 0);
- * </code></pre>
- *
- * @param ix the index where the cut/insertion takes place
- * @param replacedLength the number of deleted bytes. If 0 a pure insertion will be done
- * @param source the sequence to insert. May be NULL (for pure deletion)
- * @param length the length of the inserted sequence<br>
- * 0: a pure deletion will be done<br>
- * -1: <code>strlen(source)</code> will be taken
- *
- * @return true: Success. false: <code>ix</code> out of range
- */
-bool ReByteBuffer::splice(size_t ix, size_t replacedLength,
- const ReByteBuffer::Byte* source, size_t length) {
- bool rc;
- if (ix < 0 || ix > m_length)
- rc = false;
- else {
- rc = true;
-
- if (source == NULL)
- length = 0;
- if (length == (size_t) -1)
- length = strlen(source);
- if (ix + replacedLength > m_length)
- replacedLength = m_length - ix;
-
- ensureSize(m_length + length - replacedLength);
-
- Byte* start = m_buffer + ix;
- Byte* tail = start + replacedLength;
- size_t lengthTail = m_length - ix - replacedLength;
-
- if (length <= replacedLength) {
- // The sequence will not be longer:
- if (length > 0)
- memcpy(start, source, length);
- if (length < replacedLength) {
- memmove(start + length, tail, lengthTail);
- }
- } else {
- // The sequence will be longer:
- memmove(start + length, tail, lengthTail);
- memcpy(start, source, length);
- }
- m_length += length - replacedLength;
- m_buffer[m_length] = '\0';
- }
- return rc;
-}
-/**
- * Tests whether the buffer starts with a given a byte sequence.
- *
- * @param head the byte sequence to test
- * @param headLength -1: <code>strlen(tail)</code><br>
- * otherwise: the length of <code>tail</code>
- * @param ignoreCase <code>true</code>: the comparison is case insensitive<br>
- * <code>false</code>: the comparison is case sensitive<br>
- * @return <code>true</code>: the buffer starts with <code>head</code><br>
- * <code>false</code>: otherwise
- */
-bool ReByteBuffer::startsWith(const Byte* head, size_t headLength,
- const bool ignoreCase) const {
- bool rc = head != NULL;
- if (rc) {
- if (headLength == (size_t) -1)
- headLength = strlen(head);
- rc = indexOf(head, headLength, 0, headLength, ignoreCase) == 0;
- }
- return rc;
-}
-
-/**
- * Appends the status data of the instance onto the buffer.
- *
- * @param buffer OUT: the space for the data report
- * @param prefix NULL or a prefix of the output
- * @return <code>buffer.str()</code> (for chaining)
- */
-const char* ReByteBuffer::status(ReByteBuffer& buffer,
- const char* prefix) const {
- if (prefix != NULL)
- buffer.append(prefix);
- buffer.append("capacity:").appendInt(m_capacity).append(" length: ")
- .appendInt(m_length).append(" realloc: ").appendInt(m_reallocation)
- .append("\n");
- return buffer.str();
-}
-
+++ /dev/null
-/*
- * ReByteBuffer.hpp
- *
- * License: Public Domain
- * You can use and modify this file without any restriction.
- * Do what you want.
- * No warranties and disclaimer of any damages.
- * You also can use this license: http://www.wtfpl.net
- * The latest sources: https://github.com/republib
- */
-
-#ifndef REBYTEBUFFER_H_
-#define REBYTEBUFFER_H_
-
-#define PRIMARY_BUFFER_SIZE 513
-/** @brief An efficient dynamic memory buffer.
- *
- * Implements a very efficient dynamic byte sequence.
- * <p>
- * <strong>Note:</strong><br>
- * It is guaranteed that the sequence is terminated by a '\\0' like C strings.
- * This end marker is outside the visible buffer.<br/>
- * Technically: <br/>
- * <code>ReByteBuffer buf; assert(buf.getBuffer()[buf.getLength()] == '\\0');</code>
- * </p>
- * <p>This class can be used as a poor man's string class.
- * </p>
- * <p>Very effizient:
- * <ul>
- * <li>Every instance contains an array (512 Bytes),
- * which is used if not more space is needed.
- * In many cases there is no need of heap allocation (new or malloc().</li>
- * <li>Many of the methods are written as inlines.</li>
- * </ul>
- * </p>
- */
-class ReByteBuffer {
-public:
- typedef char Byte;
-public:
- ReByteBuffer(size_t delta = PRIMARY_BUFFER_SIZE);
- ReByteBuffer(const char* source);
- ReByteBuffer(const Byte* source, size_t sourceLength);
- virtual ~ReByteBuffer();
- ReByteBuffer(const ReByteBuffer& source);
- ReByteBuffer& operator =(const ReByteBuffer& source);
-public:
- ReByteBuffer& append(const Byte* source, size_t length = -1);
- ReByteBuffer& append(const ReByteBuffer& source);
- ReByteBuffer& append(double, const char* format = "%f");
- /** Appends a 8 bit value in an architecture independent way.
- * @param value integer to append
- * @return <code>*this</code> (for chaining)
- */
- inline ReByteBuffer& appendBits8(int value) {
- setLength(m_length + 1);
- m_buffer[m_length - 1] = (char) value;
- return *this;
- }
- /** Appends a 16 bit value in an architecture independent way.
- * @param value integer to append
- * @return <code>*this</code> (for chaining)
- */
- inline ReByteBuffer& appendBits16(int value) {
- setLength(m_length + 2);
- m_buffer[m_length - 2] = char(value >> 8);
- m_buffer[m_length - 1] = char(value);
- return *this;
- }
- /** Appends a 24 bit value in an architecture independent way.
- * @param value integer to append
- * @return <code>*this</code> (for chaining)
- */
- inline ReByteBuffer& appendBits24(int value) {
- setLength(m_length + 3);
- m_buffer[m_length - 3] = char(value >> 16);
- m_buffer[m_length - 2] = char(value >> 8);
- m_buffer[m_length - 1] = char(value);
- return *this;
- }
- /** Appends a 24 bit value in an architecture independent way.
- * @param value integer to append
- * @return <code>*this</code> (for chaining)
- */
- inline ReByteBuffer& appendBits32(int value) {
- setLength(m_length + 4);
- m_buffer[m_length - 4] = char(value >> 24);
- m_buffer[m_length - 3] = char(value >> 16);
- m_buffer[m_length - 2] = char(value >> 8);
- m_buffer[m_length - 1] = char(value);
- return *this;
- }
- /** Appends a 64 bit value in an architecture independent way.
- * @param value integer to append
- * @return <code>*this</code> (for chaining)
- */
- inline ReByteBuffer& appendBits64(int64_t value) {
- setLength(m_length + 8);
- m_buffer[m_length - 8] = char(value >> 56);
- m_buffer[m_length - 7] = char(value >> 48);
- m_buffer[m_length - 6] = char(value >> 40);
- m_buffer[m_length - 5] = char(value >> 32);
- m_buffer[m_length - 4] = char(value >> 24);
- m_buffer[m_length - 3] = char(value >> 16);
- m_buffer[m_length - 2] = char(value >> 8);
- m_buffer[m_length - 1] = char(value);
- return *this;
- }
- /** Appends a character.
- * @param aChar character to append
- * @return <code>*this</code> (for chaining)
- */
- inline ReByteBuffer& appendChar(char aChar) {
- setLength(m_length + 1);
- m_buffer[m_length - 1] = aChar;
- return *this;
- }
- /** Appends a character at least one time.
- * @param aChar character to append
- * @param count number of times to append
- * @return <code>*this</code> (for chaining)
- */
- inline ReByteBuffer& appendChar(char aChar, int count) {
- if (count > 0) {
- size_t oldLength = m_length;
- setLength(m_length + count);
- memset(m_buffer + oldLength, aChar, count);
- }
- return *this;
- }
- ReByteBuffer& appendFix(const char* data, size_t length, int maxLength,
- int minLength = 0, const char* separator = "*", char padding = ' ');
- ReByteBuffer& appendDump(const char* data, size_t length = -1,
- int maxLength = 80);
- ReByteBuffer& appendHexDump(const char* data, size_t length = -1,
- int offset = 0, int bytePerLine = 16, const char* offsetFormat =
- "%04x: ", bool withAscii = true, int groupWidth = 1, int gapBehind =
- -1, const char* separator = " | ");
- ReByteBuffer& appendInt(int number, const char* format = "%d");
- ReByteBuffer& appendInt(unsigned int number, const char* format = "%d");
- ReByteBuffer& appendInt(int64_t number, const char* format = "%lld");
- ReByteBuffer& appendInt(uint64_t number, const char* format = "%lld");
- ReByteBuffer& appendMilliSec(int time, int minLength = 5);
- ReByteBuffer& appendTime(int time, int minLength = 1);
- /** @brief Returns the n-th byte of the internal buffer.
- * @param index The index of the wanted byte.
- * @return 0: Wrong index. Otherwise: The byte from the wanted position.
- */
- inline Byte at(size_t index) const {
- return index >= m_length ? 0 : m_buffer[index];
- }
- int atoi(size_t start = 0, int end = -1) const;
- /** @brief Returns the buffer (permitting modifying).
- * @return The internal used buffer.
- */
- inline Byte* buffer() const {
- return m_buffer;
- }
- /**@brief Returns the current size of the internal buffer.
- * @return The current size of the internal buffer.
- */
- inline size_t capacity() const {
- return m_capacity;
- }
- int count(const char* toCount, size_t lengthToCount = -1);
- /**@brief Returns the minimum allocation unit.
- * @return The minimum of bytes to allocate.
- */
- inline size_t delta() const {
- return m_delta;
- }
- bool endsWith(const Byte* tail, size_t tailLength = -1, bool ignoreCase =
- false) const;
- void ensureSize(size_t size);
- /** After the call the last character is the given.
- * @param aChar the character which will be the last
- * @return <code>*this</code> (for chaining)
- */
- inline ReByteBuffer& ensureLastChar(char aChar) {
- if (lastChar() != aChar)
- appendChar(aChar);
- return *this;
- }
- /** @brief Tests whether another instance is equal to this instance.
- * @param data string to compare
- * @param length length of <code>data</code>. If -1: <code>strlen(data)</code>
- * @param ignoreCase <code>true</code>: case insensitive comparison
- * @return <code>true</code>: the buffer's contents are equal
- */
- inline
- bool equals(const char* data, size_t length,
- bool ignoreCase = false) const {
- if (length == (size_t) -1)
- length = strlen(data);
- bool rc = length == m_length
- && ((!ignoreCase && _memcmp(data, m_buffer, length) == 0)
- || (ignoreCase && _strnicmp(data, m_buffer, length) == 0));
- return rc;
- }
- /** @brief Tests whether another instance is equal to this instance.
- * @param buffer the buffer to compare
- * @param ignoreCase <code>true</code>: case insensitive comparison
- * @return <code>true</code>: the buffer's contents are equal
- */
- inline
- bool equals(const ReByteBuffer& buffer, bool ignoreCase = false) const {
- bool rc = buffer.length() == m_length
- && ((!ignoreCase && _memcmp(buffer.str(), m_buffer, m_length) == 0)
- || (ignoreCase
- && _strnicmp(buffer.str(), m_buffer, m_length) == 0));
- return rc;
- }
- ReByteBuffer& fill(Byte filler = 0, int start = 0, int end = -1);
- int firstDifference(const Byte* source, size_t length, int start = 0,
- bool ignoreCase = false);
- /** @brief Finds the index of the first occurrence of a given byte.
- * @param toFind This byte will be searched.
- * @param start The first index for searching.
- * @return -1: not found. Otherwise: The index of the first occurrence.
- */
- inline
- int indexOf(Byte toFind, int start = 0) const {
- while ((size_t) start < m_length)
- if (m_buffer[start++] == toFind)
- return start - 1;
- return -1;
- }
- int indexOf(const Byte* toFind, size_t toFindLength, int start = 0,
- int end = -1, bool ignoreCase = false) const;
- /** @brief Inserts a byte sequence.
- * @param ix The position in the internal buffer for the insertion.
- * @param source The sequence to insert.
- * @param length The length of the inserted sequence.
- *
- * @return true: Success. false: <code>ix</code> out of range.
- */
- inline
- bool insert(size_t ix, const Byte* source, size_t length) {
- return splice(ix, 0, source, length);
- }
- bool isPrefixOf(const char* source, size_t length = -1, bool ignoreCase =
- false, int minLength = 0);
- /** Returns the last character.
- * @return '\0': empty buffer<br>
- * otherwise: the last character
- */
- inline
- char lastChar() const {
- return m_length == 0 ? '\0' : m_buffer[m_length - 1];
- }
- /**@brief Returns the length of the buffer (the count of used bytes).
- * @return The count of the allocated bytes in the internal buffer.
- */
- inline size_t length() const {
- return m_length;
- }
- /** Sets the length to a lower value.
- * @param decrement the count to reduce the length
- * @return The count of the allocated bytes in the internal buffer.
- */
- inline ReByteBuffer& reduceLength(int decrement = 1) {
- if (decrement > 0 && m_length > 0) {
- if (decrement > (int) m_length)
- decrement = m_length;
- setLength(m_length - decrement);
- }
- return *this;
- }
- /** @brief Cuts a sequence from the internal buffer.
- *
- * @param ix The index where the cut/insertion takes place.
- * @param deletedLength The number of deleted bytes.
- * This value may be larger than the existing bytes.
- *
- * @return true: Success. false: <code>ix</code> out of range.
- */
- inline
- bool remove(size_t ix, size_t deletedLength) {
- return splice(ix, deletedLength, NULL, 0);
- }
- ReByteBuffer& replaceAll(const Byte* toFind, size_t toFindLength,
- const Byte* replacement, size_t replacementLength, int start = 0);
- /** Removes an unwanted character at the end.
- * @param aChar character to remove
- * @return <code>*this</code> (for chaining)
- */
- inline ReByteBuffer& removeLastChar(char aChar) {
- if (m_length > 0 && m_buffer[m_length - 1] == aChar)
- setLength(m_length - 1);
- return *this;
- }
- /** @brief Finds the index of the last occurrence of a given byte (reverse index of).
- * @param toFind This byte will be searched.
- * @param start The first index for searching. If < 0: relative to the end.
- * @return -1: not found. Otherwise: The index of the last occurrence.
- */
- inline
- int rindexOf(Byte toFind, int start = -1) const {
- if (start < 0)
- start = m_length + start;
- while (start >= 0)
- if (m_buffer[start--] == toFind)
- return start + 1;
- return -1;
- }
- int rindexOf(const Byte* toFind, size_t toFindLength, int start = 0,
- int end = -1, bool ignoreCase = false) const;
- /** @brief Sets the content of the buffer by copying a byte sequence.
- * @param source The byte sequence to copy.
- * @param length The length of <code>source</code>.
- * @return *this (for chaining).
- */
- inline ReByteBuffer& set(const Byte* source, size_t length) {
- return setLength(0).append(source, length);
- }
- /** @brief Sets the content of the buffer by copying a byte sequence.
- * @param source the source to copy.
- * @return *this (for chaining).
- */
- inline ReByteBuffer& set(const ReByteBuffer& source) {
- return setLength(0).append(source);
- }
- void setDelta(int delta);
- ReByteBuffer& setLength(size_t length);
- ReByteBuffer& setLengthAndFillOut(size_t length, Byte filler = 0);
- bool splice(size_t ix, size_t replacedLength, const Byte* source,
- size_t length);
- bool startsWith(const Byte* head, size_t headLength = -1,
- const bool ignoreCase = false) const;
- const char* status(ReByteBuffer& buffer, const char* prefix = NULL) const;
- /** @brief Returns the buffer content as C string.
- * This is exactly the same result as from <code>getBuffer()</code>.
- * @return The internal used buffer.
- */
- inline
- const char* str() const {
- return (const char*) m_buffer;
- }
-protected:
- // The minimum difference between old and new size after a new allocation.
- int m_delta;
- //@ If the needed space is small enough this buffer will be used.
- char m_primaryBuffer[PRIMARY_BUFFER_SIZE];
- //@ The internal buffer. Points to <code>m_primaryBuffer</code> if the space is small enough.
- char* m_buffer;
- //@ The used bytes in <code>m_buffer</code>.
- size_t m_length;
- //@ The size of <code>m_buffer</code>.
- size_t m_capacity;
- //@ number of reallocation in ensureSize()
- int m_reallocation;
-};
-
-#endif /* REBYTEBUFFER_H_ */
/*
* ReCString.cpp
- *
+ *
* License: Public Domain
* You can use and modify this file without any restriction.
* Do what you want.
/*
* ReCString.hpp
- *
+ *
* License: Public Domain
* You can use and modify this file without any restriction.
* Do what you want.
/*
* ReClassId.cpp
- *
+ *
* License: Public Domain
* You can use and modify this file without any restriction.
* Do what you want.
*/
#include "base/rebase.hpp"
-static ReByteBuffer s_unknownClassname;
+static ReByteArray s_unknownClassname;
const char* classIdToString(ReClassId classId) {
const char* rc = "?";
/*
* ReClassId.hpp
- *
+ *
* License: Public Domain
* You can use and modify this file without any restriction.
* Do what you want.
/*
* ReConfigFile.cpp
- *
+ *
* License: Public Domain
* You can use and modify this file without any restriction.
* Do what you want.
FILE* fp = fopen(filename, "r");
char line[4096];
char* equal;
- ReByteBuffer buffer;
+ ReByteArray buffer;
if (fp != NULL) {
int lineNo = 0;
* @return The wanted integer or the default value.
*/
int ReConfigFile::getInteger(const char* key, int defaultVal) {
- ReByteBuffer value;
+ ReByteArray value;
getString(key, value, NULL);
int rc = defaultVal;
if (!isdigit(value.at(0)))
* @param buffer Out: The buffer for the result string.
* @param defaultVal If the key could not found this value will be returned. May be NULL.
*/
-void ReConfigFile::getString(const char* key, ReByteBuffer& buffer,
+void ReConfigFile::getString(const char* key, ReByteArray& buffer,
const char* defaultVal) {
if (!get(key, -1, buffer)) {
if (defaultVal == NULL)
* @return The wanted boolean or the default value.
*/
bool ReConfigFile::getBool(const char* key, bool defaultVal) {
- ReByteBuffer value;
+ ReByteArray value;
getString(key, value, NULL);
bool rc = defaultVal;
if (ReStringUtils::isInList(value.str(), i18n(m_falseValues)))
/*
* ReConfigFile.hpp
- *
+ *
* License: Public Domain
* You can use and modify this file without any restriction.
* Do what you want.
public:
void readFile(const char* filename);
int getInteger(const char* key, int defaultVal = 0);
- void getString(const char* key, ReByteBuffer& buffer,
+ void getString(const char* key, ReByteArray& buffer,
const char* defaultVal = NULL);
bool getBool(const char* key, bool defaultVal = false);
/** @brief Returns whether the instance is in a valid state.
return m_valid;
}
protected:
- ReByteBuffer m_filename;
+ ReByteArray m_filename;
bool m_valid;
};
/*
* ReDirectory.cpp
- *
+ *
* License: Public Domain
* You can use and modify this file without any restriction.
* Do what you want.
#include "base/rebase.hpp"
+/// pattern for "all files", used in findFirst():
+const char* ReDirectory::ALL_FILES = "";
+
/** @brief Constructor.
*/
ReDirectory::ReDirectory() :
m_path(),
m_pattern(),
+ m_currentFull(),
+ m_stat(),
#if defined __linux__
m_dir(NULL),
m_entry(NULL),
/** @brief Returns the name of the current file found by the last <code>findFirst()</code>
* or <code>findNext()</code>.
*
- * @return NULL: No current file exists. Otherwise: The name of the current file.
+ * @return NULL: No current file exists<br>
+ * Otherwise: The name of the current file (without path)
*
*/
-const char* ReDirectory::currentFile() {
+const char* ReDirectory::currentNode() {
#if defined __linux__
const char* rc = m_entry == NULL ? NULL : m_entry->d_name;
#elif defined __WIN32__
return rc;
}
+/**
+ * Returns the file status info of the current file.
+ *
+ * @param the status info given by <code>lstat()</code>
+ */
+struct stat& ReDirectory::currentLStat(){
+ if (m_stat.st_gid == -1 && filetimeIsUndefined(m_stat.st_mtim)){
+ lstat(currentFull().str(), &m_stat);
+ }
+ return m_stat;
+}
+
+/**
+ * Returns whether the current file is a directory.
+ *
+ * @return <code>true</code>: the current file is a directory
+ */
+bool ReDirectory::currentIsDir(){
+#if defined __linux__
+ return S_ISDIR(currentLStat().st_mode);
+#elif defined __WIN32__
+ return
+#endif
+}
+
+/**
+ * Returns whether the current file is a directory.
+ *
+ * @return <code>true</code>: the current file is a directory
+ */
+ReFileTime_t ReDirectory::currentModified(){
+#if defined __linux__
+ return currentLStat().st_mtim;
+#elif defined __WIN32__
+ return
+#endif
+}
+
/**
* Deletes a directory tree.
*
void ReDirectory::deleteTree(const char* base, bool deleteBaseToo) {
if (true) {
ReDirectory dir(base);
- if (dir.findFirst("*", false)) {
- ReByteBuffer full;
+ if (dir.findFirst(ALL_FILES, false)) {
do {
struct stat info;
- const char* node = dir.currentFile();
+ const char* node = dir.currentNode();
if ((!(node[0] == '.'
&& (node[1] == '\0' || (node[1] == '.' && node[2] == '\0'))))
- && stat(dir.fullpath(full).str(), &info) == 0) {
+ && stat(dir.currentFull().str(), &info) == 0) {
if (S_ISDIR(info.st_mode))
- deleteTree(full.str(), true);
+ deleteTree(dir.currentFull().str(), true);
else
- _unlink(full.str());
+ _unlink(dir.currentFull().str());
}
} while (dir.findNext());
}
}
}
+/**
+ * Returns the filetime of a given file.
+ *
+ * @param filename filename with path
+ * @param modified OUT: the modification date. May be NULL
+ * @param created OUT: the modification date. May be NULL
+ * @param accessed OUT: the modification date. May be NULL
+ */
+bool ReDirectory::filetime(const char* filename, ReFileTime_t* modified,
+ ReFileTime_t* created, ReFileTime_t* accessed){
+#if defined __linux__
+ struct stat info;
+ bool rc = stat(filename, &info) == 0;
+ if (rc){
+ if (modified != NULL)
+ ;
+ }
+#elif defined __WIN32__
+#endif
+ return rc;
+}
/** @brief Returns the name of the directory.
*
* @return The name of the directory.
/** @brief Find the first file with a given filename pattern.
*
- * @param pattern A filename pattern.
- * @param isRegExpr true: The pattern contains regular expressions. false: The pattern contains wildcards.
+ * @param pattern A filename pattern. If "": delivery of all files
+ * @param isRegExpr <code>true</code>: The pattern contains regular expressions.<br>
+ * <code>false</code>: The pattern contains wildcards.
*
* @return true: A file has been found. false: The directory contains no file with the given pattern.
*/
rc = findNext();
}
#elif defined __WIN32__
- ReByteBuffer full(m_path);
+ ReByteArray full(m_path);
full.append(OS_SEPARATOR, -1).append(pattern, -1);
m_handle = FindFirstFileA(full.str(), &m_data);
rc = m_handle != INVALID_HANDLE_VALUE;
*/
bool ReDirectory::findNext() {
bool rc = false;
+ m_currentFull.clear();
+ m_stat.st_gid = -1;
+ setFiletimeUndef(m_stat.st_mtim);
if (m_valid) {
#if defined __linux__
while (!rc && (m_entry = readdir(m_dir)) != NULL) {
sizeof match / sizeof match[0], match, 0);
if (rc2 == 0)
rc = true;
- } else {
+ } else if (m_pattern.empty())
+ rc = true;
+ else {
if (fnmatch(m_pattern.str(), m_entry->d_name, 0) == 0)
rc = true;
}
*
* @param false: No file found. true: A file was found.
*/
-bool ReDirectory::findYoungest(ReByteBuffer& filename) {
+bool ReDirectory::findYoungest(ReByteArray& filename) {
bool rc = false;
filename.setLength(0);
- ReByteBuffer fullname;
+ ReByteArray fullname;
#if defined __linux__
if (m_entry != NULL) {
*
* @return <code>path</code> (for chaining).
*/
-ReByteBuffer& ReDirectory::fullpath(ReByteBuffer& path, const char* name) {
+ReByteArray& ReDirectory::fullpath(ReByteArray& path, const char* name) {
path.setLength(0);
if (name != NULL) {
path.set(m_path.str(), m_path.length());
m_valid = m_dir != NULL;
#elif defined __WIN32__
struct stat info;
- ReByteBuffer thePath(m_path);
+ ReByteArray thePath(m_path);
thePath.removeLastChar(OS_SEPARATOR_CHAR);
m_valid = stat(thePath.str(), &info) == 0 && S_ISDIR(info.st_mode);
#endif
/*
* ReDirectory.hpp
- *
+ *
* License: Public Domain
* You can use and modify this file without any restriction.
* Do what you want.
* The latest sources: https://github.com/republib
*/
-#ifndef REFILEFINDER_H_
-#define REFILEFINDER_H_
+#ifndef REDIRECTORY_H_
+#define REDIRECTORY_H_
/** <code>ReDirectory</code> searches files using pattern matching and/or file date.
*/
class ReDirectory {
~ReDirectory();
public:
void close();
- const char* currentFile();
+ /** @brief Returns the filename of the current file with path.
+ * @return the full filename with path
+ */
+ const ReByteArray& currentFull(){
+ if (m_currentFull.empty())
+ m_currentFull.set(m_path).append(currentNode());
+ return m_currentFull;
+ }
+ const char* currentNode();
+ bool currentIsDir();
+ struct stat& currentLStat();
+ ReFileTime_t currentModified();
bool findFirst(const char* pattern, bool isRegExpr);
bool findNext();
- bool findYoungest(ReByteBuffer& filename);
- ReByteBuffer& fullpath(ReByteBuffer& path, const char* name = NULL);
+ bool findYoungest(ReByteArray& filename);
+ ReByteArray& fullpath(ReByteArray& path, const char* name = NULL);
const char* getDir(void) const;
bool isValid();
void setDir(const char* path);
void setRegExprFlags(int flags);
public:
static void deleteTree(const char* base, bool deleteBaseToo = false);
+ static bool filetime(const char* filename, ReFileTime_t* modified,
+ ReFileTime_t* created = NULL, ReFileTime_t* accessed = NULL);
+public:
+ static const char* ALL_FILES;
private:
//@ The name of the current directory. Always ends with slash!
- ReByteBuffer m_path;
- ReByteBuffer m_pattern;
+ ReByteArray m_path;
+ ReByteArray m_pattern;
+ struct stat m_stat;
+ ReByteArray m_currentFull;
#if defined __linux__
DIR* m_dir;
struct dirent* m_entry;
//@ true: The directory is ok. false: The directory is undefined.
bool m_valid;
};
-#endif /* REFILEFINDER_H_ */
+
+/** Returns whether a filetime is undefined.
+ * @param time the filetime to test
+ * @return <code>true</code>: the given filetime is undefined
+ */
+inline bool filetimeIsUndefined(const ReFileTime_t& time) {
+#if defined __linux__
+ return time.tv_sec == 0 && time.tv_nsec == 0;
+#elif defined __WIN32__
+ return time.dwHighDateTime == 0 && time.dwLowDateTime == 0;
+#endif
+}
+/** Sets the filetime to undefined.
+ * @param time the filetime to clear
+ */
+inline void setFiletimeUndef(ReFileTime_t& time) {
+#if defined __linux__
+ time.tv_sec = time.tv_nsec = 0;
+#elif defined __WIN32__
+ time.dwHighDateTime = time.dwLowDateTime = 0;
+#endif
+}
+/** Returns whether a filetime is equal than another.
+ * @param op1 first operand
+ * @param op2 second operand
+ * @return <code>true</code>: op1 == op2
+ */
+inline bool operator ==(const ReFileTime_t& op1, const ReFileTime_t& op2){
+#if defined __linux__
+ return op1.tv_sec == op2.tv_sec && op1.tv_nsec == op2.tv_nsec;
+#else
+ return time1.dwHighDateTime == time2.dwHighDateTime
+ && time1.dwLowDateTime == time2.dwLowDateTime;
+#endif
+}
+/** Returns whether a filetime is equal than another.
+ * @param op1 first operand
+ * @param op2 second operand
+ * @return <code>true</code>: op1 == op2
+ */
+inline bool operator !=(const ReFileTime_t& op1, const ReFileTime_t& op2){
+ return ! (op1 == op2);
+}
+/** Returns whether a filetime is greater (younger) than another.
+ * @param op1 first operand
+ * @param op2 second operand
+ * @return <code>true</code>: op1 > op2
+ */
+inline bool operator >(const ReFileTime_t& op1, const ReFileTime_t& op2){
+#if defined __linux__
+ return op1.tv_sec > op2.tv_sec || op1.tv_sec == op2.tv_sec && op1.tv_nsec > op2.tv_nsec;
+#else
+ return time1.dwHighDateTime > time2.dwHighDateTime
+ || (time1.dwHighDateTime == time2.dwHighDateTime
+ && time1.dwLowDateTime > time2.dwLowDateTime);
+#endif
+}
+/** Returns whether a filetime is greater (younger) or equal than another.
+ * @param op1 first operand
+ * @param op2 second operand
+ * @return <code>true</code>: op1 > op2
+ */
+inline bool operator >=(const ReFileTime_t& op1, const ReFileTime_t& op2){
+#if defined __linux__
+ return op1.tv_sec > op2.tv_sec || op1.tv_sec == op2.tv_sec && op1.tv_nsec >= op2.tv_nsec;
+#else
+ return time1.dwHighDateTime > time2.dwHighDateTime
+ || (time1.dwHighDateTime == time2.dwHighDateTime
+ && time1.dwLowDateTime >= time2.dwLowDateTime);
+#endif
+}
+/** Returns whether a filetime is lower (younger) than another.
+ * @param op1 first operand
+ * @param op2 second operand
+ * @return <code>true</code>: op1 > op2
+ */
+inline bool operator <(const ReFileTime_t& op1, const ReFileTime_t& op2){
+ return ! (op1 >= op2);
+}
+/** Returns whether a filetime is lower (older) or equal than another.
+ * @param op1 first operand
+ * @param op2 second operand
+ * @return <code>true</code>: op1 > op2
+ */
+inline bool operator <=(const ReFileTime_t& op1, const ReFileTime_t& op2){
+ return op1 == op2 || op1 < op2;
+}
+
+
+#endif /* REDIRECTORY_H_ */
/*
* ReException.cpp
- *
+ *
* License: Public Domain
* You can use and modify this file without any restriction.
* Do what you want.
*/
ReNotImplementedException::ReNotImplementedException(const char* description) :
ReException(
- ReByteBuffer(i18n("not implemented: ")).append(description).str()) {
+ ReByteArray(i18n("not implemented: ")).append(description).str()) {
}
/*
* ReException.hpp
- *
+ *
* License: Public Domain
* You can use and modify this file without any restriction.
* Do what you want.
/*
* ReHashList.cpp
- *
+ *
* License: Public Domain
* You can use and modify this file without any restriction.
* Do what you want.
if (prefix != NULL)
fprintf(stream, "%s\n", prefix);
ReArrayPosition position;
- ReByteBuffer key, value;
+ ReByteArray key, value;
while (next(position, &key, &value)) {
fprintf(stream, "%s : [%3d] %s\n", key.str(), (int) value.length(),
value.str());
* @return false: The key was not found. true: The key was found.
*/
bool ReHashList::get(const Byte* key, size_t keyLength,
- ReByteBuffer& value) const {
+ ReByteArray& value) const {
ReSeqArray::Index index;
ReSeqArray::Tag tag;
bool rc = m_keys.binarySearch(key, keyLength, index, &tag);
*
* @return false: The key was not found. true: The key was found.
*/
-bool ReHashList::get(const ReByteBuffer& key, ReByteBuffer& value) const {
+bool ReHashList::get(const ReByteArray& key, ReByteArray& value) const {
bool rc = get(key.str(), key.length(), value);
return rc;
}
*
* @param true: An item was found. false: No more items.
*/
-bool ReHashList::next(ReArrayPosition& position, ReByteBuffer* key,
- ReByteBuffer* value) const {
+bool ReHashList::next(ReArrayPosition& position, ReByteArray* key,
+ ReByteArray* value) const {
bool rc = position.m_position + 1 < m_keys.count();
if (rc) {
- ReByteBuffer dummy;
+ ReByteArray dummy;
ReSeqArray::Tag tag;
if (key == NULL)
key = &dummy;
* @param key The key.
* @param value The value.
*/
-void ReHashList::put(const ReByteBuffer& key, const ReByteBuffer& value) {
+void ReHashList::put(const ReByteArray& key, const ReByteArray& value) {
put(key.str(), key.length(), value.str(), value.length());
}
* @param prefix NULL or a prefix of the output
* @return <code>buffer.str()</code> (for chaining)
*/
-const char* ReHashList::status(ReByteBuffer& buffer, const char* prefix) const {
+const char* ReHashList::status(ReByteArray& buffer, const char* prefix) const {
if (prefix != NULL)
buffer.append(prefix).append("\n", 1);
m_keys.status(buffer, "keys: ");
/*
* ReHashList.hpp
- *
+ *
* License: Public Domain
* You can use and modify this file without any restriction.
* Do what you want.
public:
void clear();
void dump(FILE* stream, const char* prefix = NULL) const;
- bool get(const Byte* key, size_t keyLength, ReByteBuffer& value) const;
- bool get(const ReByteBuffer& key, ReByteBuffer& value) const;
- bool next(ReArrayPosition& position, ReByteBuffer* key,
- ReByteBuffer* val) const;
+ bool get(const Byte* key, size_t keyLength, ReByteArray& value) const;
+ bool get(const ReByteArray& key, ReByteArray& value) const;
+ bool next(ReArrayPosition& position, ReByteArray* key,
+ ReByteArray* val) const;
void put(const Byte* key, size_t keyLength, const Byte* value,
size_t valueLength);
void put(const char* key, const char* value);
- void put(const ReByteBuffer& key, const ReByteBuffer& value);
+ void put(const ReByteArray& key, const ReByteArray& value);
void setCapacity(int maxKeys, int keySpace, int contentSpace);
void setSizes(int sizeOfKeyString, int sizeOfValueString);
- const char* status(ReByteBuffer& buffer, const char* prefix = NULL) const;
+ const char* status(ReByteArray& buffer, const char* prefix = NULL) const;
protected:
int find(const Byte* key, size_t length) const;
/*
* ReI18N.cpp
- *
+ *
* License: Public Domain
* You can use and modify this file without any restriction.
* Do what you want.
/*
* ReI18N.hpp
- *
+ *
* License: Public Domain
* You can use and modify this file without any restriction.
* Do what you want.
/*
* ReLogger.cpp
- *
+ *
* License: Public Domain
* You can use and modify this file without any restriction.
* Do what you want.
strcat(m_filePattern + len, first + 1);
}
- ReByteBuffer fn, protocol, path, name, ext;
+ ReByteArray fn, protocol, path, name, ext;
ReStringUtils::splitPath(m_filePattern, &protocol, &path, &name, &ext);
ReStringUtils::joinPath(fn, &protocol, &path, NULL, NULL);
- if (fn.length() == 0)
+ if (fn.empty())
fn.set(".", 1);
ReDirectory dir(fn.str());
if (!dir.isValid()) {
m_currentFileNo = fn.atoi(ix, 4);
}
struct stat info;
- ReByteBuffer fullname;
+ ReByteArray fullname;
dir.fullpath(fullname, fn.str());
#ifdef __WIN32__
#define lstat stat
/*
* ReLogger.hpp
- *
+ *
* License: Public Domain
* You can use and modify this file without any restriction.
* Do what you want.
/*
* ReMutex.cpp
- *
+ *
* License: Public Domain
* You can use and modify this file without any restriction.
* Do what you want.
/*
* ReMutex.hpp
- *
+ *
* License: Public Domain
* You can use and modify this file without any restriction.
* Do what you want.
/*
* ReProgramArgs.cpp
- *
+ *
* License: Public Domain
* You can use and modify this file without any restriction.
* Do what you want.
m_program(NULL),
m_lastError() {
m_properties.setCapacity(64, 64 * 8, 64 * 1024);
- ReByteBuffer line;
+ ReByteArray line;
for (const char** argv = usageList; *argv != NULL; argv++) {
line.set(*argv);
line.removeLastChar('\n');
if (strncmp(*argv, "$0", 2) != 0)
m_examples.append(*argv);
else {
- ReByteBuffer line;
+ ReByteArray line;
line.append(m_program, -1);
m_examples.append(line.str() + 2);
}
if (strstr(examples, "$0") == NULL)
m_examples.split(examples, '\n');
else {
- ReByteBuffer line;
+ ReByteArray line;
line.append(examples, -1);
line.replaceAll("$0", 2, m_program, -1);
m_examples.split(line.str(), '\n');
void ReProgramArgs::addProperties(const char*name, const char* description,
char shortOpt, const char* longOpt, DataType dataType,
const char* defaultValue, size_t lengthValue) {
- ReByteBuffer properties;
- ReByteBuffer descr(description, -1);
- ReByteBuffer replacement("\n", 1);
+ ReByteArray properties;
+ ReByteArray descr(description, -1);
+ ReByteArray replacement("\n", 1);
replacement.append(PREFIX_LINE_OPTION);
descr.replaceAll("\n", 1, replacement.str(), replacement.length());
properties.append(descr).appendChar('\1');
*/
void ReProgramArgs::addInt(const char* name, const char* description,
char shortOpt, const char* longOpt, int defaultVal) {
- ReByteBuffer number;
+ ReByteArray number;
number.appendInt(defaultVal);
addProperties(name, description, shortOpt, longOpt, DT_INT, number.str(),
number.length());
*/
void ReProgramArgs::analyseLong(const char* opt) {
ReStringList properties(512, 1024, 2, 2);
- ReByteBuffer name;
+ ReByteArray name;
search('\0', opt, name, properties);
const char* nameStr = name.str();
bool rc = false;
ReStringList properties(512, 1024, 2, 2);
bool again;
- ReByteBuffer name;
+ ReByteArray name;
do {
again = false;
*/
bool ReProgramArgs::getBool(const char* name) {
ReStringList properties(512, 1024, 2, 2);
- ReByteBuffer buffer;
+ ReByteArray buffer;
ReVarArgs args;
if (!m_properties.get(name, -1, buffer))
throw ReOptionException(this, i18n("$1 is not an option name"), name);
*/
int ReProgramArgs::getInt(const char* name) {
ReStringList properties(512, 1024, 2, 2);
- ReByteBuffer buffer;
+ ReByteArray buffer;
ReVarArgs args;
if (!m_properties.get(name, -1, buffer))
throw ReOptionException(this, i18n("$1 is not an option name"), name);
*
* @throws ReOptionException Unknown name or wrong type.
*/
-const char* ReProgramArgs::getString(const char* name, ReByteBuffer& buffer) {
+const char* ReProgramArgs::getString(const char* name, ReByteArray& buffer) {
ReStringList properties(512, 1024, 2, 2);
ReVarArgs args;
if (!m_properties.get(name, strlen(name), buffer))
if (m_properties.next(position, NULL, NULL)) {
lines.append(i18n("<options>:"));
}
- ReByteBuffer name;
- ReByteBuffer prop;
- ReByteBuffer line;
- ReByteBuffer param;
+ ReByteArray name;
+ ReByteArray prop;
+ ReByteArray line;
+ ReByteArray param;
while (m_properties.next(position, &name, &prop)) {
ReStringList properties(512, 1024, 2, 2);
* @throws ReOptionException Unknown option.
*/
void ReProgramArgs::search(char shortName, const char* longName,
- ReByteBuffer& name, ReStringList& list) {
+ ReByteArray& name, ReStringList& list) {
ReArrayPosition position;
- ReByteBuffer properties;
+ ReByteArray properties;
bool found = false;
size_t lengthLongName = 0;
if (longName != NULL) {
default:
break;
}
- ReByteBuffer buffer;
+ ReByteArray buffer;
// First character says: defined.
buffer.appendChar(' ').append(value, -1);
m_values.put(name, buffer.str());
/*
* ReProgramArgs.hpp
- *
+ *
* License: Public Domain
* You can use and modify this file without any restriction.
* Do what you want.
const char* arg(size_t index) const;
bool getBool(const char* name);
int getInt(const char* name);
- const char* getString(const char* name, ReByteBuffer& buffer);
+ const char* getString(const char* name, ReByteArray& buffer);
void help(const char* message, bool issueLastError,
ReStringList& lines) const;
void help(const char* message, bool issueLastError, FILE* stream) const;
size_t lengthValue);
void analyseLong(const char* opt);
bool analyseShort(const char* opt, const char* nextArg);
- void search(char shortName, const char* longName, ReByteBuffer& name,
+ void search(char shortName, const char* longName, ReByteArray& name,
ReStringList& list);
void setValue(const char* name, const char* value, const char* dataType);
protected:
const char** m_args;
int m_argCount;
const char* m_program;
- ReByteBuffer m_lastError;
+ ReByteArray m_lastError;
};
#endif /* REPROGRAMARGS_H_ */
/*
* ReSeqArray.cpp
- *
+ *
* License: Public Domain
* You can use and modify this file without any restriction.
* Do what you want.
* @param prefix NULL or a introduction
*/
void ReSeqArray::dump(FILE* fp, const char* prefix) const {
- ReByteBuffer buffer;
+ ReByteArray buffer;
Tag tag;
if (prefix != NULL)
fprintf(fp, "%s\n", prefix);
* @param true: The index is ok, the sequence is in the output buffer.
* false: No copy has been done.
*/
-bool ReSeqArray::get(Index index, ReByteBuffer& value, Tag* tag) const {
+bool ReSeqArray::get(Index index, ReByteArray& value, Tag* tag) const {
bool rc = false;
if (index < count()) {
const Sequence* seq = getInfo(index);
* @param prefix NULL or a prefix of the output
* @return <code>buffer.str()</code> (for chaining)
*/
-const char* ReSeqArray::status(ReByteBuffer& buffer, const char* prefix) const {
+const char* ReSeqArray::status(ReByteArray& buffer, const char* prefix) const {
if (prefix != NULL)
buffer.append(prefix);
buffer.append("age: ").appendInt(m_age).append("\n");
/*
* ReSeqArray.hpp
- *
+ *
* License: Public Domain
* You can use and modify this file without any restriction.
* Do what you want.
}
void dump(FILE* fp, const char* prefix) const;
Index find(const Byte* toFind, size_t length = -1, Tag* tag = NULL) const;
- bool get(Index index, ReByteBuffer& value, Tag* tag = NULL) const;
+ bool get(Index index, ReByteArray& value, Tag* tag = NULL) const;
/** Returns whether the comparisons inside the list are case insensitive.
* @return <code>true</code> the comparisons inside the list are case insensitive
*/
void setSorted(bool onNotOff);
void setIgnoreCase(bool onNotOff);
void sort();
- const char* status(ReByteBuffer& buffer, const char* prefix = NULL) const;
+ const char* status(ReByteArray& buffer, const char* prefix = NULL) const;
protected:
/** @brief Returns a pointer of the content buffer.
* @return A pointer of the first byte of the content buffer.
void shiftDown(int from, int to);
protected:
//@ Contains the sequences itself.
- ReByteBuffer m_content;
+ ReByteArray m_content;
//@ Contains an array of <code>Sequence</code>s.
- ReByteBuffer m_list;
+ ReByteArray m_list;
//@ If strings have been replaced/deleted the space in m_content is still allocated.
//@ This is the sum of lost space.
size_t m_lost;
/*
* ReSerializable.cpp
- *
+ *
* License: Public Domain
* You can use and modify this file without any restriction.
* Do what you want.
ReSerializationException::ReSerializationException(const char* message,
ReSerializable* instance) :
ReException(
- ReByteBuffer(message, -1).appendChar(' ').append(
+ ReByteArray(message, -1).appendChar(' ').append(
instance->parentClassName()).str()) {
}
/**
ReSerializationLengthException::ReSerializationLengthException(
int currentLength, int expectedLength, ReSerializable* instance) :
ReSerializationException(
- ReByteBuffer(i18n("pack error: length to small: ")).appendInt(
+ ReByteArray(i18n("pack error: length to small: ")).appendInt(
currentLength).appendChar('/').appendInt(expectedLength).str(),
instance),
m_currentLength(currentLength),
ReSerializeStringLengthException::ReSerializeStringLengthException(
int currentLength, int maxLength, ReSerializable* instance) :
ReSerializationException(
- ReByteBuffer(i18nTranslate("string length too large: ")).appendInt(
+ ReByteArray(i18nTranslate("string length too large: ")).appendInt(
currentLength).appendChar('/').appendInt(maxLength).str(),
instance),
m_currentLength(currentLength),
* @param time the filetime to serialize
*
*/
-void ReSerializable::packFileTime(ReByteBuffer& sequence,
+void ReSerializable::packFileTime(ReByteArray& sequence,
const ReFileTime_t& time) {
uint64_t value;
#if defined __linux__
/*
* ReSerializable.hpp
- *
+ *
* License: Public Domain
* You can use and modify this file without any restriction.
* Do what you want.
* @param sequence the serialized sequence
* @throw ReSerializationLengthException
*/
- inline void deserializeBuffer(const ReByteBuffer& sequence) {
+ inline void deserializeBuffer(const ReByteArray& sequence) {
size_t length = sequence.length();
const uint8_t* seq = reinterpret_cast<const uint8_t*>(sequence.str());
deserialize(seq, length);
* @param sequence IN/OUT: the sequence with the serialized values
* @param value the value to serialize
*/
- inline void packBool(ReByteBuffer& sequence, bool value) {
+ inline void packBool(ReByteArray& sequence, bool value) {
sequence.appendChar(value ? 't' : 'f');
}
- void packFileTime(ReByteBuffer& sequence, const ReFileTime_t& time);
+ void packFileTime(ReByteArray& sequence, const ReFileTime_t& time);
/** Appends a string with a maximal length of 255 to the sequence.
* @param sequence IN/OUT: the sequence with the serialized values
* @param value the value to serialize
*/
- inline void packString255(ReByteBuffer& sequence, ReByteBuffer& value) {
+ inline void packString255(ReByteArray& sequence, ReByteArray& value) {
if (value.length() > 255)
throw ReSerializeStringLengthException(value.length(), 255, this);
sequence.appendBits8(value.length()).append(value);
* @param sequence IN/OUT: the sequence with the serialized values
* @param value the value to serialize
*/
- inline void packString255(ReByteBuffer& sequence, const char* value,
+ inline void packString255(ReByteArray& sequence, const char* value,
size_t length = -1) {
if (length == (size_t) -1)
length = strlen(value);
* @param sequence IN/OUT: the sequence with the serialized values
* @param value the value to serialize
*/
- inline void packString64k(ReByteBuffer& sequence, ReByteBuffer& value) {
+ inline void packString64k(ReByteArray& sequence, ReByteArray& value) {
if (value.length() > 0xffff)
throw ReSerializeStringLengthException(value.length(), 0xffff,
this);
* @param length length of <code>value</code><br>
* -1: <code>strlen(value)</code>
*/
- inline void packString64k(ReByteBuffer& sequence, const char* value,
+ inline void packString64k(ReByteArray& sequence, const char* value,
size_t length = -1) {
if (length == (size_t) -1)
length = strlen(value);
* @param sequence IN/OUT: the sequence with the serialized values
* @param value the value to serialize
*/
- inline void packString4t(ReByteBuffer& sequence, ReByteBuffer& value) {
+ inline void packString4t(ReByteArray& sequence, ReByteArray& value) {
sequence.appendBits32(value.length()).append(value);
}
/** Appends a string with a maximal length of 4 TiByte to the sequence.
* @param length length of <code>value</code><br>
* -1: <code>strlen(value)</code>
*/
- inline void packString4t(ReByteBuffer& sequence, const char* value,
+ inline void packString4t(ReByteArray& sequence, const char* value,
size_t length = -1) {
if (length == (size_t) -1)
length = strlen(value);
* @param sequence IN/OUT: the sequence containing the serialized bytes
* @return the <code>sequence</code> (for chaining)
*/
- virtual ReByteBuffer& serialize(ReByteBuffer& sequence) = 0;
+ virtual ReByteArray& serialize(ReByteArray& sequence) = 0;
/** Reads a 8 bit integer from the serialized byte sequence.
* @param sequence IN/OUT: the byte sequence with the serialized data
* @param length IN/OUT: the length of <code>sequence</code>
* @param value OUT: the value read from the sequence
*/
inline void unpackString255(const uint8_t*& sequence, size_t& length,
- ReByteBuffer& value) {
+ ReByteArray& value) {
size_t strLen = 0;
if (length < 1 || (strLen = *sequence) > length)
throw ReSerializationLengthException(length, 1 + strLen, this);
* @param value OUT: the value read from the sequence
*/
inline void unpackString64k(const uint8_t*& sequence, size_t& length,
- ReByteBuffer& value) {
+ ReByteArray& value) {
size_t strLen = 0;
if (length < 2 || (strLen = (sequence[0] << 8) + sequence[1]) > length)
throw ReSerializationLengthException(length, 2 + strLen, this);
* @param value OUT: the value read from the sequence
*/
inline void unpackString4t(const uint8_t*& sequence, size_t& length,
- ReByteBuffer& value) {
+ ReByteArray& value) {
size_t strLen = 0;
if (length < 4
|| (strLen = (sequence[0] << 24) + (sequence[1] << 16)
/*
* ReStringList.cpp
- *
+ *
* License: Public Domain
* You can use and modify this file without any restriction.
* Do what you want.
* @param tag a number which will stored with the string. Not interpreted by the instance
* @return the instance itself (for chaining)
*/
-ReStringList& ReStringList::append(const ReByteBuffer& source, Tag tag) {
+ReStringList& ReStringList::append(const ReByteArray& source, Tag tag) {
add(-1, source.str(), source.length() + 1, tag);
return *this;
}
* @param tag the new tag
*/
void ReStringList::replaceTag(Index index, Tag tag) {
- ReByteBuffer buffer;
+ ReByteArray buffer;
if (get(index, buffer))
set(index, buffer.str(), buffer.length(), tag);
}
*/
ReSeqArray::Tag ReStringList::tagOf(Index index) const {
Tag rc = -1;
- ReByteBuffer buffer;
+ ReByteArray buffer;
if (!get(index, buffer, &rc)) {
rc = -1;
}
*/
size_t ReStringList::strLengthOf(Index index) const {
size_t rc = 0;
- ReByteBuffer buffer;
+ ReByteArray buffer;
if (get(index, buffer))
rc = buffer.length() - 1;
return rc;
*/
size_t ReStringList::sumOfSizes() const {
size_t rc = 0;
- ReByteBuffer buffer;
+ ReByteArray buffer;
for (int ii = count() - 1; ii >= 0; ii--) {
get(ii, buffer);
rc += buffer.length();
clear();
const char* end = list == NULL ? NULL : strchr(list, separator);
const char* end2;
- ReByteBuffer item;
+ ReByteArray item;
while (end != NULL) {
if (separator == '\n' && end != list && end[-1] == '\r')
end2 = end - 1;
* @param result OUT: the result buffer
* @return <code>buffer</code> (for chaining)
*/
-ReByteBuffer& ReStringList::join(const char* separator, ReByteBuffer& result,
+ReByteArray& ReStringList::join(const char* separator, ReByteArray& result,
bool append) const {
size_t theCount = count();
if (!append)
/*
* ReStringList.hpp
- *
+ *
* License: Public Domain
* You can use and modify this file without any restriction.
* Do what you want.
virtual ~ReStringList();
public:
ReStringList& append(const char* source, Tag tag = 0);
- ReStringList& append(const ReByteBuffer& source, Tag tag = 0);
+ ReStringList& append(const ReByteArray& source, Tag tag = 0);
ReStringList& append(const ReStringList& source);
bool equal(const ReStringList& toCompare) const;
int firstDiff(const ReStringList& toCompare) const;
Index indexOf(const char* toFind, bool ignoreCase = false,
Index start = 0) const;
void insert(Index index, const char* source, Tag tag = 0);
- ReByteBuffer& join(const char* separator, ReByteBuffer& result,
+ ReByteArray& join(const char* separator, ReByteArray& result,
bool append = false) const;
Index nextStartingWith(Index index, const char* prefix, bool ignoreCase =
false);
/*
* ReStringUtils.cpp
- *
+ *
* License: Public Domain
* You can use and modify this file without any restriction.
* Do what you want.
*
* @result <code>fullpath</code>. (for chaining).
*/
-ReByteBuffer& ReStringUtils::joinPath(ReByteBuffer& fullpath,
- ReByteBuffer* protocol, ReByteBuffer* path, ReByteBuffer* name,
- ReByteBuffer* ext) {
+ReByteArray& ReStringUtils::joinPath(ReByteArray& fullpath,
+ ReByteArray* protocol, ReByteArray* path, ReByteArray* name,
+ ReByteArray* ext) {
fullpath.setLength(0);
if (protocol != NULL)
fullpath.append(*protocol);
*
* @result <code>fullpath</code>. (for chaining).
*/
-ReByteBuffer& ReStringUtils::joinPath(ReByteBuffer& fullpath,
+ReByteArray& ReStringUtils::joinPath(ReByteArray& fullpath,
const char* protocol, const char* path, const char* name, const char* ext) {
fullpath.setLength(0);
if (protocol != NULL)
* @param name Out: The name part of the filename. May be NULL.
* @param ext Out: The extension. May be NULL.
*/
-void ReStringUtils::splitPath(const char* fullname, ReByteBuffer* protocol,
- ReByteBuffer* path, ReByteBuffer* name, ReByteBuffer* ext) {
+void ReStringUtils::splitPath(const char* fullname, ReByteArray* protocol,
+ ReByteArray* path, ReByteArray* name, ReByteArray* ext) {
const char currentSlash =
strchr(fullname, '/') != NULL ? '/' : OS_SEPARATOR_CHAR;
const char* start = strchr(fullname, ':');
/*
* ReStringUtils.hpp
- *
+ *
* License: Public Domain
* You can use and modify this file without any restriction.
* Do what you want.
public:
static bool isInList(const char* phrase, const char* list, bool ignoreCase =
true, char separator = AUTO_SEPARATOR);
- static ReByteBuffer& joinPath(ReByteBuffer& result, ReByteBuffer* protocol,
- ReByteBuffer* path, ReByteBuffer* name, ReByteBuffer* ext);
- static ReByteBuffer& joinPath(ReByteBuffer& result, const char* protocol,
+ static ReByteArray& joinPath(ReByteArray& result, ReByteArray* protocol,
+ ReByteArray* path, ReByteArray* name, ReByteArray* ext);
+ static ReByteArray& joinPath(ReByteArray& result, const char* protocol,
const char* path, const char* name, const char* ext);
static int lengthOfUnsigned(const char* text, int length = -1,
unsigned int* value = NULL);
- static void splitPath(const char* fullname, ReByteBuffer* protocol,
- ReByteBuffer* path, ReByteBuffer* name, ReByteBuffer* ext);
+ static void splitPath(const char* fullname, ReByteArray* protocol,
+ ReByteArray* path, ReByteArray* name, ReByteArray* ext);
static int strnicmp(const char* string1, const char* string2,
size_t length);
};
/*
* ReTestUnit.cpp
- *
+ *
* License: Public Domain
* You can use and modify this file without any restriction.
* Do what you want.
*/
#include "base/rebase.hpp"
-ReByteBuffer ReTestUnit::m_tempDir;
+ReByteArray ReTestUnit::m_tempDir;
/** @brief Constructor.
*
logF(true, i18n("%s-%d: not false!"), m_sourceFile.str(), lineNo);
}
}
-/** @brief Checks a pointer expression. A not <code>null</code> value will be logged.
- *
- * @param pointer this expression will be tested
- * if not <code>null</code> an error messsage will be issued
- * @param lineNo the line number of the test (for the error message)
- */
-void ReTestUnit::assertNull(void* pointer, int lineNo) {
- if (pointer != NULL) {
- logF(true, "%s-%d: is not null %llx", m_sourceFile.str(), lineNo,
- (int64_t) pointer);
- }
-}
-/** @brief Checks a pointer expression. A <code>null</code> value will be logged.
+
+/** @brief Checks whether a directory exists. If not this will be logged.
*
- * @param pointer this expression will be tested
- * if <code>null</code> an error messsage will be issued
+ * @param dir the name of the directory
* @param lineNo the line number of the test (for the error message)
*/
-void ReTestUnit::assertNotNull(void* pointer, int lineNo) {
- if (pointer == NULL) {
- logF(true, i18n("%s-%d: is null"), m_sourceFile.str(), lineNo);
+void ReTestUnit::assertDirExists(const char* dir, int lineNo) {
+ struct stat info;
+ if (stat(dir, &info) != 0) {
+ logF(true, i18n("%s-%d: Directory does not exist: %s"),
+ m_sourceFile.str(), lineNo, dir);
+ } else if (!S_ISDIR(info.st_mode)) {
+ logF(true, i18n("%s-%d: File exists but this is not a directory: %s"),
+ m_sourceFile.str(), lineNo, dir);
}
}
+
/** @brief Compares two integer values. If not equal this will be logged.
*
* @param expected the expected value
m_sourceFile.str(), lineNo, expected, expected, current, current);
}
}
+
/** @brief Compares two integer values. If not equal this will be logged.
*
* @param expected the expected value
* @param current the current value
* @param lineNo the line number of the test (for the error message)
*/
-void ReTestUnit::assertEqual(const char* expected, const ReByteBuffer& current,
+void ReTestUnit::assertEqual(const char* expected, const ReByteArray& current,
int lineNo) {
assertEqual(expected, current.str(), lineNo);
}
* @param current the current value
* @param lineNo the line number of the test (for the error message)
*/
-void ReTestUnit::assertEqual(const ReByteBuffer& expected,
- const ReByteBuffer& current, int lineNo) {
+void ReTestUnit::assertEqual(const ReByteArray& expected,
+ const ReByteArray& current, int lineNo) {
assertEqual(expected.str(), current.str(), lineNo);
}
/** @brief Compares two string values. If not equal this will be logged.
}
}
-/** @brief Checks whether a file exists. If not this will be logged.
- *
- * @param name the filename
- * @param lineNo the line number of the test (for the error message)
- */
-void ReTestUnit::assertFileExists(const char* name, int lineNo) {
- struct stat info;
- if (stat(name, &info) != 0) {
- logF(true, i18n("%s-%d: File does not exist: %s"), m_sourceFile.str(),
- lineNo, name);
- } else if (S_ISDIR(info.st_mode)) {
- logF(true, i18n("%s-%d: File does exist but this is a directory: %s"),
- m_sourceFile.str(), lineNo, name);
- }
-}
/** @brief Checks whether two files have the same content. If not this will be logged.
*
* @param name1 name of the first file
*/
void ReTestUnit::assertEqualFiles(const char* name1, const char* name2,
int lineNo) {
- ReByteBuffer buffer;
+ ReByteArray buffer;
ReStringList list1;
ReStringList list2;
list1.readFromFile(name1);
list2.readFromFile(name2);
int ix = list1.firstDiff(list2);
if (ix >= 0) {
- ReByteBuffer line1(list1.strOf(ix), list1.strLengthOf(ix));
+ ReByteArray line1(list1.strOf(ix), list1.strLengthOf(ix));
int ixLine = line1.firstDifference(list2.strOf(ix),
list2.strLengthOf(ix));
logF(true, i18n("%s-%d: Files differ in line %d-%d\n%s\n%s\n%s"),
}
+
+/** @brief Checks whether a file exists. If not this will be logged.
+ *
+ * @param name the filename
+ * @param lineNo the line number of the test (for the error message)
+ */
+void ReTestUnit::assertFileExists(const char* name, int lineNo) {
+ struct stat info;
+ if (stat(name, &info) != 0) {
+ logF(true, i18n("%s-%d: File does not exist: %s"), m_sourceFile.str(),
+ lineNo, name);
+ } else if (S_ISDIR(info.st_mode)) {
+ logF(true, i18n("%s-%d: File does exist but this is a directory: %s"),
+ m_sourceFile.str(), lineNo, name);
+ }
+}
+
+/** @brief Checks a pointer expression. A <code>null</code> value will be logged.
+ *
+ * @param pointer this expression will be tested
+ * if <code>null</code> an error messsage will be issued
+ * @param lineNo the line number of the test (for the error message)
+ */
+void ReTestUnit::assertNotNull(void* pointer, int lineNo) {
+ if (pointer == NULL) {
+ logF(true, i18n("%s-%d: is null"), m_sourceFile.str(), lineNo);
+ }
+}
+
+/** @brief Checks a pointer expression. A not <code>null</code> value will be logged.
+ *
+ * @param pointer this expression will be tested
+ * if not <code>null</code> an error messsage will be issued
+ * @param lineNo the line number of the test (for the error message)
+ */
+void ReTestUnit::assertNull(void* pointer, int lineNo) {
+ if (pointer != NULL) {
+ logF(true, "%s-%d: is not null %llx", m_sourceFile.str(), lineNo,
+ (int64_t) pointer);
+ }
+}
+
/** @brief Returns the full path of a file in the test directory.
*
* @param node the node (filename without path)
* @param buffer OUT: the filename will be constructed in this buffer
* @return <code>buffer.str()</code>: the full filename
*/
-const char* ReTestUnit::buildFilename(const char* node, ReByteBuffer& buffer) {
+const char* ReTestUnit::buildFilename(const char* node, ReByteArray& buffer) {
createTestDir();
buffer.setLength(0).append(m_tempDir).append(node);
return buffer.str();
return m_buffer.str();
}
+/** @brief Creates a file and fills it with an given content.
+ *
+ * @param filename the name of the file
+ * @param content the content of the file. If NULL the file will be empty
+ */
+void ReTestUnit::createDir(const char* filename) {
+ _mkdir(filename, ALLPERMS);
+}
+
+/** @brief Creates a file and fills it with an given content.
+ *
+ * @param filename the name of the file
+ * @param content the content of the file. If NULL the file will be empty
+ */
+void ReTestUnit::createFile(const char* filename, const char* content) {
+ FILE* fp = fopen(filename, "w");
+ if (fp == NULL) {
+ int error = getLastOSError();
+ logF(true, "createFile(%d): %s", error, filename);
+ } else if (content != NULL) {
+ fwrite(content, strlen(content), 1, fp);
+ fclose(fp);
+ }
+}
+
/** @brief Creates an empty temporary directory.
* the name can be retrieved by <code>getTestDir()</code>.
*/
void ReTestUnit::createTestDir() {
- if (m_tempDir.length() == 0) {
+ if (m_tempDir.empty()) {
if (getenv("TMP") != NULL) {
m_tempDir = getenv("TMP");
} else if (getenv("TEMP")) {
}
}
-/**
- * @brief Calculates the time since a given start.
- *
- * <pre>int64_t start = test.timer();
- * ...
- * int duration = test.milliSecSince(start);
- * </pre>
- *
- * @return a time usable for for runtime measurement
- */
-int ReTestUnit::milliSecSince(int64_t start) {
- return ReBaseUtils::milliSecSince(start);
-}
-
-/**
- * @brief Returns a time value usable for runtime measurement.
- *
- * Note: The value is platform dependent. Use with <code>milliSecSince()</code>.
- * <pre>int64_t start = test.timer();
- * ...
- * int duration = test.milliSecSince(start);
- * </pre>
- * @return a time usable for for runtime measurement
- */
-int64_t ReTestUnit::timer() {
- return ReBaseUtils::timer();
-}
-
-/** @brief Returns the temporary directory.
- *
- * @return the name of a temporary directory
- */
-const char* ReTestUnit::testDir() {
- createTestDir();
- return m_tempDir.str();
-}
-
-/** @brief Creates a file and fills it with an given content.
- *
- * @param filename the name of the file
- * @param content the content of the file. If NULL the file will be empty
- */
-void ReTestUnit::createFile(const char* filename, const char* content) {
- FILE* fp = fopen(filename, "w");
- if (fp == NULL) {
- int error = getLastOSError();
- logF(true, "createFile(%d): %s", error, filename);
- } else if (content != NULL) {
- fwrite(content, strlen(content), 1, fp);
- fclose(fp);
- }
-}
-/** @brief Creates a file and fills it with an given content.
- *
- * @param filename the name of the file
- * @param content the content of the file. If NULL the file will be empty
- */
-void ReTestUnit::createDir(const char* filename) {
- _mkdir(filename, ALLPERMS);
-}
-
-/** @brief Checks whether a directory exists. If not this will be logged.
- *
- * @param dir the name of the directory
- * @param lineNo the line number of the test (for the error message)
- */
-void ReTestUnit::assertDirExists(const char* dir, int lineNo) {
- struct stat info;
- if (stat(dir, &info) != 0) {
- logF(true, i18n("%s-%d: Directory does not exist: %s"),
- m_sourceFile.str(), lineNo, dir);
- } else if (!S_ISDIR(info.st_mode)) {
- logF(true, i18n("%s-%d: File exists but this is not a directory: %s"),
- m_sourceFile.str(), lineNo, dir);
- }
-}
-
/** @brief Logs a message.
*
* It can be used to inform the user about coming (error-) messages
va_end(args);
return log(isError, buffer);
}
+
+/**
+ * @brief Calculates the time since a given start.
+ *
+ * <pre>int64_t start = test.timer();
+ * ...
+ * int duration = test.milliSecSince(start);
+ * </pre>
+ *
+ * @return a time usable for for runtime measurement
+ */
+int ReTestUnit::milliSecSince(int64_t start) {
+ return ReBaseUtils::milliSecSince(start);
+}
+
+/** @brief Returns the temporary directory.
+ *
+ * @return the name of a temporary directory
+ */
+const char* ReTestUnit::testDir() {
+ createTestDir();
+ return m_tempDir.str();
+}
+
+/**
+ * Tests a file against a given content with wildcards.
+ *
+ * @param filename name of the file to test
+ * @param content expected content: each line can contain one or more '*'s
+ * used as wildcards (any count of any character)
+ */
+void ReTestUnit::testFileContentWithWildcards(ReByteArray& filename, const char* content) {
+ ReStringList current;
+ current.readFromFile(filename.str());
+ ReStringList expected;
+ expected.split(content, '\n');
+ if (expected.count() != current.count())
+ checkEqu(expected.count(), current.count());
+ ReByteArray line;
+ ReStringList cols;
+ for (size_t ix = 0; ix < current.count(); ix++) {
+ line.setLength(0).append(current.strOf(ix), -1);
+ cols.split(expected.strOf(ix), '*');
+ const char* col1 = cols.strOf(0);
+ if (!line.startsWith(col1))
+ checkEqu(col1, line);
+ int count = cols.count();
+ if (count > 1){
+ const char* col2;
+ if (count > 2){
+ int startIx = cols.strLengthOf(0) + 1;
+ int lastIndex = line.length() - cols.strLengthOf(count - 1);
+ for (int ix = 1; ix < count - 1; ix++){
+ col2 = cols.strOf(ix);
+
+ int found = line.indexOf(col2, cols.strLengthOf(ix), startIx);
+ if (found < 0 || found >= lastIndex){
+ checkEqu(col2, line.str() + startIx);
+ break;
+ }
+ startIx = found + cols.strLengthOf(ix);
+ }
+ }
+ col2 = cols.strOf(count - 1);
+ if (!line.endsWith(col2)) {
+ checkEqu(col2, line);
+ }
+ }
+ }
+}
+
+/**
+ * @brief Returns a time value usable for runtime measurement.
+ *
+ * Note: The value is platform dependent. Use with <code>milliSecSince()</code>.
+ * <pre>int64_t start = test.timer();
+ * ...
+ * int duration = test.milliSecSince(start);
+ * </pre>
+ * @return a time usable for for runtime measurement
+ */
+int64_t ReTestUnit::timer() {
+ return ReBaseUtils::timer();
+}
+
/*
* ReTestUnit.hpp
- *
+ *
* License: Public Domain
* You can use and modify this file without any restriction.
* Do what you want.
void assertEqual(int expected, int current, int lineNo);
void assertEqual(unsigned int expected, unsigned int current, int lineNo);
void assertEqual(const char* expected, const char* current, int lineNo);
- void assertEqual(const char* expected, const ReByteBuffer& current,
+ void assertEqual(const char* expected, const ReByteArray& current,
int lineNo);
- void assertEqual(const ReByteBuffer& expected, const ReByteBuffer& current,
+ void assertEqual(const ReByteArray& expected, const ReByteArray& current,
int lineNo);
void assertEqualIgnoreCase(const char* expected, const char* current,
int lineNo);
void assertNotNull(void* pointer, int lineNo);
void assertNull(void* pointer, int lineNo);
void assertTrue(bool conditon, int lineNo);
- const char* buildFilename(const char* node, ReByteBuffer& buffer);
+ const char* buildFilename(const char* node, ReByteArray& buffer);
void createDir(const char* filename);
void createFile(const char* filename, const char* content);
const char* colMarker(int col);
- const char* testDir();
virtual bool log(bool isError, const char* message);
virtual bool logF(bool isError, const char* format, ...);
int milliSecSince(int64_t start);
+ const char* testDir();
+ void testFileContentWithWildcards(ReByteArray& filename, const char* content);
int64_t timer();
private:
void createTestDir();
protected:
int m_errorCount;
- ReByteBuffer m_name;
- ReByteBuffer m_sourceFile;
- ReByteBuffer m_buffer;
+ ReByteArray m_name;
+ ReByteArray m_sourceFile;
+ ReByteArray m_buffer;
ReMemoryAppender* m_memoryAppender;
ReLogger m_silentLogger;
protected:
- static ReByteBuffer m_tempDir;
+ static ReByteArray m_tempDir;
};
#define checkT(cond) assertTrue(cond, __LINE__)
#define checkF(cond) assertFalse(cond, __LINE__)
/*
* ReThread.cpp
- *
+ *
* License: Public Domain
* You can use and modify this file without any restriction.
* Do what you want.
/*
* ReThread.hpp
- *
+ *
* License: Public Domain
* You can use and modify this file without any restriction.
* Do what you want.
/*
* ReVarArgs.cpp
- *
+ *
* License: Public Domain
* You can use and modify this file without any restriction.
* Do what you want.
int const ReVarArgs::STD_SPACE = 20;
char const ReVarArgs::PLACE_HOLDER_MARK = '$';
-typedef ReByteBuffer::Byte Byte;
+typedef ReByteArray::Byte Byte;
/** @brief Constructor.
*/
ReVarArgs::ReVarArgs(void) :
if (length >= minWidth) {
store(value, maxWidth);
} else {
- ReByteBuffer buffer;
+ ReByteArray buffer;
buffer.setLengthAndFillOut(minWidth, ' ');
if (alignRight)
memcpy(buffer.buffer() + minWidth - length, value, length);
/*
* ReVarArgs.hpp
- *
+ *
* License: Public Domain
* You can use and modify this file without any restriction.
* Do what you want.
* @param maxWidth maximum width of the string
* @param alignRight <code>true</code>: padding is done at the start
*/
- inline ReVarArgs& arg(const ReByteBuffer& value, int minWidth = 0,
+ inline ReVarArgs& arg(const ReByteArray& value, int minWidth = 0,
int maxWidth = 1024, bool alignRight = false) {
return arg(value.str(), minWidth, maxWidth, alignRight);
}
int m_maxArgNo;
//@ Stores the format. When the first call of <code>asCharPtr()</code>
//@ the expanded string will be stored here.
- ReByteBuffer m_format;
+ ReByteArray m_format;
//@ Stores the argument strings including the trailing '\0'.
- ReByteBuffer m_argBuffer;
+ ReByteArray m_argBuffer;
//@ Stores the positions (indexes) of the arguments in m_argBuffer.
int m_args[100];
//@ true: The compound string is constructed (with expanded placeholders). false: Otherwise.
/*
* baselocations.hpp
- *
+ *
* License: Public Domain
* You can use and modify this file without any restriction.
* Do what you want.
/*
* rebase.hpp
- *
+ *
* License: Public Domain
* You can use and modify this file without any restriction.
* Do what you want.
*/
#ifndef REBASE_HPP_
#define REBASE_HPP_
+
#define min()
#define max()
#include <stdlib.h>
#include "base/ReClassId.hpp"
#include "base/ReException.hpp"
#include "base/ReMutex.hpp"
-#include "base/ReByteBuffer.hpp"
+#include "base/ReByteArray.hpp"
#include "base/ReSerializable.hpp"
#include "base/ReVarArgs.hpp"
#include "base/ReLogger.hpp"
/*
* restring.hpp
- *
+ *
* License: Public Domain
* You can use and modify this file without any restriction.
* Do what you want.
/*
* basetest.cpp
- *
+ *
* License: Public Domain
* You can use and modify this file without any restriction.
* Do what you want.
--- /dev/null
+/*
+ * cuReByteArray.cpp
+ *
+ * License: Public Domain
+ * You can use and modify this file without any restriction.
+ * Do what you want.
+ * No warranties and disclaimer of any damages.
+ * You also can use this license: http://www.wtfpl.net
+ * The latest sources: https://github.com/republib
+ */
+#include "base/rebase.hpp"
+class TestReByteBuffer: public ReTestUnit {
+ typedef ReByteArray::Byte Byte;
+public:
+ TestReByteBuffer() :
+ ReTestUnit("ReByteBuffer", __FILE__) {
+ run();
+ }
+private:
+ void run() {
+ testAppendBits();
+ testAppendDump();
+ testAppendFix();
+ testEnsureLastChar();
+ testLastChar();
+ testReduceLength();
+ testRemoveLastChar();
+ testAppendChar();
+ testAppendFloat();
+ testAppendInt64();
+ testEnsureSize2();
+ testHexDump();
+ testFill();
+ testAppendMilliSec();
+ testSetDelta();
+ testFirstDiff();
+ testCount();
+ testEnsureSizeGetLength();
+ testIndexOf();
+ testRIndexOf();
+ testStartsWidth();
+ testEndsWidth();
+ testOpAssignCopyConstructor();
+ testAt();
+ testBasic();
+ testAtoi();
+ testIndexOfCharRIndexOfChar();
+ testRIndexOf();
+ testInsert();
+ testRemove();
+ testSplice();
+ testReplace();
+ }
+ void testAppendBits() {
+ ReByteArray buffer;
+ buffer.appendBits8(0x31).appendBits16(0x3233).appendBits24(0x343536);
+ buffer.appendBits32(0x37383941);
+ checkEqu("123456789A", buffer);
+ buffer.set("x", 1).appendBits64(0x4243444546474849LL);
+ checkEqu("xBCDEFGHI", buffer);
+ }
+ void testIsPrefixOf() {
+ ReByteArray buffer;
+ // predefined length (of source):
+ // case sensitive, same size
+ checkT(buffer.set("aBc").isPrefixOf("aBc"));
+ // case sensitive, shorter
+ checkT(buffer.set("aB").isPrefixOf("aBc"));
+ checkF(buffer.set("ab").isPrefixOf("aBc"));
+ // case sensitive, longer
+ checkF(buffer.set("aBcd").isPrefixOf("aBc"));
+
+ // given length (of source):
+ // case sensitive, same size
+ checkT(buffer.set("aBc").isPrefixOf("aBcd", 3));
+ // case sensitive, shorter
+ checkT(buffer.set("aB").isPrefixOf("aBcd", 3));
+ checkF(buffer.set("ab").isPrefixOf("aBcd", 3));
+ // case sensitive, longer
+ checkF(buffer.set("aBcd").isPrefixOf("aBcd", 3));
+
+ // case insensitive, same size
+ checkT(buffer.set("aBc").isPrefixOf("abc", -1, true));
+ // case sensitive, shorter
+ checkT(buffer.set("aB").isPrefixOf("abc", -1, true));
+ // case sensitive, longer
+ checkF(buffer.set("aBcd").isPrefixOf("abc", -1, true));
+
+ // minSize:
+ checkT(buffer.set("aBc").isPrefixOf("abcd", -1, true, 2));
+ checkF(buffer.set("aB").isPrefixOf("abc", -1, true, 3));
+ }
+ void testAppendDump() {
+ ReByteArray buffer;
+ // true ASCII:
+ buffer.appendDump("abc");
+ checkEqu("abc", buffer.str());
+ buffer.setLength(0).appendDump("abcdefg", -1, 4);
+ checkEqu("abcd", buffer.str());
+ buffer.setLength(0).appendDump("a\tb\nc\rd");
+ checkEqu("a\tb\nc\rd", buffer.str());
+ // binary:
+ int64_t ii = 0x12345678abcdefll;
+ buffer.setLength(0).appendDump(reinterpret_cast<const char*>(&ii),
+ sizeof ii, 40);
+ checkEqu(
+ "0000: ef cd ab 78 56 34 12 00 | ...xV4.. ",
+ buffer.str());
+ }
+ void testAppendFix() {
+ ReByteArray buffer;
+ // maxLength exceeded
+ // odd maxlength:
+ buffer.appendFix("123456", -1, 5);
+ checkEqu("12*56", buffer);
+ // given separator, even maxLength
+ buffer.appendFix("abcdefg", -1, 4, 4, ".");
+ checkEqu("12*56ab.g", buffer);
+ // given separator with more than one char / no separator
+ buffer.appendFix("ABCDEF", -1, 5, 5, "...").appendFix("xyz", -1, 2, 0,
+ NULL);
+ checkEqu("12*56ab.gA...Fxz", buffer);
+
+ buffer = "x";
+ // minlength not reached:
+ // data length given, minLength == length
+ buffer.appendFix("123", 2U, 99, 2, NULL, ':');
+ checkEqu("x12", buffer);
+ // positive minLength
+ buffer.appendFix("abc", -1, 99, 4, NULL, ':');
+ checkEqu("x12abc:", buffer);
+ // negative minLength
+ buffer.appendFix("AB", -1, 99, -4, NULL, '.');
+ checkEqu("x12abc:..AB", buffer);
+
+ buffer = "y";
+ // minLength and maxLength not reached:
+ // minLength equal, maxLength equal:
+ buffer.appendFix("1234", 4, 4, 4);
+ checkEqu("y1234", buffer);
+ // minLength smaller, maxLength larger:
+ buffer.appendFix("a", 1, 2, 1);
+ checkEqu("y1234a", buffer);
+
+ }
+ void testEnsureLastChar() {
+ ReByteArray buffer("1/");
+ buffer.ensureLastChar('/');
+ checkEqu(2U, buffer.length());
+ checkEqu('/', buffer.lastChar());
+ buffer.ensureLastChar('x');
+ checkEqu(3U, buffer.length());
+ checkEqu('x', buffer.lastChar());
+ }
+ void testLastChar() {
+ ReByteArray buffer("12345");
+ checkEqu('5', buffer.lastChar());
+ buffer.setLength(0);
+ checkEqu('\0', buffer.lastChar());
+ }
+ void testReduceLength() {
+ ReByteArray buffer("12345");
+ buffer.reduceLength();
+ checkEqu(4U, buffer.length());
+ checkEqu("1234", buffer);
+ buffer.reduceLength(2);
+ checkEqu(2U, buffer.length());
+ checkEqu("12", buffer);
+ buffer.reduceLength(0).reduceLength(-1);
+ checkEqu(2U, buffer.length());
+ checkEqu("12", buffer);
+ buffer.reduceLength(99);
+ checkEqu(0U, buffer.length());
+ }
+ void testRemoveLastChar() {
+ ReByteArray buffer("123");
+ buffer.removeLastChar('x').removeLastChar('3');
+ checkEqu(2U, buffer.length());
+ checkEqu("12", buffer);
+ }
+ void testAppendChar() {
+ ReByteArray buffer;
+ buffer.appendChar('1');
+ checkEqu(1U, buffer.length());
+ checkEqu("1", buffer);
+ buffer.appendChar('2');
+ checkEqu(2U, buffer.length());
+ checkEqu("12", buffer);
+
+ buffer.appendChar('x', 1);
+ checkEqu(3U, buffer.length());
+ checkEqu("12x", buffer);
+
+ buffer.appendChar('y', 3);
+ checkEqu(6U, buffer.length());
+ checkEqu("12xyyy", buffer);
+
+ buffer.appendChar('x', 0);
+ checkEqu(6U, buffer.length());
+ checkEqu("12xyyy", buffer);
+
+ buffer.appendChar('x', -1);
+ checkEqu(6U, buffer.length());
+ checkEqu("12xyyy", buffer);
+
+ }
+ void testAppendFloat() {
+ ReByteArray buffer;
+
+ buffer.append(125 / 100.0);
+ checkEqu("1.250000", buffer);
+ buffer.append(0.333, "%.2f");
+ checkEqu("1.2500000.33", buffer);
+ }
+ void testAppendInt64() {
+ ReByteArray buffer;
+ buffer.appendInt((int64_t) 12345678901ll);
+ checkEqu("12345678901", buffer);
+ buffer.appendInt((uint64_t) 0x123456789ll, "%llx");
+ checkEqu("12345678901123456789", buffer);
+
+ }
+ void testEnsureSize2() {
+ ReByteArray buffer;
+ buffer.setLength(PRIMARY_BUFFER_SIZE - 1);
+ buffer.fill('x', PRIMARY_BUFFER_SIZE - 1);
+ checkEqu(PRIMARY_BUFFER_SIZE - 1, (int ) buffer.capacity());
+ buffer.ensureSize(PRIMARY_BUFFER_SIZE);
+ checkEqu(PRIMARY_BUFFER_SIZE*2 - 1, (int ) buffer.capacity());
+ }
+ void testHexDump() {
+ ReByteArray buf;
+ /* appendHexDump(const char* data, size_t length, int offset = 0, int bytePerLine = 16,
+ const char* offsetFormat = "%04x ", bool withAscii = true,
+ int groupWidth = 1, int gapBehind = -1, const char* separator = " | ");
+ */
+ buf.appendHexDump("abcdefghijklmnopq");
+ checkEqu(
+ "0000: 61 62 63 64 65 66 67 68 69 6a 6b 6c 6d 6e 6f 70 | abcdefgh ijklmnop\n"
+ "0010: 71 | q \n",
+ buf);
+ buf.setLength(0).appendHexDump("abcdefghijklmnopq", 16);
+ checkEqu(
+ "0000: 61 62 63 64 65 66 67 68 69 6a 6b 6c 6d 6e 6f 70 | abcdefgh ijklmnop\n",
+ buf);
+ buf.setLength(0).appendHexDump("\t\nü23456789x123456", -1, 20, 8,
+ "%3d: ", true, 4, 0, NULL);
+ checkEqu(" 20: 090ac3bc 32333435....2345\n"
+ " 28: 36373839 783132336789x123\n"
+ " 36: 343536 456 \n", buf);
+ buf.setLength(0).appendHexDump("abcdefghijk", -1, 0, 8, "%3d: ", true,
+ 2, 4);
+ checkEqu(" 0: 6162 6364 6566 6768 | abcd efgh\n"
+ " 8: 696a 6b | ijk \n", buf);
+ }
+ void testFill() {
+ ReByteArray buf;
+ buf.fill('=', 0, 3);
+ checkEqu("===", buf);
+ buf.fill('x', 1, 2);
+ checkEqu("=x=", buf);
+ }
+ void testAppendMilliSec() {
+ ReByteArray buf;
+ checkEqu("5.123", buf.appendMilliSec(5123));
+ checkEqu("32:45.789",
+ buf.setLength(0).appendMilliSec(32 * 60 * 1000 + 45789));
+ checkEqu("17:04:06.976",
+ buf.setLength(0).appendMilliSec(
+ 17 * 3600 * 1000 + 4 * 60 * 1000 + 6976));
+ }
+ void testSetDelta() {
+ ReByteArray buf("abcd");
+ int maxDelta = 512 * (1 << 10);
+ buf.setDelta(-maxDelta);
+ int count = 0;
+ while (buf.capacity() < (size_t) maxDelta) {
+ buf.ensureSize(buf.capacity() + 2);
+ count++;
+ }
+ checkT(count <= 10 + 1);
+ }
+ void testFirstDiff() {
+ ReByteArray buf("abcd");
+ // firstDifference(const Byte* source, size_t length, int start, bool ignoreCase)
+ // ignoreCase == false:
+ // start == 0, length == -1, same length:
+ checkEqu(-1, buf.firstDifference("abcd", -1));
+ checkEqu(0, buf.firstDifference("xbcd", -1));
+ checkEqu(1, buf.firstDifference("aBcd", -1));
+ // start == 2, length == -1, same length:
+ checkEqu(-1, buf.firstDifference("cd", -1, 2));
+ checkEqu(2, buf.firstDifference("xd", -1, 2));
+ checkEqu(3, buf.firstDifference("cD", -1, 2));
+ // start == 0, length > 0, same length:
+ checkEqu(-1, buf.firstDifference("axcd", 1));
+ checkEqu(0, buf.firstDifference("xbcd", 2));
+ checkEqu(1, buf.firstDifference("aBcd", 2));
+ // start == 2, length > 0, same length:
+ checkEqu(-1, buf.firstDifference("cdx", 1, 2));
+ checkEqu(2, buf.firstDifference("xd", 1, 2));
+ checkEqu(3, buf.firstDifference("cD", 2, 2));
+
+ // ignoreCase == true:
+ // start == 0, length == -1, same length:
+ checkEqu(-1, buf.firstDifference("Abcd", -1, 0, true));
+ checkEqu(0, buf.firstDifference("xbcd", -1, 0, true));
+ checkEqu(-1, buf.firstDifference("aBcd", -1, 0, true));
+ checkEqu(1, buf.firstDifference("aXcd", -1, 0, true));
+ // start == 2, length == -1, same length:
+ checkEqu(-1, buf.firstDifference("cd", -1, 2, true));
+ checkEqu(2, buf.firstDifference("xd", -1, 2, true));
+ checkEqu(-1, buf.firstDifference("cD", -1, 2, true));
+ checkEqu(3, buf.firstDifference("CX", -1, 2, true));
+ // start == 0, length > 0, same length:
+ checkEqu(-1, buf.firstDifference("Axcd", 1, 0, true));
+ checkEqu(0, buf.firstDifference("xbcd", 2, 0, true));
+ checkEqu(-1, buf.firstDifference("AXcd", 1, 0, true));
+ // start == 2, length > 0, same length:
+ checkEqu(-1, buf.firstDifference("cDx", 1, 2, true));
+ checkEqu(2, buf.firstDifference("xd", 1, 2, true));
+ checkEqu(-1, buf.firstDifference("cD", 1, 2, true));
+ checkEqu(3, buf.firstDifference("cX", 2, 2, true));
+
+ // larger length:
+ checkEqu(4, buf.firstDifference("abcde", -1, 0, false));
+ checkEqu(4, buf.firstDifference("cde", -1, 2, false));
+ // wrong indexe:
+ checkEqu(0, buf.firstDifference("cdx", 1, -1, true));
+ checkEqu(0, buf.firstDifference("cdx", 1, -1, false));
+ }
+ void testCount() {
+ ReByteArray buffer("aabbaabb");
+ checkEqu(4, buffer.count("a"));
+ checkEqu(4, buffer.count("b"));
+ checkEqu(2, buffer.count("ab"));
+ checkEqu(1, buffer.count("aabbaabb"));
+ }
+ void testStartsWidth() {
+ // . . . . . . . . . 01234567
+ ReByteArray buffer("aabbaabb");
+ // case sensitive
+ checkT(buffer.startsWith("aabbaabb", -1, false));
+ checkT(buffer.startsWith("aabbaabb", 8, false));
+ checkT(buffer.startsWith("a", -1, false));
+ checkT(buffer.startsWith("aab", -1, false));
+ checkT(buffer.startsWith("ax", 1, false));
+
+ // case insensitive
+ checkT(buffer.startsWith("AabbaabB", -1, true));
+ checkT(buffer.startsWith("aabbaabB", 8, true));
+ checkT(buffer.startsWith("A", -1, true));
+ checkT(buffer.startsWith("aAb", -1, true));
+ checkT(buffer.startsWith("Aax", 2, true));
+ checkT(buffer.startsWith("aab", -1, false));
+
+ // not matching:
+ checkF(buffer.startsWith("b", 1, false));
+ checkF(buffer.startsWith("ab", 2, false));
+ checkF(buffer.startsWith("A", 1, false));
+ checkF(buffer.startsWith("Ab", 2, false));
+
+ // binary:
+ buffer.buffer()[1] = '\0';
+ ReByteArray buffer2("aab");
+ ReByteArray buffer3("aax");
+ buffer2.buffer()[1] = '\0';
+ buffer3.buffer()[1] = '\0';
+ checkT(buffer.startsWith(buffer2.str(), 3, false));
+ checkF(buffer.startsWith(buffer3.str(), 3, false));
+ buffer2.buffer()[0] = 'A';
+ buffer3.buffer()[0] = 'A';
+ checkT(buffer.startsWith(buffer2.str(), 3, true));
+ checkF(buffer.startsWith(buffer3.str(), 3, true));
+ }
+
+ void testEndsWidth() {
+ // . . . . . . . . . 01234567
+ ReByteArray buffer("aabbaabb");
+ // case sensitive
+ checkT(buffer.endsWith("b", -1, false));
+ checkT(buffer.endsWith("abb", -1, false));
+ checkT(buffer.endsWith("bx", 1, false));
+
+ // case insensitive
+ checkT(buffer.endsWith("B", -1, true));
+ checkT(buffer.endsWith("aBb", -1, true));
+ checkT(buffer.endsWith("Bbx", 2, true));
+ checkT(buffer.endsWith("Abb", -1, true));
+
+ // not matching:
+ checkF(buffer.endsWith("a", -1, false));
+ checkF(buffer.endsWith("a", 1, false));
+ checkF(buffer.endsWith("ab", 2, false));
+ checkF(buffer.endsWith("B", 1, false));
+ checkF(buffer.endsWith("Ab", 2, false));
+
+ // binary:
+ buffer.buffer()[6] = '\0';
+ ReByteArray buffer2("abb");
+ buffer2.buffer()[1] = '\0';
+ checkT(buffer.endsWith(buffer2.str(), 3, false));
+ buffer2.buffer()[0] = 'A';
+ checkT(buffer.endsWith(buffer2.str(), 3, true));
+ }
+
+ void testIndexOf() {
+ // . . . . . . . . . 01234567
+ ReByteArray buffer("aabbaabb");
+ // const Byte* toFind, size_t toFindLength, int start,int end, bool ignoreCase
+ checkEqu(0, buffer.indexOf("aa", -1, 0, -1, false));
+ int ix;
+ for (ix = 1; ix <= 4; ix++)
+ checkEqu(4, buffer.indexOf("aa", 2, ix, -1, false));
+ checkEqu(4, buffer.indexOf("aa", 2, 1, 6, false));
+ checkEqu(-1, buffer.indexOf("aa", 2, 1, 5, false));
+ checkEqu(1, buffer.indexOf("ab", 2, 0, -1, false));
+ checkEqu(-1, buffer.indexOf("Aa", 2, 0, -1, false));
+
+ checkEqu(0, buffer.indexOf("aA", 2, 0, -1, true));
+ for (ix = 1; ix <= 4; ix++)
+ checkEqu(4, buffer.indexOf("Aa", 2, ix, -1, true));
+ checkEqu(4, buffer.indexOf("aA", 2, 1, 6, true));
+ checkEqu(-1, buffer.indexOf("Aa", 2, 1, 5, true));
+ checkEqu(1, buffer.indexOf("aB", 2, 0, -1, true));
+ }
+ void testRIndexOf() {
+ // . . . . . . . . . 01234567
+ ReByteArray buffer("aabbaabb");
+ // const Byte* toFind, size_t toFindLength, int start,int end, bool ignoreCase
+ checkEqu(4, buffer.rindexOf("aa", -1, 0, -1, false));
+ int ix;
+ for (ix = 9; ix >= 6; ix--)
+ checkEqu(4, buffer.rindexOf("aa", 2, 0, ix, false));
+ checkEqu(0, buffer.rindexOf("aa", 2, 0, 5, false));
+ checkEqu(-1, buffer.rindexOf("aa", 2, 1, 3, false));
+ checkEqu(1, buffer.rindexOf("ab", 2, 0, 5, false));
+ checkEqu(1, buffer.rindexOf("ab", 2, 1, 5, false));
+ checkEqu(-1, buffer.rindexOf("Aa", 2, 0, -1, false));
+
+ for (ix = 9; ix >= 6; ix--)
+ checkEqu(4, buffer.rindexOf("Aa", 2, 0, ix, true));
+ checkEqu(0, buffer.rindexOf("aA", 2, 0, 5, true));
+ checkEqu(-1, buffer.rindexOf("Aa", 2, 1, 3, true));
+ checkEqu(1, buffer.rindexOf("aB", 2, 0, 5, true));
+ checkEqu(1, buffer.rindexOf("Ab", 2, 1, 5, true));
+ checkEqu(4, buffer.rindexOf("Aa", 2, 0, -1, true));
+ }
+ void testBasic() {
+ ReByteArray buffer(10);
+
+ buffer.append((Byte*) "123", 3);
+ checkEqu("123", buffer.buffer());
+ checkEqu("123", buffer);
+ checkEqu(3u, buffer.length());
+ buffer.append((Byte*) "ab", 2);
+ checkEqu("123ab", buffer.buffer());
+ checkEqu(5u, buffer.length());
+
+ buffer.setLengthAndFillOut(8, 'x');
+ checkEqu("123abxxx", buffer.buffer());
+ checkEqu(8u, buffer.length());
+ buffer.setLength(3);
+ checkEqu("123", buffer.buffer());
+ checkEqu(3u, buffer.length());
+
+ buffer.setLengthAndFillOut(PRIMARY_BUFFER_SIZE - 1, 'y');
+ buffer.setLengthAndFillOut(PRIMARY_BUFFER_SIZE, 'z');
+ checkEqu("yyz", buffer.buffer() + PRIMARY_BUFFER_SIZE - 3);
+ checkEqu(PRIMARY_BUFFER_SIZE + 10 - 1, (int ) buffer.capacity());
+
+ ReByteArray buffer2;
+ buffer2.set("xyz", -1);
+ buffer.set("abc", -1);
+ checkEqu("abc", buffer.buffer());
+ checkEqu(3u, buffer.length());
+ buffer.append(buffer2);
+ checkEqu("abcxyz", buffer.buffer());
+ checkEqu("abcxyz", buffer);
+ checkEqu(6u, buffer.length());
+
+ buffer.setLength(0);
+ buffer.appendInt(-1);
+ checkEqu("-1", buffer);
+ checkEqu(2u, buffer.length());
+
+ buffer.appendInt(9, "%03d");
+ checkEqu("-1009", buffer);
+ checkEqu(5u, buffer.length());
+
+ buffer.setLength(0).appendInt((unsigned int) 123);
+ checkEqu("123", buffer);
+ buffer.appendInt((unsigned int) 0x87654321, "%x");
+ checkEqu("12387654321", buffer);
+
+ }
+ void testOpAssignCopyConstructor() {
+ ReByteArray buf1;
+ buf1.set("abc", 3);
+ ReByteArray buf3;
+ {
+ ReByteArray buf2(buf1);
+ checkEqu("abc", buf2);
+ buf3 = buf2;
+ buf2.append("123", 3);
+ }
+ checkEqu("abc", buf3);
+ checkEqu("abc", buf1);
+ }
+ void testAt() {
+ ReByteArray buf1;
+ buf1.set("abc", 3);
+ for (size_t ii = 0; ii < buf1.length(); ii++) {
+ checkEqu(int('a' + ii), (int ) buf1.at(ii));
+ }
+ checkEqu(0, buf1.at(-1));
+ checkEqu(0, buf1.at(3));
+ checkEqu(0, buf1.at(4));
+ }
+ void testAtoi() {
+ ReByteArray buffer;
+ buffer.set("y1234", -1);
+
+ checkEqu(1, buffer.atoi(1, 2));
+ checkEqu(12, buffer.atoi(1, 3));
+ checkEqu(123, buffer.atoi(1, 4));
+ checkEqu(1234, buffer.atoi(1, 5));
+ checkEqu(1234, buffer.atoi(1, 6));
+ checkEqu(0, buffer.atoi(0, 6));
+
+ buffer.set("456y", -1);
+
+ checkEqu(4, buffer.atoi(0, 1));
+ checkEqu(45, buffer.atoi(0, 2));
+ checkEqu(456, buffer.atoi(0, 3));
+ checkEqu(456, buffer.atoi(0, 4));
+ checkEqu(0, buffer.atoi(4, 6));
+
+ buffer.set("987654321", -1);
+ checkEqu(987654321, buffer.atoi());
+
+ buffer.set("187654302ab", -1);
+ checkEqu(187654302, buffer.atoi());
+
+ buffer.set("y0x1234", -1);
+
+ checkEqu(0x1, buffer.atoi(1, 4));
+ checkEqu(0x12, buffer.atoi(1, 5));
+ checkEqu(0x123, buffer.atoi(1, 6));
+ checkEqu(0x1234, buffer.atoi(1, 7));
+ checkEqu(0x1234, buffer.atoi(1, 8));
+ checkEqu(0, buffer.atoi(0, 8));
+ checkEqu(0, buffer.atoi(2, 8));
+
+ buffer.set("0x456y", -1);
+
+ checkEqu(0x4, buffer.atoi(0, 3));
+ checkEqu(0x45, buffer.atoi(0, 4));
+ checkEqu(0x456, buffer.atoi(0, 6));
+ checkEqu(0x456, buffer.atoi(0, 7));
+ checkEqu(0, buffer.atoi(5, 6));
+
+ buffer.set("0x98765432", -1);
+ checkEqu(0x98765432U, (unsigned ) buffer.atoi());
+
+ buffer.set("0xabcdef01", -1);
+ checkEqu(0xabcdef01U, (unsigned ) buffer.atoi());
+ buffer.set("0xABCDEF01", -1);
+ checkEqu(0xabcdef01U, (unsigned ) buffer.atoi());
+ buffer.set("0xaFFe01", -1);
+ checkEqu(0xaFFe01U, (unsigned ) buffer.atoi());
+ }
+ void testEnsureSizeGetLength() {
+ ReByteArray buf1;
+ buf1.ensureSize(2000);
+ checkEqu(2000u, buf1.capacity());
+ buf1.set("0123456789", 10);
+ checkEqu(10u, buf1.length());
+
+ buf1.setLength(5);
+ checkEqu("01234", buf1);
+ checkEqu(5u, buf1.length());
+
+ buf1.setLengthAndFillOut(8, 'X');
+ checkEqu("01234XXX", buf1);
+ checkEqu(8u, buf1.length());
+ checkEqu(2000u, buf1.capacity());
+ }
+
+ void testIndexOfCharRIndexOfChar() {
+ ReByteArray buffer;
+ buffer.set("123123", -1);
+ checkEqu(0, buffer.indexOf('1'));
+ checkEqu(1, buffer.indexOf('2'));
+ checkEqu(3, buffer.indexOf('1', 1));
+ checkEqu(2, buffer.indexOf('3', 2));
+ checkEqu(5, buffer.indexOf('3', 3));
+ checkEqu(-1, buffer.indexOf('4'));
+ checkEqu(-1, buffer.indexOf('1', 4));
+
+ checkEqu(3, buffer.rindexOf('1'));
+ checkEqu(4, buffer.rindexOf('2'));
+ checkEqu(3, buffer.rindexOf('1', -2));
+ checkEqu(3, buffer.rindexOf('1', -3));
+ checkEqu(0, buffer.rindexOf('1', -4));
+
+ checkEqu(4, buffer.rindexOf('2', 4));
+ checkEqu(1, buffer.rindexOf('2', 3));
+
+ checkEqu(4, buffer.rindexOf('2', -2));
+ checkEqu(1, buffer.rindexOf('2', -3));
+
+ checkEqu(0, buffer.rindexOf('1', 0));
+
+ checkEqu(-1, buffer.rindexOf('4'));
+ checkEqu(-1, buffer.rindexOf('2', 0));
+
+ checkEqu(1, buffer.indexOf("23", 2, 0));
+ checkEqu(1, buffer.indexOf("23", -1, 0));
+ checkEqu(1, buffer.indexOf("23x", 2, 0));
+ checkEqu(4, buffer.indexOf("23", 2, 2));
+ checkEqu(4, buffer.indexOf("23", -1, 2));
+
+ checkEqu(-1, buffer.indexOf("234", -1, 0));
+ checkEqu(-1, buffer.indexOf("23", -1, 5));
+ }
+ void testInsert() {
+ ReByteArray buf1;
+ checkT(buf1.insert(0, "123", 2));
+ checkEqu("12", buf1);
+ checkEqu(2u, buf1.length());
+
+ checkT(buf1.insert(0, "abc", 1));
+ checkEqu("a12", buf1);
+ checkEqu(3u, buf1.length());
+
+ checkT(buf1.insert(1, "x", 1));
+ checkEqu("ax12", buf1);
+ checkEqu(4u, buf1.length());
+
+ checkT(buf1.insert(4, "yz", 2));
+ checkEqu("ax12yz", buf1);
+ checkEqu(6u, buf1.length());
+
+ checkF(buf1.insert(-1, "-", 1));
+ checkF(buf1.insert(8, "/", 1));
+
+ }
+ void testRemove() {
+ ReByteArray buf1;
+ buf1.set("1234567890", 10);
+ checkT(buf1.remove(0, 2));
+ checkEqu("34567890", buf1);
+ checkEqu(8u, buf1.length());
+
+ checkF(buf1.remove(-1, 2));
+ checkEqu("34567890", buf1);
+ checkEqu(8u, buf1.length());
+
+ checkF(buf1.remove(9, 2));
+ checkEqu("34567890", buf1);
+ checkEqu(8u, buf1.length());
+
+ checkT(buf1.remove(7, 2));
+ checkEqu("3456789", buf1);
+ checkEqu(7u, buf1.length());
+
+ checkT(buf1.remove(5, 2));
+ checkEqu("34567", buf1);
+ checkEqu(5u, buf1.length());
+
+ checkT(buf1.remove(0, 99));
+ checkEqu("", buf1);
+ checkEqu(0u, buf1.length());
+ }
+ void testReplace() {
+ ReByteArray buffer;
+
+ buffer.set("1234", 4);
+ buffer.replaceAll("12", 2, "abc", 3);
+ checkEqu("abc34", buffer);
+
+ buffer.replaceAll("c34", 2, "uv", 3);
+ checkEqu("abuv", buffer);
+
+ buffer.set("$$x$$", -1);
+ buffer.replaceAll("$", 1, "XX", 2);
+ checkEqu("XXXXxXXXX", buffer);
+ }
+ void testSplice() {
+ ReByteArray buffer;
+
+ buffer.append((Byte*) "12.ab", 5);
+ checkT(buffer.splice(0, 0, "xy", 2));
+ checkEqu("xy12.ab", buffer.buffer());
+ buffer.splice(2, 2, NULL, 0);
+ checkEqu("xy.ab", buffer.buffer());
+ buffer.splice(0, 2, "w", 1);
+ checkEqu("w.ab", buffer.buffer());
+
+ buffer.setLength(0);
+ buffer.append((Byte*) "123", 3);
+ buffer.insert(1, "ab", 2);
+ checkEqu("1ab23", buffer.buffer());
+ checkEqu(5u, buffer.length());
+ buffer.remove(0, 1);
+ checkEqu("ab23", buffer.buffer());
+ checkEqu(4u, buffer.length());
+ buffer.remove(3, 55);
+ checkEqu("ab2", buffer.buffer());
+ checkEqu(3u, buffer.length());
+ buffer.remove(2, 2);
+ checkEqu("ab", buffer.buffer());
+ checkEqu(2u, buffer.length());
+ buffer.remove(1, 1);
+ checkEqu("a", buffer.buffer());
+ checkEqu(1u, buffer.length());
+ }
+};
+extern void testReByteBuffer(void);
+
+void testReByteBuffer(void) {
+ TestReByteBuffer unit;
+}
+
+++ /dev/null
-/*
- * cuReByteBuffer.cpp
- *
- * License: Public Domain
- * You can use and modify this file without any restriction.
- * Do what you want.
- * No warranties and disclaimer of any damages.
- * You also can use this license: http://www.wtfpl.net
- * The latest sources: https://github.com/republib
- */
-#include "base/rebase.hpp"
-class TestReByteBuffer: public ReTestUnit {
- typedef ReByteBuffer::Byte Byte;
-public:
- TestReByteBuffer() :
- ReTestUnit("ReByteBuffer", __FILE__) {
- run();
- }
-private:
- void run() {
- testAppendBits();
- testAppendDump();
- testAppendFix();
- testEnsureLastChar();
- testLastChar();
- testReduceLength();
- testRemoveLastChar();
- testAppendChar();
- testAppendFloat();
- testAppendInt64();
- testEnsureSize2();
- testHexDump();
- testFill();
- testAppendMilliSec();
- testSetDelta();
- testFirstDiff();
- testCount();
- testEnsureSizeGetLength();
- testIndexOf();
- testRIndexOf();
- testStartsWidth();
- testEndsWidth();
- testOpAssignCopyConstructor();
- testAt();
- testBasic();
- testAtoi();
- testIndexOfCharRIndexOfChar();
- testRIndexOf();
- testInsert();
- testRemove();
- testSplice();
- testReplace();
- }
- void testAppendBits() {
- ReByteBuffer buffer;
- buffer.appendBits8(0x31).appendBits16(0x3233).appendBits24(0x343536);
- buffer.appendBits32(0x37383941);
- checkEqu("123456789A", buffer);
- buffer.set("x", 1).appendBits64(0x4243444546474849LL);
- checkEqu("xBCDEFGHI", buffer);
- }
- void testIsPrefixOf() {
- ReByteBuffer buffer;
- // predefined length (of source):
- // case sensitive, same size
- checkT(buffer.set("aBc").isPrefixOf("aBc"));
- // case sensitive, shorter
- checkT(buffer.set("aB").isPrefixOf("aBc"));
- checkF(buffer.set("ab").isPrefixOf("aBc"));
- // case sensitive, longer
- checkF(buffer.set("aBcd").isPrefixOf("aBc"));
-
- // given length (of source):
- // case sensitive, same size
- checkT(buffer.set("aBc").isPrefixOf("aBcd", 3));
- // case sensitive, shorter
- checkT(buffer.set("aB").isPrefixOf("aBcd", 3));
- checkF(buffer.set("ab").isPrefixOf("aBcd", 3));
- // case sensitive, longer
- checkF(buffer.set("aBcd").isPrefixOf("aBcd", 3));
-
- // case insensitive, same size
- checkT(buffer.set("aBc").isPrefixOf("abc", -1, true));
- // case sensitive, shorter
- checkT(buffer.set("aB").isPrefixOf("abc", -1, true));
- // case sensitive, longer
- checkF(buffer.set("aBcd").isPrefixOf("abc", -1, true));
-
- // minSize:
- checkT(buffer.set("aBc").isPrefixOf("abcd", -1, true, 2));
- checkF(buffer.set("aB").isPrefixOf("abc", -1, true, 3));
- }
- void testAppendDump() {
- ReByteBuffer buffer;
- // true ASCII:
- buffer.appendDump("abc");
- checkEqu("abc", buffer.str());
- buffer.setLength(0).appendDump("abcdefg", -1, 4);
- checkEqu("abcd", buffer.str());
- buffer.setLength(0).appendDump("a\tb\nc\rd");
- checkEqu("a\tb\nc\rd", buffer.str());
- // binary:
- int64_t ii = 0x12345678abcdefll;
- buffer.setLength(0).appendDump(reinterpret_cast<const char*>(&ii),
- sizeof ii, 40);
- checkEqu(
- "0000: ef cd ab 78 56 34 12 00 | ...xV4.. ",
- buffer.str());
- }
- void testAppendFix() {
- ReByteBuffer buffer;
- // maxLength exceeded
- // odd maxlength:
- buffer.appendFix("123456", -1, 5);
- checkEqu("12*56", buffer);
- // given separator, even maxLength
- buffer.appendFix("abcdefg", -1, 4, 4, ".");
- checkEqu("12*56ab.g", buffer);
- // given separator with more than one char / no separator
- buffer.appendFix("ABCDEF", -1, 5, 5, "...").appendFix("xyz", -1, 2, 0,
- NULL);
- checkEqu("12*56ab.gA...Fxz", buffer);
-
- buffer = "x";
- // minlength not reached:
- // data length given, minLength == length
- buffer.appendFix("123", 2U, 99, 2, NULL, ':');
- checkEqu("x12", buffer);
- // positive minLength
- buffer.appendFix("abc", -1, 99, 4, NULL, ':');
- checkEqu("x12abc:", buffer);
- // negative minLength
- buffer.appendFix("AB", -1, 99, -4, NULL, '.');
- checkEqu("x12abc:..AB", buffer);
-
- buffer = "y";
- // minLength and maxLength not reached:
- // minLength equal, maxLength equal:
- buffer.appendFix("1234", 4, 4, 4);
- checkEqu("y1234", buffer);
- // minLength smaller, maxLength larger:
- buffer.appendFix("a", 1, 2, 1);
- checkEqu("y1234a", buffer);
-
- }
- void testEnsureLastChar() {
- ReByteBuffer buffer("1/");
- buffer.ensureLastChar('/');
- checkEqu(2U, buffer.length());
- checkEqu('/', buffer.lastChar());
- buffer.ensureLastChar('x');
- checkEqu(3U, buffer.length());
- checkEqu('x', buffer.lastChar());
- }
- void testLastChar() {
- ReByteBuffer buffer("12345");
- checkEqu('5', buffer.lastChar());
- buffer.setLength(0);
- checkEqu('\0', buffer.lastChar());
- }
- void testReduceLength() {
- ReByteBuffer buffer("12345");
- buffer.reduceLength();
- checkEqu(4U, buffer.length());
- checkEqu("1234", buffer);
- buffer.reduceLength(2);
- checkEqu(2U, buffer.length());
- checkEqu("12", buffer);
- buffer.reduceLength(0).reduceLength(-1);
- checkEqu(2U, buffer.length());
- checkEqu("12", buffer);
- buffer.reduceLength(99);
- checkEqu(0U, buffer.length());
- }
- void testRemoveLastChar() {
- ReByteBuffer buffer("123");
- buffer.removeLastChar('x').removeLastChar('3');
- checkEqu(2U, buffer.length());
- checkEqu("12", buffer);
- }
- void testAppendChar() {
- ReByteBuffer buffer;
- buffer.appendChar('1');
- checkEqu(1U, buffer.length());
- checkEqu("1", buffer);
- buffer.appendChar('2');
- checkEqu(2U, buffer.length());
- checkEqu("12", buffer);
-
- buffer.appendChar('x', 1);
- checkEqu(3U, buffer.length());
- checkEqu("12x", buffer);
-
- buffer.appendChar('y', 3);
- checkEqu(6U, buffer.length());
- checkEqu("12xyyy", buffer);
-
- buffer.appendChar('x', 0);
- checkEqu(6U, buffer.length());
- checkEqu("12xyyy", buffer);
-
- buffer.appendChar('x', -1);
- checkEqu(6U, buffer.length());
- checkEqu("12xyyy", buffer);
-
- }
- void testAppendFloat() {
- ReByteBuffer buffer;
-
- buffer.append(125 / 100.0);
- checkEqu("1.250000", buffer);
- buffer.append(0.333, "%.2f");
- checkEqu("1.2500000.33", buffer);
- }
- void testAppendInt64() {
- ReByteBuffer buffer;
- buffer.appendInt((int64_t) 12345678901ll);
- checkEqu("12345678901", buffer);
- buffer.appendInt((uint64_t) 0x123456789ll, "%llx");
- checkEqu("12345678901123456789", buffer);
-
- }
- void testEnsureSize2() {
- ReByteBuffer buffer;
- buffer.setLength(PRIMARY_BUFFER_SIZE - 1);
- buffer.fill('x', PRIMARY_BUFFER_SIZE - 1);
- checkEqu(PRIMARY_BUFFER_SIZE - 1, (int ) buffer.capacity());
- buffer.ensureSize(PRIMARY_BUFFER_SIZE);
- checkEqu(PRIMARY_BUFFER_SIZE*2 - 1, (int ) buffer.capacity());
- }
- void testHexDump() {
- ReByteBuffer buf;
- /* appendHexDump(const char* data, size_t length, int offset = 0, int bytePerLine = 16,
- const char* offsetFormat = "%04x ", bool withAscii = true,
- int groupWidth = 1, int gapBehind = -1, const char* separator = " | ");
- */
- buf.appendHexDump("abcdefghijklmnopq");
- checkEqu(
- "0000: 61 62 63 64 65 66 67 68 69 6a 6b 6c 6d 6e 6f 70 | abcdefgh ijklmnop\n"
- "0010: 71 | q \n",
- buf);
- buf.setLength(0).appendHexDump("abcdefghijklmnopq", 16);
- checkEqu(
- "0000: 61 62 63 64 65 66 67 68 69 6a 6b 6c 6d 6e 6f 70 | abcdefgh ijklmnop\n",
- buf);
- buf.setLength(0).appendHexDump("\t\nü23456789x123456", -1, 20, 8,
- "%3d: ", true, 4, 0, NULL);
- checkEqu(" 20: 090ac3bc 32333435....2345\n"
- " 28: 36373839 783132336789x123\n"
- " 36: 343536 456 \n", buf);
- buf.setLength(0).appendHexDump("abcdefghijk", -1, 0, 8, "%3d: ", true,
- 2, 4);
- checkEqu(" 0: 6162 6364 6566 6768 | abcd efgh\n"
- " 8: 696a 6b | ijk \n", buf);
- }
- void testFill() {
- ReByteBuffer buf;
- buf.fill('=', 0, 3);
- checkEqu("===", buf);
- buf.fill('x', 1, 2);
- checkEqu("=x=", buf);
- }
- void testAppendMilliSec() {
- ReByteBuffer buf;
- checkEqu("5.123", buf.appendMilliSec(5123));
- checkEqu("32:45.789",
- buf.setLength(0).appendMilliSec(32 * 60 * 1000 + 45789));
- checkEqu("17:04:06.976",
- buf.setLength(0).appendMilliSec(
- 17 * 3600 * 1000 + 4 * 60 * 1000 + 6976));
- }
- void testSetDelta() {
- ReByteBuffer buf("abcd");
- int maxDelta = 512 * (1 << 10);
- buf.setDelta(-maxDelta);
- int count = 0;
- while (buf.capacity() < (size_t) maxDelta) {
- buf.ensureSize(buf.capacity() + 2);
- count++;
- }
- checkT(count <= 10 + 1);
- }
- void testFirstDiff() {
- ReByteBuffer buf("abcd");
- // firstDifference(const Byte* source, size_t length, int start, bool ignoreCase)
- // ignoreCase == false:
- // start == 0, length == -1, same length:
- checkEqu(-1, buf.firstDifference("abcd", -1));
- checkEqu(0, buf.firstDifference("xbcd", -1));
- checkEqu(1, buf.firstDifference("aBcd", -1));
- // start == 2, length == -1, same length:
- checkEqu(-1, buf.firstDifference("cd", -1, 2));
- checkEqu(2, buf.firstDifference("xd", -1, 2));
- checkEqu(3, buf.firstDifference("cD", -1, 2));
- // start == 0, length > 0, same length:
- checkEqu(-1, buf.firstDifference("axcd", 1));
- checkEqu(0, buf.firstDifference("xbcd", 2));
- checkEqu(1, buf.firstDifference("aBcd", 2));
- // start == 2, length > 0, same length:
- checkEqu(-1, buf.firstDifference("cdx", 1, 2));
- checkEqu(2, buf.firstDifference("xd", 1, 2));
- checkEqu(3, buf.firstDifference("cD", 2, 2));
-
- // ignoreCase == true:
- // start == 0, length == -1, same length:
- checkEqu(-1, buf.firstDifference("Abcd", -1, 0, true));
- checkEqu(0, buf.firstDifference("xbcd", -1, 0, true));
- checkEqu(-1, buf.firstDifference("aBcd", -1, 0, true));
- checkEqu(1, buf.firstDifference("aXcd", -1, 0, true));
- // start == 2, length == -1, same length:
- checkEqu(-1, buf.firstDifference("cd", -1, 2, true));
- checkEqu(2, buf.firstDifference("xd", -1, 2, true));
- checkEqu(-1, buf.firstDifference("cD", -1, 2, true));
- checkEqu(3, buf.firstDifference("CX", -1, 2, true));
- // start == 0, length > 0, same length:
- checkEqu(-1, buf.firstDifference("Axcd", 1, 0, true));
- checkEqu(0, buf.firstDifference("xbcd", 2, 0, true));
- checkEqu(-1, buf.firstDifference("AXcd", 1, 0, true));
- // start == 2, length > 0, same length:
- checkEqu(-1, buf.firstDifference("cDx", 1, 2, true));
- checkEqu(2, buf.firstDifference("xd", 1, 2, true));
- checkEqu(-1, buf.firstDifference("cD", 1, 2, true));
- checkEqu(3, buf.firstDifference("cX", 2, 2, true));
-
- // larger length:
- checkEqu(4, buf.firstDifference("abcde", -1, 0, false));
- checkEqu(4, buf.firstDifference("cde", -1, 2, false));
- // wrong indexe:
- checkEqu(0, buf.firstDifference("cdx", 1, -1, true));
- checkEqu(0, buf.firstDifference("cdx", 1, -1, false));
- }
- void testCount() {
- ReByteBuffer buffer("aabbaabb");
- checkEqu(4, buffer.count("a"));
- checkEqu(4, buffer.count("b"));
- checkEqu(2, buffer.count("ab"));
- checkEqu(1, buffer.count("aabbaabb"));
- }
- void testStartsWidth() {
- // . . . . . . . . . 01234567
- ReByteBuffer buffer("aabbaabb");
- // case sensitive
- checkT(buffer.startsWith("aabbaabb", -1, false));
- checkT(buffer.startsWith("aabbaabb", 8, false));
- checkT(buffer.startsWith("a", -1, false));
- checkT(buffer.startsWith("aab", -1, false));
- checkT(buffer.startsWith("ax", 1, false));
-
- // case insensitive
- checkT(buffer.startsWith("AabbaabB", -1, true));
- checkT(buffer.startsWith("aabbaabB", 8, true));
- checkT(buffer.startsWith("A", -1, true));
- checkT(buffer.startsWith("aAb", -1, true));
- checkT(buffer.startsWith("Aax", 2, true));
- checkT(buffer.startsWith("aab", -1, false));
-
- // not matching:
- checkF(buffer.startsWith("b", 1, false));
- checkF(buffer.startsWith("ab", 2, false));
- checkF(buffer.startsWith("A", 1, false));
- checkF(buffer.startsWith("Ab", 2, false));
-
- // binary:
- buffer.buffer()[1] = '\0';
- ReByteBuffer buffer2("aab");
- ReByteBuffer buffer3("aax");
- buffer2.buffer()[1] = '\0';
- buffer3.buffer()[1] = '\0';
- checkT(buffer.startsWith(buffer2.str(), 3, false));
- checkF(buffer.startsWith(buffer3.str(), 3, false));
- buffer2.buffer()[0] = 'A';
- buffer3.buffer()[0] = 'A';
- checkT(buffer.startsWith(buffer2.str(), 3, true));
- checkF(buffer.startsWith(buffer3.str(), 3, true));
- }
-
- void testEndsWidth() {
- // . . . . . . . . . 01234567
- ReByteBuffer buffer("aabbaabb");
- // case sensitive
- checkT(buffer.endsWith("b", -1, false));
- checkT(buffer.endsWith("abb", -1, false));
- checkT(buffer.endsWith("bx", 1, false));
-
- // case insensitive
- checkT(buffer.endsWith("B", -1, true));
- checkT(buffer.endsWith("aBb", -1, true));
- checkT(buffer.endsWith("Bbx", 2, true));
- checkT(buffer.endsWith("Abb", -1, true));
-
- // not matching:
- checkF(buffer.endsWith("a", -1, false));
- checkF(buffer.endsWith("a", 1, false));
- checkF(buffer.endsWith("ab", 2, false));
- checkF(buffer.endsWith("B", 1, false));
- checkF(buffer.endsWith("Ab", 2, false));
-
- // binary:
- buffer.buffer()[6] = '\0';
- ReByteBuffer buffer2("abb");
- buffer2.buffer()[1] = '\0';
- checkT(buffer.endsWith(buffer2.str(), 3, false));
- buffer2.buffer()[0] = 'A';
- checkT(buffer.endsWith(buffer2.str(), 3, true));
- }
-
- void testIndexOf() {
- // . . . . . . . . . 01234567
- ReByteBuffer buffer("aabbaabb");
- // const Byte* toFind, size_t toFindLength, int start,int end, bool ignoreCase
- checkEqu(0, buffer.indexOf("aa", -1, 0, -1, false));
- int ix;
- for (ix = 1; ix <= 4; ix++)
- checkEqu(4, buffer.indexOf("aa", 2, ix, -1, false));
- checkEqu(4, buffer.indexOf("aa", 2, 1, 6, false));
- checkEqu(-1, buffer.indexOf("aa", 2, 1, 5, false));
- checkEqu(1, buffer.indexOf("ab", 2, 0, -1, false));
- checkEqu(-1, buffer.indexOf("Aa", 2, 0, -1, false));
-
- checkEqu(0, buffer.indexOf("aA", 2, 0, -1, true));
- for (ix = 1; ix <= 4; ix++)
- checkEqu(4, buffer.indexOf("Aa", 2, ix, -1, true));
- checkEqu(4, buffer.indexOf("aA", 2, 1, 6, true));
- checkEqu(-1, buffer.indexOf("Aa", 2, 1, 5, true));
- checkEqu(1, buffer.indexOf("aB", 2, 0, -1, true));
- }
- void testRIndexOf() {
- // . . . . . . . . . 01234567
- ReByteBuffer buffer("aabbaabb");
- // const Byte* toFind, size_t toFindLength, int start,int end, bool ignoreCase
- checkEqu(4, buffer.rindexOf("aa", -1, 0, -1, false));
- int ix;
- for (ix = 9; ix >= 6; ix--)
- checkEqu(4, buffer.rindexOf("aa", 2, 0, ix, false));
- checkEqu(0, buffer.rindexOf("aa", 2, 0, 5, false));
- checkEqu(-1, buffer.rindexOf("aa", 2, 1, 3, false));
- checkEqu(1, buffer.rindexOf("ab", 2, 0, 5, false));
- checkEqu(1, buffer.rindexOf("ab", 2, 1, 5, false));
- checkEqu(-1, buffer.rindexOf("Aa", 2, 0, -1, false));
-
- for (ix = 9; ix >= 6; ix--)
- checkEqu(4, buffer.rindexOf("Aa", 2, 0, ix, true));
- checkEqu(0, buffer.rindexOf("aA", 2, 0, 5, true));
- checkEqu(-1, buffer.rindexOf("Aa", 2, 1, 3, true));
- checkEqu(1, buffer.rindexOf("aB", 2, 0, 5, true));
- checkEqu(1, buffer.rindexOf("Ab", 2, 1, 5, true));
- checkEqu(4, buffer.rindexOf("Aa", 2, 0, -1, true));
- }
- void testBasic() {
- ReByteBuffer buffer(10);
-
- buffer.append((Byte*) "123", 3);
- checkEqu("123", buffer.buffer());
- checkEqu("123", buffer);
- checkEqu(3u, buffer.length());
- buffer.append((Byte*) "ab", 2);
- checkEqu("123ab", buffer.buffer());
- checkEqu(5u, buffer.length());
-
- buffer.setLengthAndFillOut(8, 'x');
- checkEqu("123abxxx", buffer.buffer());
- checkEqu(8u, buffer.length());
- buffer.setLength(3);
- checkEqu("123", buffer.buffer());
- checkEqu(3u, buffer.length());
-
- buffer.setLengthAndFillOut(PRIMARY_BUFFER_SIZE - 1, 'y');
- buffer.setLengthAndFillOut(PRIMARY_BUFFER_SIZE, 'z');
- checkEqu("yyz", buffer.buffer() + PRIMARY_BUFFER_SIZE - 3);
- checkEqu(PRIMARY_BUFFER_SIZE + 10 - 1, (int ) buffer.capacity());
-
- ReByteBuffer buffer2;
- buffer2.set("xyz", -1);
- buffer.set("abc", -1);
- checkEqu("abc", buffer.buffer());
- checkEqu(3u, buffer.length());
- buffer.append(buffer2);
- checkEqu("abcxyz", buffer.buffer());
- checkEqu("abcxyz", buffer);
- checkEqu(6u, buffer.length());
-
- buffer.setLength(0);
- buffer.appendInt(-1);
- checkEqu("-1", buffer);
- checkEqu(2u, buffer.length());
-
- buffer.appendInt(9, "%03d");
- checkEqu("-1009", buffer);
- checkEqu(5u, buffer.length());
-
- buffer.setLength(0).appendInt((unsigned int) 123);
- checkEqu("123", buffer);
- buffer.appendInt((unsigned int) 0x87654321, "%x");
- checkEqu("12387654321", buffer);
-
- }
- void testOpAssignCopyConstructor() {
- ReByteBuffer buf1;
- buf1.set("abc", 3);
- ReByteBuffer buf3;
- {
- ReByteBuffer buf2(buf1);
- checkEqu("abc", buf2);
- buf3 = buf2;
- buf2.append("123", 3);
- }
- checkEqu("abc", buf3);
- checkEqu("abc", buf1);
- }
- void testAt() {
- ReByteBuffer buf1;
- buf1.set("abc", 3);
- for (size_t ii = 0; ii < buf1.length(); ii++) {
- checkEqu(int('a' + ii), (int ) buf1.at(ii));
- }
- checkEqu(0, buf1.at(-1));
- checkEqu(0, buf1.at(3));
- checkEqu(0, buf1.at(4));
- }
- void testAtoi() {
- ReByteBuffer buffer;
- buffer.set("y1234", -1);
-
- checkEqu(1, buffer.atoi(1, 2));
- checkEqu(12, buffer.atoi(1, 3));
- checkEqu(123, buffer.atoi(1, 4));
- checkEqu(1234, buffer.atoi(1, 5));
- checkEqu(1234, buffer.atoi(1, 6));
- checkEqu(0, buffer.atoi(0, 6));
-
- buffer.set("456y", -1);
-
- checkEqu(4, buffer.atoi(0, 1));
- checkEqu(45, buffer.atoi(0, 2));
- checkEqu(456, buffer.atoi(0, 3));
- checkEqu(456, buffer.atoi(0, 4));
- checkEqu(0, buffer.atoi(4, 6));
-
- buffer.set("987654321", -1);
- checkEqu(987654321, buffer.atoi());
-
- buffer.set("187654302ab", -1);
- checkEqu(187654302, buffer.atoi());
-
- buffer.set("y0x1234", -1);
-
- checkEqu(0x1, buffer.atoi(1, 4));
- checkEqu(0x12, buffer.atoi(1, 5));
- checkEqu(0x123, buffer.atoi(1, 6));
- checkEqu(0x1234, buffer.atoi(1, 7));
- checkEqu(0x1234, buffer.atoi(1, 8));
- checkEqu(0, buffer.atoi(0, 8));
- checkEqu(0, buffer.atoi(2, 8));
-
- buffer.set("0x456y", -1);
-
- checkEqu(0x4, buffer.atoi(0, 3));
- checkEqu(0x45, buffer.atoi(0, 4));
- checkEqu(0x456, buffer.atoi(0, 6));
- checkEqu(0x456, buffer.atoi(0, 7));
- checkEqu(0, buffer.atoi(5, 6));
-
- buffer.set("0x98765432", -1);
- checkEqu(0x98765432U, (unsigned ) buffer.atoi());
-
- buffer.set("0xabcdef01", -1);
- checkEqu(0xabcdef01U, (unsigned ) buffer.atoi());
- buffer.set("0xABCDEF01", -1);
- checkEqu(0xabcdef01U, (unsigned ) buffer.atoi());
- buffer.set("0xaFFe01", -1);
- checkEqu(0xaFFe01U, (unsigned ) buffer.atoi());
- }
- void testEnsureSizeGetLength() {
- ReByteBuffer buf1;
- buf1.ensureSize(2000);
- checkEqu(2000u, buf1.capacity());
- buf1.set("0123456789", 10);
- checkEqu(10u, buf1.length());
-
- buf1.setLength(5);
- checkEqu("01234", buf1);
- checkEqu(5u, buf1.length());
-
- buf1.setLengthAndFillOut(8, 'X');
- checkEqu("01234XXX", buf1);
- checkEqu(8u, buf1.length());
- checkEqu(2000u, buf1.capacity());
- }
-
- void testIndexOfCharRIndexOfChar() {
- ReByteBuffer buffer;
- buffer.set("123123", -1);
- checkEqu(0, buffer.indexOf('1'));
- checkEqu(1, buffer.indexOf('2'));
- checkEqu(3, buffer.indexOf('1', 1));
- checkEqu(2, buffer.indexOf('3', 2));
- checkEqu(5, buffer.indexOf('3', 3));
- checkEqu(-1, buffer.indexOf('4'));
- checkEqu(-1, buffer.indexOf('1', 4));
-
- checkEqu(3, buffer.rindexOf('1'));
- checkEqu(4, buffer.rindexOf('2'));
- checkEqu(3, buffer.rindexOf('1', -2));
- checkEqu(3, buffer.rindexOf('1', -3));
- checkEqu(0, buffer.rindexOf('1', -4));
-
- checkEqu(4, buffer.rindexOf('2', 4));
- checkEqu(1, buffer.rindexOf('2', 3));
-
- checkEqu(4, buffer.rindexOf('2', -2));
- checkEqu(1, buffer.rindexOf('2', -3));
-
- checkEqu(0, buffer.rindexOf('1', 0));
-
- checkEqu(-1, buffer.rindexOf('4'));
- checkEqu(-1, buffer.rindexOf('2', 0));
-
- checkEqu(1, buffer.indexOf("23", 2, 0));
- checkEqu(1, buffer.indexOf("23", -1, 0));
- checkEqu(1, buffer.indexOf("23x", 2, 0));
- checkEqu(4, buffer.indexOf("23", 2, 2));
- checkEqu(4, buffer.indexOf("23", -1, 2));
-
- checkEqu(-1, buffer.indexOf("234", -1, 0));
- checkEqu(-1, buffer.indexOf("23", -1, 5));
- }
- void testInsert() {
- ReByteBuffer buf1;
- checkT(buf1.insert(0, "123", 2));
- checkEqu("12", buf1);
- checkEqu(2u, buf1.length());
-
- checkT(buf1.insert(0, "abc", 1));
- checkEqu("a12", buf1);
- checkEqu(3u, buf1.length());
-
- checkT(buf1.insert(1, "x", 1));
- checkEqu("ax12", buf1);
- checkEqu(4u, buf1.length());
-
- checkT(buf1.insert(4, "yz", 2));
- checkEqu("ax12yz", buf1);
- checkEqu(6u, buf1.length());
-
- checkF(buf1.insert(-1, "-", 1));
- checkF(buf1.insert(8, "/", 1));
-
- }
- void testRemove() {
- ReByteBuffer buf1;
- buf1.set("1234567890", 10);
- checkT(buf1.remove(0, 2));
- checkEqu("34567890", buf1);
- checkEqu(8u, buf1.length());
-
- checkF(buf1.remove(-1, 2));
- checkEqu("34567890", buf1);
- checkEqu(8u, buf1.length());
-
- checkF(buf1.remove(9, 2));
- checkEqu("34567890", buf1);
- checkEqu(8u, buf1.length());
-
- checkT(buf1.remove(7, 2));
- checkEqu("3456789", buf1);
- checkEqu(7u, buf1.length());
-
- checkT(buf1.remove(5, 2));
- checkEqu("34567", buf1);
- checkEqu(5u, buf1.length());
-
- checkT(buf1.remove(0, 99));
- checkEqu("", buf1);
- checkEqu(0u, buf1.length());
- }
- void testReplace() {
- ReByteBuffer buffer;
-
- buffer.set("1234", 4);
- buffer.replaceAll("12", 2, "abc", 3);
- checkEqu("abc34", buffer);
-
- buffer.replaceAll("c34", 2, "uv", 3);
- checkEqu("abuv", buffer);
-
- buffer.set("$$x$$", -1);
- buffer.replaceAll("$", 1, "XX", 2);
- checkEqu("XXXXxXXXX", buffer);
- }
- void testSplice() {
- ReByteBuffer buffer;
-
- buffer.append((Byte*) "12.ab", 5);
- checkT(buffer.splice(0, 0, "xy", 2));
- checkEqu("xy12.ab", buffer.buffer());
- buffer.splice(2, 2, NULL, 0);
- checkEqu("xy.ab", buffer.buffer());
- buffer.splice(0, 2, "w", 1);
- checkEqu("w.ab", buffer.buffer());
-
- buffer.setLength(0);
- buffer.append((Byte*) "123", 3);
- buffer.insert(1, "ab", 2);
- checkEqu("1ab23", buffer.buffer());
- checkEqu(5u, buffer.length());
- buffer.remove(0, 1);
- checkEqu("ab23", buffer.buffer());
- checkEqu(4u, buffer.length());
- buffer.remove(3, 55);
- checkEqu("ab2", buffer.buffer());
- checkEqu(3u, buffer.length());
- buffer.remove(2, 2);
- checkEqu("ab", buffer.buffer());
- checkEqu(2u, buffer.length());
- buffer.remove(1, 1);
- checkEqu("a", buffer.buffer());
- checkEqu(1u, buffer.length());
- }
-};
-extern void testReByteBuffer(void);
-
-void testReByteBuffer(void) {
- TestReByteBuffer unit;
-}
-
/*
* cuReCString.cpp
- *
+ *
* License: Public Domain
* You can use and modify this file without any restriction.
* Do what you want.
/*
* cuReDirTools.cpp
- *
+ *
* License: Public Domain
* You can use and modify this file without any restriction.
* Do what you want.
ReDirectory::deleteTree(m_base.str(), true);
}
private:
- ReByteBuffer m_base;
- ReByteBuffer m_buffer;
+ ReByteArray m_base;
+ ReByteArray m_buffer;
bool m_testAll;
ReLogger* m_logger;
private:
void run() {
- testRandom();
- testDelete();
- testChecksumBuild();
+ testToolSync();
if (m_testAll) {
+ testRandom();
+ testDelete();
+ testChecksumBuild();
testDirOptions();
checkSetFilterFromProgramArgs();
testList2();
testDirStatistic();
testCopyFile();
testList();
- testToolSync();
testBatch();
testChecksumBuild();
testDelete();
}
void testDelete() {
rebuildTree();
- ReByteBuffer nameCurrent;
+ ReByteArray nameCurrent;
buildFilename("current", nameCurrent);
- ReByteBuffer optOutput("--output-file=");
+ ReByteArray optOutput("--output-file=");
optOutput.append(nameCurrent);
const char* argv[] = { "delete", "-p;x*.txt", optOutput.str(), m_base
.str(), NULL };
mayNotExist(s_allFiles);
}
void mustExist(const char** names) {
- ReByteBuffer name;
+ ReByteArray name;
struct stat info;
for (int ix = 0; names[ix] != NULL; ix++) {
const char* arg = names[ix];
}
}
void mayNotExist(const char** names) {
- ReByteBuffer name;
+ ReByteArray name;
struct stat info;
for (int ix = 0; names[ix] != NULL; ix++) {
const char* arg = names[ix];
return m_buffer.str();
}
void makeFile(const char* relPath) {
- ReByteBuffer path(m_base);
+ ReByteArray path(m_base);
path.append(relPath);
path.replaceAll("/", 1, OS_SEPARATOR, -1);
createFile(path.str(), relPath);
}
void testChecksumBuild() {
rebuildTree();
- ReByteBuffer nameCurrent;
+ ReByteArray nameCurrent;
buildFilename("current", nameCurrent);
- ReByteBuffer optOutput("--output-file=");
+ ReByteArray optOutput("--output-file=");
optOutput.append(nameCurrent);
const char* argv[] = { "dt", "checksum", "-P;*;-cache", "-tr",
"-p;*.txt", "-s4711", "-arpd64", "-cBuild", optOutput.str(), m_base
.str(), NULL };
ReDirTools tools;
tools.main(-1, (char**) argv);
- // checkFile(nameCurrent, "");
+ // testFileContentWithWildcards(nameCurrent, "");
const char* argv2[] = { "dt", "checksum", "-P;*;-cache", "-tr",
"-p;*.txt", "-s4711", "-arpd64", "-cCompare", optOutput.str(),
m_base.str(), NULL };
void testCopyFile() {
rebuildTree();
#if defined __linux__
- ReByteBuffer src(m_base);
+ ReByteArray src(m_base);
src.append("dir1/dir1_2/dir1_2_1/x1.txt");
- ReByteBuffer trg(testDir());
+ ReByteArray trg(testDir());
trg.append("copy_x1.txt");
- ReByteBuffer buffer;
+ ReByteArray buffer;
buffer.ensureSize(5);
ReDirSync::copyFile(src.str(), NULL, trg.str(), buffer,
ReLogger::globalLogger());
}
void checkOneFile(const char* node, const char* parent,
const ReHashList& hash) {
- ReByteBuffer path, expected;
- checkT(hash.get(ReByteBuffer(node), path));
+ ReByteArray path, expected;
+ checkT(hash.get(ReByteArray(node), path));
expected.set(parent, -1);
if (!expected.endsWith(OS_SEPARATOR))
expected.append(OS_SEPARATOR);
ReTraverser traverser(m_base.str());
RePatternList patterns;
// exclude */cache/*
- ReByteBuffer buffer(";*;-cache");
+ ReByteArray buffer(";*;-cache");
patterns.set(buffer.str());
traverser.setDirPattern(&patterns);
int level = 0;
ReDirStatus_t* entry;
ReHashList hash;
while ((entry = traverser.rawNextFile(level)) != NULL) {
- hash.put(ReByteBuffer(entry->node(), -1), entry->m_path);
+ hash.put(ReByteArray(entry->node(), -1), entry->m_path);
logF(false, "%d: %-12s %2d %s", level, entry->node(),
int(entry->fileSize()), entry->m_path.str());
}
rebuildTree();
ReDirStatistic stat(m_logger);
const ReStringList& list = stat.calculate(m_base.str(), 1);
- ReByteBuffer buffer;
- ReByteBuffer expected;
+ ReByteArray buffer;
+ ReByteArray expected;
log(false, list.join("\n", buffer).str());
checkEqu(3u, list.count());
// "1 t:\temp\winfried\2\retestunit\dir1\n"
checkT(buffer.startsWith(" 0.000087 MB 5 6\t"));
expected.set(m_base.str(), m_base.length());
}
- /**
- * Tests a file with a given context.
- *
- * @param filename name of the file to test
- * @param content expected content: each line must contain a '*',
- * separating the start of line and the end of line
- */
- void checkFile(ReByteBuffer& filename, const char* content) {
- ReStringList current;
- current.readFromFile(filename.str());
- ReStringList expected;
- expected.split(content, '\n');
- checkEqu(expected.count(), current.count());
- ReByteBuffer line;
- ReStringList cols;
- for (size_t ix = 0; ix < current.count(); ix++) {
- line.setLength(0).append(current.strOf(ix), -1);
-#if defined __WIN32__
- line.replaceAll("/", 1, OS_SEPARATOR, 1);
-#endif
- cols.split(expected.strOf(ix), '*');
- const char* col1 = cols.strOf(0);
- if (!line.startsWith(col1))
- checkEqu(col1, line);
- const char* col2 = cols.strOf(1);
- if (!line.endsWith(col2)) {
- checkEqu(col2, line);
- }
- }
- }
void testTouch() {
rebuildTree();
- ReByteBuffer nameCurrent;
+ ReByteArray nameCurrent;
buildFilename("current", nameCurrent);
- ReByteBuffer optOutput("--output-file=");
+ ReByteArray optOutput("--output-file=");
optOutput.append(nameCurrent);
ReDirTools tools;
const char* argv[] = { "dt", "touch", "-P;*;-cache", "-tr", "-p;*.txt",
"-m2015.03.28/10:21:31", optOutput.str(), m_base.str(), NULL };
tools.main(8, (char**) argv);
- checkFile(nameCurrent,
+ testFileContentWithWildcards(nameCurrent,
"2015.03.28 10:21:31 *dirtool/1.txt\n"
"2015.03.28 10:21:31 *dirtool/dir1/dir1_2/dir1_2_1/x1.txt\n"
"2015.03.28 10:21:31 *dirtool/dir1/dir1_2/dir1_2_1/x2.txt\n"
"-h", optOutput.str(), m_base.str(), NULL };
tools.main(8, (char**) argv2);
- checkFile(nameCurrent,
+ testFileContentWithWildcards(nameCurrent,
" 0.000005 2015.03.28 10:21:31 *dirtool/1.txt\n"
" 0.000027 2015.03.28 10:21:31 *dirtool/dir1/dir1_2/dir1_2_1/x1.txt\n"
" 0.000027 2015.03.28 10:21:31 *dirtool/dir1/dir1_2/dir1_2_1/x2.txt\n"
}
void testBatch() {
rebuildTree();
- ReByteBuffer nameCurrent;
+ ReByteArray nameCurrent;
buildFilename("current", nameCurrent);
- ReByteBuffer optOutput("--output-file=");
+ ReByteArray optOutput("--output-file=");
optOutput.append(nameCurrent);
ReDirTools tools;
const char* argv[] = { "dt", "batch", "-P;*;-cache", "-td",
"rem === filtered: 0 file(s) 0.000000 MByte 6 dirs(s) *sec\n"
"rem === total: 4 file(s) 0.000067 MByte 6 dirs(s) * sec";
#endif
- checkFile(nameCurrent, content);
+ testFileContentWithWildcards(nameCurrent, content);
}
void testToolStatistic() {
rebuildTree();
tools.main(5, (char**) argv);
}
void testToolSync() {
+ struct stat info;
rebuildTree();
+ ReByteArray nameCurrent;
+ buildFilename("current", nameCurrent);
+ ReByteArray optOutput("--output-file=");
+ optOutput.append(nameCurrent);
ReDirTools tools;
- ReByteBuffer source(m_base);
+ ReByteArray source(m_base);
source.append("dir1");
- ReByteBuffer target(testDir());
+ ReByteArray target(testDir());
target.ensureLastChar(OS_SEPARATOR_CHAR);
target.append("synctest", -1);
_mkdir(target.str(), ALLPERMS);
- const char* argv[] = { "dt", "sync", "-P;*;-cache", "-p;*.txt", source
+ ReDirectory::deleteTree(target.str(), false);
+ const char* argv[] = { "dt", "sync", "-P;*;-cache", "-p;*.txt", "-v3", optOutput.str(), source
.str(), target.str() };
- tools.main(6, (char**) argv);
+ tools.main(8, (char**) argv);
+ target.appendChar(OS_SEPARATOR_CHAR);
+ for(const char** pFile = s_allFiles; *pFile != NULL; pFile++){
+ ReByteArray fullTarget(target);
+ fullTarget.append(*pFile);
+ if (fullTarget.endsWith(".txt") || ! fullTarget.contains("cache") >= 0){
+ checkT(stat(fullTarget.str(), &info));
+ } else {
+ checkF(stat(fullTarget.str(), &info));
+ }
+ }
+ static const char* content =
+ "+dir1_2/dir1_2_1/x1.txt\n"
+ "+dir1_2/dir1_2_1/x2.txt\n"
+ "+cache/cache.txt\n"
+ "-/tmp/retestunit/synctest/dir1/cache/cache.txt\n"
+ "=== copied: * sec 3 file(s) 0.000074 MByte (* MB/sec).\n"
+ "=== tree: 5 dir(s) 3 file(s) 0.000074 MByte";
+ ReByteArray content2(content);
+ content2.replace('/', OS_SEPARATOR_CHAR);
+ testFileContentWithWildcards(nameCurrent, content2.str());
+ }
+ void testToolSync2() {
+ rebuildTree();
+ ReDirTools tools;
+ ReByteArray source(m_base);
+ source.append("dir1");
+ ReByteArray target(testDir());
+ target.ensureLastChar(OS_SEPARATOR_CHAR);
+ target.append("synctest", -1);
+ _mkdir(target.str(), ALLPERMS);
+ const char* argv[] = { "dt", "sync", "--delete=1h", "-p;*.txt", source
+ .str(), target.str() };
+ //tools.main(6, (char**) argv);
}
+ /*
+ " 1.txt", //
+ "*dir1", //
+ "*dir2", //
+ "*dir1/cache", //
+ "*dir1/dir1_1", //
+ "*dir1/dir1_2", //
+ "*dir1/dir1_2/dir1_2_1", //
+ " dir1/dir1_2/dir1_2_1/x1.txt", //
+ " dir1/dir1_2/dir1_2_1/x2.txt", //
+ " dir2/2.x", //
+ " dir1/cache/cache.txt", //
+ NULL };
+
+ */
};
extern void testReDirTools(void);
/*
* cuReDirectory.cpp
- *
+ *
* License: Public Domain
* You can use and modify this file without any restriction.
* Do what you want.
class TestReDirectory: public ReTestUnit {
public:
TestReDirectory() :
- ReTestUnit("ReFileFinder", __FILE__) {
+ ReTestUnit("TestReDirectory", __FILE__) {
run();
}
private:
void run() {
- ReByteBuffer dir;
+ testFileTime();
+ testBase();
+ }
+ void checkOrder(ReFileTime_t& time1, ReFileTime_t& time2, ReFileTime_t& time3){
+ checkT(time1 < time2);
+ checkF(time1 == time2);
+ checkT(time1 != time2);
+ checkF(time1 > time2);
+ checkF(time1 >= time2);
+
+ checkF(time2 < time3);
+ checkT(time2 == time3);
+ checkF(time2 != time3);
+ checkF(time2 > time3);
+ checkT(time2 >= time3);
+
+ }
+ void testFileTime(){
+ // time1 < time2 == time3
+ ReFileTime_t time1;
+ ReFileTime_t time2;
+ ReFileTime_t time3;
+
+#ifdef __linux__
+ time1.tv_sec = 1234;
+ time1.tv_nsec = 56789;
+ time2.tv_sec = time1.tv_sec + 1;
+ time2.tv_nsec = time1.tv_nsec - 1;
+#elif defined __WIN32__
+ time1.dwHighDateTime = 1234;
+ time1.dwLowDateTime = 56789;
+ time2.dwHighDateTime = time1.dwHighDateTime + 1;
+ time2.dwLowDateTime = time1.dwLowDateTime - 1;
+#endif
+ time3 = time2;
+ checkOrder(time1, time2, time3);
+
+#ifdef __linux__
+ time2.tv_sec = time1.tv_sec;
+ time2.tv_nsec = time1.tv_nsec + 1;
+#elif defined __WIN32__
+ time2.dwHighDateTime = time1.dwHighDateTime;
+ time2.dwLowDateTime = time1.dwLowDateTime + 1;
+#endif
+ time3 = time2;
+ checkOrder(time1, time2, time3);
+
+ checkF(filetimeIsUndefined(time1));
+ setFiletimeUndef(time1);
+ checkT(filetimeIsUndefined(time1));
+ }
+ void testBase(){
+ ReByteArray dir;
dir.set(testDir(), -1);
- ReByteBuffer file1 = dir;
+ ReByteArray file1 = dir;
file1.append("abc.1.txt", -1);
createFile(file1.str(), "abc1");
- ReByteBuffer file2 = dir;
+ ReByteArray file2 = dir;
file2.append("abc.2.txt", -1);
createFile(file2.str(), "abc2");
checkT(finder.isValid());
checkT(finder.findFirst("abc.*.txt", false));
- checkEqu("abc.1.txt", finder.currentFile());
+ checkEqu("abc.1.txt", finder.currentNode());
checkT(finder.findNext());
- checkEqu("abc.2.txt", finder.currentFile());
+ checkEqu("abc.2.txt", finder.currentNode());
checkF(finder.findNext());
checkF(finder.findFirst("abx.*.txt", false));
#ifdef __linux__
checkT(finder.findFirst("abc[.][0-9][.]txt", true));
- checkEqu("abc.1.txt", finder.currentFile());
+ checkEqu("abc.1.txt", finder.currentNode());
checkT(finder.findNext());
- checkEqu("abc.2.txt", finder.currentFile());
+ checkEqu("abc.2.txt", finder.currentNode());
checkF(finder.findNext());
checkF(finder.findFirst("abx[.][0-9][.]txt", true));
#endif
/*
* cuReException.cpp
- *
+ *
* License: Public Domain
* You can use and modify this file without any restriction.
* Do what you want.
/*
* cuReHashList.cpp
- *
+ *
* License: Public Domain
* You can use and modify this file without any restriction.
* Do what you want.
ReSeqArray list;
list.setCapacity(maxKeys, maxKeys * maxLength);
list.setSizes(4, maxKeys <= 0xffff ? 2 : 3);
- ReByteBuffer key, value;
+ ReByteArray key, value;
int64_t start = timer();
int ix;
int collisions = 0;
}
void testBasic() {
ReHashList hash;
- ReByteBuffer key, value;
+ ReByteArray key, value;
hash.put("abc", "123");
checkT(hash.get("abc", -1, value));
int flagsKey = 0;
int flagsVal = 0;
ReArrayPosition pos;
- ReByteBuffer key, value;
+ ReByteArray key, value;
while (hash.next(pos, &key, &value)) {
int x = atol(key.buffer());
int y = atol(value.buffer());
/*
* cuReI18N.cpp
- *
+ *
* License: Public Domain
* You can use and modify this file without any restriction.
* Do what you want.
/*
* cuReLogger.cpp
- *
+ *
* License: Public Domain
* You can use and modify this file without any restriction.
* Do what you want.
appender.say(NULL, "x1");
appender.say(NULL, "x2");
appender.say(NULL, "x3");
- ReByteBuffer line;
+ ReByteArray line;
checkEqu(3U, appender.count());
checkT(appender.get(2, line));
checkT(line.indexOf("x1", 2) >= 0);
checkT(line.indexOf("x3", 2) >= 0);
checkT(appender.get(0, line));
checkT(line.indexOf("x4", 2) >= 0);
- ReByteBuffer all;
+ ReByteArray all;
checkEqu(3, appender.join(all).count("\n"));
}
void testSlaveAppender() {
slave1.say(LOG_INFO | CAT_TEST, 9999, "slave1");
slave2.say(LOG_INFO | CAT_TEST, 9999, "slave2");
- ReByteBuffer line;
+ ReByteArray line;
memoryAppender.get(0, line);
checkT(line.indexOf('%') >= 0);
checkT(line.indexOf("slave2", -1) >= 0);
/*
* cuReMD5.cpp
- *
+ *
* License: Public Domain
* You can use and modify this file without any restriction.
* Do what you want.
md5.update((const uint8_t*) "", 0);
checkEqu("d41d8cd98f00b204e9800998ecf8427e", md5.hexDigest());
}
- int testOneLong(ReByteBuffer& text, int seed2 = 0) {
+ int testOneLong(ReByteArray& text, int seed2 = 0) {
ReMD5 md5;
int rc = 0;
ReShiftRandom random;
random.setSeed(text.length() + seed2);
md5.update((uint8_t*) text.str(), text.length());
- ReByteBuffer digest(md5.hexDigest());
+ ReByteArray digest(md5.hexDigest());
md5.reset();
int max2 = text.length() / 20;
if (max2 < 1)
return rc;
}
void testLong() {
- ReByteBuffer text(
+ ReByteArray text(
"01234567890abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVEXYZ0123456789001234567890abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVEXYZ01234567890\n");
for (int ii = 178 - 69 + 1; ii > 0; ii--) {
text.setLength(ii);
}
}
void testBig() {
- ReByteBuffer text;
+ ReByteArray text;
ReShiftRandom random;
int64_t start = timer();
int count = 1000;
}
printf("count: %d updates: %d avg length: %d duration: %s\n", count,
parts, sumLength / count,
- ReByteBuffer("").appendMilliSec(milliSecSince(start)).str());
+ ReByteArray("").appendMilliSec(milliSecSince(start)).str());
}
void testSpeed() {
int max = 1024 * 1024 * 50;
- ReByteBuffer buffer;
+ ReByteArray buffer;
buffer.ensureSize(max);
buffer.setLength(max - 1);
buffer.fill('x', max - 1);
#endif
max / 1024.0 / 1024, passes,
max / 1024.0 / 1024 * 1000 * passes / duration,
- ReByteBuffer("").appendMilliSec(duration).str());
+ ReByteArray("").appendMilliSec(duration).str());
}
};
extern void testReMD5(void);
/*
* cuReMatcher.cpp
- *
+ *
* License: Public Domain
* You can use and modify this file without any restriction.
* Do what you want.
/*
* cuReProgramArgs.cpp
- *
+ *
* License: Public Domain
* You can use and modify this file without any restriction.
* Do what you want.
checkF(args.getBool("boolarg"));
checkEqu(9, args.getInt("intarg"));
- ReByteBuffer buffer;
+ ReByteArray buffer;
checkEqu("empty", args.getString("estringarg", buffer));
checkEqu("abc", args.getString("stringarg", buffer));
checkEqu("arg1", args.arg(0));
checkEqu("arg2", args.arg(1));
checkEqu(2, args.argCount());
- ReByteBuffer fn;
+ ReByteArray fn;
FILE* fp = fopen(buildFilename("help.tmp.txt", fn), "w");
checkF(fp == NULL);
if (fp != NULL) {
args.help("Not really an error!", false, fp);
fclose(fp);
- ReByteBuffer fnExpected;
+ ReByteArray fnExpected;
buildFilename("help.exp.txt", fnExpected);
createExpectedShortHelp(fnExpected.str());
checkFileEqu(fnExpected.str(), fn.str());
args.addString("estringarg3", "This 3thrd string may be empty", 'V',
"estring3", true, "undef3");
- ReByteBuffer buffer;
+ ReByteArray buffer;
const char* vector[] = { "testprog", "--boolval", "--boolval2=true",
"--boolval3=f", "--boolval4=0", "--intval=3", "--string=x y",
"--estring=", "--estring2=not empty", "arg1", "arg2" };
checkEqu("arg1", args.arg(0));
checkEqu("arg2", args.arg(1));
checkEqu(2, args.argCount());
- ReByteBuffer fn;
+ ReByteArray fn;
FILE* fp = fopen(buildFilename("help.tmp.txt", fn), "w");
checkT(fp != NULL);
if (fp) {
args.help(NULL, false, fp);
fclose(fp);
- ReByteBuffer fnExpected;
+ ReByteArray fnExpected;
createExpectedLongHelp(buildFilename("help.exp.txt", fnExpected));
checkFileEqu(fnExpected.str(), fn.str());
}
/*
* cuReRPD64.cpp
- *
+ *
* License: Public Domain
* You can use and modify this file without any restriction.
* Do what you want.
RPD64.update((const uint8_t*) "", 0);
checkEqu("3c7b4e20d8ee3cf7716c2dacdddd9e30", RPD64.hexDigest());
}
- int testOneLong(ReByteBuffer& text, int seed2 = 0) {
+ int testOneLong(ReByteArray& text, int seed2 = 0) {
ReRPD64 RPD64;
int rc = 0;
ReShiftRandom random;
random.setSeed(text.length() + seed2);
RPD64.update((uint8_t*) text.str(), text.length());
- ReByteBuffer digest(RPD64.hexDigest());
+ ReByteArray digest(RPD64.hexDigest());
RPD64.reset();
int max2 = text.length() / 20;
if (max2 < 1)
return rc;
}
void testLong() {
- ReByteBuffer text(
+ ReByteArray text(
"01234567890abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVEXYZ0123456789001234567890abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVEXYZ01234567890\n");
for (int ii = 178 - 69 + 1; ii > 0; ii--) {
text.setLength(ii);
}
}
void testBig() {
- ReByteBuffer text;
+ ReByteArray text;
ReShiftRandom random;
int64_t start = timer();
int count = 1000;
}
printf("count: %d updates: %d avg length: %d duration: %s\n", count,
parts, sumLength / count,
- ReByteBuffer("").appendMilliSec(milliSecSince(start)).str());
+ ReByteArray("").appendMilliSec(milliSecSince(start)).str());
}
void testSpeed() {
int max = 1024 * 1024 * 50;
- ReByteBuffer buffer;
+ ReByteArray buffer;
buffer.ensureSize(max);
buffer.setLength(max - 1);
buffer.fill('x', max - 1);
#endif
max / 1024.0 / 1024, passes,
max / 1024.0 / 1024 * 1000 * passes / duration,
- ReByteBuffer("").appendMilliSec(duration).str());
+ ReByteArray("").appendMilliSec(duration).str());
}
};
extern void testReRPD64(void);
/*
* cuReRandomizer.cpp
- *
+ *
* License: Public Domain
* You can use and modify this file without any restriction.
* Do what you want.
/*
* cuReSeqArray.cpp
- *
+ *
* License: Public Domain
* You can use and modify this file without any restriction.
* Do what you want.
}
void checkElement(ReSeqArray& list, ReSeqArray::Index index,
const char* value, ReSeqArray::Tag expectedTag) {
- ReByteBuffer buffer;
+ ReByteArray buffer;
ReSeqArray::Tag tag;
checkT(list.get(index, buffer, &tag));
checkIEqu(value, buffer.str());
void testBinSearch() {
ReSeqArray list;
list.setIgnoreCase(true);
- ReByteBuffer value, expectedValue;
+ ReByteArray value, expectedValue;
list.add(-1, "abc", -1, 300);
list.add(-1, "abc", -1, 350);
list.add(-1, "abce", -1, 100);
void testBinSearch2() {
ReSeqArray list;
ReSeqArray::Index index;
- ReByteBuffer value;
+ ReByteArray value;
list.setSorted(true);
value = "ab";
for (int count = 2; count < 16; count++) {
void testSorted() {
ReSeqArray list;
list.setIgnoreCase(true);
- ReByteBuffer value, expectedValue;
+ ReByteArray value, expectedValue;
list.add(-1, "bcd", -1, 200);
list.add(-1, "abcd", -1, 100);
list.add(-1, "abc", -1, 300);
void testIgnoreCase() {
ReSeqArray list;
list.setIgnoreCase(true);
- ReByteBuffer value, expectedValue;
+ ReByteArray value, expectedValue;
list.add(-1, "bcd", -1, 200);
list.add(0, "abc", -1, 100);
// list.dump(stdout);
}
void testAdd() {
ReSeqArray list;
- ReByteBuffer value, expectedValue;
+ ReByteArray value, expectedValue;
ReSeqArray::Tag tag = 0;
ReSeqArray::Tag expectedTag = 0;
size_t maxIx = 64;
}
void testFind() {
ReSeqArray list;
- ReByteBuffer value, expectedValue;
+ ReByteArray value, expectedValue;
ReSeqArray::Tag tag = 0;
ReSeqArray::Tag expectedTag = 0;
size_t maxIx = 13;
}
void testBase() {
ReSeqArray list;
- ReByteBuffer value;
+ ReByteArray value;
ReSeqArray::Tag tag = 0;
list.setSizes(8, 4);
list.add(-1, "xxx", -1, ReSeqArray::Tag(1l) << 31);
}
void testRemove() {
ReSeqArray list;
- ReByteBuffer value;
+ ReByteArray value;
ReSeqArray::Tag tag = 0;
list.add(-1, "abc", -1, 100);
/*
* cuReSerializable.cpp
- *
+ *
* License: Public Domain
* You can use and modify this file without any restriction.
* Do what you want.
unpackString64k(sequence, length, m_string64k);
unpackString4t(sequence, length, m_string4t);
}
- virtual ReByteBuffer& serialize(ReByteBuffer& buffer) {
+ virtual ReByteArray& serialize(ReByteArray& buffer) {
buffer.appendBits24(m_serialId).appendBits8(m_int8);
buffer.appendBits16(m_int16).appendBits32(m_int32);
packBool(buffer, m_bool);
packString4t(buffer, m_string4t);
return buffer;
}
- const char* toString(ReByteBuffer& buffer) {
+ const char* toString(ReByteArray& buffer) {
buffer.setLength(0).append("id: ").appendInt(m_serialId);
buffer.append(" i8:").appendInt(m_int8, "%x");
buffer.append(" i16:").appendInt(m_int16, "%x");
int m_int32;
bool m_bool;
int64_t m_int64;
- ReByteBuffer m_string255;
- ReByteBuffer m_string64k;
- ReByteBuffer m_string4t;
+ ReByteArray m_string255;
+ ReByteArray m_string64k;
+ ReByteArray m_string4t;
private:
static int m_serialId;
};
int ExampleClass::m_serialId = 0x123401;
class TestReSerializable: public ReTestUnit {
- typedef ReByteBuffer::Byte Byte;
+ typedef ReByteArray::Byte Byte;
public:
TestReSerializable() :
ReTestUnit("ReSerializable", __FILE__) {
testBasic();
}
void testBasic() {
- ReByteBuffer buffer;
+ ReByteArray buffer;
ExampleClass example(250, 64000, 12345678, true, 0x12345678abcdll,
"king", "lives", "!");
checkEqu(
"id: 1192961 i8:fa i16:fa00 i32:bc614e b:t i64:12345678abcd s255:king s64k:lives s4t:!",
example.toString(buffer));
- ReByteBuffer serialBuffer;
+ ReByteArray serialBuffer;
example.serialize(serialBuffer);
ExampleClass example2;
example2.deserializeBuffer(serialBuffer);
/*
* cuReStringList.cpp
- *
+ *
* License: Public Domain
* You can use and modify this file without any restriction.
* Do what you want.
}
void testAppendByteBuffer() {
ReStringList list;
- ReByteBuffer line;
+ ReByteArray line;
line.set("Hi", -1);
list.append(line, 99);
line.append("!", -1);
checkEqu("4", list.strOf(3));
checkEqu("", list.strOf(4));
checkEqu("99", list.strOf(5));
- ReByteBuffer value("x");
+ ReByteArray value("x");
list.join(";", value);
checkEqu(str, value);
}
void testFile() {
if (true) {
- ReByteBuffer file;
+ ReByteArray file;
buildFilename("abc.csv", file);
ReStringList list;
void testBase() {
if (true) {
ReStringList list;
- ReByteBuffer value;
+ ReByteArray value;
list.append("123", 100);
checkEqu(0U, list.indexOf("123"));
/*
* cuReStringUtils.cpp
- *
+ *
* License: Public Domain
* You can use and modify this file without any restriction.
* Do what you want.
}
void testSplitPath() {
- ReByteBuffer fullname, protocol, path, name, ext;
+ ReByteArray fullname, protocol, path, name, ext;
const char* fn = "file:/etc/samba/smb.cnf";
ReStringUtils::splitPath(fn, &protocol, &path, &name, &ext);
/*
* cuReTCP.cpp
- *
+ *
* License: Public Domain
* You can use and modify this file without any restriction.
* Do what you want.
ReTCPClient client(theLogger);
client.connect("localhost", s_port);
client.send("echo", "Hello world");
- ReByteBuffer command, data;
+ ReByteArray command, data;
client.receive(command, data);
if (!command.equals("Echo ")) {
theLogger->sayF(LOG_ERROR | CAT_TEST, location,
direction).end();
ReTCPClient client(logger);
if (client.connect("localhost", s_port)) {
- ReByteBuffer data, command, answer;
+ ReByteArray data, command, answer;
int size = 1024 * 1024 * 10;
const char* request;
if (upload) {
int miByte = count * (size / (1024 * 1024));
_snprintf(msg, sizeof msg,
"%s: %d MiByte in %s/%d sec: %.3f (%.3f) MiByte/sec", direction,
- miByte, ReByteBuffer("").appendMilliSec((int) duration).str(),
+ miByte, ReByteArray("").appendMilliSec((int) duration).str(),
duration2, miByte * 1000.0 / (double) duration,
miByte / (double) duration2);
logger->say(LOG_INFO | CAT_LIB, location, msg);
/*
* cuReTest.cpp
- *
+ *
* License: Public Domain
* You can use and modify this file without any restriction.
* Do what you want.
testEquFiles();
}
void testFileNameInTestDir() {
- ReByteBuffer fn;
+ ReByteArray fn;
const char* name = buildFilename("xyz.txt", fn);
checkEqu(name, fn.str());
checkT(fn.endsWith("xyz.txt"));
checkEqu("^", colMarker(0));
}
void testEquFiles() {
- ReByteBuffer fn1;
+ ReByteArray fn1;
buildFilename("x1.txt", fn1);
- ReByteBuffer fn2;
+ ReByteArray fn2;
buildFilename("x2.txt", fn2);
createFile(fn1.str(), "123\nline 2");
createFile(fn2.str(), "123\nline 2");
/*
* cuReTraverser.cpp
- *
+ *
* License: Public Domain
* You can use and modify this file without any restriction.
* Do what you want.
ReDirectory::deleteTree(m_base.str(), true);
}
private:
- ReByteBuffer m_base;
- ReByteBuffer m_buffer;
+ ReByteArray m_base;
+ ReByteArray m_buffer;
ReLogger* m_logger;
private:
const char* makeDir(const char* relPath) {
return m_buffer.str();
}
void makeFile(const char* relPath) {
- ReByteBuffer path(m_base);
+ ReByteArray path(m_base);
path.append("/").append(relPath);
path.replaceAll("/", 1, OS_SEPARATOR, -1);
createFile(path.str(), relPath);
}
void testCopyFile() {
#if defined __linux__
- ReByteBuffer src(m_base);
+ ReByteArray src(m_base);
src.append("dir1/dir1_2/dir1_2_1/x1.txt");
- ReByteBuffer trg(testDir());
+ ReByteArray trg(testDir());
trg.append("copy_x1.txt");
- ReByteBuffer buffer;
+ ReByteArray buffer;
buffer.ensureSize(5);
ReDirSync::copyFile(src.str(), NULL, trg.str(), buffer,
ReLogger::globalLogger());
void checkOneFile(const char* node, const char* parent,
const ReHashList& hash) {
- ReByteBuffer path, expected;
- checkT(hash.get(ReByteBuffer(node), path));
+ ReByteArray path, expected;
+ checkT(hash.get(ReByteArray(node), path));
expected.set(parent, -1);
if (!expected.endsWith(OS_SEPARATOR))
expected.append(OS_SEPARATOR);
ReTraverser traverser(m_base.str());
RePatternList patterns;
// exclude */cache/*
- ReByteBuffer buffer(";*;-cache");
+ ReByteArray buffer(";*;-cache");
patterns.set(buffer.str());
traverser.setDirPattern(&patterns);
int level = 0;
int state = 0;
while ((entry = traverser.rawNextFile(level)) != NULL) {
const char* node = entry->node();
- hashPath.put(ReByteBuffer(node, -1), entry->m_path);
+ hashPath.put(ReByteArray(node, -1), entry->m_path);
if (traverser.hasChangedPath(state))
listChanged.add(-1, node);
logF(false, "%d: %-12s %2d %s", level, node, int(entry->fileSize()),
/*
* cuReVarArgs.cpp
- *
+ *
* License: Public Domain
* You can use and modify this file without any restriction.
* Do what you want.
/*
* cuReconfig.cpp
- *
+ *
* License: Public Domain
* You can use and modify this file without any restriction.
* Do what you want.
testBasic();
}
void testBasic() {
- ReByteBuffer fn;
+ ReByteArray fn;
buildFilename("reconfigfile.cfg", fn);
createFile(fn.str(),
"#x.int=a\nx.int=1\nx.bool=true\nx.str=abc\nx.bool2=0\nstring=abc\n");
checkF(config.getBool("x.bool2", true));
checkF(config.getBool("x.bool2", false));
- ReByteBuffer buffer;
+ ReByteArray buffer;
config.getString("string", buffer, "x");
checkEqu("abc", buffer);
config.getString("string1", buffer, "x");
/*
* testall.cpp
- *
+ *
* License: Public Domain
* You can use and modify this file without any restriction.
* Do what you want.
#include "net/renet.hpp"
#endif
-static bool s_testAll = true;
+static bool s_testAll = false;
void testBase() {
extern void testReSerializable(void);
}
void testAll() {
try {
+ testOs();
testBase();
testNet();
if (s_testAll) {
testString();
testMath();
- testOs();
//testNet();
testBase();
}
/*
* dirtool.cpp
- *
+ *
* License: Public Domain
* You can use and modify this file without any restriction.
* Do what you want.
/*
* ReMD5.cpp
- *
+ *
* License: Public Domain
* You can use and modify this file without any restriction.
* Do what you want.
* You also can use this license: http://www.wtfpl.net
* The latest sources: https://github.com/republib
*/
-
-#include "base/rebase.hpp"
-#include "math/remath.hpp"
-
-const int ReMD5::m_s[RE_DIGEST_CHUNK_SIZE] = { 7, 12, 17, 22, 7, 12, 17, 22, 7,
- 12, 17, 22, 7, 12, 17, 22, 5, 9, 14, 20, 5, 9, 14, 20, 5, 9, 14, 20, 5, 9,
- 14, 20, 4, 11, 16, 23, 4, 11, 16, 23, 4, 11, 16, 23, 4, 11, 16, 23, 6, 10,
- 15, 21, 6, 10, 15, 21, 6, 10, 15, 21, 6, 10, 15, 21 };
-// for x in [1..64] : int(2**32 * sin(x))
-const uint32_t ReMD5::m_K[RE_DIGEST_CHUNK_SIZE] = { 0xd76aa478, 0xe8c7b756,
- 0x242070db, 0xc1bdceee, 0xf57c0faf, 0x4787c62a, 0xa8304613, 0xfd469501,
- 0x698098d8, 0x8b44f7af, 0xffff5bb1, 0x895cd7be, 0x6b901122, 0xfd987193,
- 0xa679438e, 0x49b40821, 0xf61e2562, 0xc040b340, 0x265e5a51, 0xe9b6c7aa,
- 0xd62f105d, 0x02441453, 0xd8a1e681, 0xe7d3fbc8, 0x21e1cde6, 0xc33707d6,
- 0xf4d50d87, 0x455a14ed, 0xa9e3e905, 0xfcefa3f8, 0x676f02d9, 0x8d2a4c8a,
- 0xfffa3942, 0x8771f681, 0x6d9d6122, 0xfde5380c, 0xa4beea44, 0x4bdecfa9,
- 0xf6bb4b60, 0xbebfbc70, 0x289b7ec6, 0xeaa127fa, 0xd4ef3085, 0x04881d05,
- 0xd9d4d039, 0xe6db99e5, 0x1fa27cf8, 0xc4ac5665, 0xf4292244, 0x432aff97,
- 0xab9423a7, 0xfc93a039, 0x655b59c3, 0x8f0ccc92, 0xffeff47d, 0x85845dd1,
- 0x6fa87e4f, 0xfe2ce6e0, 0xa3014314, 0x4e0811a1, 0xf7537e82, 0xbd3af235,
- 0x2ad7d2bb, 0xeb86d391 };
-
-/**
- * Constructor.
- *
- * @param digest the buffer for the binary checksum
- * @param digestSize the length of <code>digest</code>
- * @param waiting a buffer for a chunk. Must have space for at least 2*chunksize bytes
- * NULL: an intrinsic buffer will be used
- * @param chunkSize the length of one full input block
- */
-ReDigest::ReDigest(uint8_t* digest, size_t digestSize, uint8_t* waiting,
- size_t chunkSize) :
- m_digest(digest),
- m_digestSize(digestSize),
- // m_waitingBuffer[RE_DIGEST_CHUNK_SIZE];
- m_waiting(waiting != NULL ? waiting : m_waitingBuffer),
- m_lengthWaiting(0),
- m_chunkSize(chunkSize),
- m_length(0),
- m_finalized(false),
- m_salt(0) {
-}
-/**
- * Destructor.
- */
-ReDigest::~ReDigest() {
-}
-/**
- * Returns the binary digest value.
- *
- * @return the binary digest (16 byte array)
- */
-const uint8_t* ReDigest::digest() {
- if (!m_finalized) {
- finalize();
- }
- return m_digest;
-}
-
-/**
- * Returns the binary digest value.
- *
- * @return the binary digest (16 byte array)
- */
-const ReByteBuffer& ReDigest::hexDigest() {
- if (m_hexDigest.length() == 0) {
- digest();
- for (size_t ix = 0; ix < m_digestSize; ix++) {
- m_hexDigest.appendInt(m_digest[ix], "%02x");
- }
- }
- return m_hexDigest;
-}
-
-/**
- * Processes a 64 byte block.
- *
- * @param block a block which should be added to the digest
- * @param blockLength the length of <code>block</code>
- */
-void ReDigest::update(const uint8_t* block, int blockLength) {
- if (blockLength == -1)
- blockLength = strlen((const char*) block);
- // process the "waiting" input (incomplete chunk):
- m_length += blockLength;
- if (m_lengthWaiting > 0) {
- int rest = m_chunkSize - m_lengthWaiting;
- if (rest > blockLength)
- rest = blockLength;
- memcpy(m_waiting + m_lengthWaiting, block, rest);
- blockLength -= rest;
- block += rest;
- m_lengthWaiting += rest;
- // Is the chunk complete?
- if (m_lengthWaiting == m_chunkSize) {
- processChunk(m_waiting);
- m_lengthWaiting = 0;
- }
- }
- // process full 512 bit chunks (64 byte blocks):
- for (int ix = blockLength / m_chunkSize; ix > 0; ix--) {
- processChunk(block);
- block += m_chunkSize;
- }
- blockLength %= m_chunkSize;
- if (blockLength != 0) {
- assert(m_lengthWaiting == 0);
- memcpy(m_waiting, block, blockLength);
- m_lengthWaiting = blockLength;
- }
-}
-
-/**
- * Sets the salt of the checksum algorithm.
- *
- * Important: set the salt before you make the first <code>update()</code>!
- *
- * The salt makes that the checksum of the same input is (extremly) different
- * to another salt.
- *
- * @param salt the salt to set
- */
-void ReDigest::setSalt(uint64_t salt) {
- m_salt = salt;
-}
-/**
- * Constructor.
- */
-ReMD5::ReMD5() :
- ReDigest(m_digest, sizeof m_digest),
- m_a0(0x67452301),
- m_b0(0xefcdab89),
- m_c0(0x98badcfe),
- m_d0(0x10325476) {
-}
-
-/**
- * Destructor.
- */
-ReMD5::~ReMD5() {
-}
-
-/**
- * Finalizes the digest.
- *
- * Handles the rest block (< 64 byte) and append a special tail: a "1" bit
- * and the length of the total input length (in bits).
- *
- * @param block the rest input (incomplete chunk)
- * @param blockLength the length of the block: 0..63
- */
-void ReMD5::finalize() {
- uint8_t* block = m_waiting;
- int blockLength = m_lengthWaiting;
- // append "1" bit to message
- // Notice: the input bytes are considered as bits strings,
- // where the first bit is the most significant bit of the byte.
- block[blockLength++] = 0x80;
- //Pre-processing: padding with zeros
- //append "0" bit until message length in bits ≡ 448 (mod 512)
- // fill the rest of the chunk with '\0'.
- // the last 8 bytes is set to the length in bits (length in bytes * 8)
- int restLength = (m_length + 1) % RE_DIGEST_CHUNK_SIZE;
- // 0 -> 56, 1 -> 55, 2 -> 54, ... 55 -> 1, 56 -> 0,
- // 57 -> 63, 58 -> 62, ... 63 -> 57
- int zeros = restLength <= 56 ? 56 - restLength : 120 - restLength;
- memset(block + blockLength, 0, zeros);
- blockLength += zeros;
- //append original length in bits mod (2 pow 64) to message
- uint64_t lengthBits = 8LL * m_length + m_salt;
-#if defined __LITTLE_ENDIAN__
- memcpy(block + blockLength, &lengthBits, 8);
- blockLength += 8;
-#else
- block[blockLength++] = lengthBits;
- lengthBits >>= 8;
- block[blockLength++] = lengthBits;
- lengthBits >>= 8;
- block[blockLength++] = lengthBits;
- lengthBits >>= 8;
- block[blockLength++] = lengthBits;
- lengthBits >>= 8;
- block[blockLength++] = lengthBits;
- lengthBits >>= 8;
- block[blockLength++] = lengthBits;
- lengthBits >>= 8;
- block[blockLength++] = lengthBits;
- lengthBits >>= 8;
- block[blockLength++] = lengthBits;
-#endif
- processChunk(block);
- if (blockLength > RE_DIGEST_CHUNK_SIZE)
- processChunk(block + RE_DIGEST_CHUNK_SIZE);
-#if defined __LITTLE_ENDIAN__
- memcpy(m_digest, &m_a0, 4);
- memcpy(m_digest + 4, &m_b0, 4);
- memcpy(m_digest + 8, &m_c0, 4);
- memcpy(m_digest + 12, &m_d0, 4);
-#else
+\r
+#include "base/rebase.hpp"\r
+#include "math/remath.hpp"\r
+\r
+const int ReMD5::m_s[RE_DIGEST_CHUNK_SIZE] = { 7, 12, 17, 22, 7, 12, 17, 22, 7,\r
+ 12, 17, 22, 7, 12, 17, 22, 5, 9, 14, 20, 5, 9, 14, 20, 5, 9, 14, 20, 5, 9,\r
+ 14, 20, 4, 11, 16, 23, 4, 11, 16, 23, 4, 11, 16, 23, 4, 11, 16, 23, 6, 10,\r
+ 15, 21, 6, 10, 15, 21, 6, 10, 15, 21, 6, 10, 15, 21 };\r
+// for x in [1..64] : int(2**32 * sin(x))\r
+const uint32_t ReMD5::m_K[RE_DIGEST_CHUNK_SIZE] = { 0xd76aa478, 0xe8c7b756,\r
+ 0x242070db, 0xc1bdceee, 0xf57c0faf, 0x4787c62a, 0xa8304613, 0xfd469501,\r
+ 0x698098d8, 0x8b44f7af, 0xffff5bb1, 0x895cd7be, 0x6b901122, 0xfd987193,\r
+ 0xa679438e, 0x49b40821, 0xf61e2562, 0xc040b340, 0x265e5a51, 0xe9b6c7aa,\r
+ 0xd62f105d, 0x02441453, 0xd8a1e681, 0xe7d3fbc8, 0x21e1cde6, 0xc33707d6,\r
+ 0xf4d50d87, 0x455a14ed, 0xa9e3e905, 0xfcefa3f8, 0x676f02d9, 0x8d2a4c8a,\r
+ 0xfffa3942, 0x8771f681, 0x6d9d6122, 0xfde5380c, 0xa4beea44, 0x4bdecfa9,\r
+ 0xf6bb4b60, 0xbebfbc70, 0x289b7ec6, 0xeaa127fa, 0xd4ef3085, 0x04881d05,\r
+ 0xd9d4d039, 0xe6db99e5, 0x1fa27cf8, 0xc4ac5665, 0xf4292244, 0x432aff97,\r
+ 0xab9423a7, 0xfc93a039, 0x655b59c3, 0x8f0ccc92, 0xffeff47d, 0x85845dd1,\r
+ 0x6fa87e4f, 0xfe2ce6e0, 0xa3014314, 0x4e0811a1, 0xf7537e82, 0xbd3af235,\r
+ 0x2ad7d2bb, 0xeb86d391 };\r
+\r
+/**\r
+ * Constructor.\r
+ *\r
+ * @param digest the buffer for the binary checksum\r
+ * @param digestSize the length of <code>digest</code>\r
+ * @param waiting a buffer for a chunk. Must have space for at least 2*chunksize bytes\r
+ * NULL: an intrinsic buffer will be used\r
+ * @param chunkSize the length of one full input block\r
+ */\r
+ReDigest::ReDigest(uint8_t* digest, size_t digestSize, uint8_t* waiting,\r
+ size_t chunkSize) :\r
+ m_digest(digest),\r
+ m_digestSize(digestSize),\r
+ // m_waitingBuffer[RE_DIGEST_CHUNK_SIZE];\r
+ m_waiting(waiting != NULL ? waiting : m_waitingBuffer),\r
+ m_lengthWaiting(0),\r
+ m_chunkSize(chunkSize),\r
+ m_length(0),\r
+ m_finalized(false),\r
+ m_salt(0) {\r
+}\r
+/**\r
+ * Destructor.\r
+ */\r
+ReDigest::~ReDigest() {\r
+}\r
+/**\r
+ * Returns the binary digest value.\r
+ *\r
+ * @return the binary digest (16 byte array)\r
+ */\r
+const uint8_t* ReDigest::digest() {\r
+ if (!m_finalized) {\r
+ finalize();\r
+ }\r
+ return m_digest;\r
+}\r
+\r
+/**\r
+ * Returns the binary digest value.\r
+ *\r
+ * @return the binary digest (16 byte array)\r
+ */\r
+const ReByteArray& ReDigest::hexDigest() {\r
+ if (m_hexDigest.empty()) {\r
+ digest();\r
+ for (size_t ix = 0; ix < m_digestSize; ix++) {\r
+ m_hexDigest.appendInt(m_digest[ix], "%02x");\r
+ }\r
+ }\r
+ return m_hexDigest;\r
+}\r
+\r
+/**\r
+ * Processes a 64 byte block.\r
+ *\r
+ * @param block a block which should be added to the digest\r
+ * @param blockLength the length of <code>block</code>\r
+ */\r
+void ReDigest::update(const uint8_t* block, int blockLength) {\r
+ if (blockLength == -1)\r
+ blockLength = strlen((const char*) block);\r
+ // process the "waiting" input (incomplete chunk):\r
+ m_length += blockLength;\r
+ if (m_lengthWaiting > 0) {\r
+ int rest = m_chunkSize - m_lengthWaiting;\r
+ if (rest > blockLength)\r
+ rest = blockLength;\r
+ memcpy(m_waiting + m_lengthWaiting, block, rest);\r
+ blockLength -= rest;\r
+ block += rest;\r
+ m_lengthWaiting += rest;\r
+ // Is the chunk complete?\r
+ if (m_lengthWaiting == m_chunkSize) {\r
+ processChunk(m_waiting);\r
+ m_lengthWaiting = 0;\r
+ }\r
+ }\r
+ // process full 512 bit chunks (64 byte blocks):\r
+ for (int ix = blockLength / m_chunkSize; ix > 0; ix--) {\r
+ processChunk(block);\r
+ block += m_chunkSize;\r
+ }\r
+ blockLength %= m_chunkSize;\r
+ if (blockLength != 0) {\r
+ assert(m_lengthWaiting == 0);\r
+ memcpy(m_waiting, block, blockLength);\r
+ m_lengthWaiting = blockLength;\r
+ }\r
+}\r
+\r
+/**\r
+ * Sets the salt of the checksum algorithm.\r
+ *\r
+ * Important: set the salt before you make the first <code>update()</code>!\r
+ *\r
+ * The salt makes that the checksum of the same input is (extremly) different\r
+ * to another salt.\r
+ *\r
+ * @param salt the salt to set\r
+ */\r
+void ReDigest::setSalt(uint64_t salt) {\r
+ m_salt = salt;\r
+}\r
+/**\r
+ * Constructor.\r
+ */\r
+ReMD5::ReMD5() :\r
+ ReDigest(m_digest, sizeof m_digest),\r
+ m_a0(0x67452301),\r
+ m_b0(0xefcdab89),\r
+ m_c0(0x98badcfe),\r
+ m_d0(0x10325476) {\r
+}\r
+\r
+/**\r
+ * Destructor.\r
+ */\r
+ReMD5::~ReMD5() {\r
+}\r
+\r
+/**\r
+ * Finalizes the digest.\r
+ *\r
+ * Handles the rest block (< 64 byte) and append a special tail: a "1" bit\r
+ * and the length of the total input length (in bits).\r
+ *\r
+ * @param block the rest input (incomplete chunk)\r
+ * @param blockLength the length of the block: 0..63\r
+ */\r
+void ReMD5::finalize() {\r
+ uint8_t* block = m_waiting;\r
+ int blockLength = m_lengthWaiting;\r
+ // append "1" bit to message\r
+ // Notice: the input bytes are considered as bits strings,\r
+ // where the first bit is the most significant bit of the byte.\r
+ block[blockLength++] = 0x80;\r
+ //Pre-processing: padding with zeros\r
+ //append "0" bit until message length in bits ≡ 448 (mod 512)\r
+ // fill the rest of the chunk with '\0'.\r
+ // the last 8 bytes is set to the length in bits (length in bytes * 8)\r
+ int restLength = (m_length + 1) % RE_DIGEST_CHUNK_SIZE;\r
+ // 0 -> 56, 1 -> 55, 2 -> 54, ... 55 -> 1, 56 -> 0,\r
+ // 57 -> 63, 58 -> 62, ... 63 -> 57\r
+ int zeros = restLength <= 56 ? 56 - restLength : 120 - restLength;\r
+ memset(block + blockLength, 0, zeros);\r
+ blockLength += zeros;\r
+ //append original length in bits mod (2 pow 64) to message\r
+ uint64_t lengthBits = 8LL * m_length + m_salt;\r
+#if defined __LITTLE_ENDIAN__\r
+ memcpy(block + blockLength, &lengthBits, 8);\r
+ blockLength += 8;\r
+#else\r
+ block[blockLength++] = lengthBits;\r
+ lengthBits >>= 8;\r
+ block[blockLength++] = lengthBits;\r
+ lengthBits >>= 8;\r
+ block[blockLength++] = lengthBits;\r
+ lengthBits >>= 8;\r
+ block[blockLength++] = lengthBits;\r
+ lengthBits >>= 8;\r
+ block[blockLength++] = lengthBits;\r
+ lengthBits >>= 8;\r
+ block[blockLength++] = lengthBits;\r
+ lengthBits >>= 8;\r
+ block[blockLength++] = lengthBits;\r
+ lengthBits >>= 8;\r
+ block[blockLength++] = lengthBits;\r
+#endif\r
+ processChunk(block);\r
+ if (blockLength > RE_DIGEST_CHUNK_SIZE)\r
+ processChunk(block + RE_DIGEST_CHUNK_SIZE);\r
+#if defined __LITTLE_ENDIAN__\r
+ memcpy(m_digest, &m_a0, 4);\r
+ memcpy(m_digest + 4, &m_b0, 4);\r
+ memcpy(m_digest + 8, &m_c0, 4);\r
+ memcpy(m_digest + 12, &m_d0, 4);\r
+#else\r
#define oneWord(word, ix) m_digest[ix] = word; word >>= 8; \\r
m_digest[ix + 1] = word; word >>= 8; m_digest[ix + 2] = word; word >>= 8; \\r
- m_digest[ix + 3] = word
- oneWord(m_a0, 0);
- oneWord(m_b0, 4);
- oneWord(m_c0, 8);
- oneWord(m_d0, 12);
-#endif
-}
-
-/**
- * Processes a 512 bit block ("chunk").
- *
- * This method is a direct programming of the algorithm described in wikipedia.
- */
-void ReMD5::processChunk2(const uint8_t block[RE_DIGEST_CHUNK_SIZE]) {
- uint32_t M[16];
- // break chunk into sixteen 32-bit words M[j], 0 ≤ j ≤ 15
- for (int ix = 0; ix < 16; ix++) {
- uint32_t x = block[3];
- for (int jj = 2; jj >= 0; jj--) {
- x = (x << 8) + block[jj];
- }
- M[ix] = x;
- block += 4;
- }
- //Initialize hash value for this chunk:
- uint32_t A = m_a0;
- uint32_t B = m_b0;
- uint32_t C = m_c0;
- uint32_t D = m_d0;
- //Main loop:
-
- int F, g;
-//#define TRACE_MD5
-#if defined TRACE_MD5
- printf("neu: (%s)\n", block);
-#endif
- for (int i = 0; i < RE_DIGEST_CHUNK_SIZE; i++) {
-#if defined TRACE_MD5
- if (i < 8)
- printf("%2d: A: %08x B: %08x C: %08x D%08x\n", i, A, B, C, D);
-#endif
- if (i < 16) {
-# define F1(B, C, D) ((B & C) | (~ B & D))
- // F := (B and C) or ((not B) and D)
- F = F1(B, C, D);
- g = i;
- } else if (i < 32) {
- // F := (D and B) or (C and (not D))
- // g := (5×i + 1) mod 16
-# define F2(B, C, D) ((D & B) | (C & ~ D))
- F = F2(B, C, D);
- g = (5 * i + 1) % 16;
- } else if (i < 48) {
- // F := B xor C xor D
- // g := (3×i + 5) mod 16
-# define F3(B, C, D) ((B ^ C) ^ D)
- F = F3(B, C, D);
- g = (3 * i + 5) % 16;
- } else {
- // F := C xor (B or (not D))
-# define F4(B, C, D) (C ^ (B | ~ D))
- // g := (7×i) mod 16
- F = F4(B, C, D);
- g = (7 * i) % 16;
- }
-#if defined TRACE_MD5
- if (i < 8)
- printf(" K[%2d]: %08x M[%2d]: %08x shift: %02d\n",
- i, m_K[i], g, M[g], m_s[i]);
-#endif
- uint32_t dTemp = D;
- D = C;
- C = B;
- // B := B + leftrotate((A + F + K[i] + M[g]), s[i])
- uint32_t x = (A + F + m_K[i] + M[g]);
- int shift = m_s[i];
- B += (x << shift) | (x >> (32 - shift));
- A = dTemp;
- }
- //Add this chunk's hash to result so far:
- m_a0 += A;
- m_b0 += B;
- m_c0 += C;
- m_d0 += D;
-}
-/** ----------------------
- */
-#if defined OPTIMIZER_WORKS_GREAT
-inline void rotate_left_and_add(uint32_t& rc, uint32_t data, int shift, uint32_t term) {
- rc = ((data << shift) | (data >> (32-shift))) + term;
-}
-//#define TRACE_MD5
-#if defined TRACE_MD5
-static int s_ix = 0;
-#endif
-inline void X1(uint32_t &var, uint32_t x, uint32_t y, uint32_t z,
- uint32_t data, uint32_t aConst, uint32_t shift) {
-#if defined TRACE_MD5
- printf("%2d: A: %08x B: %08x C: %08x D%08x\n", s_ix++ % 16, var, x, y, z);
- printf(" K[%2d]: %08x M[?]: %08x shift: %02d\n",
- s_ix - 1, aConst, data, shift);
-#endif
- rotate_left_and_add(var, var + F1(x, y, z) + data + aConst, shift, x);
-}
-inline void X2(uint32_t& var, uint32_t x, uint32_t y, uint32_t z,
- uint32_t data, uint32_t aConst, uint32_t shift) {
-#if defined TRACE_MD5
- printf("%2d: A: %08x B: %08x C: %08x D%08x\n", s_ix++ % 16, var, x, y, z);
- printf(" K[%2d]: %08x M[?]: %08x shift: %02d\n",
- s_ix - 1, aConst, data, shift);
-#endif
- rotate_left_and_add(var, var + F2(x, y, z) + data + aConst, shift, x);
-}
-
-inline void X3(uint32_t& var, uint32_t x, uint32_t y, uint32_t z,
- uint32_t data, uint32_t aConst, uint32_t shift) {
-#if defined TRACE_MD5
- printf("%2d: A: %08x B: %08x C: %08x D%08x\n", s_ix++ % 16, var, x, y, z);
- printf(" K[%2d]: %08x M[?]: %08x shift: %02d\n",
- s_ix - 1, aConst, data, shift);
-#endif
- rotate_left_and_add(var, var + F3(x, y, z) + data + aConst, shift, x);
-}
-
-inline void X4(uint32_t& var, uint32_t x, uint32_t y, uint32_t z,
- uint32_t data, uint32_t aConst, uint32_t shift) {
-#if defined TRACE_MD5
- printf("%2d: A: %08x B: %08x C: %08x D%08x\n", s_ix++ % 16, var, x, y, z);
- printf(" K[%2d]: %08x M[?]: %08x shift: %02d\n",
- s_ix - 1, aConst, data, shift);
-#endif
- rotate_left_and_add(var, var + F4(x, y, z) + data + aConst, shift, x);
-}
-#else
+ m_digest[ix + 3] = word\r
+ oneWord(m_a0, 0);\r
+ oneWord(m_b0, 4);\r
+ oneWord(m_c0, 8);\r
+ oneWord(m_d0, 12);\r
+#endif\r
+}\r
+\r
+/**\r
+ * Processes a 512 bit block ("chunk").\r
+ *\r
+ * This method is a direct programming of the algorithm described in wikipedia.\r
+ */\r
+void ReMD5::processChunk2(const uint8_t block[RE_DIGEST_CHUNK_SIZE]) {\r
+ uint32_t M[16];\r
+ // break chunk into sixteen 32-bit words M[j], 0 ≤ j ≤ 15\r
+ for (int ix = 0; ix < 16; ix++) {\r
+ uint32_t x = block[3];\r
+ for (int jj = 2; jj >= 0; jj--) {\r
+ x = (x << 8) + block[jj];\r
+ }\r
+ M[ix] = x;\r
+ block += 4;\r
+ }\r
+ //Initialize hash value for this chunk:\r
+ uint32_t A = m_a0;\r
+ uint32_t B = m_b0;\r
+ uint32_t C = m_c0;\r
+ uint32_t D = m_d0;\r
+ //Main loop:\r
+\r
+ int F, g;\r
+//#define TRACE_MD5\r
+#if defined TRACE_MD5\r
+ printf("neu: (%s)\n", block);\r
+#endif\r
+ for (int i = 0; i < RE_DIGEST_CHUNK_SIZE; i++) {\r
+#if defined TRACE_MD5\r
+ if (i < 8)\r
+ printf("%2d: A: %08x B: %08x C: %08x D%08x\n", i, A, B, C, D);\r
+#endif\r
+ if (i < 16) {\r
+# define F1(B, C, D) ((B & C) | (~ B & D))\r
+ // F := (B and C) or ((not B) and D)\r
+ F = F1(B, C, D);\r
+ g = i;\r
+ } else if (i < 32) {\r
+ // F := (D and B) or (C and (not D))\r
+ // g := (5×i + 1) mod 16\r
+# define F2(B, C, D) ((D & B) | (C & ~ D))\r
+ F = F2(B, C, D);\r
+ g = (5 * i + 1) % 16;\r
+ } else if (i < 48) {\r
+ // F := B xor C xor D\r
+ // g := (3×i + 5) mod 16\r
+# define F3(B, C, D) ((B ^ C) ^ D)\r
+ F = F3(B, C, D);\r
+ g = (3 * i + 5) % 16;\r
+ } else {\r
+ // F := C xor (B or (not D))\r
+# define F4(B, C, D) (C ^ (B | ~ D))\r
+ // g := (7×i) mod 16\r
+ F = F4(B, C, D);\r
+ g = (7 * i) % 16;\r
+ }\r
+#if defined TRACE_MD5\r
+ if (i < 8)\r
+ printf(" K[%2d]: %08x M[%2d]: %08x shift: %02d\n",\r
+ i, m_K[i], g, M[g], m_s[i]);\r
+#endif\r
+ uint32_t dTemp = D;\r
+ D = C;\r
+ C = B;\r
+ // B := B + leftrotate((A + F + K[i] + M[g]), s[i])\r
+ uint32_t x = (A + F + m_K[i] + M[g]);\r
+ int shift = m_s[i];\r
+ B += (x << shift) | (x >> (32 - shift));\r
+ A = dTemp;\r
+ }\r
+ //Add this chunk's hash to result so far:\r
+ m_a0 += A;\r
+ m_b0 += B;\r
+ m_c0 += C;\r
+ m_d0 += D;\r
+}\r
+/** ----------------------\r
+ */\r
+#if defined OPTIMIZER_WORKS_GREAT\r
+inline void rotate_left_and_add(uint32_t& rc, uint32_t data, int shift, uint32_t term) {\r
+ rc = ((data << shift) | (data >> (32-shift))) + term;\r
+}\r
+//#define TRACE_MD5\r
+#if defined TRACE_MD5\r
+static int s_ix = 0;\r
+#endif\r
+inline void X1(uint32_t &var, uint32_t x, uint32_t y, uint32_t z,\r
+ uint32_t data, uint32_t aConst, uint32_t shift) {\r
+#if defined TRACE_MD5\r
+ printf("%2d: A: %08x B: %08x C: %08x D%08x\n", s_ix++ % 16, var, x, y, z);\r
+ printf(" K[%2d]: %08x M[?]: %08x shift: %02d\n",\r
+ s_ix - 1, aConst, data, shift);\r
+#endif\r
+ rotate_left_and_add(var, var + F1(x, y, z) + data + aConst, shift, x);\r
+}\r
+inline void X2(uint32_t& var, uint32_t x, uint32_t y, uint32_t z,\r
+ uint32_t data, uint32_t aConst, uint32_t shift) {\r
+#if defined TRACE_MD5\r
+ printf("%2d: A: %08x B: %08x C: %08x D%08x\n", s_ix++ % 16, var, x, y, z);\r
+ printf(" K[%2d]: %08x M[?]: %08x shift: %02d\n",\r
+ s_ix - 1, aConst, data, shift);\r
+#endif\r
+ rotate_left_and_add(var, var + F2(x, y, z) + data + aConst, shift, x);\r
+}\r
+\r
+inline void X3(uint32_t& var, uint32_t x, uint32_t y, uint32_t z,\r
+ uint32_t data, uint32_t aConst, uint32_t shift) {\r
+#if defined TRACE_MD5\r
+ printf("%2d: A: %08x B: %08x C: %08x D%08x\n", s_ix++ % 16, var, x, y, z);\r
+ printf(" K[%2d]: %08x M[?]: %08x shift: %02d\n",\r
+ s_ix - 1, aConst, data, shift);\r
+#endif\r
+ rotate_left_and_add(var, var + F3(x, y, z) + data + aConst, shift, x);\r
+}\r
+\r
+inline void X4(uint32_t& var, uint32_t x, uint32_t y, uint32_t z,\r
+ uint32_t data, uint32_t aConst, uint32_t shift) {\r
+#if defined TRACE_MD5\r
+ printf("%2d: A: %08x B: %08x C: %08x D%08x\n", s_ix++ % 16, var, x, y, z);\r
+ printf(" K[%2d]: %08x M[?]: %08x shift: %02d\n",\r
+ s_ix - 1, aConst, data, shift);\r
+#endif\r
+ rotate_left_and_add(var, var + F4(x, y, z) + data + aConst, shift, x);\r
+}\r
+#else\r
#define rotate_left_and_add(var, data, shift, term) { \\r
uint32_t val = data; \\r
var = ((val << shift) | (val >> (32-shift))) + term; \\r
-}
+}\r
#define X1(var, x, y, z, data, aConst, shift) \\r
- rotate_left_and_add(var, var + F1(x, y, z) + data + aConst, shift, x)
+ rotate_left_and_add(var, var + F1(x, y, z) + data + aConst, shift, x)\r
#define X2(var, x, y, z, data, aConst, shift) \\r
- rotate_left_and_add(var, var + F2(x, y, z) + data + aConst, shift, x)
+ rotate_left_and_add(var, var + F2(x, y, z) + data + aConst, shift, x)\r
#define X3(var, x, y, z, data, aConst, shift) \\r
- rotate_left_and_add(var, var + F3(x, y, z) + data + aConst, shift, x)
+ rotate_left_and_add(var, var + F3(x, y, z) + data + aConst, shift, x)\r
#define X4(var, x, y, z, data, aConst, shift) \\r
- rotate_left_and_add(var, var + F4(x, y, z) + data + aConst, shift, x)
-#endif /* OPTIMIZER_WORKS_GREAT */
-
-/**
- * Processes a 512 bit block ("chunk").
- *
- * This is a optimized version, derived from the method above.
- * We unroll the loop, this brings speed with factor 2.
- * <pre>
- * B := B + leftrotate((A + F + K[i] + M[g]), s[i])
- * D := C;
- * C := B;
- * B := B + leftrotate((A + F + K[i] + M[g]), s[i])
- * A := D(old)
- * (D, C, B, A) = (C, B, B + leftrotate((A + F + K[i] + M[g]), s[i]), D)
- * ==> (A, B, C, D) = (D, B + leftrotate((A + F + K[i] + M[g]), s[i]), B, A)
- * The unrolled loop:
- * i = g = 0;
- * (A, B, C, D) = (D, B + leftrotate((A + F1(B, C, D) + K[0] + M[0]), s[0]), B, A)
- * only one var must be calculated, the other 3 are exchanged only.
- * i = g = 1;
- * (A, B, C, D) = (D, B + leftrotate((A + F1(B, C, D) + K[1] + M[1]), s[1]), B, A)
- * i = g = 2;
- * (A, B, C, D) = (D, B + leftrotate((A + F1(B, C, D) + K[2] + M[2]), s[2]), B, A)
- * i = g = 3;
- * (A, B, C, D) = (D, B + leftrotate((A + F1(B, C, D) + K[3] + M[3]), s[3]), B, A)
- * in each of the 4 statements another variable (of A, B, C and D) will be calculated
- * so we do not exchange in each step, we calculate in the end position
- * we define a function to do this:
- * void X1(uint32_t &var, uint32_t x, uint32_t y, uint32_t z, uint32_t data, uint32_t shift, uint32_t aConst){
- * var = rotate_left(var+ F1(x, y, z) + data + aConst, shift) + x;
- * }
- * Note: the input parameter of X1 must respect the exchange:
- * A -> D -> C -> B ...
- * X1(A, B, C, D, M[0], K[0], s[0]);
- * X1(D, A, B, C, M[1], K[1], s[1]);
- * X1(C, D, A, B, M[2], K[2], s[2]);
- * X1(B, C, D, A, M[3], K[3], s[3]);
- * ...
- * </pre>
- */
-void ReMD5::processChunk(const uint8_t block[RE_DIGEST_CHUNK_SIZE]) {
- uint32_t M[16];
- // break chunk into sixteen 32-bit words M[j], 0 ≤ j ≤ 15
-#ifdef __LITTLE_ENDIAN__
- for (int ix = 0; ix < 16; ix++) {
- //memcpy(&M[ix], block + ix * 4, 4);
- M[ix] = *(uint32_t*) (block + ix * 4);
- }
-#elif defined __BIG_ENDIAN__
- for (int ix = 0; ix < 16; ix++) {
- uint32_t x = block[3];
- for (int jj = 2; jj >= 0; jj--) {
- x = (x << 8) + block[jj];
- }
- M[ix] = x;
- block += 4;
- }
-#else
-# error "missing __LITTLE_ENDIAN__ or __BIG_ENDIAN__"
-#endif
- //Initialize hash value for this chunk:
- uint32_t A = m_a0;
- uint32_t B = m_b0;
- uint32_t C = m_c0;
- uint32_t D = m_d0;
-#if defined NeverAndNeverAndNeverAgain
- // Derivation of the optimization:
-
-#endif
- /* Round 1 */
- X1(A, B, C, D, M[0], 0xd76aa478, 7);
- X1(D, A, B, C, M[1], 0xe8c7b756, 12);
- X1(C, D, A, B, M[2], 0x242070db, 17);
- X1(B, C, D, A, M[3], 0xc1bdceee, 22);
- X1(A, B, C, D, M[4], 0xf57c0faf, 7);
- X1(D, A, B, C, M[5], 0x4787c62a, 12);
- X1(C, D, A, B, M[6], 0xa8304613, 17);
- X1(B, C, D, A, M[7], 0xfd469501, 22);
- X1(A, B, C, D, M[8], 0x698098d8, 7);
- X1(D, A, B, C, M[9], 0x8b44f7af, 12);
- X1(C, D, A, B, M[10], 0xffff5bb1, 17);
- X1(B, C, D, A, M[11], 0x895cd7be, 22);
- X1(A, B, C, D, M[12], 0x6b901122, 7);
- X1(D, A, B, C, M[13], 0xfd987193, 12);
- X1(C, D, A, B, M[14], 0xa679438e, 17);
- X1(B, C, D, A, M[15], 0x49b40821, 22);
-
- /* Round 2 */
- X2(A, B, C, D, M[1], 0xf61e2562, 5);
- X2(D, A, B, C, M[6], 0xc040b340, 9);
- X2(C, D, A, B, M[11], 0x265e5a51, 14);
- X2(B, C, D, A, M[0], 0xe9b6c7aa, 20);
- X2(A, B, C, D, M[5], 0xd62f105d, 5);
- X2(D, A, B, C, M[10], 0x02441453, 9);
- X2(C, D, A, B, M[15], 0xd8a1e681, 14);
- X2(B, C, D, A, M[4], 0xe7d3fbc8, 20);
- X2(A, B, C, D, M[9], 0x21e1cde6, 5);
- X2(D, A, B, C, M[14], 0xc33707d6, 9);
- X2(C, D, A, B, M[3], 0xf4d50d87, 14);
- X2(B, C, D, A, M[8], 0x455a14ed, 20);
- X2(A, B, C, D, M[13], 0xa9e3e905, 5);
- X2(D, A, B, C, M[2], 0xfcefa3f8, 9);
- X2(C, D, A, B, M[7], 0x676f02d9, 14);
- X2(B, C, D, A, M[12], 0x8d2a4c8a, 20);
-
- /* Round 3 */
- X3(A, B, C, D, M[5], 0xfffa3942, 4);
- X3(D, A, B, C, M[8], 0x8771f681, 11);
- X3(C, D, A, B, M[11], 0x6d9d6122, 16);
- X3(B, C, D, A, M[14], 0xfde5380c, 23);
- X3(A, B, C, D, M[1], 0xa4beea44, 4);
- X3(D, A, B, C, M[4], 0x4bdecfa9, 11);
- X3(C, D, A, B, M[7], 0xf6bb4b60, 16);
- X3(B, C, D, A, M[10], 0xbebfbc70, 23);
- X3(A, B, C, D, M[13], 0x289b7ec6, 4);
- X3(D, A, B, C, M[0], 0xeaa127fa, 11);
- X3(C, D, A, B, M[3], 0xd4ef3085, 16);
- X3(B, C, D, A, M[6], 0x04881d05, 23);
- X3(A, B, C, D, M[9], 0xd9d4d039, 4);
- X3(D, A, B, C, M[12], 0xe6db99e5, 11);
- X3(C, D, A, B, M[15], 0x1fa27cf8, 16);
- X3(B, C, D, A, M[2], 0xc4ac5665, 23);
-
- /* Round 4 */
- X4(A, B, C, D, M[0], 0xf4292244, 6);
- X4(D, A, B, C, M[7], 0x432aff97, 10);
- X4(C, D, A, B, M[14], 0xab9423a7, 15);
- X4(B, C, D, A, M[5], 0xfc93a039, 21);
- X4(A, B, C, D, M[12], 0x655b59c3, 6);
- X4(D, A, B, C, M[3], 0x8f0ccc92, 10);
- X4(C, D, A, B, M[10], 0xffeff47d, 15);
- X4(B, C, D, A, M[1], 0x85845dd1, 21);
- X4(A, B, C, D, M[8], 0x6fa87e4f, 6);
- X4(D, A, B, C, M[15], 0xfe2ce6e0, 10);
- X4(C, D, A, B, M[6], 0xa3014314, 15);
- X4(B, C, D, A, M[13], 0x4e0811a1, 21);
- X4(A, B, C, D, M[4], 0xf7537e82, 6);
- X4(D, A, B, C, M[11], 0xbd3af235, 10);
- X4(C, D, A, B, M[2], 0x2ad7d2bb, 15);
- X4(B, C, D, A, M[9], 0xeb86d391, 21);
-
- //Add this chunk's hash to result so far:
- m_a0 += A;
- m_b0 += B;
- m_c0 += C;
- m_d0 += D;
-}
-/**
- * Prepares the instance for a new checksum.
- */
-void ReMD5::reset() {
- m_a0 = 0x67452301;
- m_b0 = 0xefcdab89;
- m_c0 = 0x98badcfe;
- m_d0 = 0x10325476;
- memset(m_digest, 0, sizeof m_digest);
- memset(m_waiting, 0, m_chunkSize);
- m_lengthWaiting = 0;
- m_length = 0;
- m_hexDigest.setLength(0);
- m_finalized = false;
-}
+ rotate_left_and_add(var, var + F4(x, y, z) + data + aConst, shift, x)\r
+#endif /* OPTIMIZER_WORKS_GREAT */\r
+\r
+/**\r
+ * Processes a 512 bit block ("chunk").\r
+ *\r
+ * This is a optimized version, derived from the method above.\r
+ * We unroll the loop, this brings speed with factor 2.\r
+ * <pre>\r
+ * B := B + leftrotate((A + F + K[i] + M[g]), s[i])\r
+ * D := C;\r
+ * C := B;\r
+ * B := B + leftrotate((A + F + K[i] + M[g]), s[i])\r
+ * A := D(old)\r
+ * (D, C, B, A) = (C, B, B + leftrotate((A + F + K[i] + M[g]), s[i]), D)\r
+ * ==> (A, B, C, D) = (D, B + leftrotate((A + F + K[i] + M[g]), s[i]), B, A)\r
+ * The unrolled loop:\r
+ * i = g = 0;\r
+ * (A, B, C, D) = (D, B + leftrotate((A + F1(B, C, D) + K[0] + M[0]), s[0]), B, A)\r
+ * only one var must be calculated, the other 3 are exchanged only.\r
+ * i = g = 1;\r
+ * (A, B, C, D) = (D, B + leftrotate((A + F1(B, C, D) + K[1] + M[1]), s[1]), B, A)\r
+ * i = g = 2;\r
+ * (A, B, C, D) = (D, B + leftrotate((A + F1(B, C, D) + K[2] + M[2]), s[2]), B, A)\r
+ * i = g = 3;\r
+ * (A, B, C, D) = (D, B + leftrotate((A + F1(B, C, D) + K[3] + M[3]), s[3]), B, A)\r
+ * in each of the 4 statements another variable (of A, B, C and D) will be calculated\r
+ * so we do not exchange in each step, we calculate in the end position\r
+ * we define a function to do this:\r
+ * void X1(uint32_t &var, uint32_t x, uint32_t y, uint32_t z, uint32_t data, uint32_t shift, uint32_t aConst){\r
+ * var = rotate_left(var+ F1(x, y, z) + data + aConst, shift) + x;\r
+ * }\r
+ * Note: the input parameter of X1 must respect the exchange:\r
+ * A -> D -> C -> B ...\r
+ * X1(A, B, C, D, M[0], K[0], s[0]);\r
+ * X1(D, A, B, C, M[1], K[1], s[1]);\r
+ * X1(C, D, A, B, M[2], K[2], s[2]);\r
+ * X1(B, C, D, A, M[3], K[3], s[3]);\r
+ * ...\r
+ * </pre>\r
+ */\r
+void ReMD5::processChunk(const uint8_t block[RE_DIGEST_CHUNK_SIZE]) {\r
+ uint32_t M[16];\r
+ // break chunk into sixteen 32-bit words M[j], 0 ≤ j ≤ 15\r
+#ifdef __LITTLE_ENDIAN__\r
+ for (int ix = 0; ix < 16; ix++) {\r
+ //memcpy(&M[ix], block + ix * 4, 4);\r
+ M[ix] = *(uint32_t*) (block + ix * 4);\r
+ }\r
+#elif defined __BIG_ENDIAN__\r
+ for (int ix = 0; ix < 16; ix++) {\r
+ uint32_t x = block[3];\r
+ for (int jj = 2; jj >= 0; jj--) {\r
+ x = (x << 8) + block[jj];\r
+ }\r
+ M[ix] = x;\r
+ block += 4;\r
+ }\r
+#else\r
+# error "missing __LITTLE_ENDIAN__ or __BIG_ENDIAN__"\r
+#endif\r
+ //Initialize hash value for this chunk:\r
+ uint32_t A = m_a0;\r
+ uint32_t B = m_b0;\r
+ uint32_t C = m_c0;\r
+ uint32_t D = m_d0;\r
+#if defined NeverAndNeverAndNeverAgain\r
+ // Derivation of the optimization:\r
+\r
+#endif\r
+ /* Round 1 */\r
+ X1(A, B, C, D, M[0], 0xd76aa478, 7);\r
+ X1(D, A, B, C, M[1], 0xe8c7b756, 12);\r
+ X1(C, D, A, B, M[2], 0x242070db, 17);\r
+ X1(B, C, D, A, M[3], 0xc1bdceee, 22);\r
+ X1(A, B, C, D, M[4], 0xf57c0faf, 7);\r
+ X1(D, A, B, C, M[5], 0x4787c62a, 12);\r
+ X1(C, D, A, B, M[6], 0xa8304613, 17);\r
+ X1(B, C, D, A, M[7], 0xfd469501, 22);\r
+ X1(A, B, C, D, M[8], 0x698098d8, 7);\r
+ X1(D, A, B, C, M[9], 0x8b44f7af, 12);\r
+ X1(C, D, A, B, M[10], 0xffff5bb1, 17);\r
+ X1(B, C, D, A, M[11], 0x895cd7be, 22);\r
+ X1(A, B, C, D, M[12], 0x6b901122, 7);\r
+ X1(D, A, B, C, M[13], 0xfd987193, 12);\r
+ X1(C, D, A, B, M[14], 0xa679438e, 17);\r
+ X1(B, C, D, A, M[15], 0x49b40821, 22);\r
+\r
+ /* Round 2 */\r
+ X2(A, B, C, D, M[1], 0xf61e2562, 5);\r
+ X2(D, A, B, C, M[6], 0xc040b340, 9);\r
+ X2(C, D, A, B, M[11], 0x265e5a51, 14);\r
+ X2(B, C, D, A, M[0], 0xe9b6c7aa, 20);\r
+ X2(A, B, C, D, M[5], 0xd62f105d, 5);\r
+ X2(D, A, B, C, M[10], 0x02441453, 9);\r
+ X2(C, D, A, B, M[15], 0xd8a1e681, 14);\r
+ X2(B, C, D, A, M[4], 0xe7d3fbc8, 20);\r
+ X2(A, B, C, D, M[9], 0x21e1cde6, 5);\r
+ X2(D, A, B, C, M[14], 0xc33707d6, 9);\r
+ X2(C, D, A, B, M[3], 0xf4d50d87, 14);\r
+ X2(B, C, D, A, M[8], 0x455a14ed, 20);\r
+ X2(A, B, C, D, M[13], 0xa9e3e905, 5);\r
+ X2(D, A, B, C, M[2], 0xfcefa3f8, 9);\r
+ X2(C, D, A, B, M[7], 0x676f02d9, 14);\r
+ X2(B, C, D, A, M[12], 0x8d2a4c8a, 20);\r
+\r
+ /* Round 3 */\r
+ X3(A, B, C, D, M[5], 0xfffa3942, 4);\r
+ X3(D, A, B, C, M[8], 0x8771f681, 11);\r
+ X3(C, D, A, B, M[11], 0x6d9d6122, 16);\r
+ X3(B, C, D, A, M[14], 0xfde5380c, 23);\r
+ X3(A, B, C, D, M[1], 0xa4beea44, 4);\r
+ X3(D, A, B, C, M[4], 0x4bdecfa9, 11);\r
+ X3(C, D, A, B, M[7], 0xf6bb4b60, 16);\r
+ X3(B, C, D, A, M[10], 0xbebfbc70, 23);\r
+ X3(A, B, C, D, M[13], 0x289b7ec6, 4);\r
+ X3(D, A, B, C, M[0], 0xeaa127fa, 11);\r
+ X3(C, D, A, B, M[3], 0xd4ef3085, 16);\r
+ X3(B, C, D, A, M[6], 0x04881d05, 23);\r
+ X3(A, B, C, D, M[9], 0xd9d4d039, 4);\r
+ X3(D, A, B, C, M[12], 0xe6db99e5, 11);\r
+ X3(C, D, A, B, M[15], 0x1fa27cf8, 16);\r
+ X3(B, C, D, A, M[2], 0xc4ac5665, 23);\r
+\r
+ /* Round 4 */\r
+ X4(A, B, C, D, M[0], 0xf4292244, 6);\r
+ X4(D, A, B, C, M[7], 0x432aff97, 10);\r
+ X4(C, D, A, B, M[14], 0xab9423a7, 15);\r
+ X4(B, C, D, A, M[5], 0xfc93a039, 21);\r
+ X4(A, B, C, D, M[12], 0x655b59c3, 6);\r
+ X4(D, A, B, C, M[3], 0x8f0ccc92, 10);\r
+ X4(C, D, A, B, M[10], 0xffeff47d, 15);\r
+ X4(B, C, D, A, M[1], 0x85845dd1, 21);\r
+ X4(A, B, C, D, M[8], 0x6fa87e4f, 6);\r
+ X4(D, A, B, C, M[15], 0xfe2ce6e0, 10);\r
+ X4(C, D, A, B, M[6], 0xa3014314, 15);\r
+ X4(B, C, D, A, M[13], 0x4e0811a1, 21);\r
+ X4(A, B, C, D, M[4], 0xf7537e82, 6);\r
+ X4(D, A, B, C, M[11], 0xbd3af235, 10);\r
+ X4(C, D, A, B, M[2], 0x2ad7d2bb, 15);\r
+ X4(B, C, D, A, M[9], 0xeb86d391, 21);\r
+\r
+ //Add this chunk's hash to result so far:\r
+ m_a0 += A;\r
+ m_b0 += B;\r
+ m_c0 += C;\r
+ m_d0 += D;\r
+}\r
+/**\r
+ * Prepares the instance for a new checksum.\r
+ */\r
+void ReMD5::reset() {\r
+ m_a0 = 0x67452301;\r
+ m_b0 = 0xefcdab89;\r
+ m_c0 = 0x98badcfe;\r
+ m_d0 = 0x10325476;\r
+ memset(m_digest, 0, sizeof m_digest);\r
+ memset(m_waiting, 0, m_chunkSize);\r
+ m_lengthWaiting = 0;\r
+ m_length = 0;\r
+ m_hexDigest.setLength(0);\r
+ m_finalized = false;\r
+}\r
/*
* ReMD5.hpp
- *
+ *
* License: Public Domain
* You can use and modify this file without any restriction.
* Do what you want.
virtual ~ReDigest();
public:
const uint8_t* digest();
- const ReByteBuffer& hexDigest();
+ const ReByteArray& hexDigest();
virtual void update(const uint8_t* block, int blockLength);
/** Updates the digest with data of any length.
* @param block the data to process
*/
- inline void update(const ReByteBuffer& block) {
+ inline void update(const ReByteArray& block) {
update(reinterpret_cast<const uint8_t*>(block.str()),
(int) block.length());
}
protected:
uint8_t* m_digest;
size_t m_digestSize;
- ReByteBuffer m_hexDigest;
+ ReByteArray m_hexDigest;
// normally only the first chunk is used (64 byte), but while finalization
// a 2nd chunk may be needed.
uint8_t m_waitingBuffer[2 * RE_DIGEST_CHUNK_SIZE];
/*
* ReObfuscator.cpp
- *
+ *
* License: Public Domain
* You can use and modify this file without any restriction.
* Do what you want.
/*
* ReObfuscator.hpp
- *
+ *
* License: Public Domain
* You can use and modify this file without any restriction.
* Do what you want.
/*
* ReRPD64.cpp
- *
+ *
* License: Public Domain
* You can use and modify this file without any restriction.
* Do what you want.
/*
* ReRPD64.hpp
- *
+ *
* License: Public Domain
* You can use and modify this file without any restriction.
* Do what you want.
/*
* ReRandomizer.cpp
- *
+ *
* License: Public Domain
* You can use and modify this file without any restriction.
* Do what you want.
* @result The buffer.
*/
const char* ReRandomizer::nextString(int minLength, int maxLength,
- ReByteBuffer &buffer) {
+ ReByteArray &buffer) {
int len = nextInt(maxLength, minLength);
buffer.setLength(len);
char* ptr = buffer.buffer();
/*
* ReRandomizer.hpp
- *
+ *
* License: Public Domain
* You can use and modify this file without any restriction.
* Do what you want.
virtual int64_t nextInt64(int64_t maxValue = LLONG_MAX,
int64_t minValue = 0);
char nextChar();
- const char* nextString(int minLength, int maxLength, ReByteBuffer& buffer);
+ const char* nextString(int minLength, int maxLength, ReByteArray& buffer);
void shuffle(void* array, size_t length, size_t elemSize);
/** @brief Sets the instance to a defined start state.
*/
/*
* remath.hpp
- *
+ *
* License: Public Domain
* You can use and modify this file without any restriction.
* Do what you want.
/*
* ReTCP.cpp
- *
+ *
* License: Public Domain
* You can use and modify this file without any restriction.
* Do what you want.
hints.ai_family = AF_UNSPEC;
hints.ai_socktype = SOCK_STREAM;
- getaddrinfo(ip, ReByteBuffer("").appendInt(port).str(), &hints, &addr);
+ getaddrinfo(ip, ReByteArray("").appendInt(port).str(), &hints, &addr);
if (addr == NULL) {
m_logger->sayF(LOG_ERROR | CAT_NETWORK, LC_CONNECT_1,
i18n("ip not reachable: $1")).arg(ip).end();
*
* @throws ReTCPBrokenPipeException
*/
-void ReTCPConnection::receive(ReByteBuffer& command, ReByteBuffer& data) {
+void ReTCPConnection::receive(ReByteArray& command, ReByteArray& data) {
command.setLength(8);
int received = recv(m_handleSocket, command.buffer(), 8, 0);
if (received == 0) {
LC_RECEIVE_5,
i18n("received: $1 bytes in $2 round(s) [$3]: $4")).arg(
length).arg(rounds).arg(m_peerName).arg(
- ReByteBuffer().appendDump(data.str(), data.length(), 80).str())
+ ReByteArray().appendDump(data.str(), data.length(), 80).str())
.end();
}
command.setLength(0);
m_loggerOwner->logger()->sayF(LOG_DEBUG | CAT_NETWORK, LC_WRITE_2,
i18n("sent: $1 bytes in $2 round(s): $3 $4")).arg(length).arg(
rounds).arg(command).arg(
- ReByteBuffer().appendDump(data, length, 80).str()).end();
+ ReByteArray().appendDump(data, length, 80).str()).end();
}
/**
* Serves the commands of a single connection (in a single thread).
*/
void ReTCPServerConnection::run() {
- ReByteBuffer command;
+ ReByteArray command;
ReNetCommandHandler::ProcessingState rc = ReNetCommandHandler::PS_UNDEF;
m_loggerOwner->logger()->sayF(LOG_INFO | CAT_NETWORK,
LC_SERVER_CONNECTION_RUN_1, i18n("new connection to $1")).arg(m_name)
memcpy(m_ip, "0.0.0.0", 8);
m_name.set(m_ip).appendChar(':').appendInt(m_port);
- getaddrinfo(NULL, ReByteBuffer().appendInt(m_port).str(), &hints,
+ getaddrinfo(NULL, ReByteArray().appendInt(m_port).str(), &hints,
&addrInfo);
m_family = addrInfo->ai_family;
// make a socket:
* PS_ABORT: connection should be finished
*/
ReNetCommandHandler::ProcessingState ReTCPEchoServer::handleNetCommand(
- ReByteBuffer& command, ReByteBuffer& data, ReTCPConnection* connection) {
+ ReByteArray& command, ReByteArray& data, ReTCPConnection* connection) {
ProcessingState rc = PS_UNDEF;
if (command.equals("echo ")) {
connection->send("Echo", data.str(), data.length());
/*
* ReTCP.hpp
- *
+ *
* License: Public Domain
* You can use and modify this file without any restriction.
* Do what you want.
int m_port;
ReLoggerOwner* m_loggerOwner;
char m_ip[INET6_ADDRSTRLEN + 1];
- ReByteBuffer m_name;
+ ReByteArray m_name;
};
/**
inline int id() const {
return m_id;
}
- void receive(ReByteBuffer& command, ReByteBuffer& data);
+ void receive(ReByteArray& command, ReByteArray& data);
void send(const char* command, const char* data, int length = -1);
void setConnectedAddress(int family, const char* ip, int port);
/** Sets the socket handle.
m_logSendReceive = value;
}
protected:
- ReByteBuffer m_peerName;
- ReByteBuffer m_received;
- ReByteBuffer m_toSend;
+ ReByteArray m_peerName;
+ ReByteArray m_received;
+ ReByteArray m_toSend;
int m_handleSocket;
int m_id;
uint32_t m_noSent;
* PS_FAILED: command processed, error occurred<br>
* PS_ABORT: connection should be finished
*/
- virtual ProcessingState handleNetCommand(ReByteBuffer& command,
- ReByteBuffer& data, ReTCPConnection* connection) = 0;
+ virtual ProcessingState handleNetCommand(ReByteArray& command,
+ ReByteArray& data, ReTCPConnection* connection) = 0;
protected:
ReNetCommandHandler* m_nextHandler;
ReTCPEchoServer(int port, ReLogger* logger);
virtual ~ReTCPEchoServer();
public:
- virtual ProcessingState handleNetCommand(ReByteBuffer& command,
- ReByteBuffer& data, ReTCPConnection* connection);
+ virtual ProcessingState handleNetCommand(ReByteArray& command,
+ ReByteArray& data, ReTCPConnection* connection);
};
/**
/*
* ReUdpConnection.cpp
- *
+ *
* License: Public Domain
* You can use and modify this file without any restriction.
* Do what you want.
* Otherwise: The length of the received message.
*
*/
-int ReUdpConnection::receive(int timeout, ReByteBuffer* buffer, bool doLog) {
+int ReUdpConnection::receive(int timeout, ReByteArray* buffer, bool doLog) {
socklen_t addrLength = sizeof m_address;
bool doRead = true;
if (buffer == NULL) {
*
* @return The internal buffer.
*/
-ReByteBuffer& ReUdpConnection::buffer() {
+ReByteArray& ReUdpConnection::buffer() {
return m_buffer;
}
* @return true: The message should be logged.
* false: Otherwise.
*/
-bool ReUdpMaster::canLog(ReByteBuffer& message) {
+bool ReUdpMaster::canLog(ReByteArray& message) {
return true;
}
/** @brief Receives UDP messages and send answers.
*/
void ReUdpMaster::run() {
- ReByteBuffer answer;
+ ReByteArray answer;
bool again = true;
while (again) {
receive(0, NULL, false);
/*
* ReUdpConnection.hpp
- *
+ *
* License: Public Domain
* You can use and modify this file without any restriction.
* Do what you want.
int port() const {
return m_port;
}
- int receive(int timeout = 0, ReByteBuffer* buffer = NULL,
+ int receive(int timeout = 0, ReByteArray* buffer = NULL,
bool doLog = true);
int send(const char* buffer, int bufferLength = -1);
void close();
- ReByteBuffer& buffer();
+ ReByteArray& buffer();
protected:
int m_socket;
struct sockaddr_in m_address;
- ReByteBuffer m_buffer;
+ ReByteArray m_buffer;
int m_port;
time_t m_lastReceipt;
ReLogger* m_logger;
public:
ReUdpMaster(int port, ReLogger* logger);
virtual ~ReUdpMaster();
- virtual bool canLog(ReByteBuffer& message);
+ virtual bool canLog(ReByteArray& message);
public:
void run();
protected:
- virtual bool handlePage(ReByteBuffer& buffer, ReByteBuffer& answer,
+ virtual bool handlePage(ReByteArray& buffer, ReByteArray& answer,
ReUdpMaster& server) = 0;
};
/*
* renet.hpp
- *
+ *
* License: Public Domain
* You can use and modify this file without any restriction.
* Do what you want.
/*
* ReDirTools.cpp
- *
+ *
* License: Public Domain
* You can use and modify this file without any restriction.
* Do what you want.
LC_COMPARE_STORAGE_7, // 50121
LC_COMPARE_DIR_1, // 50122
LC_DELETE_1, // 50123
+ LC_DELETE_SUPERFLUOUS_1, // 50124
+ LC_SYNC_1, // 50125
};
const char* ReDirTools::m_version = "2015.03.22";
ReLogger* ReDirTools::m_logger = NULL;
const char* s_syncExamples[] = {
"dirtool sync --basename-pattern=;*.txt;*.doc e:\\data\\ d:\\backup\\data2",
"dirtool sync --type=r --max-size=1G usr etc /media/backup",
- "dirtool sync --delete=7d /home/ /backup",
+ "dirtool sync --delete=7d --editor=kate /home/ /backup",
NULL };
const char* s_tcpUsage[] = {
m_programArgs.addString("verbose",
i18n(
"verbose level: 0: no info, 1: summary only, 2: normal, 3: chatter mode, 4: debug"),
- 'v', "verbose", false, "1");
+ 'v', "verbose", false, "2");
m_programArgs.addInt("trace",
i18n("all <number> seconds the current path will be traced\n"
"0: no trace"), 'T', "trace-interval", 0);
* @throws ReOptionExecption
*/
ReFileTime_t ReDirOptions::checkDate(const char* value) {
- ReByteBuffer theValue(value, -1);
+ ReByteArray theValue(value, -1);
time_t rcTime;
if (theValue.count(".") == 2) {
// a date:
*/
void ReDirOptions::help(const char* errorMessage, const char* message2) const {
- ReByteBuffer msg;
+ ReByteArray msg;
if (errorMessage != 0)
msg.append(errorMessage, -1);
if (message2 != NULL)
* @throws
*/
void ReDirOptions::checkStandardFilterOptions() {
- ReByteBuffer buffer;
+ ReByteArray buffer;
if (m_programArgs.getString("older", buffer)[0] != '\0')
checkDate(buffer.str());
if (m_programArgs.getString("younger", buffer)[0] != '\0')
*
* @param buffer the pattern list as string, e.g. ";*;-cache"
*/
-void ReDirOptions::optimizePathPattern(ReByteBuffer& buffer) {
+void ReDirOptions::optimizePathPattern(ReByteArray& buffer) {
ReStringList list;
ReStringList rootList;
list.split(buffer.str() + 1, buffer.str()[0]);
buffer.replaceAll(OS_SEPARATOR, 1, "/", 1);
- ReByteBuffer item;
+ ReByteArray item;
for (int ix = 0; ix < (int) list.count(); ix++) {
item.set(list.strOf(ix), -1);
if (item.endsWith("/*"))
* @param filter OUT: the filter to set
*/
void ReDirOptions::setFilterFromProgramArgs(ReDirEntryFilter& filter) {
- ReByteBuffer buffer;
+ ReByteArray buffer;
if (m_programArgs.getString("younger", buffer)[0] != '\0')
filter.m_maxAge = checkDate(buffer.str());
if (m_programArgs.getString("older", buffer)[0] != '\0')
m_pathPatterns.set(buffer.str());
filter.m_pathPatterns = &m_pathPatterns;
}
- if ((m_interval = m_programArgs.getInt("trace")) != 0)
+ if ((m_interval = m_programArgs.getInt("trace") * CLOCKS_PER_SEC) != 0){
m_triggerCount = 10;
+ }
if (m_programArgs.getString("output", buffer)[0] != '\0') {
if ((m_output = fopen(buffer.str(), "w")) == NULL) {
help("cannot open output file", buffer.str());
m_programArgs.getString("verbose", buffer);
unsigned int nValue = 0;
int length;
- if (buffer.length() == 0)
+ if (buffer.empty())
m_verboseLevel = V_NORMAL;
else if ( (length = ReStringUtils::lengthOfUnsigned(buffer.str(),
buffer.length(), &nValue)) == 0 || length != buffer.length())
m_hasStandardArgs(true),
m_traverser(NULL, this, logger),
m_filter(),
- m_start(time(NULL)),
+ m_start(clock()),
//m_statInfo(),
m_logger(logger) {
#pragma warning( pop )
* @return <code>true</code> (for chaining)
*/
bool ReTool::trace(const char* currentFile) {
- ReByteBuffer buffer(" ");
+ ReByteArray buffer(" ");
int duration = int(time(NULL) - m_startTime);
buffer.appendInt(duration / 60).appendInt(duration % 60, ":%02d: ");
buffer.appendInt(m_files).appendChar('/').appendInt(
m_programArgs.init(argc, argv);
if (m_programArgs.argCount() < m_minArguments)
m_programArgs.help(i18n("too few arguments"), false, stdout);
- if (m_hasStandardArgs)
+ if (m_hasStandardArgs){
+ checkStandardFilterOptions();
setFilterFromProgramArgs(m_filter);
+ }
doIt();
if (m_output != stdout) {
fclose(m_output);
void ReTool::processFileArguments() {
int max = m_programArgs.argCount() - m_reservedLast;
// Test whether the arguments are files or directories:
- ReByteBuffer arg;
+ ReByteArray arg;
for (int ii = m_reservedFirst; ii < max; ii++) {
arg = m_programArgs.arg(ii);
if (!exists(arg) != 0)
m_programArgs.help(
- ReByteBuffer(i18n("not a file or a directory: ")).append(arg)
+ ReByteArray(i18n("not a file or a directory: ")).append(arg)
.str(), false, stderr);
}
// process the files:
* @param filename the name of the file
*/
void ReTool::processSingleFile(const char* filename) {
- ReByteBuffer protocol;
- ReByteBuffer path;
- ReByteBuffer name;
- ReByteBuffer ext;
+ ReByteArray protocol;
+ ReByteArray path;
+ ReByteArray name;
+ ReByteArray ext;
ReStringUtils::splitPath(filename, &protocol, &path, &name, &ext);
protocol.append(path);
- if (protocol.length() == 0)
+ if (protocol.empty())
protocol.append(".");
else
protocol.reduceLength();
*/
void ReTool::printSummary(const char* prefix) {
if (m_verboseLevel >= V_SUMMARY) {
- int duration = int(time(NULL) - m_start);
- ReByteBuffer line;
- ReByteBuffer line2;
+ double duration = (double) (clock() - m_start) / CLOCKS_PER_SEC;
+ ReByteArray line;
+ ReByteArray line2;
statisticAsString(line);
double rate =
- duration == 0 ? 0.0 : (m_files + m_directories) / duration;
+ duration == 0.0 ? 0.0 : (m_files + m_directories) / duration;
line.append(rate, " %.1f").append(i18n("/sec"), -1);
m_traverser.statisticAsString(line2);
- line2.appendChar(' ').appendTime(duration).append(" ", 1).append(
+ line2.appendChar(' ').appendTime(int(duration * 1000)).append(" ", 1).append(
i18n("sec"));
fprintf(m_output, "%s=== filtered: %s\n", prefix == NULL ? "" : prefix,
line.str());
}
static void replaceMakros(const char* arguments, ReDirStatus_t* entry,
- const char* delim, ReByteBuffer& line) {
+ const char* delim, ReByteArray& line) {
line.set(arguments, -1);
// we prepare the removal of unwanted delimiters in constructed placeholders:
// example: !path!!name!: without correction: "e:\\data\\""xxx"
// We want: "e:\\data\\xxx"
line.replaceAll("!!", 2, "!\x01!", 3);
- ReByteBuffer replacement;
+ ReByteArray replacement;
if (strstr(arguments, "!full!") != NULL) {
replacement.set(delim, -1).append(entry->m_path);
replacement.append(entry->node(), -1).append(delim, -1);
line.replaceAll("!ext!", 5, replacement.str(), replacement.length());
}
// We remove the unwanted delimiters (see above):
- ReByteBuffer buffer;
+ ReByteArray buffer;
buffer.set(delim, -1).appendChar('\01').append(delim, -1);
line.replaceAll(buffer.str(), buffer.length(), "", 0);
}
* Creates the batch file.
*/
void ReDirBatch::doIt() {
- ReByteBuffer buffer;
+ ReByteArray buffer;
m_programArgs.getString("arguments", m_arguments);
m_programArgs.getString("script", m_script);
if (m_arguments.length() + m_script.length() == 0)
* @param entry the properties of the file to process
*/
void ReDirBatch::processFile(ReDirStatus_t* entry) {
- ReByteBuffer line;
+ ReByteArray line;
#if defined __linux__
static const char* delim = "'";
#elif defined __WIN32__
ReDirStatus_t* entry;
ReRPD64 digest2;
digest2.setSalt(0x2004199111121989ll);
- ReByteBuffer line;
+ ReByteArray line;
FILE* fp = fopen(storageFile, "w");
if (fp == NULL) {
m_logger->sayF(LOG_ERROR | CAT_FILE, LC_BUILD_DIRECTORY_1,
i18n("corrupted storage file: $1")).arg(storageFile).end();
} else {
ReStringList cols;
- ReByteBuffer fullname(path);
+ ReByteArray fullname(path);
fullname.ensureLastChar(OS_SEPARATOR_CHAR);
int pathLength = fullname.length();
struct stat info;
void ReDirChecksum::doIt() {
int size = m_programArgs.getInt("buffersize") * 1024;
m_buffer.setLength(size);
- ReByteBuffer value;
+ ReByteArray value;
m_programArgs.getString("command", value);
if (value.equals("list", -1, true))
m_command = CMD_LIST;
* @param entry the properties of the directory to process
*/
void ReDirChecksum::processDir(ReDirStatus_t* entry) {
- ReByteBuffer storageFile;
+ ReByteArray storageFile;
if (m_command != CMD_LIST) {
storageFile.append(entry->fullName());
storageFile.ensureLastChar(OS_SEPARATOR_CHAR);
* @return <code>digest</code> (for chaining)
*/
ReDigest& ReDirChecksum::calculateChecksum(const char* name, ReDigest& digest,
- ReByteBuffer& buffer, ReLogger* logger) {
+ ReByteArray& buffer, ReLogger* logger) {
FILE* fp = fopen(name, "rb");
if (fp == NULL) {
if (logger != NULL)
* @param entry the properties of the file to process
*/
void ReDirList::processFile(ReDirStatus_t* entry) {
- ReByteBuffer bufferRights;
- ReByteBuffer bufferTime;
+ ReByteArray bufferRights;
+ ReByteArray bufferTime;
if (m_shortFormat)
fprintf(m_output, "%s%s\n", entry->m_path.str(), entry->node());
else {
int numbersPerLine = m_programArgs.getInt("perline");
int width = m_programArgs.getInt("width");
if (width <= 0)
- width = ReByteBuffer("").appendInt(to).length();
- ReByteBuffer format("%");
+ width = ReByteArray("").appendInt(to).length();
+ ReByteArray format("%");
format.appendInt(width).append("d%s");
int found = 0;
ReSeqArray values(count);
- ReByteBuffer value;
+ ReByteArray value;
if (!multiple && count >= to - from + 1)
help(
i18n(
*/
const ReStringList& ReDirStatistic::calculate(const char* base, int level,
void (*formatter)(const ReDirStatisticData& data, ReDirStatistic& parent,
- ReByteBuffer& line)) {
+ ReByteArray& line)) {
ReDirEntryFilter filter;
ReTraverser traverser(base, this);
setFilterFromProgramArgs(filter);
int currentDepth = -1;
ReDirStatisticData* current = dataStack[0];
current->m_path.set(base, -1);
- ReByteBuffer line;
+ ReByteArray line;
bool useFilter = filter.m_minSize > 0 || filter.m_maxSize != -1
|| !filetimeIsUndefined(filter.m_minAge)
|| !filetimeIsUndefined(filter.m_maxAge) || m_nodePatterns.count() > 0;
m_programArgs.help("depth is not an integer", false, stdout);
}
void (*proc)(const ReDirStatisticData& data, ReDirStatistic& parent,
- ReByteBuffer& line) = &formatWithSizeFilesAndDirs;
+ ReByteArray& line) = &formatWithSizeFilesAndDirs;
if (m_programArgs.getBool("kbyte"))
proc = &formatLikeDu;
const ReStringList& list = calculate(m_programArgs.arg(0), depth, proc);
- ReByteBuffer buffer;
+ ReByteArray buffer;
for (size_t ix = 0; ix < list.count(); ix++) {
buffer.set(list.strOf(ix), list.strLengthOf(ix));
fprintf(m_output, "%s\n", buffer.str());
}
if (m_verboseLevel >= V_SUMMARY) {
- int duration = int(time(NULL) - m_start);
+ int duration = int((clock() - m_start) / CLOCKS_PER_SEC);
fprintf(m_output, "=== duration: ");
if (duration >= 3600)
fprintf(m_output, "%d:", duration / 3600);
* @param line OUT: the formatted line, the conclusion of the statistic data
*/
void formatLikeDu(const ReDirStatisticData& data, ReDirStatistic& parent,
- ReByteBuffer& line) {
+ ReByteArray& line) {
line.setLength(0);
// Round up to the next KiByte:
line.appendInt(int((data.m_sizes + 1023) / 1024)).append("\t").append(
* @param line OUT: the formatted line, the conclusion of the statistic data
*/
void formatWithSizeFilesAndDirs(const ReDirStatisticData& data,
- ReDirStatistic& parent, ReByteBuffer& line) {
+ ReDirStatistic& parent, ReByteArray& line) {
line.setLength(0);
// Round up to the next KiByte:
char buffer[256];
* Sets the filetime for the specified files.
*/
void ReDirTouch::doIt() {
- ReByteBuffer buffer;
+ ReByteArray buffer;
if (m_programArgs.getString("modified", buffer)[0] != '\0')
m_modified = checkDate(buffer.str());
if (m_programArgs.getString("accessed", buffer)[0] != '\0')
const char* name = entry->fullName();
if (touch(name, modified, accessed, ReLogger::globalLogger()) == 0
&& m_verboseLevel >= V_NORMAL) {
- ReByteBuffer bufferTime;
- ReByteBuffer bufferTime2;
+ ReByteArray bufferTime;
+ ReByteArray bufferTime2;
if (m_verboseLevel == V_NORMAL) {
if (countTimes == 2)
fprintf(m_output, "%s | %s | %s\n",
fprintf(m_output, "%s %s\n", bufferTime.str(), name);
}
} else {
- ReByteBuffer bufferTime3;
- ReByteBuffer bufferTime4;
+ ReByteArray bufferTime3;
+ ReByteArray bufferTime4;
if (countTimes == 2)
fprintf(m_output, "%s -> %s | %s -> %s | %s\n",
ReDirStatus_t::filetimeToString(entry->modified(),
*
* @param path the name of the subdir to create
*/
-void ReDirSync::makeDirWithParents(ReByteBuffer& path, int minWidth,
+void ReDirSync::makeDirWithParents(ReByteArray& path, int minWidth,
ReTraverser& traverser) {
if (!exists(path)) {
ReFileProperties_t* props = NULL;
i18n("does nothing, but says what should be done"), 'Y', "dry", false);
m_programArgs.addString("delete",
i18n(
- "delete the files/folders of the target directory not existing in the source directory.\n"
+ "deletes the files/folders of the target directory not existing in the source directory.\n"
"If a time expression is given only files will be deleted if they are older than this.\n"
"a time expression is a date, a time, a date/time or a relative time.\n"
"relative times are a number and a unit.\n"
"units: m(inutes) h(hours), d(days). Default: m(inutes)\n"
- "examples: -D7d --delete=30d -D24h -D2009.3.2/12:00 -D1999.01.01"),
- 'E', "delete", false, NULL);
+ "examples: -E7d --delete=30d -E24h -E2009.3.2/12:00 -E1999.01.01"),
+ 'E', "delete", true, NULL);
+ m_programArgs.addBool("deletebefore",
+ i18n("deletes the superfluous files before copying.\n"
+ "This needs fewer space but it is more dangerous:\n"
+ "you have no time if the target is wrong: all files will be deleted"), 'B', "delete-before", false);
+ m_programArgs.addString("editor",
+ i18n(
+ "this editor will be started with a file containing a summary message (signals the end)"),
+ 'e', "editor", false, NULL);
m_programArgs.addInt("timediff",
i18n("filetime difference is considered to be equal\n"
"if the difference is less than this value (in seconds)"), 'I',
* <code>false</code>error occurred
*/
bool ReDirSync::copyFile(const char* source, ReFileProperties_t* properties,
- const char* target, ReByteBuffer& buffer, ReLogger* logger) {
+ const char* target, ReByteArray& buffer, ReLogger* logger) {
bool rc = false;
#ifdef __linux__
struct stat info;
#endif
return rc;
}
+/**
+ * Delete the files existing in the target directory tree and not in the source tree.
+ *
+ * @param source the source directory
+ * @param target the target directory
+ * @param deleteTime UNDEF or a time: only files older than this will be deleted
+ */
+void ReDirSync::deleteSuperfluous(const ReByteArray& source, const ReByteArray& target,
+ const ReFileTime_t& deleteTime){
+ ReTraceUnit& tracer = *this;
+ ReDirectory trg(target.str());
+ if (trg.findFirst(ReDirectory::ALL_FILES, false)) {
+ ReByteArray src, trg2;
+ struct stat info;
+ ReFileTime_t modified;
+ bool ignoreTime = filetimeIsUndefined(deleteTime);
+ bool dry = m_programArgs.getBool("dry");
+ do {
+ if (strcmp(".", trg.currentNode()) == 0 || strcmp("..", trg.currentNode()) == 0)
+ continue;
+ if (tracer.isCountTriggered() && tracer.isTimeTriggered())
+ tracer.trace(trg.currentFull().str());
+
+ src.set(source).append(trg.currentNode());
+ if (lstat(src.str(), &info) == 0){
+ if (S_ISDIR(info.st_mode)){
+ trg2.set(target).append(trg.currentNode());
+ deleteSuperfluous(src, trg2, deleteTime);
+ }
+ } else if (ignoreTime || trg.currentModified() >= deleteTime){
+ if (trg.currentIsDir()){
+ if (! dry)
+ ReDirectory::deleteTree(trg.currentFull().str(), true);
+ if (m_verboseLevel >= V_NORMAL)
+ fprintf(m_output, "-%s%s\n", trg.currentFull().str(), dry ? " would be deleted (dir)" : "");
+ } else {
+ if (unlink(trg.currentFull().str()) != 0)
+ m_logger->sayF(LOG_ERROR | CAT_FILE, LC_DELETE_SUPERFLUOUS_1,
+ i18n("cannot delete file: $1 (errno: $2)")).arg(trg.currentFull()).arg(
+ errno).end();
+ else if (m_verboseLevel >= V_NORMAL)
+ fprintf(m_output, "-%s%s\n", trg.currentFull().str(), dry ? " would be deleted" : "");
+ }
+ }
+ } while (trg.findNext());
+ }
+}
/**
* Sets the file properties.
*
bool ReDirSync::makeDirectory(const char* directory, int minLength,
ReFileProperties_t* properties, ReLogger* logger) {
bool rc = true;
- ReByteBuffer path(directory);
+ ReByteArray path(directory);
int start = 0;
#if defined __WIN32__
start = path.indexOf(':');
return rc;
}
+static void printStatus(FILE* fp, double duration, int files, int sumSizes, int treeDirs,
+ int treeFiles, int64_t treeSumSizes){
+ fprintf(fp,
+ i18n(
+ "=== copied: %02d:%02d sec %7d file(s) %12.6f MByte (%.3f MB/sec).\n"
+ "=== tree: %5d dir(s) %7d file(s) %12.6f MByte\n"),
+ int(duration) / 60, int(duration) % 60, files, sumSizes / 1E6,
+ sumSizes / 1E6 / (duration == 0.0 ? 0.001 : duration), treeDirs,
+ treeFiles, treeSumSizes / 1E6);
+}
/**
* Synchronizes two directory trees.
*/
void ReDirSync::doIt() {
ReDirEntryFilter filter;
const char* sep = OS_SEPARATOR;
- ReByteBuffer buffer;
- ReByteBuffer target(m_programArgs.arg(m_programArgs.argCount() - 1));
+ ReByteArray buffer;
+ ReByteArray target(m_programArgs.arg(m_programArgs.argCount() - 1));
target.removeLastChar(OS_SEPARATOR_CHAR);
if (!exists(target))
- help(i18n("target does not exist: $1"), target.str());
+ help(i18n("target does not exist: "), target.str());
else if (!S_ISDIR(m_statInfo.st_mode))
help(i18n("target is not a directory: $1"), target.str());
size_t lengthTargetBase = target.length();
bool dry = m_programArgs.getBool("dry");
bool ignoreDate = m_programArgs.getBool("ignoredate");
bool mustExist = m_programArgs.getBool("mustexist");
- if (m_programArgs.getString("delete", buffer)[0] != '\0')
- checkDate(buffer.str());
+ bool deleteTarget = false;
+ ReFileTime_t deleteDate;
+ setFiletimeUndef(deleteDate);
+ bool deleteBefore = m_programArgs.getBool("deletebefore");
+ if (m_programArgs.getString("delete", buffer) != NULL){
+ deleteTarget = true;
+ if (! buffer.empty())
+ deleteDate = checkDate(buffer.str());
+ }
- setFilterFromProgramArgs(filter);
int64_t sumSizes = 0;
int files = 0;
int treeFiles = 0;
int treeDirs = 0;
int64_t treeSumSizes = 0ll;
- ReByteBuffer source, targetFile;
+ ReByteArray source, targetFile;
for (int ix = 0; ix < m_programArgs.argCount() - 1; ix++) {
source.set(m_programArgs.arg(ix), -1);
target.setLength(lengthTargetBase);
size_t ixSourceRelative = source.length();
size_t ixTargetRelative = target.length();
+ if (deleteTarget && deleteBefore)
+ deleteSuperfluous(source, target, deleteDate);
m_traverser.changeBase(source.str());
m_traverser.setPropertiesFromFilter(&filter);
int level;
ReDirStatus_t* entry;
- ReByteBuffer line;
+ ReByteArray line;
while ((entry = m_traverser.nextFile(level, &filter)) != NULL) {
if (entry->isDirectory())
continue;
// append the new relative path from source to target:
target.setLength(ixTargetRelative);
target.append(entry->m_path.str() + ixSourceRelative, -1);
- if (!exists(target))
+ if (!exists(target) && ! dry)
makeDirWithParents(target, ixTargetRelative, m_traverser);
targetFile.set(target).append(entry->node(), -1);
const char* targetRelativePath = targetFile.str() + ixTargetRelative
if (!dry)
copyFile(entry, targetFile.str());
}
+ if (deleteTarget && ! deleteBefore)
+ deleteSuperfluous(source, target, deleteDate);
treeFiles += m_traverser.files();
treeDirs += m_traverser.directories();
treeSumSizes += m_traverser.sizes();
}
+ double duration = double((clock() - m_start)) / CLOCKS_PER_SEC;
if (m_verboseLevel >= V_SUMMARY) {
- int duration = int(time(NULL) - m_start);
- fprintf(m_output,
- i18n(
- "=== copied: %02d:%02d sec %7d file(s) %12.6f MByte (%.3f MB/sec).\n"
- "=== tree: %5d dir(s) %7d file(s) %12.6f MByte\n"),
- duration / 60, duration % 60, files, sumSizes / 1E6,
- sumSizes / 1E6 / (duration == 0 ? 1 : duration), treeDirs,
- treeFiles, treeSumSizes / 1E6);
+ printStatus(m_output, duration, files, sumSizes, treeDirs,
+ treeFiles, treeSumSizes);
+ }
+ if (m_programArgs.getString("editor", buffer) != NULL){
+ ReByteArray tempFile = ReFileUtils::tempDir("redirtool.status.");
+ tempFile.appendInt(time(NULL), "%x").append(".txt");
+ FILE* fp = fopen(tempFile.str(), "w");
+ if (fp == NULL)
+ m_logger->sayF(LOG_ERROR | CAT_FILE, LC_SYNC_1,
+ i18n("cannot open status file ($1): $2")).arg(errno).arg(tempFile).end();
+ else {
+ fprintf(fp, i18n("backup finished!\n\n"));
+ printStatus(fp, duration, files, sumSizes, treeDirs,
+ treeFiles, treeSumSizes);
+ fclose(fp);
+ buffer.insert(0, "\"", -1);
+ buffer.append("\" ").append(tempFile);
+ system(buffer.str());
+ }
}
}
*/
void ReDirTCP::doIt() {
int port = m_programArgs.getInt("port");
- ReByteBuffer buffer;
+ ReByteArray buffer;
int64_t bufferSize = checkSize(m_programArgs.getString("size", buffer));
// the protocol does not allow more than 16 MiByte because of the flags:
if (bufferSize > 16LL * 1024 * 1024 - 64LL)
help(i18n("buffersize exceeds 16777184 = 16MiByte - 32: "),
buffer.str());
- ReByteBuffer command = m_programArgs.arg(0);
+ ReByteArray command = m_programArgs.arg(0);
if (command.isPrefixOf("server", -1, true)) {
ReTCPEchoServer server(port, m_logger);
server.setLogSendReceive(false);
server.listenForAll();
} else if (command.isPrefixOf("client", -1, true)) {
const char* ip = m_programArgs.arg(1);
- ReByteBuffer direction("download");
+ ReByteArray direction("download");
int rounds = 10;
int interval = 5;
if (m_programArgs.argCount() > 2) {
if (client.connect(ip, port)) {
time_t start = time(NULL);
const char* command = upload ? "strlen" : "filldata";
- ReByteBuffer message;
+ ReByteArray message;
if (upload)
message.appendChar('x', bufferSize);
else
time_t lastPrint = start;
int64_t size = 0;
int duration = 0;
- ReByteBuffer answer, data;
+ ReByteArray answer, data;
client.setLogSendReceive(false);
int64_t sizeCurrent = 0;
for (int ii = 0; ii < rounds; ii++) {
* Creates the batch file.
*/
void ReDirWhich::doIt() {
- ReByteBuffer value, path;
+ ReByteArray value, path;
bool all = false;
ReStringList items;
char sep = 0;
m_programArgs.getString("list", path);
- if (path.length() == 0) {
+ if (path.empty()) {
m_programArgs.getString("variable", value);
if (getenv(value.str()) == NULL)
help("Umgebungsvariable nicht definiert: ", value.str());
}
items.split(path.str(), sep);
struct stat info;
- ReByteBuffer full;
+ ReByteArray full;
for (int ix = 0; ix < m_programArgs.argCount(); ix++) {
bool found = false;
- ReByteBuffer arg(m_programArgs.arg(ix));
+ ReByteArray arg(m_programArgs.arg(ix));
for (size_t ixItem = 0; ixItem < items.count(); ixItem++) {
full.set(items.strOf(ixItem));
if (arg.indexOf('*') < 0) {
if (dir.findFirst(arg.str(), false)) {
do {
printf("%s%c%s\n", full.str(), OS_SEPARATOR_CHAR,
- dir.currentFile());
+ dir.currentNode());
} while (dir.findNext());
}
}
* @return <code>true</code>: part is a prefix of full
*/
static bool isArg(const char* full, const char* part) {
- ReByteBuffer fullArg(full);
+ ReByteArray fullArg(full);
bool rc = fullArg.startsWith(part, -1);
return rc;
}
/*
* ReDirTools.hpp
- *
+ *
* License: Public Domain
* You can use and modify this file without any restriction.
* Do what you want.
}
void setFilterFromProgramArgs(ReDirEntryFilter& filter);
protected:
- void optimizePathPattern(ReByteBuffer& buffer);
+ void optimizePathPattern(ReByteArray& buffer);
protected:
ReProgramArgs m_programArgs;
RePatternList m_nodePatterns;
@param name can be changed and recovered!
@return <code>true</code>: a file with the given name exists
*/
- inline bool exists(ReByteBuffer& name) {
+ inline bool exists(ReByteArray& name) {
#if defined __linux__
// linux ignores a trailing slash:
return stat(name.str(), &m_statInfo) == 0;
bool m_hasStandardArgs;
ReTraverser m_traverser;
ReDirEntryFilter m_filter;
- int64_t m_start;
+ clock_t m_start;
struct stat m_statInfo;
ReLogger* m_logger;
};
virtual void processDir(ReDirStatus_t* entry);
virtual void processFile(ReDirStatus_t* entry);
protected:
- ReByteBuffer m_arguments;
- ReByteBuffer m_script;
+ ReByteArray m_arguments;
+ ReByteArray m_script;
bool m_isExe;
};
void updateStorage(const char* path, const char* storageFile);
public:
static ReDigest& calculateChecksum(const char* name, ReDigest& digest,
- ReByteBuffer& buffer, ReLogger* logger);
+ ReByteArray& buffer, ReLogger* logger);
protected:
Command m_command;
ReDigest* m_digest;
- ReByteBuffer m_buffer;
+ ReByteArray m_buffer;
};
/**
void clear();
ReDirStatisticData& add(const ReDirStatisticData& source);
public:
- ReByteBuffer m_path;
+ ReByteArray m_path;
};
class ReDirStatistic;
extern void formatLikeDu(const ReDirStatisticData& data, ReDirStatistic& parent,
- ReByteBuffer& line);
+ ReByteArray& line);
extern void formatWithSizeFilesAndDirs(const ReDirStatisticData& data,
- ReDirStatistic& parent, ReByteBuffer& line);
+ ReDirStatistic& parent, ReByteArray& line);
/**
* Calculates a statistic of a directory tree.
public:
const ReStringList& calculate(const char* base, int depth,
void (*format)(const ReDirStatisticData& data, ReDirStatistic& parent,
- ReByteBuffer& line) = formatLikeDu);
+ ReByteArray& line) = formatLikeDu);
void doIt();
private:
ReStringList m_list;
protected:
virtual void doIt();
void copyFile(ReDirStatus_t* entry, const char* target);
- void makeDirWithParents(ReByteBuffer& path, int minWidth,
+ void deleteSuperfluous(const ReByteArray& source, const ReByteArray& target,
+ const ReFileTime_t& deleteTime);
+ void makeDirWithParents(ReByteArray& path, int minWidth,
ReTraverser& traverser);
public:
static bool copyFile(const char* source, ReFileProperties_t* properties,
- const char* target, ReByteBuffer& buffer, ReLogger* logger = NULL);
+ const char* target, ReByteArray& buffer, ReLogger* logger = NULL);
static bool makeDirectory(const char* directory, int minLength,
ReFileProperties_t* properties, ReLogger* logger = NULL);
static bool setProperties(const char* fullName,
ReFileProperties_t* properties, ReLogger* logger = NULL);
protected:
- ReByteBuffer m_buffer;
+ ReByteArray m_buffer;
};
/**
static ReErrNo_t touch(const char* filename, const ReFileTime_t& modified,
const ReFileTime_t& accessed, ReLogger* logger = NULL);
protected:
- ReByteBuffer m_buffer;
+ ReByteArray m_buffer;
ReFileTime_t m_modified;
ReFileTime_t m_accessed;
};
-/*\r
- * ReFileUtils.cpp\r
- * \r
- * License: Public Domain\r
- * You can use and modify this file without any restriction.\r
- * Do what you want.\r
- * No warranties and disclaimer of any damages.\r
- * You also can use this license: http://www.wtfpl.net\r
- * The latest sources: https://github.com/republib\r
- */\r
+/*
+ * ReFileUtils.cpp
+ *
+ * License: Public Domain
+ * You can use and modify this file without any restriction.
+ * Do what you want.
+ * No warranties and disclaimer of any damages.
+ * You also can use this license: http://www.wtfpl.net
+ * The latest sources: https://github.com/republib
+ */
#include "base/rebase.hpp"\r
#include "os/reos.hpp"\r
\r
* @param node the name of the subdirectory\r
* @return the full name of the subdirectory\r
*/\r
-ReByteBuffer ReFileUtils::tempDir(const char* node){\r
- ReByteBuffer rc;\r
+ReByteArray ReFileUtils::tempDir(const char* node){\r
+ ReByteArray rc;\r
if (getenv("TMP") != NULL) {\r
rc = getenv("TMP");\r
} else if (getenv("TEMP")) {\r
* @param node the name of the subdirectory\r
* @param the full name of the subdirectory\r
*/\r
-ReByteBuffer ReFileUtils::tempFile(const char* node, const char* subdir){\r
- ReByteBuffer rc = tempDir(subdir);\r
+ReByteArray ReFileUtils::tempFile(const char* node, const char* subdir){\r
+ ReByteArray rc = tempDir(subdir);\r
rc.ensureLastChar(OS_SEPARATOR_CHAR);\r
rc.append(node);\r
return rc;\r
-/*\r
- * ReFileUtils.hpp\r
- * \r
- * License: Public Domain\r
- * You can use and modify this file without any restriction.\r
- * Do what you want.\r
- * No warranties and disclaimer of any damages.\r
- * You also can use this license: http://www.wtfpl.net\r
- * The latest sources: https://github.com/republib\r
- */\r
+/*
+ * ReFileUtils.hpp
+ *
+ * License: Public Domain
+ * You can use and modify this file without any restriction.
+ * Do what you want.
+ * No warranties and disclaimer of any damages.
+ * You also can use this license: http://www.wtfpl.net
+ * The latest sources: https://github.com/republib
+ */
#if ! defined REFILE_UTILS_HPP\r
#define REFILE_UTILS_HPP\r
\r
class ReFileUtils {\r
public:\r
- static ReByteBuffer tempDir(const char* node);\r
- static ReByteBuffer tempFile(const char* node, const char* subdir);\r
+ static ReByteArray tempDir(const char* node);\r
+ static ReByteArray tempFile(const char* node, const char* subdir);\r
};\r
#endif
\ No newline at end of file
/*
* ReRemoteDir.cpp
- *
+ *
* License: Public Domain
* You can use and modify this file without any restriction.
* Do what you want.
*
* @param sequence IN/OUT: the place for the byte sequence
*/
-ReByteBuffer& ReRemoteDir::serialize(ReByteBuffer& sequence) {
+ReByteArray& ReRemoteDir::serialize(ReByteArray& sequence) {
return sequence;
}
}
ReNetCommandHandler::ProcessingState ReRemoteDirService::handleNetCommand(
- ReByteBuffer& command, ReByteBuffer& data, ReTCPConnection* connection) {
+ ReByteArray& command, ReByteArray& data, ReTCPConnection* connection) {
return ReNetCommandHandler::PS_UNDEF;
}
/*
* ReRemoteDir.hpp
- *
+ *
* License: Public Domain
* You can use and modify this file without any restriction.
* Do what you want.
public:
virtual void deserialize(uint8_t*& sequence, size_t& length);
void populate(const char* path);
- virtual ReByteBuffer& serialize(ReByteBuffer& sequence);
+ virtual ReByteArray& serialize(ReByteArray& sequence);
protected:
ReRemoteDir* m_parent;
int m_indexFileInParent;
- ReByteBuffer m_namePool;
+ ReByteArray m_namePool;
int m_fileCount;
ReRemoteFile* m_files;
private:
ReRemoteDirService();
~ReRemoteDirService();
public:
- virtual ProcessingState handleNetCommand(ReByteBuffer& command,
- ReByteBuffer& data, ReTCPConnection* connection);
+ virtual ProcessingState handleNetCommand(ReByteArray& command,
+ ReByteArray& data, ReTCPConnection* connection);
};
#endif /* REREMOTEDIR_HPP_ */
/*
* ReTraverser.cpp
- *
+ *
* License: Public Domain
* You can use and modify this file without any restriction.
* Do what you want.
* @param buffer OUT: the file time
* @return <code>buffer.str()</code> (for chaining)
*/
-const char* ReDirStatus_t::filetimeAsString(ReByteBuffer& buffer) {
+const char* ReDirStatus_t::filetimeAsString(ReByteArray& buffer) {
return filetimeToString(modified(), buffer);
}
* @return <code>buffer.str()</code>, e.g. "2014.01.07 02:59:43"
*/
const char* ReDirStatus_t::filetimeToString(const ReFileTime_t* time,
- ReByteBuffer& buffer) {
+ ReByteArray& buffer) {
time_t time1 = filetimeToTime(time);
struct tm* time2 = localtime(&time1);
buffer.setLength(4 + 2 * 2 + 2 * 2 + 1 + 3 * 2 + 2 * 1);
static int s_diffTime = 0x7fffffff;
if (s_diffTime == 0x7fffffff){
s_diffTime = 0;
- ReByteBuffer tempFile = ReFileUtils::tempFile("$$redir$$.tmp", NULL);
+ ReByteArray tempFile = ReFileUtils::tempFile("$$redir$$.tmp", NULL);
const char* filename = tempFile.str();
FILE* fp = fopen(filename, "w");
if (fp != NULL){
#elif defined __WIN32__
if (m_handle != INVALID_HANDLE_VALUE)
FindClose(m_handle);
- ReByteBuffer thePath(m_path);
+ ReByteArray thePath(m_path);
thePath.append(m_path.lastChar() == '\\' ? "*" : "\\*");
m_handle = FindFirstFileA(thePath.str(), &m_data);
rc = m_handle != INVALID_HANDLE_VALUE;
* @return the filename with path
*/
const char* ReDirStatus_t::fullName() {
- if (m_fullName.length() == 0)
+ if (m_fullName.empty())
m_fullName.set(m_path).append(node(), -1);
return m_fullName.str();
}
* @return <code>true</code>: success
*/
bool ReDirStatus_t::getFileOwner(HANDLE handle, const char* file,
- ReByteBuffer& name, ReLogger* logger) {
+ ReByteArray& name, ReLogger* logger) {
bool rc = false;
PSID pSidOwner = NULL;
PSECURITY_DESCRIPTOR pSD = NULL;
#endif
}
-inline void addRight(int mode, ReByteBuffer& buffer) {
+inline void addRight(int mode, ReByteArray& buffer) {
char right;
switch (mode & 7) {
case 1:
}
buffer.appendChar(right);
}
-inline void addId(const char* id, int maxLength, ReByteBuffer& buffer) {
+inline void addId(const char* id, int maxLength, ReByteArray& buffer) {
int length = strlen(id);
if (length == maxLength)
buffer.append(id, length);
* @param ownerWidth the width for group/owner
* @return <code>buffer.str()</code> (for chaining)
*/
-const char* ReDirStatus_t::rightsAsString(ReByteBuffer& buffer, bool numerical,
+const char* ReDirStatus_t::rightsAsString(ReByteArray& buffer, bool numerical,
int ownerWidth) {
buffer.setLength(0);
#if defined __linux__
}
}
- ReByteBuffer owner;
+ ReByteArray owner;
if (handle != INVALID_HANDLE_VALUE)
getFileOwner(handle, name, owner, m_logger);
CloseHandle(handle);
unpackInt24(sequence, length, id);
if (id != m_serialId)
throw ReSerializeFormatException("wrong serialId", this);
- ReByteBuffer buffer;
+ ReByteArray buffer;
unpackString64k(sequence, length, buffer);
bool ignoreCase;
unpackBool(sequence, length, ignoreCase);
*
* @param sequence IN/OUT: the place for the byte sequence
*/
-ReByteBuffer& ReDirEntryFilter::serialize(ReByteBuffer& sequence) {
+ReByteArray& ReDirEntryFilter::serialize(ReByteArray& sequence) {
sequence.appendBits24(m_serialId);
packString64k(sequence, m_nodePatterns->patternString());
packBool(sequence, m_nodePatterns->ignoreCase());
* @param formatFiles the <code>sprintf</code> format for the directory count, e.g. "%6d"
* @return a human readable string
*/
-const char* ReDirTreeStatistic::statisticAsString(ReByteBuffer& buffer,
+const char* ReDirTreeStatistic::statisticAsString(ReByteArray& buffer,
bool append, const char* formatFiles, const char* formatSizes,
const char* formatDirs) {
if (!append)
m_count(0),
m_triggerCount(triggerCount),
m_lastTrace(0),
- m_interval(interval),
- m_startTime(time(NULL)) {
+ m_interval(interval * CLOCKS_PER_SEC),
+ m_startTime(clock()) {
m_lastTrace = m_startTime;
}
/**
m_dirs[0] = new ReDirStatus_t(m_logger);
// remove a preceeding "./". This simplifies the pattern expressions:
if (m_base.startsWith(
- ReByteBuffer(".").appendChar(OS_SEPARATOR_CHAR).str())) {
+ ReByteArray(".").appendChar(OS_SEPARATOR_CHAR).str())) {
m_base.remove(0, 2);
}
}
m_dirs[0] = new ReDirStatus_t(m_logger);
// remove a preceeding "./". This simplifies the pattern expressions:
if (m_base.startsWith(
- ReByteBuffer(".").appendChar(OS_SEPARATOR_CHAR).str())) {
+ ReByteArray(".").appendChar(OS_SEPARATOR_CHAR).str())) {
m_base.remove(0, 2);
}
}
* @return <code>true</code>: a new file is available<br>
* <cude>false/code>: findFirstEntry() signals: no entry.
*/
-bool ReTraverser::initEntry(const ReByteBuffer& parent, const char* node,
+bool ReTraverser::initEntry(const ReByteArray& parent, const char* node,
int level) {
bool rc = false;
if (level < MAX_ENTRY_STACK_DEPTH) {
/*
* ReTraverser.hpp
- *
+ *
* License: Public Domain
* You can use and modify this file without any restriction.
* Do what you want.
typedef DIR* FindFileHandle_t;
#endif
-/** Returns whether a filetime is undefined.
- * @param time the filetime to test
- * @return <code>true</code>: the given filetime is undefined
- */
-inline bool filetimeIsUndefined(ReFileTime_t& time) {
-#if defined __linux__
- return time.tv_sec == 0 && time.tv_nsec == 0;
-#elif defined __WIN32__
- return time.dwHighDateTime == 0 && time.dwLowDateTime == 0;
-#endif
-}
-/** Sets the filetime to undefined.
- * @param time the filetime to clear
- */
-inline void setFiletimeUndef(ReFileTime_t& time) {
-#if defined __linux__
- time.tv_sec = time.tv_nsec = 0;
-#elif defined __WIN32__
- time.dwHighDateTime = time.dwLowDateTime = 0;
-#endif
-}
class ReDirStatus_t {
public:
public:
const ReFileTime_t* accessed();
ReFileSize_t fileSize();
- const char* filetimeAsString(ReByteBuffer& buffer);
+ const char* filetimeAsString(ReByteArray& buffer);
bool findFirst();
bool findNext();
void freeEntry();
bool isRegular();
const ReFileTime_t* modified();
const char* node() const;
- const char* rightsAsString(ReByteBuffer& buffer, bool numerical,
+ const char* rightsAsString(ReByteArray& buffer, bool numerical,
int ownerWidth);
Type_t type();
char typeAsChar();
public:
static const char* filetimeToString(const ReFileTime_t* time,
- ReByteBuffer& buffer);
+ ReByteArray& buffer);
static time_t filetimeToTime(const ReFileTime_t* time);
#if defined __WIN32__
- static bool getFileOwner(HANDLE handle, const char* file, ReByteBuffer& name,
+ static bool getFileOwner(HANDLE handle, const char* file, ReByteArray& name,
ReLogger* logger = NULL);
static bool getPrivilege(const char* privilege, ReLogger* logger);
#endif
static void timeToFiletime(time_t time, ReFileTime_t& filetime);
public:
- ReByteBuffer m_path;
- ReByteBuffer m_fullName;
+ ReByteArray m_path;
+ ReByteArray m_fullName;
int m_passNo;
ReLogger* m_logger;
#ifdef __linux__
public:
virtual void deserialize(const uint8_t*& sequence, size_t& length);
bool match(ReDirStatus_t& entry);
- virtual ReByteBuffer& serialize(ReByteBuffer& sequence);
+ virtual ReByteArray& serialize(ReByteArray& sequence);
public:
ReDirStatus_t::Type_t m_types;
RePatternList* m_nodePatterns;
* at least <code>m_interval</code> seconds
*/
inline bool isTimeTriggered() {
- time_t now = time(NULL);
- bool rc = now - m_lastTrace > m_interval;
+ clock_t now = clock();
+ bool rc = (now - m_lastTrace) >= m_interval;
if (rc) {
m_lastTrace = now;
}
protected:
int m_count;
int m_triggerCount;
- time_t m_lastTrace;
- int m_interval;
- time_t m_startTime;
+ clock_t m_lastTrace;
+ /// time interval in clocks (sec * CLOCK_PER_SEC)
+ clock_t m_interval;
+ clock_t m_startTime;
};
class ReDirTreeStatistic {
public:
ReDirTreeStatistic();
public:
- const char* statisticAsString(ReByteBuffer& buffer, bool append = false,
+ const char* statisticAsString(ReByteArray& buffer, bool append = false,
const char* formatFiles = "%8d ", const char* formatSizes = "%12.6f",
const char* formatDirs = "%7d ");
/**
protected:
void destroy();
void freeEntry(int level);
- bool initEntry(const ReByteBuffer& parent, const char* node, int level);
+ bool initEntry(const ReByteArray& parent, const char* node, int level);
/**
* Tests whether a directory should be processed.
* @param node the base name of the subdir
int m_minLevel;
int m_maxLevel;
int m_level;
- ReByteBuffer m_base;
+ ReByteArray m_base;
ReDirStatus_t* m_dirs[MAX_ENTRY_STACK_DEPTH];
/// each directory will be passed twice: for all files + for directories only
/// 1: depth first 2: breadth first
/*
* reos.hpp
- *
+ *
* License: Public Domain
* You can use and modify this file without any restriction.
* Do what you want.
#error "unknown os"
#endif
-/** Returns whether a time is greater (younger) than another.
- * @param time1 first operand
- * @param time2 second operand
- * @return <code>true</code>: time1 > time2
- */
-inline bool operator >(const ReFileTime_t& time1, const ReFileTime_t& time2) {
-#if defined __linux__
- return time1.tv_sec > time2.tv_sec
- || (time1.tv_sec == time2.tv_sec && time1.tv_nsec > time2.tv_nsec);
-#else
- return time1.dwHighDateTime > time2.dwHighDateTime
- || (time1.dwHighDateTime == time2.dwHighDateTime
- && time1.dwLowDateTime > time2.dwLowDateTime);
-#endif
-}
#include "os/ReFileUtils.hpp"
#include "os/ReTraverser.hpp"
#include "os/ReDirTools.hpp"
/*
* ReMatcher.cpp
- *
+ *
* License: Public Domain
* You can use and modify this file without any restriction.
* Do what you want.
* @param prefix NULL or a introduction
*/
void ReSimpleMatcher::dump(FILE* fp, const char* prefix) const {
- ReByteBuffer buffer;
+ ReByteArray buffer;
if (prefix != NULL)
fprintf(fp, "%s\n", prefix);
fprintf(fp, "pattern: %s token (%d): %s\n", m_pattern.str(),
* m_notPattern: the name matches not<br>
* <code>false</code>: otherwise
*/
-bool ReSimpleMatcher::match(const ReByteBuffer& toTest, ReHit* hit) const {
+bool ReSimpleMatcher::match(const ReByteArray& toTest, ReHit* hit) const {
bool rc = m_findAll;
if (!rc) {
do {
* m_notPattern: the name matches not<br>
* <code>false</code>: otherwise
*/
-bool ReSimpleMatcher::searchTokens(const ReByteBuffer& toTest, int from, int to,
+bool ReSimpleMatcher::searchTokens(const ReByteArray& toTest, int from, int to,
ReHit* hit, bool greedy) const {
bool rc = true;
if (!greedy) {
* m_notPattern: the name matches not<br>
* <code>false</code>: otherwise
*/
-bool ReSimpleMatcher::search(const ReByteBuffer& toTest, ReHit* hit,
+bool ReSimpleMatcher::search(const ReByteArray& toTest, ReHit* hit,
bool greedy) const {
bool rc = m_findAll;
if (!rc) {
* @param prefix NULL or a prefix of the output
* @return <code>buffer.str()</code> (for chaining)
*/
-const char* ReSimpleMatcher::status(ReByteBuffer& buffer,
+const char* ReSimpleMatcher::status(ReByteArray& buffer,
const char* prefix) const {
if (prefix != NULL)
buffer.append(prefix);
* @param prefix NULL or a introduction
*/
void RePatternList::dump(FILE* fp, const char* prefix) const {
- ReByteBuffer buffer;
+ ReByteArray buffer;
if (prefix != NULL)
fprintf(fp, "%s\n", prefix);
for (int ix = 0; ix < m_count; ix++) {
* <code>false</code>: no pattern matches or at least one
* "not-pattern" matches
*/
-bool RePatternList::match(const ReByteBuffer& name) {
+bool RePatternList::match(const ReByteArray& name) {
bool rc = false;
int count = m_startNot < 0 ? m_count : m_count - m_startNot + 1;
// matches at least one positive pattern?
patterns++;
}
int sepLength = strlen(separator);
- ReByteBuffer theNotPattern(notPrefix == NULL ? "" : notPrefix);
- ReByteBuffer thePatterns(patterns);
+ ReByteArray theNotPattern(notPrefix == NULL ? "" : notPrefix);
+ ReByteArray thePatterns(patterns);
if (thePatterns.endsWith(separator)) {
thePatterns.setLength(thePatterns.length() - sepLength);
}
* ix + 1: otherwise
*/
int RePatternList::setOne(int index, const char* pattern, size_t patternLength,
- bool ignoreCase, const ReByteBuffer& notPrefix) {
- ReByteBuffer thePattern(pattern, patternLength);
+ bool ignoreCase, const ReByteArray& notPrefix) {
+ ReByteArray thePattern(pattern, patternLength);
bool isNotPattern = (notPrefix.length() > 0
&& thePattern.startsWith(notPrefix.str(), notPrefix.length()));
int start = isNotPattern ? notPrefix.length() : 0;
* @param prefix NULL or a prefix of the output
* @return <code>buffer.str()</code> (for chaining)
*/
-const char* RePatternList::status(ReByteBuffer& buffer,
+const char* RePatternList::status(ReByteArray& buffer,
const char* prefix) const {
if (prefix != NULL)
buffer.append(prefix);
/*
* ReMatcher.hpp
- *
+ *
* License: Public Domain
* You can use and modify this file without any restriction.
* Do what you want.
virtual ~ReMatcher();
public:
virtual bool compile(const char* pattern) = 0;
- virtual bool match(const ReByteBuffer& toTest, ReHit* hit = NULL) const = 0;
- virtual bool search(const ReByteBuffer& toTest, ReHit* hit = NULL,
+ virtual bool match(const ReByteArray& toTest, ReHit* hit = NULL) const = 0;
+ virtual bool search(const ReByteArray& toTest, ReHit* hit = NULL,
bool greedy = false) const = 0;
public:
inline bool isIgnoreCase() const {
inline bool ignoreCase() const {
return m_ignoreCase;
}
- virtual bool match(const ReByteBuffer& toTest, ReHit* hit = NULL) const;
- virtual bool search(const ReByteBuffer& toTest, ReHit* hit = NULL,
+ virtual bool match(const ReByteArray& toTest, ReHit* hit = NULL) const;
+ virtual bool search(const ReByteArray& toTest, ReHit* hit = NULL,
bool greedy = false) const;
/** Sets the mode whether the case will be ignored or not.
* @param onNotOff <code>true</code>: the case will be ignored.
void setIgnoreCase(bool onNotOff) {
m_ignoreCase = onNotOff;
}
- const char* status(ReByteBuffer& buffer, const char* prefix) const;
+ const char* status(ReByteArray& buffer, const char* prefix) const;
protected:
- bool searchTokens(const ReByteBuffer& toTest, int from, int to, ReHit* hit,
+ bool searchTokens(const ReByteArray& toTest, int from, int to, ReHit* hit,
bool greedy) const;
private:
- ReByteBuffer m_pattern;
+ ReByteArray m_pattern;
ReStringList m_tokens;
bool m_ignoreCase;
};
bool rc = m_count == 0 ? false : m_patterns[0]->ignoreCase();
return rc;
}
- bool match(const ReByteBuffer& name);
+ bool match(const ReByteArray& name);
/** @brief Tests whether a string matches the patterns.
* @param name the string to Test
* @return <code>true</code>: the string matches
*/
inline bool match(const char* name) {
- return match(ReByteBuffer(name));
+ return match(ReByteArray(name));
}
/** Returns the original pattern string.
* @return the string describing the patterns.
}
void set(const char* patterns, bool ignoreCase = false,
const char* separator = NULL, const char* notPrefix = "-");
- const char* status(ReByteBuffer& buffer, const char* prefix) const;
+ const char* status(ReByteArray& buffer, const char* prefix) const;
/** Sets the mode whether the case will be ignored or not.
* @param onNotOff <code>true</code>: the case will be ignored.
*/
}
private:
int setOne(int index, const char* pattern, size_t patternLength,
- bool ignoreCase, const ReByteBuffer& notPrefix);
+ bool ignoreCase, const ReByteArray& notPrefix);
private:
- ReByteBuffer m_patternString;
+ ReByteArray m_patternString;
// store of all patterns: the not patterns are at the bottom
ReSimpleMatcher** m_patterns;
// count of all patterns (including not patterns:
/*
* restring.hpp
- *
+ *
* License: Public Domain
* You can use and modify this file without any restriction.
* Do what you want.
projects / crepublib / commitdiff