entry loadEntry() {
entry e = { NULL, -1, 0 };
uint32_t length, offset[4];
/* reset error container */
errors.level = 0;
offset[0] = CURR_OFFSET;
if (!loadType(&e)) {
return e;
}
offset[1] = CURR_OFFSET;
if (e.type == REDIS_SELECTDB) {
if ((length = loadLength(NULL)) == REDIS_RDB_LENERR) {
SHIFT_ERROR(offset[1],
"Error reading database number");
return e;
}
if (length > 63) {
SHIFT_ERROR(offset[1],
"Database number out of range (%d)", length);
return e;
}
} else if (e.type == REDIS_EOF) {
if (positions[level].offset < positions[level].size) {
SHIFT_ERROR(offset[0],
"Unexpected EOF");
} else {
e.success = 1;
}
return e;
} else {
/* optionally consume expire */
if (e.type == REDIS_EXPIRETIME) {
if (!processTime()) return e;
if (!loadType(&e)) return e;
db_stats.total_expires++;
}
offset[1] = CURR_OFFSET;
if (!loadPair(&e)) {
SHIFT_ERROR(offset[1], "Error for type %s", types[e.type]);
return e;
}
}
/* all entries are followed by a valid type:
* e.g. a new entry, SELECTDB, EXPIRE, EOF */
offset[2] = CURR_OFFSET;
if (peekType() == -1) {
SHIFT_ERROR(offset[2], "Followed by invalid type");
SHIFT_ERROR(offset[0], "Error for type %s", types[e.type]);
e.success = 0;
} else {
e.success = 1;
}
return e;
}
static void tensorFill(rpc::RPCMessage& raw_message) {
thpp::Tensor *t = unpackRetrieveTensor(raw_message);
thpp::Type type = peekType(raw_message);
if (thpp::isInteger(type)) {
auto value = unpackInteger(raw_message);
finalize(raw_message);
dynamic_cast<thpp::IntTensor*>(t)->fill(value);
} else if (thpp::isFloat(type)) {
auto value = unpackFloat(raw_message);
finalize(raw_message);
dynamic_cast<thpp::FloatTensor*>(t)->fill(value);
} else {
throw std::runtime_error("expected a scalar type");
}
}
static void tensorIndexFill(rpc::RPCMessage& raw_message) {
thpp::Tensor *tensor = unpackRetrieveTensor(raw_message);
int dim = unpackInteger(raw_message);
thpp::Tensor *index = unpackRetrieveTensor(raw_message);
thpp::Type type = peekType(raw_message);
if (thpp::isInteger(type)) {
auto val = unpackInteger(raw_message);
finalize(raw_message);
dynamic_cast<thpp::IntTensor*>(tensor)->indexFill(dim, *index, val);
} else if (thpp::isFloat(type)) {
auto val = unpackFloat(raw_message);
finalize(raw_message);
dynamic_cast<thpp::FloatTensor*>(tensor)->indexFill(dim, *index, val);
} else {
throw std::runtime_error("expected a scalar type");
}
}
static void tensorRange(rpc::RPCMessage& raw_message) {
thpp::Tensor *r = unpackRetrieveTensor(raw_message);
thpp::Type type = peekType(raw_message);
if (thpp::isInteger(type)) {
long long xmin = unpackInteger(raw_message);
long long xmax = unpackInteger(raw_message);
long long step = unpackInteger(raw_message);
finalize(raw_message);
dynamic_cast<thpp::IntTensor*>(r)->range(xmin, xmax, step);
} else if (thpp::isFloat(type)) {
double xmin = unpackFloat(raw_message);
double xmax = unpackFloat(raw_message);
double step = unpackFloat(raw_message);
finalize(raw_message);
dynamic_cast<thpp::FloatTensor*>(r)->range(xmin, xmax, step);
} else {
throw std::runtime_error("expected a scalar type");
}
}
ISOBox::ISOBox(ArrayBuffer* data)
{
m_type = peekType(data);
m_length = peekLength(data);
ASSERT(m_length >= 8);
}
