static std::string visit(const Value& v, int depth)
{
std::stringstream ret;
switch (v.getType())
{
case Value::Type::NONE:
case Value::Type::BYTE:
case Value::Type::INTEGER:
case Value::Type::FLOAT:
case Value::Type::DOUBLE:
case Value::Type::BOOLEAN:
case Value::Type::STRING:
ret << v.asString() << "\n";
break;
case Value::Type::VECTOR:
ret << visitVector(v.asValueVector(), depth);
break;
case Value::Type::MAP:
ret << visitMap(v.asValueMap(), depth);
break;
case Value::Type::INT_KEY_MAP:
ret << visitMap(v.asIntKeyMap(), depth);
break;
case Value::Type::VEC2:
ret << "(" << v.asVec2().x << "," << v.asVec2().y << ")\n";
default:
CCASSERT(false, "Invalid type!");
break;
}
return ret.str();
}
void AST_Compare::accept(ASTVisitor* v) {
bool skip = v->visit_compare(this);
if (skip)
return;
left->accept(v);
visitVector(comparators, v);
}
void AST_Print::accept(ASTVisitor* v) {
bool skip = v->visit_print(this);
if (skip)
return;
if (dest)
dest->accept(v);
visitVector(values, v);
}
void AST_With::accept(ASTVisitor* v) {
bool skip = v->visit_with(this);
if (skip)
return;
context_expr->accept(v);
if (optional_vars)
optional_vars->accept(v);
visitVector(body, v);
}
void AST_ExceptHandler::accept(ASTVisitor* v) {
bool skip = v->visit_excepthandler(this);
if (skip)
return;
if (type)
type->accept(v);
if (name)
name->accept(v);
visitVector(body, v);
}
QByteArray U2BitCompression::uncompress(const char* data, const QByteArray& alphabetChars, U2OpStatus&) {
// algorithm
// 1. Derive all chars from header
// 2. Assign bit masks per chars that have signed bit in header
// 3. Unpack value
int alphabetSize = alphabetChars.size();
const char* aChars = alphabetChars.data();
const uchar* bits = (const uchar*)data;
int alphaMaskOffset = 0;
int len = readLength(bits, alphaMaskOffset);
// restore bit masks
QVector<bool> visitVector(alphabetSize, false);
bool* visited = visitVector.data();
int nChars = 0;
for (int i = 0; i < alphabetSize; i++) {
if (U2Bits::getBit(bits, i + alphaMaskOffset)) {
visited[i] = true;
nChars++;
}
}
int bitsPerChar = U2Bits::getNumberOfBitsPerChar(nChars);
QVector<char> mask2Char(nChars, 0);
uchar m = 0;
for (int i = 0; i < alphabetSize; i++) {
if (visited[i]) {
mask2Char[m] = aChars[i];
m++;
}
}
int pos = alphaMaskOffset + alphabetSize;
#if QT_VERSION >= QT_VERSION_CHECK(4, 7, 0)
QByteArray result(len, Qt::Uninitialized);
#else
QByteArray result(len, (char)0);
#endif
char* res = result.data();
for (int i = 0; i < len; i++, pos += bitsPerChar) {
int m = U2Bits::bitsRange2Int32(bits, pos, bitsPerChar);
char c = mask2Char[m];
assert(c != 0);
res[i] = c;
}
return result;
}
QByteArray U2BitCompression::compress(const char* text, int len, int alphabetSize, const int* alphabetCharNums, U2OpStatus& os) {
// algorithm:
// 1. compute chars freq -> derive number of bits per char
// 2. assign bit masks per char. Do not assign any bit masks for non used alphabet chars
// 3. compress chars
// 4. create header with used char mask
// Result bits [len type][len][used alpha bits][compressed text]
// where [len type] is a type of length field: 00 -> empty, 01 -> 8 byte, 10 -> 16 bytes, 11 -> 32 bytes
// [len] - length of the result sequence
// [used alpha bits] bit is set if alpha char is used in the text.
// [compressed text] the data in compressed form
assert(alphabetSize <= 32); //avoid this check in runtime -> use this method correctly
// find all used chars in text
QVector<bool> visitVector(alphabetSize, false);
bool* visited = visitVector.data();
for (int i = 0; i < len; i++) {
uchar c = text[i];
int n = alphabetCharNums[c];
if (n == -1) {
os.setError(tr("Bit compression: illegal character in text '%1'").arg(char(c)));
return QByteArray();
}
if (!visited[n]) {
visited[n] = true;
}
}
// assign sequential bit-mask for all used chars
QVector<uchar> maskVector(alphabetSize, 0);
uchar* mask = maskVector.data();
uchar m = 0;
for (int i = 0; i < alphabetSize; i++) {
if (visited[i]) {
mask[i] = m;
m++;
}
}
// store header and data to bit set
int bitsPerChar = U2Bits::getNumberOfBitsPerChar(m);
int compressedBitSize = len * bitsPerChar;
int lenBits = getLenBitsSize(len);
int headerSizeBits = 2 + lenBits + alphabetSize;
int resultSizeBits = headerSizeBits + compressedBitSize;
static QByteArray res;
QByteArray bitSet = U2Bits::allocateBits(resultSizeBits);
uchar* bits = (uchar*)bitSet.data();
writeLength(bits, len, lenBits);
int pos = 2 + lenBits;
for (; pos < alphabetSize; pos++) {
if (visited[pos]) {
U2Bits::setBit(bits, pos);
}
}
for (int i = 0; i < len; i++, pos+=bitsPerChar) {
uchar c = text[i];
int n = alphabetCharNums[c];
uchar m = mask[n];
U2Bits::setBits(bits, pos, &m, bitsPerChar);
}
return bitSet;
}
void AST_ExtSlice::accept(ASTVisitor* v) {
bool skip = v->visit_extslice(this);
if (skip)
return;
visitVector(dims, v);
}
