void DebugLogger::Upgrade(LPCTSTR toVersion, int result) { #pragma pack(push) #pragma pack(1) struct RecordData { int result; char toVersion[24]; }; #pragma pack(pop) // 根据可变配置文件中的配置项决定是否上传数据 lux VariableConfigBlock *config = WorkingParameters::GetInstance()->GetCurrentConfigParameters(); int uploadLevel = config->GetIntParameter(_T("UploadLevel"), 1); if (uploadLevel == 0) { return; } if (logFile_.m_hFile == INVALID_HANDLE_VALUE) { return; } if (IsUploadDetail(uploadLevel, result)) { RecordData data; ZeroMemory(&data, sizeof(data)); strncpy(data.toVersion, CT2A(toVersion, CP_UTF8), _countof(data.toVersion)); data.result = result; WriteRecord("UPG ", &data, sizeof(data)); } else { WriteRecord("UPG ", &result, sizeof(result)); } }
void DebugLogger::CalibrateInfrared(int result, const IRState states[6]) { #pragma pack(push) #pragma pack(1) struct RecordData { int result; IRState states[6]; }; #pragma pack(pop) // 根据可变配置文件中的配置项决定是否上传数据 lux VariableConfigBlock *config = WorkingParameters::GetInstance()->GetCurrentConfigParameters(); int uploadLevel = config->GetIntParameter(_T("UploadLevel"), 1); if (uploadLevel == 0) { return; } if (logFile_.m_hFile == INVALID_HANDLE_VALUE) { return; } if (IsUploadDetail(uploadLevel, result)) { RecordData data; ZeroMemory(&data, sizeof(data)); data.result = result; memcpy(data.states, states, sizeof(data.states)); WriteRecord("IRC ", &data, sizeof(data)); } else { WriteRecord("IRC ", &result, sizeof(result)); } }
OGRErr TigerPolygon::CreateFeature( OGRFeature *poFeature ) { char szRecord[OGR_TIGER_RECBUF_LEN]; /* -------------------------------------------------------------------- */ /* Write basic data record ("RTA") */ /* -------------------------------------------------------------------- */ if( !SetWriteModule( "A", psRTAInfo->nRecordLength+2, poFeature ) ) return OGRERR_FAILURE; memset( szRecord, ' ', psRTAInfo->nRecordLength ); WriteFields( psRTAInfo, poFeature, szRecord ); WriteRecord( szRecord, psRTAInfo->nRecordLength, "A" ); /* -------------------------------------------------------------------- */ /* Prepare S record. */ /* -------------------------------------------------------------------- */ memset( szRecord, ' ', psRTSInfo->nRecordLength ); WriteFields( psRTSInfo, poFeature, szRecord ); WriteRecord( szRecord, psRTSInfo->nRecordLength, "S", fpRTS ); return OGRERR_NONE; }
void EditDecks::closeData() { edit_catch_conf->setErrorRml(edit_errorrml_edit->text()); WriteRecord(0); WriteRecord(edit_record_channel); WriteRecord(edit_play_channel); done(0); }
/***************************************************************************** * FUNCTION * PmgInitExtMelodyStruct * DESCRIPTION * * PARAMETERS * void * RETURNS * void *****************************************************************************/ void PmgInitExtMelodyStruct(void) { /*----------------------------------------------------------------*/ /* Local Variables */ /*----------------------------------------------------------------*/ S16 pError = NVRAM_READ_FAIL; /*----------------------------------------------------------------*/ /* Code Body */ /*----------------------------------------------------------------*/ ReadRecord(NVRAM_EF_EXT_MELODY_INFO_LID, 1, &gPmgExtMelodyInfo, sizeof(gPmgExtMelodyInfo), &pError); if (pError == NVRAM_READ_FAIL || gPmgExtMelodyInfo.TotleNum == 0xFF || gPmgExtMelodyInfo.ValidBit == 0xFF) { memset(&gPmgExtMelodyInfo, 0, sizeof(gPmgExtMelodyInfo)); WriteRecord(NVRAM_EF_EXT_MELODY_INFO_LID, 1, &gPmgExtMelodyInfo, sizeof(gPmgExtMelodyInfo), &pError); } #if 0 /* Scan all files to see if exist */ /* under construction !*/ /* under construction !*/ /* under construction !*/ /* under construction !*/ /* under construction !*/ /* under construction !*/ /* under construction !*/ /* under construction !*/ /* under construction !*/ /* under construction !*/ /* under construction !*/ #endif /* 0 */ }
OGRErr TigerAltName::CreateFeature( OGRFeature *poFeature ) { char szRecord[OGR_TIGER_RECBUF_LEN]; const int *panValue; int nValueCount = 0; if( !SetWriteModule( FILE_CODE, psRTInfo->nRecordLength+2, poFeature ) ) return OGRERR_FAILURE; memset( szRecord, ' ', psRTInfo->nRecordLength ); WriteFields( psRTInfo, poFeature, szRecord ); panValue = poFeature->GetFieldAsIntegerList( "FEAT", &nValueCount ); for( int i = 0; i < nValueCount; i++ ) { char szWork[9]; sprintf( szWork, "%8d", panValue[i] ); strncpy( szRecord + 18 + 8 * i, szWork, 8 ); } WriteRecord( szRecord, psRTInfo->nRecordLength, FILE_CODE ); return OGRERR_NONE; }
bool FormatRecord (const std::string &path) { auto record = 0; if (!IsRecord(path, &record)) throw util::exception("invalid record path"); throw std::logic_error("not implemented"); #if 0 auto hdd_path = path.substr(0, path.rfind(':')); auto hdd = HDD::OpenDisk(hdd_path); if (!hdd) return Error("open"); // The disk signature is part of record 1, so unformatting is dangerous if (record == 1 && opt.nosig == 1) throw util::exception("unformatting record 1 would destroy BDOS signature!"); auto olddisk = std::make_shared<DISK>(); MEMORY mem(MGT_TRACK_SIZE); for (BYTE cyl = 0; cyl < NORMAL_TRACKS; ++cyl) for (BYTE head = 0; head < NORMAL_SIDES; ++head) olddisk->FormatRegularTrack(cyl, head, &fmtMGT, mem); return !WriteRecord(hdd.get(), record, *olddisk, true); #endif }
/***************************************************************************** * FUNCTION * avk_pluto_nvram_test_reset_rec * DESCRIPTION * test case of reset record * PARAMETERS * void * RETURNS * void *****************************************************************************/ AVK_CASE(AVK_PLUTO_NVRAM_TEST_RESET_REC, AVK_PLUTO_NVRAM) { /*----------------------------------------------------------------*/ /* Local Variables */ /*----------------------------------------------------------------*/ S16 error; S32 ret, i; kal_uint8 *dft_ptr; U8 buff[AVK_PLUTO_NVRAM_TEST_REC_SIZE]; U8 buff_backup[AVK_PLUTO_NVRAM_TEST_REC_SIZE]; /*----------------------------------------------------------------*/ /* Code Body */ /*----------------------------------------------------------------*/ ret = ReadRecord(AVK_PLUTO_NVRAM_TEST_REC_LID, 1, buff_backup, AVK_PLUTO_NVRAM_TEST_REC_SIZE, &error); MMI_ASSERT(ret == AVK_PLUTO_NVRAM_TEST_REC_SIZE && error == NVRAM_READ_SUCCESS); ret = mmi_frm_reset_record(NVRAM_RESET_CERTAIN, NVRAM_APP_RESERVED, AVK_PLUTO_NVRAM_TEST_REC_LID, 1, 1); MMI_ASSERT(ret > 0); /* check reset operation correctness */ MMI_ASSERT(nvram_get_default_value(AVK_PLUTO_NVRAM_TEST_REC_LID, 1, &dft_ptr) == NVRAM_DEFAULT_VALUE_POINT); ret = ReadRecord(AVK_PLUTO_NVRAM_TEST_REC_LID, 1, buff, AVK_PLUTO_NVRAM_TEST_REC_SIZE, &error); MMI_ASSERT(ret == AVK_PLUTO_NVRAM_TEST_REC_SIZE && error == NVRAM_READ_SUCCESS); for (i = 0; i < AVK_PLUTO_NVRAM_TEST_REC_SIZE; i++) { MMI_ASSERT(buff[i] == dft_ptr[i]); } /* restore original data */ ret = WriteRecord(AVK_PLUTO_NVRAM_TEST_REC_LID, 1, buff_backup, AVK_PLUTO_NVRAM_TEST_REC_SIZE, &error); MMI_ASSERT(ret == AVK_PLUTO_NVRAM_TEST_REC_SIZE && error == NVRAM_WRITE_SUCCESS); AVK_CASE_RESULT(MMI_TRUE); }
/***************************************************************************** * FUNCTION * mmi_netset_access_user_ctrl_plmn_nvram * DESCRIPTION * * PARAMETERS * write_flag [IN] * RETURNS * void *****************************************************************************/ void mmi_netset_access_user_ctrl_plmn_nvram(U8 write_flag) { /*----------------------------------------------------------------*/ /* Local Variables */ /*----------------------------------------------------------------*/ S16 error; /*----------------------------------------------------------------*/ /* Code Body */ /*----------------------------------------------------------------*/ if (write_flag) { WriteRecord( NVRAM_EF_USER_CTRL_PLMN_LID, 1, (void*)(&gUserCtrlPlmnList.PrefPLMN[0][0]), NVRAM_EF_USER_CTRL_PLMN_SIZE, &error); } else { ReadRecord( NVRAM_EF_USER_CTRL_PLMN_LID, 1, (void*)(&gUserCtrlPlmnList.PrefPLMN[0][0]), NVRAM_EF_USER_CTRL_PLMN_SIZE, &error); } }
/***************************************************************************** * FUNCTION * avk_pluto_nvram_async_write_handler * DESCRIPTION * handler for async write response * PARAMETERS * write_cnf : [IN] nvram write response * RETURNS * 0 : for protocal event, to diliver msg for other listener * 1 : stop diliver the msg for other listener *****************************************************************************/ static U8 avk_pluto_nvram_async_write_handler(void *write_cnf) { /*----------------------------------------------------------------*/ /* Local Variables */ /*----------------------------------------------------------------*/ nvram_write_cnf_struct *nvram_write_cnf; S16 error; S32 ret, i; U8 buff[AVK_PLUTO_NVRAM_TEST_REC_SIZE]; /*----------------------------------------------------------------*/ /* Code Body */ /*----------------------------------------------------------------*/ nvram_write_cnf = (nvram_write_cnf_struct *)write_cnf; if (nvram_write_cnf->file_idx == AVK_PLUTO_NVRAM_TEST_REC_LID) { mmi_frm_clear_protocol_event_handler(MSG_ID_NVRAM_WRITE_CNF, avk_pluto_nvram_async_write_handler); MMI_ASSERT(nvram_write_cnf->result == NVRAM_IO_ERRNO_OK); memset(buff, AVK_PLUTO_NVRAM_TEST_DATA_VAL + 10, AVK_PLUTO_NVRAM_TEST_REC_SIZE); ret = ReadRecord(AVK_PLUTO_NVRAM_TEST_REC_LID, 1, buff, AVK_PLUTO_NVRAM_TEST_REC_SIZE, &error); MMI_ASSERT((ret == AVK_PLUTO_NVRAM_TEST_REC_SIZE) && (error == NVRAM_READ_SUCCESS)); for (i = 0; i < AVK_PLUTO_NVRAM_TEST_REC_SIZE; i++) { MMI_ASSERT(buff[i] == AVK_PLUTO_NVRAM_TEST_DATA_VAL); } ret = WriteRecord(AVK_PLUTO_NVRAM_TEST_REC_LID, 1, g_avk_pluto_nvram_cntx.buff_backup, AVK_PLUTO_NVRAM_TEST_REC_SIZE, &error); MMI_ASSERT((ret == AVK_PLUTO_NVRAM_TEST_REC_SIZE) && (error == NVRAM_WRITE_SUCCESS)); AVK_CASE_RESULT(MMI_TRUE); AVK_ASYN_DONE(); return 1; } return 0; }
OGRErr TigerPoint::CreateFeature( OGRFeature *poFeature, int pointIndex) { char szRecord[OGR_TIGER_RECBUF_LEN]; OGRPoint *poPoint = poFeature->GetGeometryRef()->toPoint(); if( !SetWriteModule( m_pszFileCode, psRTInfo->nRecordLength+2, poFeature ) ) return OGRERR_FAILURE; memset( szRecord, ' ', psRTInfo->nRecordLength ); WriteFields( psRTInfo, poFeature, szRecord ); if( poPoint != nullptr && (poPoint->getGeometryType() == wkbPoint || poPoint->getGeometryType() == wkbPoint25D) ) { WritePoint( szRecord, pointIndex, poPoint->getX(), poPoint->getY() ); } else { if (bRequireGeom) { return OGRERR_FAILURE; } } WriteRecord( szRecord, psRTInfo->nRecordLength, m_pszFileCode ); return OGRERR_NONE; }
/***************************************************************************** * FUNCTION * PmgDelExtMelodyBySlot * DESCRIPTION * * PARAMETERS * slot [IN] * RETURNS * void *****************************************************************************/ void PmgDelExtMelodyBySlot(U8 slot) /* root function for delete */ { /*----------------------------------------------------------------*/ /* Local Variables */ /*----------------------------------------------------------------*/ S16 pError; /*----------------------------------------------------------------*/ /* Code Body */ /*----------------------------------------------------------------*/ if (gPmgExtMelodyInfo.TotleNum > 0) { gPmgExtMelodyInfo.TotleNum--; } else { return; } /* Update phone book entries */ mmi_phb_update_delete_audio(gPmgExtMelodyInfo.info[slot].id); mmi_phb_update_delete_audio_caller_group(gPmgExtMelodyInfo.info[slot].id); UpdateDeleteExtMldToneSetup((U16) (PMG_EXT_MELODY_BEGIN + slot)); /* Delete solt mask */ PMG_BIT_OFF(gPmgExtMelodyInfo.ValidBit, slot); /* Delete data in nvram */ memset(&gPmgExtMelodyInfo.info[slot], 0, sizeof(gPmgExtMelodyInfo.info[slot])); PMG_ASSERT(NVRAM_EF_EXT_MELODY_INFO_SIZE == sizeof(gPmgExtMelodyInfo)); WriteRecord(NVRAM_EF_EXT_MELODY_INFO_LID, 1, &gPmgExtMelodyInfo, sizeof(gPmgExtMelodyInfo), &pError); PMG_ASSERT(pError == NVRAM_WRITE_SUCCESS); }
void TensorBoardFileWriter::WriteImage(const std::wstring& name, NDArrayViewPtr imageData, uint64_t step) { assert(imageData != nullptr); tensorflow::Event event; event.set_wall_time(static_cast<double>(std::time(0))); tensorflow::Summary* summary = event.mutable_summary(); std::vector<size_t> dimensions = imageData->Shape().Dimensions(); const size_t batch_size = dimensions.at(3); const size_t depth = dimensions.at(2); const size_t width = dimensions.at(1); const size_t height = dimensions.at(0); const DataType dtype = imageData->GetDataType(); std::vector<size_t> start(4, 0); std::vector<size_t> extent; extent.push_back(height); extent.push_back(width); extent.push_back(depth); extent.push_back(1); const int compression = -1; const std::vector<size_t> imageDim({height, width, depth}); NDShape imageShape(imageDim); for (size_t i = 0; i < batch_size; i++) { tensorflow::Summary::Value* summaryValue = summary->add_value(); summaryValue->set_tag(ToString(name) + "/image/" + std::to_string(i)); tensorflow::Summary::Image* summaryImage = summaryValue->mutable_image(); summaryImage->set_height(height); summaryImage->set_width(width); summaryImage->set_colorspace(depth); start.back() = static_cast<size_t>(i); auto image = imageData->SliceView(start, extent)->AsShape(imageDim); vector<uchar> buffer; switch (dtype) { case DataType::Float: WriteImageToBuffer(image->WritableDataBuffer<float>(), height, width, CV_32FC(depth), buffer); break; case DataType::Double: WriteImageToBuffer(image->WritableDataBuffer<double>(), height, width, CV_64FC(depth), buffer); break; default: fprintf(stderr, "TensorBoardFileWriter: Unsupported data type: %d ", static_cast<int>(dtype)); break; } string str(buffer.begin(), buffer.end()); summaryImage->set_encoded_image_string(str); } WriteRecord(Serialize(event)); }
/***************************************************************************** * FUNCTION * SpofWritetoNvram * DESCRIPTION * Write SPOF Value to NVRAM * PARAMETERS * None. * RETURNS * None. * GLOBALS AFFECTED * None. *****************************************************************************/ void SpofWritetoNvram(void) { S16 error; U8 nvram_buf[NVRAM_ALM_SPOF_DATA_SIZE]; memset(nvram_buf, 0, NVRAM_ALM_SPOF_DATA_SIZE); memcpy(nvram_buf,g_spof_cntx.SPOFList, sizeof(g_spof_cntx.SPOFList)); WriteRecord(NVRAM_EF_ALM_SPOF_DATA_LID, 2, (void*)nvram_buf, NVRAM_ALM_SPOF_DATA_SIZE, &error); }
void TensorBoardFileWriter::WriteVersion(time_t time) { // Version string present in the first entry of every event file. tensorflow::Event event; event.set_wall_time(static_cast<double>(time)); event.set_file_version("brain.Event:2"); WriteRecord(Serialize(event)); }
/***************************************************************************** * FUNCTION * PmgReplaceExtMelodyBySlotPathFileName * DESCRIPTION * * PARAMETERS * pathfileName [?] * freeSlot [IN] * RETURNS * *****************************************************************************/ PMG_ADDFILE_ERRNO PmgReplaceExtMelodyBySlotPathFileName(S8 *pathfileName, U8 freeSlot) /* fileName is unicode */ { /*----------------------------------------------------------------*/ /* Local Variables */ /*----------------------------------------------------------------*/ /* U8 freeSlot=0; */ S16 pError; U8 i; PMG_ADDFILE_ERRNO res = MMI_FALSE; DYNEXTMELODYELEM target; /*----------------------------------------------------------------*/ /* Code Body */ /*----------------------------------------------------------------*/ if (mmi_ucs2strlen(pathfileName) >= (MAX_EXT_MELODY_FULLNAME_WIDTH / ENCODING_LENGTH)) { return PMG_ADDFILE_ERR_STR_TOO_LONG; } res = PmgSeparateFilePathName( (S8*) pathfileName, (S8*) target.filepath, sizeof(target.filepath), (S8*) target.filename, sizeof(target.filename)); if (res != PMG_ADDFILE_ERR_SUCCESS) { return res; } /* check if it is shorname and mark it if possible */ if (is_target_short_filename) { MARK_EXTMELODY_SHORTNAME(target.filepath); } /* Check Duplicate */ for (i = 0; i < MAXIMUM_EXT_MELODY_NUM; i++) { if ((i != freeSlot) && (PmgIsEmptySlot(i) == MMI_FALSE) && (mmi_ucs2cmp((S8*) gPmgExtMelodyInfo.info[i].filepath, (S8*) target.filepath) == 0) && (mmi_ucs2cmp((S8*) gPmgExtMelodyInfo.info[i].filename, (S8*) target.filename) == 0)) { return PMG_ADDFILE_ERR_DUPLICATED; } } mmi_ucs2cpy((S8*) gPmgExtMelodyInfo.info[freeSlot].filepath, (S8*) target.filepath); mmi_ucs2cpy((S8*) gPmgExtMelodyInfo.info[freeSlot].filename, (S8*) target.filename); PMG_ASSERT(NVRAM_EF_EXT_MELODY_INFO_SIZE == sizeof(gPmgExtMelodyInfo)); WriteRecord(NVRAM_EF_EXT_MELODY_INFO_LID, 1, &gPmgExtMelodyInfo, sizeof(gPmgExtMelodyInfo), &pError); PMG_ASSERT(pError == NVRAM_WRITE_SUCCESS); return PMG_ADDFILE_ERR_SUCCESS; }
void CreateTestFile() { struct Route route1 = { "18A" , 8, 6.2 }; struct Route route2 = { "11" , 5, 7.15 }; struct Route route3 = { "15Б" , 2, 9.8 }; struct Route route4 = { "32" , 4, 8.48 }; struct Route route5 = { "50" , 11, 10.6 }; file = fopen("brest.txt", "w"); if (file != NULL) { WriteRecord(&route1); WriteRecord(&route2); WriteRecord(&route3); WriteRecord(&route4); WriteRecord(&route5); fclose(file); } }
void TensorBoardFileWriter::WriteValue(const std::wstring& name, float value, uint64_t step) { tensorflow::Event event; event.set_step(step); event.set_wall_time(static_cast<double>(std::time(0))); tensorflow::Summary* summary = event.mutable_summary(); tensorflow::Summary::Value* summaryValue = summary->add_value(); summaryValue->set_tag(ToString(name)); summaryValue->set_simple_value(value); WriteRecord(Serialize(event)); }
/* Prompts the user for information, and storing that in a record, and then to disk. Pass: name of file to save to */ void NewRecordMenu(char *filename) { struct employeeRecord *record; char buffer[1024]; FILE *f; record = malloc(sizeof(struct employeeRecord)); /* Prompt for a name */ printf("Enter the name: "); fgets(buffer, 1024, stdin); /* Remove the \n from the string */ buffer[strlen(buffer) - 1] = '\0'; /* Initialize the name length */ record->nameLength = strlen(buffer); /* Initialize the name */ record->name = malloc(sizeof(char) * (record->nameLength + 1)); strcpy(record->name, buffer); /* Prompt for an address */ printf("Enter the address: "); fgets(buffer, 1024, stdin); /* Remove the \n from the string */ buffer[strlen(buffer) - 1] = '\0'; /* Initialize the address length */ record->addressLength = strlen(buffer); /* Initialize the address */ record->address = malloc(sizeof(char) * (record->addressLength + 1)); strcpy(record->address, buffer); /* Prompt for telephone number */ printf("Enter telephone number: "); fgets(buffer, 1024, stdin); /* Convert input to int and initialize phone number */ sscanf(buffer, "%d", &(record->phoneNumber)); /* Write the record to disk */ f = fopen(filename, "a"); WriteRecord(f, record); fclose(f); free(record); }
/***************************************************************************** * FUNCTION * avk_pluto_nvram_test_access_record * DESCRIPTION * test case of access nvram record; include ReadRecord and WriteRecord * PARAMETERS * void * RETURNS * void *****************************************************************************/ AVK_CASE(AVK_PLUTO_NVRAM_TEST_ACCESS_RECORD, AVK_PLUTO_NVRAM) { /*----------------------------------------------------------------*/ /* Local Variables */ /*----------------------------------------------------------------*/ S16 error; S32 ret, i; U8 buff[AVK_PLUTO_NVRAM_TEST_REC_SIZE] = {0}; U8 buff_backup[AVK_PLUTO_NVRAM_TEST_REC_SIZE] = {0}; /*----------------------------------------------------------------*/ /* Code Body */ /*----------------------------------------------------------------*/ /* Try to reserve the data, but can not make sure if read operation is correct */ ret = ReadRecord(AVK_PLUTO_NVRAM_TEST_REC_LID, 1, buff, AVK_PLUTO_NVRAM_TEST_REC_SIZE, &error); MMI_ASSERT((ret == AVK_PLUTO_NVRAM_TEST_REC_SIZE) && (memcmp(buff, buff_backup, AVK_PLUTO_NVRAM_TEST_REC_SIZE) != 0) && (error == NVRAM_READ_SUCCESS)); memcpy(buff_backup, buff, AVK_PLUTO_NVRAM_TEST_REC_SIZE); /* test if read and write operation is correct */ memset(buff, AVK_PLUTO_NVRAM_TEST_DATA_VAL, AVK_PLUTO_NVRAM_TEST_REC_SIZE); ret = WriteRecord(AVK_PLUTO_NVRAM_TEST_REC_LID, 1, buff, AVK_PLUTO_NVRAM_TEST_REC_SIZE, &error); MMI_ASSERT((ret == AVK_PLUTO_NVRAM_TEST_REC_SIZE) && (error == NVRAM_WRITE_SUCCESS)); memset(buff, AVK_PLUTO_NVRAM_TEST_DATA_VAL + 10, sizeof(buff)); ret = ReadRecord(AVK_PLUTO_NVRAM_TEST_REC_LID, 1, buff, AVK_PLUTO_NVRAM_TEST_REC_SIZE, &error); MMI_ASSERT((ret == AVK_PLUTO_NVRAM_TEST_REC_SIZE) && (memcmp(buff, buff_backup, AVK_PLUTO_NVRAM_TEST_REC_SIZE) != 0) && (error == NVRAM_READ_SUCCESS)); for (i = 0; i < AVK_PLUTO_NVRAM_TEST_REC_SIZE; i++) { MMI_ASSERT(buff[i] == AVK_PLUTO_NVRAM_TEST_DATA_VAL); } /* * if above case pass, We can confirm read and write operation is correct * then restore the original record data */ ret = WriteRecord(AVK_PLUTO_NVRAM_TEST_REC_LID, 1, buff_backup, AVK_PLUTO_NVRAM_TEST_REC_SIZE, &error); MMI_ASSERT((ret == AVK_PLUTO_NVRAM_TEST_REC_SIZE) && (error == NVRAM_WRITE_SUCCESS)); AVK_CASE_RESULT(MMI_TRUE); }
/***************************************************************************** * FUNCTION * mmi_nfc_write_status * DESCRIPTION * This function is to write nfc status to nvram * PARAMETERS * evt * * * RETURNS * void *****************************************************************************/ static mmi_ret mmi_nfc_set_nvram_status(U8 status) { /*----------------------------------------------------------------*/ /* Local Variables */ /*----------------------------------------------------------------*/ S16 pError; /*----------------------------------------------------------------*/ /* Code Body */ /*----------------------------------------------------------------*/ WriteRecord(NVRAM_EF_NFC_STATUS_LID, 1, &status, 1, &pError); return MMI_OK; }
/***************************************************************************** * FUNCTION * mmi_em_dcd_write_nw_data * DESCRIPTION * write setting value to nvram * PARAMETERS * void * RETURNS * MMI_TRUE: success / MMI_FALSE: error *****************************************************************************/ void dcd_custom_em_write_data(void) { /*----------------------------------------------------------------*/ /* Local Variables */ /*----------------------------------------------------------------*/ #ifdef __MMI_EM_MISC_DCD__ S16 error; #endif /*----------------------------------------------------------------*/ /* Code Body */ /*----------------------------------------------------------------*/ #ifdef __MMI_EM_MISC_DCD__ WriteRecord(NVRAM_EF_DCD_EM_PARAM_DATA_LID, 1, g_em_dcd_nw_data_p, NVRAM_EF_DCD_EM_PARAM_DATA_SIZE, &error); ASSERT(error==NVRAM_WRITE_SUCCESS); #endif }
OGRErr TigerPolygonCorrections::CreateFeature( OGRFeature *poFeature ) { char szRecord[OGR_TIGER_RECBUF_LEN]; if( !SetWriteModule( FILE_CODE, psRTBInfo->nRecordLength+2, poFeature ) ) return OGRERR_FAILURE; memset( szRecord, ' ', psRTBInfo->nRecordLength ); WriteFields( psRTBInfo, poFeature, szRecord); WriteRecord( szRecord, psRTBInfo->nRecordLength, FILE_CODE ); return OGRERR_NONE; }
void DebugLogger::EndDebug() { // 根据可变配置文件中的配置项决定是否上传数据 lux VariableConfigBlock *config = WorkingParameters::GetInstance()->GetCurrentConfigParameters(); int uploadLevel = config->GetIntParameter(_T("UploadLevel"), 1); if (uploadLevel == 0) { return; } if (logFile_.m_hFile == INVALID_HANDLE_VALUE) { return; } char noData = 0; WriteRecord("END ", &noData, 1); }
/***************************************************************************** * FUNCTION * csb_frm_write_in_nvram * DESCRIPTION * Writes the updated data in NVRAM * PARAMETERS * * RETURNS void *****************************************************************************/ void csb_frm_write_in_nvram(void) { /*----------------------------------------------------------------*/ /* Local Variables */ /*----------------------------------------------------------------*/ S16 error = 0; /*----------------------------------------------------------------*/ /* Code Body */ /*----------------------------------------------------------------*/ WriteRecord(NVRAM_EF_CSB_SETTINGS_LID, 1, &g_CSB_struct.csb_settings, NVRAM_CSB_SETTINGS_SIZE, &error); }
int SavePersona(UFF *r, int n) { FILE *a=OpenUAF(); if(FindRecord(a,n)==-1) { CloseUAF(a); Log("SavePersona: Record %d Does Not Exist",n); Error("SavePersona: Could not find record"); } if(WriteRecord(a,r)==-1) { CloseUAF(a); Log("User Write Failed"); return(-1); } CloseUAF(a); return(0); }
void TensorBoardFileWriter::WriteModel() { assert(m_model != nullptr); // Convert the model to tensorflow GraphDef first. tensorflow::GraphDef graph; CreateTensorBoardGraph(m_model->RootFunction(), graph); std::string graphStr; graph.AppendToString(&graphStr); // Wrap it as an event. tensorflow::Event event; event.set_wall_time(static_cast<double>(std::time(0))); event.set_graph_def(graphStr); WriteRecord(Serialize(event)); }
UINT32 TES4Record::Write(FileWriter &writer, const bool &bMastersChanged, FormIDResolver &expander, FormIDResolver &collapser, std::vector<FormIDResolver *> &Expanders) { IsCompressed(false); UINT32 recSize = 0; UINT32 recType = GetType(); collapser.Accept(formID); VisitFormIDs(collapser); WriteRecord(writer); recSize = writer.record_size(); writer.file_write(&recType, 4); writer.file_write(&recSize, 4); writer.file_write(&flags, 4); writer.file_write(&formID, 4); writer.file_write(&flagsUnk, 4); if(whichGame == eIsFalloutNewVegas) { writer.file_write(&formVersion, 2); writer.file_write(&versionControl2[0], 2); } else if(whichGame == eIsSkyrim) { writer.file_write(&formVersion, 2); writer.file_write(&versionControl2[0], 2); } writer.record_flush(); expander.Accept(formID); if(IsChanged()) VisitFormIDs(expander); else Unload(); if(whichGame == eIsFalloutNewVegas) return recSize + 24; else if(whichGame == eIsSkyrim) return recSize + 24; else return recSize + 20; }
OGRErr TigerFileBase::CreateFeature( OGRFeature *poFeature ) { char szRecord[OGR_TIGER_RECBUF_LEN]; if (psRTInfo == NULL) return OGRERR_FAILURE; if( !SetWriteModule( m_pszFileCode, psRTInfo->nRecordLength+2, poFeature ) ) return OGRERR_FAILURE; memset( szRecord, ' ', psRTInfo->nRecordLength ); WriteFields( psRTInfo, poFeature, szRecord ); WriteRecord( szRecord, psRTInfo->nRecordLength, m_pszFileCode ); return OGRERR_NONE; }
void SaveFile() { if (!isFileLoaded()) return; if (file = fopen(path, "w")) { for (int i = 0; i < recordCount; i++) { WriteRecord(&routeArray[i]); } fclose(file); isFileEdited = false; printf("Файл '%s' сохранен.\n", path); getch(); } else { printf("Ошибка сохранения файла '%s'.\n"); getch(); return; } }