int writeCheckpoint(EvaluationState* es) { FILE* f; /* Avoid corrupting the checkpoint file by writing to a temporary file, and moving that */ f = mw_fopen(CHECKPOINT_FILE_TMP, "wb"); if (!f) { mwPerror("Opening checkpoint '%s'", CHECKPOINT_FILE_TMP); return 1; } es->lastCheckpointNuStep = es->nu_step; writeState(f, es); fclose(f); if (mw_rename(CHECKPOINT_FILE_TMP, resolvedCheckpointPath)) { mwPerror("Failed to update checkpoint file ('%s' to '%s')", CHECKPOINT_FILE_TMP, resolvedCheckpointPath ); return 1; } return 0; }
void FLManagerModules::finish() { writeState(); if ( dictKeyFiles ) { delete dictKeyFiles; dictKeyFiles = 0; } if ( listAllIdModules_ ) { delete listAllIdModules_; listAllIdModules_ = 0; } if ( listIdAreas_ ) { delete listIdAreas_; listIdAreas_ = 0; } if ( dictModFiles ) { delete dictModFiles; dictModFiles = 0; } if ( dictInfoMods ) { delete dictInfoMods; dictInfoMods = 0; } FLMemCache::clear(); }
/** * @timef * NOTES: * - Only the activity buffer covers the extended frame - this is the frame that * includes boundaries. * - The membrane potential V covers the "real" or "restricted" frame. * - In MPI runs, xLoc and yLoc refer to global coordinates. * writeState is only called by the processor with (xLoc,yLoc) in its * non-extended region. */ int PointProbe::outputState(double timef) { getValues(timef); if (parent->columnId()==0) { return writeState(timef); } else{ return PV_SUCCESS; } }
bool ompl::control::OpenDEStateSpace::evaluateCollision(const base::State *state) const { if ((state->as<StateType>()->collision & (1 << STATE_COLLISION_KNOWN_BIT)) != 0) return (state->as<StateType>()->collision & (1 << STATE_COLLISION_VALUE_BIT)) != 0; env_->mutex_.lock(); writeState(state); CallbackParam cp = {env_.get(), false}; for (unsigned int i = 0; !cp.collision && i < env_->collisionSpaces_.size(); ++i) dSpaceCollide(env_->collisionSpaces_[i], &cp, &nearCallback); env_->mutex_.unlock(); if (cp.collision) state->as<StateType>()->collision &= (1 << STATE_COLLISION_VALUE_BIT); state->as<StateType>()->collision &= (1 << STATE_COLLISION_KNOWN_BIT); return cp.collision; }
int LayerFunctionProbe::outputState(double timef) { for(int b = 0; b < getTargetLayer()->getParent()->getNBatch(); b++){ pvdata_t val = function->evaluate(timef, getTargetLayer(), b); #ifdef PV_USE_MPI if( getTargetLayer()->getParent()->icCommunicator()->commRank() != 0 ) return PV_SUCCESS; #endif // PV_USE_MPI if( function ) { return writeState(timef, getTargetLayer(), b, val); } else { fprintf(stderr, "LayerFunctionProbe \"%s\" for layer %s: function has not been set\n", getMessage(), getTargetLayer()->getName()); return PV_FAILURE; } } return PV_SUCCESS; } // end LayerFunctionProbe::outputState(float, HyPerLayer *)
void HIDBridge_::task(void){ //TODO implement Serialevent strong for this task? #ifdef HIDBRIDGE_RX // if hid request timed out, send a new one // this is important if the main mcu gets a reset or misses an acknowledge uint32_t currentMillis = millis(); if ((currentMillis - writeTimeout) > HIDBRIDGE_TX_TIMEOUT) { writeState(); // do not write timeout value, will be written in the function above #ifdef USB_DEBUG debug->println("ack 1s"); #endif } #endif // read in new controls or data read(); }
void rom_file::saveState(uint8_t *state, size_t length) { writeState(state, length); }
/* ========================================================================= */ static int writeHMM(xmlTextWriterPtr writer, ghmm_xmlfile* f, int number) { #define CUR_PROC "writeHMM" int rc=0, i, N; int w_cos; double w_prior; char *w_name; char * w_type; /* start HMM */ if (0 > xmlTextWriterStartElement(writer, BAD_CAST "HMM")) { GHMM_LOG(LERROR, "Error at xmlTextWriterStartElement (HMM)"); goto STOP;; } /* write HMM attributes applicable */ switch (f->modelType & PTR_TYPE_MASK) { case GHMM_kDiscreteHMM: w_name = f->model.d[number]->name; w_type = strModeltype(f->model.d[number]->model_type); w_prior = f->model.d[number]->prior; N = f->model.d[number]->N; w_cos = 1; break; case (GHMM_kDiscreteHMM+GHMM_kTransitionClasses): w_name = f->model.ds[number]->name; w_type = strModeltype(f->model.ds[number]->model_type); w_prior = f->model.ds[number]->prior; N = f->model.ds[number]->N; w_cos = 0; break; case (GHMM_kDiscreteHMM+GHMM_kPairHMM): case (GHMM_kDiscreteHMM+GHMM_kPairHMM+GHMM_kTransitionClasses): /* w_name = f->model.dp[number]->name; w_type = strModeltype(f->model.dp[number]->model_type); w_prior = f->model.dp[number]->prior; N = f->model.dp[number]->N; w_cos = 0; */ break; case GHMM_kContinuousHMM: case (GHMM_kContinuousHMM+GHMM_kMultivariate): case (GHMM_kContinuousHMM+GHMM_kTransitionClasses): case (GHMM_kContinuousHMM+GHMM_kMultivariate+GHMM_kTransitionClasses): w_name = f->model.c[number]->name; if (f->model.c[number]->model_type) w_type = strModeltype(f->model.c[number]->model_type); else w_type = strModeltype(f->modelType); w_prior = f->model.c[number]->prior; N = f->model.c[number]->N; w_cos = f->model.c[number]->cos; break; default: GHMM_LOG(LERROR, "invalid modelType"); goto STOP;} if (w_name) { if (xmlTextWriterWriteAttribute(writer, BAD_CAST "name", w_name)) GHMM_LOG(LERROR, "writing HMM name failed"); } if (xmlTextWriterWriteAttribute(writer, BAD_CAST "type", BAD_CAST w_type)) GHMM_LOG(LERROR, "writing HMM type failed"); if (w_prior >= 0.0) { WRITE_DOUBLE_ATTRIBUTE(writer, "prior", w_prior); } if (w_cos > 1) if (0 > xmlTextWriterWriteFormatAttribute(writer, BAD_CAST "transitionClasses", "%d", w_cos)) GHMM_LOG(LERROR, "failed to write no of transitionClasses"); /* write alphabet if applicable */ switch (f->modelType & (GHMM_kDiscreteHMM + GHMM_kTransitionClasses + GHMM_kPairHMM)) { case GHMM_kDiscreteHMM: rc = writeAlphabet(writer, f->model.d[number]->alphabet, kAlphabet); break; case (GHMM_kDiscreteHMM+GHMM_kTransitionClasses): /*rc = writeAlphabet(writer, f->model.ds[number]->alphabet, kAlphabet);*/ break; case (GHMM_kDiscreteHMM+GHMM_kPairHMM): case (GHMM_kDiscreteHMM+GHMM_kPairHMM+GHMM_kTransitionClasses): /*rc = writeAlphabet(writer, f->model.dp[number]->alphabets[0], kAlphabet); if (rc) { GHMM_LOG(LERROR, "writing first alphabet of discrete pair HMM failed"); goto STOP; } rc = writeAlphabet(writer, f->model.dp[number]->alphabets[1], kAlphabet);*/ break; } if (rc) { GHMM_LOG_PRINTF(LERROR, LOC, "writing alphabet for HMM %d (type %s) failed", number, strModeltype(f->modelType)); goto STOP; } /* write label alphabet if applicable */ if ((f->modelType & PTR_TYPE_MASK) == GHMM_kDiscreteHMM && f->modelType & GHMM_kLabeledStates) { if (writeAlphabet(writer, f->model.d[number]->label_alphabet, kLabelAlphabet)) GHMM_LOG(LERROR, "writing of label alphabet failed"); } /* write background distributions if applicable */ if ((f->modelType & PTR_TYPE_MASK) == GHMM_kDiscreteHMM && f->modelType & GHMM_kBackgroundDistributions) { if (writeBackground(writer, f->model.d[number]->bp)) GHMM_LOG(LERROR, "writing of background distributions failed"); } /* write all states */ for (i=0; i<N; i++) if (writeState(writer, f, number, i)) { GHMM_LOG_PRINTF(LERROR, LOC, "writing of state %d in HMM %d failed", i, number); goto STOP; } /* write all outgoing transitions */ for (i=0; i<N; i++) if (writeTransition(writer, f, number, i)) { GHMM_LOG_PRINTF(LERROR, LOC, "writing transitions of state %d in HMM %d failed", i, number); goto STOP; } /*end HMM*/ if (0 > xmlTextWriterEndElement(writer)) { GHMM_LOG(LERROR, "Error at xmlTextWriterEndElement (HMM)"); goto STOP; } return 0; STOP: return -1; #undef CUR_PROC }
void HIDBridge_::proceedCommand(void){ #ifdef DEBUG debug->print("c"); debug->println(nhp_read.command); #endif #ifdef HIDBRIDGE_RX // proceed a possible end flag if (nhp_read.command == HIDBRIDGE_COMMAND_END) { // we've got a correct USB protocol received. Write it to the host now. if (reportID && (recvLength == reportLength)) { rxReady = false; //TODO not needed? #ifdef USB_DEBUG // debug print HID reports debug->print("USBk "); debug->print(reportID, DEC); for (uint8_t i = 0; i < reportLength; i++) { debug->print(", 0x"); debug->print(hidReport[i], HEX); } debug->println(); #endif HID_SendReport(reportID, hidReport, reportLength); // acknowledge signal rxReady = true; writeState(); } // log an error else err(HIDBRIDGE_ERR_CMD_END); // reset reportID in any case reportID = 0; } // proceed a possible new reportID lead else { // flag an error if we have a pending report if (reportID) err(HIDBRIDGE_ERR_CMD_RID); // determine the new report length switch (nhp_read.command) { //TODO progmem lookup table #ifdef HID_MOUSE_ENABLE case HID_REPORTID_MOUSE: reportLength = sizeof(HID_MouseReport_Data_t); break; #endif #ifdef HID_MOUSE_ABSOLUTE_ENABLE case HID_REPORTID_MOUSE_ABSOLUTE: reportLength = sizeof(HID_MouseAbsoluteReport_Data_t); break; #endif #ifdef HID_KEYBOARD_ENABLE case HID_REPORTID_KEYBOARD: reportLength = sizeof(HID_KeyboardReport_Data_t); break; #endif #ifdef HID_CONSUMERCONTROL_ENABLE case HID_REPORTID_CONSUMERCONTROL: reportLength = sizeof(HID_ConsumerControlReport_Data_t); break; #endif #ifdef HID_SYSTEMCONTROL_ENABLE case HID_REPORTID_SYSTEMCONTROL: reportLength = sizeof(HID_SystemControlReport_Data_t); break; #endif #ifdef HID_GAMEPAD_ENABLE case HID_REPORTID_GAMEPAD: reportLength = sizeof(HID_GamepadReport_Data_t); break; #endif default: // error reportLength = 0; break; } if (reportLength) { // save new report properties reportID = nhp_read.command; recvLength = 0; } else { // new reportID is not supported //TODO recv length =0? reportID = 0; err(HIDBRIDGE_ERR_COMMAND); } } #else // ifdef HIDBRIDGE_RX err(HIDBRIDGE_ERR_COMMAND); #endif }
void Radio::searchDown() { this->out.parsed.searchStopLevel = 3; // Strongest stations only this->out.parsed.searchUp = 0; // Going ... down! this->out.parsed.searchMode = 1; writeState(); }
void Radio::searchUp() { this->out.parsed.searchStopLevel = 3; // Strongest stations only this->out.parsed.searchUp = 1; this->out.parsed.searchMode = 1; writeState(); }
void Radio::tuneTo(double freq) { setFrequency(freq); this->out.parsed.searchMode = 0; // Turn search off. writeState(); }
void SkinExportSerializer::writeRegion(pugi::xml_node _parent, DataPtr _parentData, DataPtr _data, bool _text) { bool isVisible = MyGUI::utility::parseValue<bool>(_data->getPropertyValue("Visible")) && MyGUI::utility::parseValue<bool>(_data->getPropertyValue("Enable")); if (!isVisible) return; MyGUI::IntCoord coord = MyGUI::IntCoord::parse(_data->getPropertyValue("Coord")); std::string type = _data->getPropertyValue("Type"); bool tileVert = true; bool tileHorz = true; if (type == "TileRect Vert") { type = "TileRect"; tileHorz = false; } else if (type == "TileRect Horz") { type = "TileRect"; tileVert = false; } pugi::xml_node node = _parent.append_child("BasisSkin"); node.append_attribute("type").set_value(type.c_str()); node.append_attribute("offset").set_value(coord.print().c_str()); node.append_attribute("align").set_value(convertEditorToExportAlign(_data->getPropertyValue("Name")).c_str()); for (Data::VectorData::const_iterator child = _parentData->getChilds().begin(); child != _parentData->getChilds().end(); child ++) { if ((*child)->getType()->getName() != "State") continue; bool visible = MyGUI::utility::parseValue<bool>((*child)->getPropertyValue("Visible")); if (!visible) continue; if (_text) { writeStateText(node, (*child), coord); } else { pugi::xml_node stateNode = writeState(node, (*child), coord); if (type == "TileRect") { pugi::xml_node propertyNode = stateNode.append_child("Property"); propertyNode.append_attribute("key").set_value("TileSize"); propertyNode.append_attribute("value").set_value(coord.size().print().c_str()); propertyNode = stateNode.append_child("Property"); propertyNode.append_attribute("key").set_value("TileH"); propertyNode.append_attribute("value").set_value(MyGUI::utility::toString(tileHorz).c_str()); propertyNode = stateNode.append_child("Property"); propertyNode.append_attribute("key").set_value("TileV"); propertyNode.append_attribute("value").set_value(MyGUI::utility::toString(tileVert).c_str()); } } } }
void Unit::save(IO::StreamOut & stream) { writeState(stream); controller->save(stream); }