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); }