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