/**
* @brief Generate report of given type.
* @param [in] nReportType Type of report.
*/
void DirCmpReport::GenerateReport(REPORT_TYPE nReportType)
{
switch (nReportType)
{
case REPORT_TYPE_SIMPLEHTML:
GenerateHTMLHeader();
GenerateXmlHtmlContent(false);
GenerateHTMLFooter();
break;
case REPORT_TYPE_SIMPLEXML:
GenerateXmlHeader();
GenerateXmlHtmlContent(true);
GenerateXmlFooter();
break;
case REPORT_TYPE_COMMALIST:
m_sSeparator = _T(",");
GenerateHeader();
GenerateContent();
break;
case REPORT_TYPE_TABLIST:
m_sSeparator = _T("\t");
GenerateHeader();
GenerateContent();
break;
}
}
/*!
************************************************************************
* \brief
* This function opens the output files and generates the
* appropriate sequence header
************************************************************************
*/
int start_sequence()
{
GenerateHeader(NALU_TYPE_SPS);
GenerateSeq_parameter_set_rbsp (active_sps);
//MSG(GENERATE_HEADER_SPS);
GenerateHeader(NALU_TYPE_PPS);
GeneratePic_parameter_set_rbsp (active_pps);
//MSG(GENERATE_HEADER_PPS);
//MSG(START_SEQUENCE);
return 0;
}
bool HttpConnection::ExecuteRequest()
{
log_debug("ContentLength=" << contentLength_ << ", request=" << request_);
std::string& requestContentType = httpRequestState_.GetContentType();
// find a handler that will work
RpcHandlerList::iterator it = handlers_.begin();
for (;it!= handlers_.end(); it++)
if ((*it).CanProcessContentType(requestContentType))
break;
if (it == handlers_.end())
{
log_warn("Content type not supported by server, " << requestContentType);
Initialize();
return false;
}
else
{
(*it).HandleRequest(manager_, request_, contentLength_, response_);
log_debug("Response length=" << response_.Length());
std::string& responseContentType = (*it).GetResponseContentType();
if (responseContentType.length() == 0)
responseContentType = requestContentType;
GenerateHeader(response_.Length(), responseContentType);
}
connectionState_ = WRITE_RESPONSE;
return true;
}
bool Client::Post(const char* method, Value& params, Value& result)
{
log_trace();
gettimeofday( &startTime_, 0 );
result.SetInvalid();
PreserveReceiveBuffer();
ResetTransaction();
if (Connect(result) &&
GenerateRequest(method, params) &&
GenerateHeader())
{
if (!WriteRequest(result))
{
// retry the connection
Close();
if (!Connect(result) ||
!WriteRequest(result))
{
Reset();
return false;
}
}
return true;
}
Reset();
return false;
}
bool QuickIndexImpl::Init( const tstring &path, size_t file_number, size_t entry_size, bool read_only )
{
if (0 == entry_size) {
return false;
}
bool exist = false;
index_file_path_ = path;//MakePathRegular(path);
// Write to a temp file
index_file_path_temp_ = index_file_path_ + _T(".temp");
if (!IsFileExist(index_file_path_)) {
if (read_only) {
return false;
}
if (IsFileExist(index_file_path_temp_.c_str())) {
::DeleteFile(index_file_path_temp_.c_str());
}
DWORD access = GENERIC_READ | GENERIC_WRITE | DELETE;
HANDLE file = CreateFile(index_file_path_temp_.c_str(), access, NULL, NULL,
CREATE_ALWAYS, FILE_FLAG_OVERLAPPED, NULL);
if (INVALID_HANDLE_VALUE == file) {
return false;
}
CloseHandle(file);
header_ = (QuickIndexHeader*)index_file_.Init(index_file_path_temp_, sizeof(QuickIndexHeader));
index_file_modify_ = true;
}
else {
exist = true;
if (GetFileSize(index_file_path_.c_str()) > 0) {
header_ = (QuickIndexHeader*)index_file_.Init(index_file_path_, 0);
}
else {
header_ = (QuickIndexHeader*)index_file_.Init(index_file_path_, sizeof(QuickIndexHeader));
}
}
if (NULL == header_) {
return false;
}
if (!exist) {
if (!GenerateHeader(file_number, entry_size)) {
return false;
}
if (!GrowIndexFile()) {
return false;
}
}
if (!IsHeaderValid()) {
return false;
}
return true;
}
LRESULT CMainFrame::OnGetEclLoaded(WPARAM wParam, LPARAM lParam)
{
bool showHiddenChar = false;
m_repositoryDlg.m_repositoryView->Invalidate();
std::_tstring lhs, lhsHeader;
std::_tstring rhs, rhsHeader;
if (CComQIPtr<CAttributePairNode> attrNode = m_repositoryDlg.GetSelectedItem())
{
CComQIPtr<CAttributePairNode> attributeNode = (CTreePairNode *)wParam;
if (attrNode.p != attributeNode)
return 0;
if (attributeNode->hasLHS())
showHiddenChar = GenerateHeader(attributeNode->m_lhs, attributeNode->m_rhs, lhsHeader);
if (attributeNode->hasRHS())
showHiddenChar = GenerateHeader(attributeNode->m_rhs, attributeNode->m_lhs, rhsHeader) ? true : showHiddenChar;
lhs = attributeNode->m_lhs->GetText(false);
rhs = attributeNode->m_rhs->GetText(false);
}
else if (CComQIPtr<CAttributeHistoryPairNode> histNode = m_repositoryDlg.GetSelectedItem())
{
CComQIPtr<CAttributeHistoryPairNode> historyNode = (CTreePairNode *)wParam;
if (histNode.p != historyNode)
return 0;
CComQIPtr<CAttributePairNode> attributeNode = histNode->GetParentNode();
lhsHeader = (boost::_tformat(_T("%1% (When: %2%, By: %3%)\r\n")) % attributeNode->m_lhs->GetQualifiedLabel() % historyNode->m_lhs->GetModifiedDate() % historyNode->m_lhs->GetModifiedBy()).str();
if (historyNode->hasLHS())
rhsHeader = (boost::_tformat(_T("%1% (crc: %2%)\r\n")) % historyNode->m_rhs->GetQualifiedLabel() % historyNode->m_rhs->GetChecksum()).str();
lhs = historyNode->m_lhs->GetText();
rhs = historyNode->m_rhs->GetText(false);
}
if (lhs.length() || rhs.length() || lhsHeader.length() || rhsHeader.length())
{
ShowDiff(lhs, lhsHeader, rhs, rhsHeader);
}
return 0;
}
bool Client::Notify(const char* method, Value& params, Value& result)
{
log_trace();
gettimeofday( &startTime_, 0 );
result.SetInvalid();
PreserveReceiveBuffer();
ResetTransaction();
if (Connect(result) &&
GenerateRequest(method, params, true) &&
GenerateHeader())
{
if (!WriteRequest(result))
{
// retry the connection
Close();
if (!Connect(result) ||
!WriteRequest(result))
{
Reset();
return false;
}
}
// Not all notification require a response
if (!TransportHasNotifyResponse())
{
requestId_.pop_front();
return true;
}
// continue with the processing response
if (ReadHeader(result) &&
ReadResponse(result))
{
// don't process the response for a notification
requestId_.pop_front();
result.SetNull();
return true;
}
}
Reset();
return false;
}
bool Client::Call(const char* method, Value& params, Value& result)
{
log_trace();
gettimeofday( &startTime_, 0 );
result.SetInvalid();
PreserveReceiveBuffer();
ResetTransaction();
if (Connect() &&
GenerateRequest(method, params) &&
GenerateHeader())
{
if (!WriteRequest(result))
{
// retry the connection
Close();
if (!Connect() ||
!WriteRequest(result))
{
Reset();
return false;
}
}
// continue with the processing
if (ReadHeader(result) &&
ReadResponse(result))
{
switch (ProcessResponse(result))
{
case ProcessResponseSuccess : return true;
case ProcessResponseErrorKeepOpen : return false;
default : ; // continue processing
}
}
}
Reset();
return false;
}
bool C2DimensionFile::Generate(wstring& wstrMetaRow, int row, int colounm, list<wstring>& contentStrList)
{
m_ConvertFunc = (ValueFunc*)malloc(colounm * sizeof(ValueFunc));
m_RowCount = row;
m_ColumnCount = colounm;
m_wstrMetaRow = wstrMetaRow;
m_wstrMetaRow.replace(m_wstrMetaRow.find(L"\r"), 1, L"\t");
GenerateHeader();
wstring* wstrColoumnName = new wstring[colounm];
ASSERT_NOTNULL(wstrColoumnName);
GenerateType(wstrColoumnName);
GenerateFill(wstrColoumnName, contentStrList);
delete[] wstrColoumnName;
OutputDebugStringW(m_wstrResultContent.c_str());
return true;
}
int GenerateCSCANcode(CSV_INPUT *csv_input, int nLn)
{
FILE *flp = NULL;
flp = fopen(conf.bodyFile, "w");
if (!flp)
{
fprintf(stderr, "GenerateCSCANcode Error: can not open file %s for writing\n", conf.destFile);
return RADIYGEN_ERROR;
}
fprintf(stderr, "GenerateCSCANcode: nLn = %d\n", nLn);
// Now allocate memory for signal list
// in assumption of MAX_SIGNALS_PER_LINE signals per alg. line
// Every time the new signal is added to a list we'll check if we still
// have enough memory and realloc() if more memory needed
// MAX_SIGNALS_PER_LINE is defined in codegenconst.h
// As for 30.12.2015 MAX_SIGNALS_PER_LINE = 256
signals = (SIGNAL_INFO*)malloc(nLn * MAX_SIGNALS_PER_LINE * sizeof(SIGNAL_INFO));
if (!signals)
{
fprintf(stderr, "GenerateCSCANcode Error: can not allocate %d bytes for %d signal infos. Terminated.\n",
nLn * MAX_SIGNALS_PER_LINE * sizeof(SIGNAL_INFO), nLn * MAX_SIGNALS_PER_LINE);
fclose(flp);
return RADIYGEN_ERROR;
}
memset(signals, '\x0', (nLn * MAX_SIGNALS_PER_LINE * sizeof(SIGNAL_INFO)));
// nSig external counter is updated by GetSignalInfo() which could be called in two places:
//- when signal is identified on the right by MakeComponentCall()
//- when arg list is processed that is in cbProcessListElement() csvlib's callback
nSig = 0;
for (int i = 1; i < nLn; i++) // Start loop at 1 - ignore element 0 with column names
{
fprintf(flp, "/*STARTCOMPONENT %s*/\n", (csv_input + i)->run_compon);
fprintf(flp, "/************************* Row # %d Component ID: %d *************************/\n", (csv_input + i)->nom_row, (csv_input + i)->Id_compon);
fprintf(flp, "/* Data reference: page %s of alg. album */\n", (csv_input + i)->page_alg);
fprintf(flp, "/* Component type: %s */\n", (csv_input + i)->Type_compon);
fprintf(flp, "/* Description: %s */\n", (csv_input + i)->description);
fprintf(flp, "/* Comments: %s */\n\n", (csv_input + i)->comments);
fprintf(stderr, "GenerateCSCANcode: i = %d (nLn = %d) component: %s\n", i, nLn, (csv_input + i)->run_compon);
fprintf(stderr, "----------------------------------------------------------------------\n");
CallComponent(&conf, csv_input + i, flp, nLn);
fprintf(flp, "/*ENDCOMPONENT*/\n");
}
// Put footer to the code body file
fprintf(flp, "\n}\n");
fclose(flp);
// Done with code body
fprintf(stderr, "We're done with code body generation. nSig = %d\n", nSig);
char systembuf[MAXBUF] = ""; // buffer for system commands we need to complete the job
if (GenerateHeader(signals, nSig))
{
sprintf(systembuf, "cat %s %s > %s", conf.hdrFile, conf.bodyFile, conf.destFile);
system(systembuf);
}
// Get rid of body nad header temp files is configured so
if (conf.removeTempFIles)
{
memset(systembuf, '\x0', sizeof(systembuf));
sprintf(systembuf, "rm -f %s %s", conf.hdrFile, conf.bodyFile);
system(systembuf);
}
GenerateSignalLog(signals, nSig);
if (signals)
free(signals);
return RADIYGEN_OK;
}
//-----------------------------------------------------------------------------
bool Send(Response& rResponse, const char* mime, const char* pData, unsigned long dwSize)
{
char sendbuffer[COMM_BUFFER_SIZE];
sendbuffer[0] = 0;
// send the http header and the file contents to the browser
if (rResponse.m_bNeedToSendHeader == true)
{
GenerateHeader(rResponse, sendbuffer, COMM_BUFFER_SIZE);
rResponse.m_bNeedToSendHeader = false;
}
if (rResponse.m_bStreamingEnabled == true)
{
strncat_s(sendbuffer, COMM_BUFFER_SIZE, "--BoundaryString\r\n", COMM_BUFFER_SIZE);
}
DWORD len = (DWORD)strlen(sendbuffer);
sprintf_s(sendbuffer + len, COMM_BUFFER_SIZE - len, "Content-Type: %s\r\n"
"Content-Length: %ld\r\n"
"\r\n",
mime,
dwSize);
// send header
bool res = rResponse.client_socket->Send(sendbuffer, (DWORD)strlen(sendbuffer));
if (res == true)
{
// if header could be sent
// send data
res = rResponse.client_socket->Send(pData, dwSize);
}
else
{
osSystemErrorCode systemLastError = osGetLastSystemError();
// If no system error was recorded:
if (systemLastError != 0)
{
gtString systemErrorString;
osGetLastSystemErrorAsString(systemErrorString);
Log(logERROR, "Failed to send %s response data due to error %d: %s\n", mime, systemLastError, systemErrorString.asASCIICharArray());
}
// there was an error sending
// so close the connection and return false
CloseConnection(rResponse);
return false;
}
// if the response is not streaming,
// the connection should be closed
// otherwise it should be left open
if (rResponse.m_bStreamingEnabled == false)
{
CloseConnection(rResponse);
}
return true;
}
void CuDlgPageCsv::OnCheckConfirmChoice()
{
CaDataPage1& dataPage1 = m_pData->m_dataPage1;
if (m_cCheckConfirmChoice.GetCheck() == 1)
{
CStringArray arrayHeader;
BOOL bFirstLineAsHeader = GenerateHeader(dataPage1, m_pSeparatorSet, m_pSeparator, m_nCoumnCount, arrayHeader);
if (dataPage1.GetFirstLineAsHeader() && dataPage1.GetLineCountToSkip() == 1)
{
if (!bFirstLineAsHeader)
AfxMessageBox (IDS_MSG_ERROR_HEADERLINE);
}
}
//
// You have already checked one.\nThe previous check will be cancelled.
CString strMsg;
strMsg.LoadString(IDS_CONFIRM_CHOICE_WITH_CHECKBOX);
CWnd* pParent = GetParent();
ASSERT(pParent && pParent->IsKindOf(RUNTIME_CLASS(CTabCtrl)));
if (pParent && pParent->IsKindOf(RUNTIME_CLASS(CTabCtrl)))
{
BOOL nAsked = FALSE;
TCITEM item;
memset (&item, 0, sizeof (item));
item.mask = TCIF_PARAM;
CTabCtrl* pTab = (CTabCtrl*)pParent;
int nCheck, i, nCount = pTab->GetItemCount();
for (i=0; i<nCount; i++)
{
if (pTab->GetItem (i, &item))
{
CWnd* pPage = (CWnd*)item.lParam;
ASSERT (pPage);
if (!pPage)
continue;
if (pPage == this)
continue;
nCheck = pPage->SendMessage(WMUSRMSG_GETITEMDATA, (WPARAM)CHECK_CONFIRM_CHOICE, 0);
if (nCheck == 1)
{
if (!nAsked)
{
nAsked = TRUE;
int nAnswer = AfxMessageBox (strMsg, MB_OKCANCEL|MB_ICONEXCLAMATION);
if (nAnswer != IDOK)
{
m_cCheckConfirmChoice.SetCheck (0);
return;
}
//
// Uncheck the checkbox m_cCheckConfirmChoice:
pPage->SendMessage(WMUSRMSG_UPDATEDATA, (WPARAM)CHECK_CONFIRM_CHOICE, 0);
}
else
{
//
// Uncheck the checkbox m_cCheckConfirmChoice:
pPage->SendMessage(WMUSRMSG_UPDATEDATA, (WPARAM)CHECK_CONFIRM_CHOICE, 0);
}
}
}
}
}
}
//
// wParam = CHECK_CONFIRM_CHOICE (Update the control m_cCheckConfirmChoice. lParam = 0|1)
// wParam = 0 (General, lParam = address of class CaIIAInfo)
LONG CuDlgPageCsv::OnUpdateData (WPARAM wParam, LPARAM lParam)
{
int nMode = (int)wParam;
if (nMode == CHECK_CONFIRM_CHOICE)
{
int nCheck = (int)lParam;
m_cCheckConfirmChoice.SetCheck (nCheck);
return 0;
}
ASSERT (m_pData);
ASSERT (m_pSeparatorSet);
if (!(m_pData && m_pSeparatorSet))
return 0;
CaDataPage1& dataPage1 = m_pData->m_dataPage1;
CaDataPage2& dataPage2 = m_pData->m_dataPage2;
CPtrArray& arrayRecord = dataPage2.GetArrayRecord();
int i, nSize = arrayRecord.GetSize();
for (i=0; i<nSize; i++)
{
CaRecord* pRec = (CaRecord*)arrayRecord.GetAt(i);
delete pRec;
}
arrayRecord.RemoveAll();
m_listCtrlHuge.ResizeToFit();
CaExecParamQueryRecords* p = new CaExecParamQueryRecords(m_pData, m_pSeparatorSet, &m_nCoumnCount);
#if defined (_ANIMATION_)
CString strMsgAnimateTitle;
strMsgAnimateTitle.LoadString(IDS_ANIMATE_TITLE_QUERYING);
CxDlgWait dlg (strMsgAnimateTitle);
dlg.SetUseAnimateAvi(AVI_CLOCK);
dlg.SetExecParam (p);
dlg.SetDeleteParam(FALSE);
dlg.SetShowProgressBar(TRUE);
dlg.SetUseExtraInfo();
dlg.DoModal();
#else
p->Run();
p->OnTerminate(m_hWnd);
#endif
delete p;
SetForegroundWindow ();
m_bFirstUpdate = FALSE;
//
// Display the separator:
DisplaySeparatorSetInfo(m_pSeparatorSet, m_pSeparator);
//
// Initialize headers:
CString strHeader;
if (m_nCoumnCount > 0)
{
LSCTRLHEADERPARAMS* pLsp = new LSCTRLHEADERPARAMS[m_nCoumnCount];
CStringArray arrayHeader;
BOOL bFirstLineAsHeader = GenerateHeader(dataPage1, m_pSeparatorSet, m_pSeparator, m_nCoumnCount, arrayHeader);
for (i=0; i<m_nCoumnCount; i++)
{
if (bFirstLineAsHeader)
strHeader = arrayHeader.GetAt(i);
else
strHeader.Format(_T("col%d"), i+1);
#if defined (MAXLENGTH_AND_EFFECTIVE)
int& nFieldMax = dataPage2.GetFieldSizeMax(i);
int& nFieldEff = dataPage2.GetFieldSizeEffectiveMax(i);
//if (nFieldEff < nFieldMax)
// strHeader.Format(_T("col%d (%d+%d)"), i+1, nFieldEff, nFieldMax-nFieldEff);
//else
CString strSize;
strSize.Format(_T(" (%d)"), nFieldMax);
strHeader += strSize;
#endif
pLsp[i].m_fmt = LVCFMT_LEFT;
if (strHeader.GetLength() > MAXLSCTRL_HEADERLENGTH)
lstrcpyn (pLsp[i].m_tchszHeader, strHeader, MAXLSCTRL_HEADERLENGTH);
else
lstrcpy (pLsp[i].m_tchszHeader, strHeader);
pLsp[i].m_cxWidth= 100;
pLsp[i].m_bUseCheckMark = FALSE;
}
m_listCtrlHuge.InitializeHeader(pLsp, m_nCoumnCount);
m_listCtrlHuge.SetDisplayFunction(DisplayListCtrlHugeItem, NULL);
m_listCtrlHuge.SetSharedData (&arrayRecord);
delete pLsp;
}
//
// Display the new records:
m_listCtrlHuge.ResizeToFit();
//If one tab displays for import format, then just check
//the tab checkbox automatically
CTabCtrl *cTab = (CTabCtrl *) this->GetParent();
int size = cTab->GetItemCount();
if (cTab->GetItemCount()==1)
m_cCheckConfirmChoice.SetCheck(TRUE);
return TRUE;
}
void
GenerateForm
(
istream& input,
const JString& formName,
const JString& tagName,
const JString& enclName,
const JString& codePath,
const JString& stringPath,
const JString& codeSuffix,
const JString& headerSuffix,
JPtrArray<JString>* backupList
)
{
const JString codeFileName = codePath + formName + codeSuffix;
const JString codeFileBakName = codeFileName + kBackupSuffix;
const JString headerFileName = codePath + formName + headerSuffix;
const JString headerFileBakName = headerFileName + kBackupSuffix;
if (!JFileExists(codeFileName))
{
cerr << codeFileName << " not found" << endl;
return;
}
if (!JFileExists(headerFileName))
{
cerr << headerFileName << " not found" << endl;
return;
}
cout << "Generating: " << formName << ", " << tagName << endl;
const JBoolean shouldBackup = ShouldBackupForm(formName, backupList);
// copy code file contents before start delimiter
JString tempCodeFileName;
JError err = JCreateTempFile(codePath, NULL, &tempCodeFileName);
if (!err.OK())
{
cerr << "Unable to create temporary file in " << codePath << endl;
cerr << " (" << err.GetMessage() << ')' << endl;
return;
}
ifstream origCode(codeFileName);
ofstream outputCode(tempCodeFileName);
if (!outputCode.good())
{
cerr << "Unable to open temporary file in " << codePath << endl;
remove(tempCodeFileName);
return;
}
if (!CopyBeforeCodeDelimiter(tagName, origCode, outputCode))
{
cerr << "No starting delimiter in " << codeFileName << endl;
outputCode.close();
remove(tempCodeFileName);
return;
}
// generate code for each object in the form
JPtrArray<JString> objTypes(JPtrArrayT::kDeleteAll),
objNames(JPtrArrayT::kDeleteAll);
GenerateCode(input, outputCode, stringPath, formName, tagName, enclName,
&objTypes, &objNames);
// copy code file contents after end delimiter
JBoolean done = CopyAfterCodeDelimiter(tagName, origCode, outputCode);
origCode.close();
outputCode.close();
if (!done)
{
cerr << "No ending delimiter in " << codeFileName << endl;
remove(tempCodeFileName);
return;
}
else if (shouldBackup && rename(codeFileName, codeFileBakName) != 0)
{
cerr << "Unable to rename original " << codeFileName << endl;
remove(tempCodeFileName);
return;
}
JEditVCS(codeFileName);
rename(tempCodeFileName, codeFileName);
// copy header file contents before start delimiter
JString tempHeaderFileName;
err = JCreateTempFile(codePath, NULL, &tempHeaderFileName);
if (!err.OK())
{
cerr << "Unable to create temporary file in " << codePath << endl;
cerr << " (" << err.GetMessage() << ')' << endl;
return;
}
ifstream origHeader(headerFileName);
ofstream outputHeader(tempHeaderFileName);
if (!outputHeader.good())
{
cerr << "Unable to open temporary file in " << codePath << endl;
remove(tempHeaderFileName);
return;
}
if (!CopyBeforeCodeDelimiter(tagName, origHeader, outputHeader))
{
cerr << "No starting delimiter in " << headerFileName << endl;
outputHeader.close();
remove(tempHeaderFileName);
return;
}
// generate instance variable for each object in the form
GenerateHeader(outputHeader, objTypes, objNames);
// copy header file contents after end delimiter
done = CopyAfterCodeDelimiter(tagName, origHeader, outputHeader);
origHeader.close();
outputHeader.close();
if (!done)
{
cerr << "No ending delimiter in " << headerFileName << endl;
remove(tempHeaderFileName);
return;
}
// check if header file actually changed
JString origHeaderText, newHeaderText;
JReadFile(headerFileName, &origHeaderText);
JReadFile(tempHeaderFileName, &newHeaderText);
if (newHeaderText != origHeaderText)
{
if (shouldBackup && rename(headerFileName, headerFileBakName) != 0)
{
cerr << "Unable to rename original " << headerFileName << endl;
remove(tempHeaderFileName);
return;
}
JEditVCS(headerFileName);
rename(tempHeaderFileName, headerFileName);
}
else
{
remove(tempHeaderFileName);
}
}
