XmlNode* CallbackScheduler::getXml() const
{
XmlNode* status = XmlNode::createWrapperElement("callback_scheduler");
status->addChild(m_sourceAvailability.getXml());
status->addChild(m_targetScheduler.getXml());
return status;
}
void Selection::saveGame(XmlNode *rootNode) const {
std::map<string,string> mapTagReplacements;
XmlNode *selectionNode = rootNode->addChild("Selection");
selectionNode->addAttribute("factionIndex",intToStr(factionIndex), mapTagReplacements);
selectionNode->addAttribute("teamIndex",intToStr(teamIndex), mapTagReplacements);
selectionNode->addAttribute("allowSharedTeamUnits",intToStr(allowSharedTeamUnits), mapTagReplacements);
for(unsigned int i = 0; i < selectedUnits.size(); i++) {
Unit *unit = selectedUnits[i];
XmlNode *selectedUnitsNode = selectionNode->addChild("selectedUnits");
selectedUnitsNode->addAttribute("unitId",intToStr(unit->getId()), mapTagReplacements);
}
for(unsigned int x = 0; x < (unsigned int)maxGroups; ++x) {
XmlNode *groupsNode = selectionNode->addChild("groups");
for(unsigned int i = 0; i < (unsigned int)groups[x].size(); ++i) {
Unit *unit = groups[x][i];
XmlNode *selectedUnitsNode = groupsNode->addChild("selectedUnits");
selectedUnitsNode->addAttribute("unitId",intToStr(unit->getId()), mapTagReplacements);
}
}
}
void sepa_write_header(void) {
XMLCh *tempStr = NULL;
tempStr = XMLString::transcode("Document");
doc = impl->createDocument(0, tempStr, 0);
DOMElement *document = doc->getDocumentElement();
char msgId[20]={0};
char day[10]={0};
char time[20]={0};
strncpy(day, gCr_file_t, 10);
char *hour = &gCr_file_t[11];
sprintf(msgId, "%10.010d%3.03d%6.06d", gFile_id, gServer_id,
FILE_SEPA_EFT_OUT);
sprintf(time, "%10.10sT%8.8s", day, hour);
XmlNode documentNode(document,doc);
documentNode.addAttribute("xmlns",gXmlns_str);
documentNode.addAttribute("xmlns:xsi",gXsi_str);
documentNode.addAttribute("xsi:schemaLocation",gSchemaLocation_str);
XmlNode rootNode = documentNode.addChild("CstmrDrctDbtInitn");
root = rootNode.getNodePointer();
XmlNode headerNode = rootNode.addChild("GrpHdr");
header = headerNode.getNodePointer();
headerNode.addChild("MsgId", msgId);
headerNode.addChild("CreDtTm", time);
headerNode.addChild("NbOfTxs", "0");
headerNode.addChild("CtrlSum", "0");
XmlNode initgPty=headerNode.addChild("InitgPty");
initgPty.addChild("Nm", gCH_curr.frn_company_name);
XmlNode id1=initgPty.addChild("Id");
XmlNode prvtId=id1.addChild("PrvtId");
XmlNode othr=prvtId.addChild("Othr");
othr.addChild("Id",gCreditor_id);
}
//DR-2-023-245 fill data with pmtinf field in XML
void create_CdtTrn_PmtInf_body(PmtInf *PmtOBj) {
DOMNode *pmtInf =PmtOBj->getPmtInf_node();
int counter = 0;
DOMNodeList *pmtChildList = pmtInf->getChildNodes();
DOMNode* node = NULL;
char s[64] = { 0 };
char ccy[4] = { 0 };
char *temp = NULL;
Arb_numeric out_num = ARB_NUMERIC_ZERO;
double e_amount = 0.0;
double s_amount = 0.0;
XMLCh *tempStr = NULL;
XmlNode pmtNode(pmtInf,cdtTrndoc);
char endtoend[99]={0};
sprintf(endtoend, "%02d%010d%03d%010d%03d%s", gTrans.tracking_id_serv,
gTrans.tracking_id, gTrans.counter, gTrans.bill_ref_no,
gTrans.bill_ref_resets, gTrans.sequence_type);
arb_num_rate(&out_num,&gTrans.amount,1,(gEur_impl_decimal - 2),gEur_round_method);
arb_numeric_to_double(&out_num,&e_amount);
sprintf(s,"%d.%02.0f",(int)e_amount/100,fmod(e_amount,100));
s_amount += atof(s);
sprintf(s, "%.2f", s_amount);
sprintf(ccy,"%d",gTrans.currency_code);
XmlNode cdtTrnTxInfNode = pmtNode.addChild("CdtTrfTxInf");
XmlNode pmtIdNode = cdtTrnTxInfNode.addChild("PmtId");
pmtIdNode.addChild("EndToEndId",endtoend);
cdtTrnTxInfNode.addChild("Amt").addChild("InstdAmt",s).addAttribute("Ccy", ccy);
}
XmlNode* ControlStatus::getXml()
{
XmlNode* control = XmlNode::createWrapperElement("control");
control->addChild(XmlNode::createDataElement("name", m_name));
control->addChild(XmlNode::createDataElement("min", friendlyValue(m_min)));
control->addChild(XmlNode::createDataElement("max", friendlyValue(m_max)));
control->addChild(XmlNode::createDataElement("current", friendlyValue(m_current)));
return control;
}
XmlNode* DomainPriority_001::getXml(UIntN domainIndex)
{
XmlNode* root = XmlNode::createWrapperElement("domain_priority");
root->addChild(getDomainPriority(Constants::Invalid, domainIndex).getXml());
root->addChild(XmlNode::createDataElement("control_knob_version", "001"));
return root;
}
XmlNode* TemperatureThresholds::getXml(void)
{
XmlNode* root = XmlNode::createWrapperElement("temperature_thresholds");
root->addChild(XmlNode::createDataElement("aux0", getAux0().toString()));
root->addChild(XmlNode::createDataElement("aux1", getAux1().toString()));
root->addChild(XmlNode::createDataElement("hysteresis", getHysteresis().toString()));
return root;
}
XmlNode* CoreControlKnob::getXml()
{
XmlNode* status = XmlNode::createWrapperElement("core_control_knob_status");
if (m_coreControl->supportsCoreControls())
{
status->addChild(m_coreControl->getStaticCapabilities().getXml());
status->addChild(m_coreControl->getStatus().getXml());
}
return status;
}
XmlNode* PixelClockControlFacade::getXml()
{
XmlNode* status = XmlNode::createWrapperElement("control_pixel_clock");
if (supportsStatus())
{
status->addChild(getPixelClockCapabilities().getXml());
status->addChild(getPixelClockDataSet().getXml());
}
return status;
}
XmlNode* ParticipantProxy::getXmlForCriticalTripPoints()
{
XmlNode* participant = XmlNode::createWrapperElement("participant");
participant->addChild(XmlNode::createDataElement("index", friendlyValue(m_index)));
participant->addChild(XmlNode::createDataElement("name", m_participantProperties.getParticipantProperties().getName()));
participant->addChild(XmlNode::createDataElement("temperature",
getDomain(0).getTemperatureProperty().getCurrentTemperature().toString()));
participant->addChild(m_criticalTripPointProperty.getXml());
return participant;
}
XmlNode* DomainPlatformPowerControl_001::createStatusNode(PlatformPowerLimitType::Type limitType)
{
XmlNode* pl = XmlNode::createWrapperElement("platform_power_limit");
pl->addChild(XmlNode::createDataElement("type", PlatformPowerLimitType::ToString(limitType)));
pl->addChild(XmlNode::createDataElement("enabled", createStatusStringForEnabled(limitType)));
pl->addChild(XmlNode::createDataElement("limit_value", createStatusStringForLimitValue(limitType)));
pl->addChild(XmlNode::createDataElement("time_window", createStatusStringForTimeWindow(limitType)));
pl->addChild(XmlNode::createDataElement("duty_cycle", createStatusStringForDutyCycle(limitType)));
return pl;
}
XmlNode* CoolingPreference::getXml() const
{
XmlNode* status = XmlNode::createWrapperElement("cooling_preference");
status->addChild(XmlNode::createDataElement(
"cooling_mode", CoolingMode::ToString(m_coolingMode)));
status->addChild(XmlNode::createDataElement(
"acoustic_limit", CoolingModeAcousticLimit::ToString(m_coolingModeAcousticLimit)));
status->addChild(XmlNode::createDataElement(
"power_limit", CoolingModePowerLimit::ToString(m_coolingModePowerLimit)));
return status;
}
int JabberSearchByAdvanced( WPARAM wParam, LPARAM lParam )
{
if ( !jabberOnline || !lParam)
return 0; //error
HWND hwndDlg=(HWND) lParam;
JabberSearchData * dat=(JabberSearchData *)GetWindowLong(hwndDlg,GWL_USERDATA);
if ( !dat )
return 0; //error
// check if server connected (at least one field exists)
if ( dat->nJSInfCount == 0 )
return 0;
// formating request
BOOL fRequestNotEmpty=FALSE;
// get server name
char szServerName[100];
GetDlgItemTextA( hwndDlg, IDC_SERVER, szServerName, sizeof( szServerName ));
// formating query
int iqId = JabberSerialNext();
XmlNodeIq iq( "set", iqId, szServerName );
XmlNode* query = iq.addChild( "query" ), *field;
iq.addAttr( "xml:lang", "en" ); //? not sure is it needed ?
query->addAttr( "xmlns", "jabber:iq:search" );
// next can be 2 cases:
// Forms: XEP-0055 Example 7
if ( dat->fSearchRequestIsXForm ) {
fRequestNotEmpty=TRUE;
query->addChild(JabberFormGetData(GetDlgItem(hwndDlg, IDC_FRAME), dat->xNode));
}
else { //and Simple fields: XEP-0055 Example 3
for ( int i=0; i<dat->nJSInfCount; i++ ) {
TCHAR szFieldValue[100];
GetWindowText(dat->pJSInf[i].hwndValueItem, szFieldValue, SIZEOF(szFieldValue));
if ( szFieldValue[0] != _T('\0')) {
char* szTemp=t2a(dat->pJSInf[i].szFieldName);
field = query->addChild( szTemp, szFieldValue );
mir_free(szTemp);
fRequestNotEmpty=TRUE;
} } }
if ( fRequestNotEmpty ) {
// register search request result handler
JabberIqAdd( iqId, IQ_PROC_GETSEARCH, JabberIqResultAdvancedSearch );
// send request
JabberSend( jabberThreadInfo->s, iq );
return iqId;
}
return 0;
}
static void InviteUser(TCHAR *room, TCHAR *pUser, TCHAR *text)
{
int iqId = JabberSerialNext();
XmlNode m( "message" ); m.addAttr( "from", jabberJID ); m.addAttr( "to", room ); m.addAttrID( iqId );
XmlNode* x = m.addChild( "x" ); x->addAttr( "xmlns", _T("http://jabber.org/protocol/muc#user"));
XmlNode* i = x->addChild( "invite" ); i->addAttr( "to", pUser );
if ( text[0] != 0 )
i->addChild( "reason", text );
JabberSend( jabberThreadInfo->s, m );
}
XmlNode* ConfigTdpControl::getXml(void)
{
XmlNode* root = XmlNode::createWrapperElement("config_tdp_control");
root->addChild(XmlNode::createDataElement("control_id", StatusFormat::friendlyValue(m_controlId)));
root->addChild(XmlNode::createDataElement("tdp_ratio", StatusFormat::friendlyValue(m_tdpRatio)));
root->addChild(XmlNode::createDataElement("tdp_power", StatusFormat::friendlyValue(m_tdpPower)));
root->addChild(XmlNode::createDataElement("tdp_frequency", StatusFormat::friendlyValue(m_tdpFrequency)));
return root;
}
XmlNode* PerformanceControlKnob::getXml()
{
XmlNode* status = XmlNode::createWrapperElement("performance_control_status");
if (m_performanceControl->supportsPerformanceControls())
{
status->addChild(XmlNode::createDataElement("type", controlTypeToString(m_controlType)));
auto dynamicCapabilities = m_performanceControl->getDynamicCapabilities();
status->addChild(dynamicCapabilities.getXml());
status->addChild(m_performanceControl->getStatus().getXml());
}
return status;
}
XmlNode* ActiveControl::getXml(void)
{
XmlNode* root = XmlNode::createWrapperElement("active_control");
root->addChild(XmlNode::createDataElement("control_id", StatusFormat::friendlyValue(m_controlId)));
root->addChild(XmlNode::createDataElement("trip_point", StatusFormat::friendlyValue(m_tripPoint)));
root->addChild(XmlNode::createDataElement("speed", StatusFormat::friendlyValue(m_speed)));
root->addChild(XmlNode::createDataElement("noise_level", StatusFormat::friendlyValue(m_noiseLevel)));
root->addChild(XmlNode::createDataElement("power", StatusFormat::friendlyValue(m_power)));
return root;
}
XmlNode* DomainDisplayControl_001::getXml(UIntN domainIndex)
{
checkAndCreateControlStructures(domainIndex);
XmlNode* root = XmlNode::createWrapperElement("display_control");
root->addChild(getDisplayControlStatus(Constants::Invalid, domainIndex).getXml());
root->addChild(m_displayControlDynamicCaps->getXml());
root->addChild(m_displayControlSet->getXml());
root->addChild(XmlNode::createDataElement("control_knob_version", "001"));
return root;
}
XmlNode* DomainPlatformPowerControl_001::getXml(UIntN domainIndex)
{
XmlNode* root = XmlNode::createWrapperElement("platform_power_control");
root->addChild(XmlNode::createDataElement("control_knob_version", "001"));
XmlNode* set = XmlNode::createWrapperElement("platform_power_limit_set");
set->addChild(createStatusNode(PlatformPowerLimitType::PSysPL1));
set->addChild(createStatusNode(PlatformPowerLimitType::PSysPL2));
set->addChild(createStatusNode(PlatformPowerLimitType::PSysPL3));
root->addChild(set);
return root;
}
XmlNode* DisplayControlKnob::getXml()
{
XmlNode* status = XmlNode::createWrapperElement("display_control_knob_status");
if (m_displayControl->supportsDisplayControls())
{
auto displayStatus = m_displayControl->getStatus();
status->addChild(displayStatus.getXml());
auto displayCapabilities = m_displayControl->getStatus();
status->addChild(displayCapabilities.getXml());
}
return status;
}
XmlNode* ParticipantProxy::getXmlForConfigTdpLevel()
{
XmlNode* status = XmlNode::createWrapperElement("participant_config_tdp_level");
status->addChild(XmlNode::createDataElement(
"participant_index", StatusFormat::friendlyValue(getIndex())));
status->addChild(XmlNode::createDataElement(
"participant_name", getParticipantProperties().getName()));
for (auto domain = m_domains.begin(); domain != m_domains.end(); domain++)
{
status->addChild(domain->second.getXmlForConfigTdpLevel());
}
return status;
}
XmlNode* DomainConfigTdpControl_001::getXml(UIntN domainIndex)
{
checkAndCreateControlStructures(domainIndex);
XmlNode* root = XmlNode::createWrapperElement("config_tdp_control");
root->addChild(m_configTdpControlDynamicCaps->getXml());
root->addChild(m_configTdpControlSet->getXml());
root->addChild(m_configTdpControlStatus->getXml());
root->addChild(XmlNode::createDataElement("control_knob_version", "001"));
return root;
}
XmlNode* DeferredWorkItemQueue::getXml(void) const
{
EsifMutexHelper esifMutexHelper(&m_mutex);
esifMutexHelper.lock();
XmlNode* deferredQueueStastics = XmlNode::createWrapperElement("deferred_queue_statistics");
deferredQueueStastics->addChild(XmlNode::createDataElement("current_count", StlOverride::to_string(m_queue.size())));
deferredQueueStastics->addChild(XmlNode::createDataElement("max_count", StlOverride::to_string(m_maxCount)));
esifMutexHelper.unlock();
return deferredQueueStastics;
}
string ActPolicy::getStatusAsXml(void) const
{
XmlNode* format = XmlNode::createComment("format_id=" + MyGuid.toString());
XmlNode* status = XmlNode::createWrapperElement("act_policy_status");
status->addChild(m_fivrDevices.getXml());
status->addChild(m_radioDevices.getXml());
status->addChild(m_pixelClockDevices.getXml());
XmlNode* root = XmlNode::createRoot();
root->addChild(format);
root->addChild(status);
string statusString = root->toString();
delete root;
return statusString;
}
string ActivePolicy::getStatusAsXml(void) const
{
XmlNode* root = XmlNode::createRoot();
XmlNode* format = XmlNode::createComment("format_id=89C3953AB8E42946A526C52C88626BAE");
root->addChild(format);
XmlNode* status = XmlNode::createWrapperElement("active_policy_status");
status->addChild(getParticipantTracker().getXmlForActiveCoolingControls());
status->addChild(getParticipantTracker().getXmlForActiveTripPoints());
status->addChild(m_art.getXml());
root->addChild(status);
string statusString = root->toString();
delete root;
return statusString;
}
XmlNode* DomainPowerControl_001::getXml(UIntN domainIndex)
{
XmlNode* root = XmlNode::createWrapperElement("power_control");
root->addChild(XmlNode::createDataElement("control_knob_version", "001"));
root->addChild(getPowerControlDynamicCapsSet(getParticipantIndex(), getDomainIndex()).getXml());
XmlNode* set = XmlNode::createWrapperElement("power_limit_set");
set->addChild(createStatusNode(PowerControlType::PL1));
set->addChild(createStatusNode(PowerControlType::PL2));
set->addChild(createStatusNode(PowerControlType::PL3));
set->addChild(createStatusNode(PowerControlType::PL4));
root->addChild(set);
return root;
}
XmlNode* DomainPowerControl_001::getXml(UIntN domainIndex)
{
initializePowerControlDynamicCapsSetIfNull(domainIndex);
XmlNode* root = XmlNode::createWrapperElement("power_control");
if (m_powerControlStatusSet != nullptr)
{
root->addChild(m_powerControlStatusSet->getXml());
}
root->addChild(m_powerControlDynamicCaps->getXml());
root->addChild(XmlNode::createDataElement("control_knob_version", "001"));
return root;
}
XmlNode *FetchData()
{
XmlNode *field = CreateNode();
for (int i = 0; i < m_field->GetValueCount(); ++i)
field->addChild("value", m_field->GetValue(i));
return field;
}
static void JabberAdminSet( const TCHAR* to, const char* ns, const char* szItem, const TCHAR* itemVal, const char* var, const TCHAR* varVal )
{
XmlNodeIq iq( "set", NOID, to );
XmlNode* query = iq.addQuery( ns );
XmlNode* item = query->addChild( "item" ); item->addAttr( szItem, itemVal ); item->addAttr( var, varVal );
JabberSend( jabberThreadInfo->s, iq );
}
void JabberFtAcceptSiRequest( filetransfer* ft )
{
if ( !jabberOnline || ft==NULL || ft->jid==NULL || ft->sid==NULL ) return;
JABBER_LIST_ITEM *item;
if (( item=JabberListAdd( LIST_FTRECV, ft->sid )) != NULL ) {
item->ft = ft;
XmlNodeIq iq( "result", ft->iqId, ft->jid );
XmlNode* si = iq.addChild( "si" ); si->addAttr( "xmlns", "http://jabber.org/protocol/si" );
XmlNode* f = si->addChild( "feature" ); f->addAttr( "xmlns", "http://jabber.org/protocol/feature-neg" );
XmlNode* x = f->addChild( "x" ); x->addAttr( "xmlns", "jabber:x:data" ); x->addAttr( "type", "submit" );
XmlNode* fl = x->addChild( "field" ); fl->addAttr( "var", "stream-method" );
fl->addChild( "value", "http://jabber.org/protocol/bytestreams" );
JabberSend( jabberThreadInfo->s, iq );
} }
