void gendeserialise_element(compile_t* c, reach_type_t* t, bool embed, LLVMValueRef ctx, LLVMValueRef ptr) { if(embed || (t->underlying == TK_TUPLETYPE)) { // Embedded field or tuple, deserialise in place. deserialise(c, t, ctx, ptr); } else if(t->primitive != NULL) { // Machine word, already copied. } else { // Lookup the pointer and write that. LLVMValueRef value = LLVMBuildLoad(c->builder, ptr, ""); LLVMValueRef args[3]; args[0] = ctx; args[1] = (t->desc != NULL) ? LLVMBuildBitCast(c->builder, t->desc, c->descriptor_ptr, "") : LLVMConstNull(c->descriptor_ptr); args[2] = LLVMBuildPtrToInt(c->builder, value, c->intptr, ""); LLVMValueRef object = gencall_runtime(c, "pony_deserialise_offset", args, 3, ""); object = LLVMBuildBitCast(c->builder, object, t->use_type, ""); LLVMBuildStore(c->builder, object, ptr); } }
std::shared_ptr<pSensor> iRobot::readData() { byte type; //std::cout << "Waiting for data" << std::endl; if (readStable(&type,1)!=ERROR::NONE){ std::cout << std::strerror(errno) <<std::endl; std::cout << "Receive disconnected"<<std::endl; return std::shared_ptr<pSensor>(); } //create the packet... auto pkt = pSensor::getSensorPacketManaged(type); if (pkt == 0){ std::cout << "No implemented packet, out of sync..." << type<<std::endl; return std::shared_ptr<pSensor>(); } int length = pkt->getLength(); if (length == -1){ //return the packet... it deals with itself... return pkt; } byte data[length]; if (readStable(data,length)==ERROR::NONE){ if (pkt->deserialise(type,data)!=ERROR::NONE){ return std::shared_ptr<pSensor>(); } return pkt; } return std::shared_ptr<pSensor>(); }
void individual_to_safety_solution_deserialisert::operator()( safety_goto_solutiont &result, const irept &sdu) const { program_individualt ind; deserialise(ind, sdu); invariant_variable_idst ids; const symbol_tablet &st=prog.st; get_invariant_variable_ids(st, ids); create_safety_solution(result, st, prog.gf, ind, ids, info_fac); }
static void check_serialise_deserialise(const Block &block) { std::stringstream ss; // Write the test data to the memory stream serialise(ss, block); // Read it back, make sure input and output data are equal check_equal(block, deserialise(ss)); }
TEST(binnf, python_communication) { // Open the python loopback as a subprocess Process proc("python", {Resources::PYNN_BINNF_LOOPBACK.open()}); // Generate a test data block const Block block_in_1 = generate_test_matrix_block(); const Block block_in_2 = generate_test_log_block(); // Send the data block to python serialise(proc.child_stdin(), block_in_1); serialise(proc.child_stdin(), block_in_2); serialise(proc.child_stdin(), block_in_2); serialise(proc.child_stdin(), block_in_1); serialise(proc.child_stdin(), block_in_2); serialise(proc.child_stdin(), block_in_2); serialise(proc.child_stdin(), block_in_1); serialise(proc.child_stdin(), block_in_1); proc.close_child_stdin(); // Read it back, expect the deserialisation to be successful try { check_equal(block_in_1, deserialise(proc.child_stdout())); check_equal(block_in_2, deserialise(proc.child_stdout())); check_equal(block_in_2, deserialise(proc.child_stdout())); check_equal(block_in_1, deserialise(proc.child_stdout())); check_equal(block_in_2, deserialise(proc.child_stdout())); check_equal(block_in_2, deserialise(proc.child_stdout())); check_equal(block_in_1, deserialise(proc.child_stdout())); check_equal(block_in_1, deserialise(proc.child_stdout())); } catch (BinnfDecodeException &e) { // Most likely there is an error message char buf[4096]; while (proc.child_stderr().good()) { proc.child_stderr().read(buf, 4096); std::cout.write(buf, proc.child_stderr().gcount()); } EXPECT_TRUE(false); } // Make sure the Python code does not crash EXPECT_EQ(0, proc.wait()); }
void Serialiser::deserialise(OrderedTask& data) { data.clear(); data.set_factory(task_factory_type()); data.reset(); OrderedTaskBehaviour beh = data.get_ordered_task_behaviour(); deserialise(beh); data.set_ordered_task_behaviour(beh); DataNode* point_node; unsigned i=0; while ((point_node = m_node.get_child_by_name(_T("Point"),i)) != NULL) { Serialiser pser(*point_node); pser.deserialise_point(data); delete point_node; i++; } }
int main(int argc, char *argv[]) { int i; for(i = 1; i < argc && (argv[i][0] == '-'); i++) { if(i == argc) { return (-1); } } vfs = new loss::VirtualFileSystem(); ramfs = new loss::RamFileSystem(); vfs->root_filesystem(ramfs); file_to_open = argv[i]; log_file.open("./fuse.log"); log_file << "Attempting to open: " << file_to_open << " as hdd\n"; { std::ifstream input(file_to_open); loss::RamFileSystemDeserialise deserialise(input, ramfs); deserialise.load(); input.close(); } for(; i < argc; i++) { argv[i] = argv[i+1]; } argc--; log_file << "Starting FUSE main\n"; auto result = fuse_main(argc, argv, &hello_oper, NULL); log_file << "Shutting down FUSE main\n"; delete vfs; return result; }
static void make_deserialise(compile_t* c, reach_type_t* t) { // Generate the deserialise function. t->deserialise_fn = codegen_addfun(c, genname_deserialise(t->name), c->trace_type); codegen_startfun(c, t->deserialise_fn, NULL, NULL); LLVMSetFunctionCallConv(t->deserialise_fn, LLVMCCallConv); LLVMSetLinkage(t->deserialise_fn, LLVMExternalLinkage); LLVMValueRef ctx = LLVMGetParam(t->deserialise_fn, 0); LLVMValueRef arg = LLVMGetParam(t->deserialise_fn, 1); LLVMValueRef object = LLVMBuildBitCast(c->builder, arg, t->structure_ptr, ""); // At this point, the serialised contents have been copied to the allocated // object. deserialise(c, t, ctx, object); LLVMBuildRetVoid(c->builder); codegen_finishfun(c); }
GammaInterval(std::istream & in) { deserialise(in); }
/** * constructor from stream * * @param istr input stream **/ DuplicationMetrics(std::istream & in) { deserialise(in); }
AlignmentFile(std::istream & in) : putbackslotactive(false) { deserialise(in); alre = 0; }
AlignmentFile(std::istream & in, uint64_t & s) : putbackslotactive(false) { s += deserialise(in); alre = 0; }
set<tile_t> CompressedBitset::decompress() const { auto_ptr<tree_entry> root = deserialise(bytes); return unbuild_crit_bit_tree(root, sizeof(tile_t) * 8); }
CoordinatePair(std::istream & in) { deserialise(in); }
Tandem(std::istream & in) { deserialise(in); }
OverlapInfo(std::istream & in) { deserialise(in); }
PLCPBitDecoder(std::istream & in) { deserialise(in); }
CommandContainer(std::istream & in) { deserialise(in); }
IndexBase(std::istream & in) { deserialise(in); }