bool
ZXmlParser::SetTextValue( LPCTSTR TextValue )
{
// Nodes members
// IXMLDOMElementPtr m_CurrentNode; /* Global Member */
IXMLDOMNodePtr newNode;
// Find if a CHILD TEXT NODE exist or not
if ( m_CurrentNode == NULL )
{
if ( m_pDocRoot )
m_CurrentNode = m_pDocRoot;
else
{
m_LastError = "ZXmlParser::SetTextValue( LPCTSTR ) : Can't set a Text on a NULL Node";
return( false );
}
}
if ( IsMSXML_Node( m_CurrentNode ) == NODE_CDATA_SECTION )
{
CComVariant sValue( TextValue );
m_CurrentNode->put_nodeValue( sValue );
return( true );
}
// Rq: a NODE_CDATA_SECTION can't have any childs
if ( m_CurrentNode->hasChildNodes( ) )
{
IXMLDOMNodePtr pChild;
for( pChild = m_CurrentNode->firstChild; pChild; pChild = pChild->nextSibling )
{
// Find it's a NODE TEXT
if ( IsMSXML_Node( pChild ) == NODE_TEXT )
{
// A Text Node is found, Replace it now!!
CComVariant sValue( TextValue );
pChild->put_nodeValue( sValue );
return( true );
}
}
}
// No previous Text was defined before, we can add it.
if ( IsMSXML_Node( m_CurrentNode ) == NODE_ELEMENT )
{
// Create NODE TEXT type
CComVariant vType( MSXML2::NODE_TEXT );
// Create the node
newNode = m_plDomDocument->createTextNode( TextValue );
// Attach the Node to the document
newNode = m_CurrentNode->appendChild( newNode );
}
return( true );
}
/*!
Generate a value given an integer, using formatting defined within this class.
The formatting mainly applies if formatting as a string. For example, was is
the number base? should a sign always be included? are leading zeros requried?
The formatting could include properties related to other types. For example, generate
an error if attempting to convert a negative integer to an unsigned integer.
*/
QVariant QCaIntegerFormatting::formatValue( const long &integerValue, generic::generic_types valueType ) {
switch( valueType ) {
case generic::DOUBLE :
{
QVariant dValue( (double)integerValue );
return dValue;
}
case generic::UNSIGNED_LONG :
{
qulonglong unsignedIntegerValue;
( integerValue < 0 ) ? unsignedIntegerValue=0 : unsignedIntegerValue=integerValue;
QVariant ulValue( unsignedIntegerValue );
return ulValue;
}
case generic::STRING :
{
QString string = QString::number( integerValue, radix);
QVariant sValue( string );
return sValue;
}
case generic::UNKNOWN :
{
}
default :
{
//qDebug() << "QCaIntegerFormatting::formatValue() Unknown value 'Generic' type: " << valueType;
QVariant unknown;
return unknown;
}
}
//qDebug() << "QCaIntegerFormatting::formatValue() Unknown value 'Generic' type: " << valueType;
QVariant unknown;
return unknown;
}
/**
@brief Get a parsed value from the config file
@param cName The name of the variable in the config file
@param n The position of the value in a multivalue field.
For "MyArray 10 56 38 52 46;", GetValue<int>("MyArray", 3) will return 52. (the first value is at n=0)
**/
T GetValue(const char* cName, int n=0)const
{
std::string sValue(GetStringValue(cName)+" ");
std::string sCurrValue;
int nPos=0;
for(unsigned int i=0 ; i<sValue.size() ; i++)
{
if(sValue[i]!=' ' && sValue[i]!='\t')
{
sCurrValue+=sValue[i];
}
else
{
if(nPos==n)
{
std::stringstream ss(sCurrValue);
T a;
ss>>a;
return a;
}
else
{
sCurrValue="";
nPos++;
}
}
bool CDatabase::UpdateDictValue(std::string sKey,int nValue)
{
// CString sValue;
// sValue.Format(_T("%d"),nValue);
char buf[100]={0};
_itoa_s(nValue,buf,100,10);
std::string sValue(buf);
return UpdateDictValue(sKey,sValue);
}
void facts_parsing(bool value)
{
std::string sValue(value ? "true" : "false");
if (!g_vm.count(sValue))
return;
StringVector sv = g_vm[sValue].as<StringVector>();
for (StringVector::iterator it = sv.begin(), end = sv.end();
it != end; ++it)
prepare_fact(*it, sValue);
}
// 因版本兼容问题，本函数暂只针对COOKIE和URL做最弱过滤
const std::string CTrans::CTOH(char cValue)
{
static char MAPX[16] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };
if ((cValue >= 0 && cValue <= '\40') || cValue==';' || cValue=='=' || cValue=='%' || cValue=='?' || cValue=='&')
{
std::string sValue("%");
sValue += MAPX[(unsigned char)cValue>>4];
sValue += MAPX[cValue&0x0F];
return sValue;
}
std::string CTableCompareStream::BuildWhereClauseForKeys( const XMySQL::CResultSet &rs )
{
// Build a stream of all our keyed name=value column value pairs
std::stringstream streamFields;
streamFields << _T(" WHERE ");
UINT uFieldAddedCount = 0;
const UINT uFieldCount = rs.GetFieldCount();
for( UINT u = 0; u < uFieldCount; u++ )
{
const bool bIsPrimaryKey = rs.IsFieldPrimaryKey( u );
const bool bIsUniqueKey = rs.IsFieldUniqueKey( u );
if( bIsPrimaryKey || bIsUniqueKey )
{
const UINT uFieldType = rs.GetFieldType( u );
if( uFieldAddedCount )
{
streamFields << _T(" AND ");
}
streamFields << rs.GetFieldName( u );
streamFields << _T("=");
if( rs.IsNull( u ) )
{
streamFields << _T("NULL");
}
else
{
const char * pcszFieldValue = rs.GetFieldValue( u );
streamFields << _T("'");
if( uFieldType == MYSQL_TYPE_STRING || uFieldType == MYSQL_TYPE_VAR_STRING || uFieldType == MYSQL_TYPE_VARCHAR || uFieldType == MYSQL_TYPE_BLOB )
{
std::string sValue( pcszFieldValue );
m_mySource.EscapeString( sValue );
streamFields << sValue;
}
else
{
streamFields << pcszFieldValue;
}
streamFields << _T("'");
}
uFieldAddedCount++;
}
}
return streamFields.str();
}
void CModelReaderNode093_Object::OnAttribute(_In_z_ const nfWChar * pAttributeName, _In_z_ const nfWChar * pAttributeValue)
{
__NMRASSERT(pAttributeName);
__NMRASSERT(pAttributeValue);
if (wcscmp(pAttributeName, XML_3MF_ATTRIBUTE_OBJECT_ID) == 0) {
if (m_nID != 0)
throw CNMRException(NMR_ERROR_DUPLICATEOBJECTID);
// Convert to integer and make a input and range check!
m_nID = fnWStringToUint32(pAttributeValue);
// Increase ID to avoid 0 (was allowed for 0.9.3)
m_nID++;
}
if (wcscmp(pAttributeName, XML_3MF_ATTRIBUTE_OBJECT_TYPE) == 0) {
if (m_bHasType)
throw CNMRException(NMR_ERROR_DUPLICATEOBJECTTYPE);
// Convert to integer and make a input and range check!
std::wstring sString(pAttributeValue);
m_sType = sString;
m_bHasType = true;
}
if (wcscmp(pAttributeName, XML_3MF_ATTRIBUTE_OBJECT_NAME) == 0) {
std::wstring sValue(pAttributeValue);
m_sName = sValue;
}
if (wcscmp(pAttributeName, XML_3MF_ATTRIBUTE_TRIANGLE_COLORID) == 0) {
nfInt32 nValue = fnWStringToInt32(pAttributeValue);
if ((nValue >= 0) && (nValue < XML_3MF_MAXRESOURCEINDEX)) {
m_nColorID = nValue + 1;
}
}
if (wcscmp(pAttributeName, XML_3MF_ATTRIBUTE_TRIANGLE_MATERIALID) == 0) {
nfInt32 nValue = fnWStringToInt32(pAttributeValue);
if ((nValue >= 0) && (nValue < XML_3MF_MAXRESOURCEINDEX))
m_nMaterialID = nValue + 1;
}
}
void __fastcall TMinosChatForm::SendButtonClick( TObject */*Sender*/ )
{
// We need to send the message to all connected stations
for ( std::vector<Server>::iterator i = serverList.begin(); i != serverList.end(); i++ )
{
RPCChatControlClient rpc( 0 );
boost::shared_ptr<RPCParam>st(new RPCParamStruct);
boost::shared_ptr<RPCParam>sName(new RPCStringParam( "SendChatMessage" ));
boost::shared_ptr<RPCParam>sValue(new RPCStringParam( ChatEdit->Text.c_str() ));
st->addMember( sName, "Name" );
st->addMember( sValue, "Value" );
rpc.getCallArgs() ->addParam( st );
rpc.queueCall( "chat@" + ( (*i).name ) );
}
ChatEdit->Text = ""; // otherwise it is a pain!
ActiveControl = ChatEdit;
}
std::string CTableCompareStream::BuildWhereClauseForKeys( const CTableCompareABC::Record &rec )
{
// Build a stream of all our keyed name=value column value pairs
std::stringstream streamFields;
streamFields << _T(" WHERE ");
UINT uFieldAddedCount = 0;
for( UINT u = 0; u < rec.arrFields.size(); u++ )
{
const CTableCompareABC::Field &fld = rec.arrFields.at( u );
if( fld.bIsPrimaryKey || fld.bIsUniqueKey )
{
if( uFieldAddedCount )
{
streamFields << _T(" AND ");
}
streamFields << fld.strName;
streamFields << _T("=");
if( fld.bIsNull )
{
streamFields << _T("NULL");
}
else
{
streamFields << _T("'");
if( fld.uType == MYSQL_TYPE_STRING || fld.uType == MYSQL_TYPE_VAR_STRING || fld.uType == MYSQL_TYPE_VARCHAR || fld.uType == MYSQL_TYPE_BLOB )
{
std::string sValue( fld.strValue );
m_mySource.EscapeString( sValue );
streamFields << sValue;
}
else
{
streamFields << fld.strValue;
}
streamFields << _T("'");
}
uFieldAddedCount++;
}
}
return streamFields.str();
}
std::string CTableCompareStream::BuildDifferentFieldValues( const CTableCompareABC::Record &rec )
{
// Build a stream of all our name=value column value pairs
std::stringstream streamFields;
for( UINT u = 1; u < rec.arrFields.size(); u++ ) // first field is always KeyHash field so skip past it
{
const CTableCompareABC::Field &fld = rec.arrFields.at( u );
if( !fld.bIsDifferent )
{
continue;
}
if( streamFields.str().size() )
{
streamFields << _T(",");
}
streamFields << fld.strName;
streamFields << _T("=");
if( fld.bIsNull )
{
streamFields << _T("NULL");
}
else
{
streamFields << _T("'");
if( fld.uType == MYSQL_TYPE_STRING || fld.uType == MYSQL_TYPE_VAR_STRING || fld.uType == MYSQL_TYPE_VARCHAR || fld.uType == MYSQL_TYPE_BLOB )
{
std::string sValue( fld.strValue );
m_mySource.EscapeString( sValue );
streamFields << sValue;
}
else
{
streamFields << fld.strValue;
}
streamFields << _T("'");
}
}
return streamFields.str();
}
void CModelReaderNode093_Color::OnAttribute(_In_z_ const nfWChar * pAttributeName, _In_z_ const nfWChar * pAttributeValue)
{
__NMRASSERT(pAttributeName);
__NMRASSERT(pAttributeValue);
if (wcscmp(pAttributeName, XML_3MF_ATTRIBUTE_COLOR_VALUE) == 0) {
std::wstring sValue(pAttributeValue);
m_sColorString = sValue;
}
if (wcscmp(pAttributeName, XML_3MF_ATTRIBUTE_COLOR_ID) == 0) {
if (m_nResourceID != 0)
throw CNMRException(NMR_ERROR_DUPLICATECOLORID);
// Convert to integer and make a input and range check!
m_nResourceID = fnWStringToUint32(pAttributeValue);
m_nResourceID++;
}
}
CStdString RegUtils::GetStringValueFromRegistry(const HKEY& hKey, const CStdString& sValueName)
{
_variant_t vtValue;
if (!GetValueFromRegistry(hKey, sValueName, vtValue))
{
LOG_WS_ERROR(_T("Unable to get value from registry"));
return _T("");
}
if (vtValue.vt != VT_BSTR)
{
LOG_WS_ERROR(_T("Unexpected type returned from the registry"));
return _T("");
}
CStdString sValue(vtValue.bstrVal);
return sValue;
}
//按照给定的格式将制定的值格式化为字符串
string CCardField::FormatValue(string value) const
{
if(value.empty())
return value;
int nWid = nEnd - nStart + 1;//字段宽度（字符数）
if(sFormat.empty())
{
if(value.size() > nWid)
value = value.substr(0,nWid);
return value;
}
string sTp = sFormat.substr(1,sFormat.size()-1);
char buffer[255];
string sFor = GetFormatString();
if (sFormat[0] == 'I')//I2
{
int iVal = std::atoi(value.c_str());
if(iVal == 0)
return "";//如果实例值是0，返回""
else
sprintf(buffer, sFor.c_str(), iVal);
}
else if (sFormat[0] == 'F')//F4.3
{
double bVal = std::atof(value.c_str());
if (bVal > -0.000001f && bVal < 0.000001f)
return "";//如果实例值是0，返回""
else
sprintf(buffer, sFor.c_str(), bVal);
}
else if (sFormat[0] == 'A')//A4
{
sprintf(buffer, sFor.c_str(), value.c_str());
}
string sValue(buffer);
if(sValue.size() > nWid)
sValue = sValue.substr(0,nWid);
return sValue;
}
string TrackerConfig::getParam(const string& sXPathExpr) const
{
xmlXPathObjectPtr xpElement = findConfigNodes(sXPathExpr);
xmlNodeSetPtr nodes = xpElement->nodesetval;
if (!nodes || nodes->nodeNr == 0) {
throw (Exception(AVG_ERR_OPTION_UNKNOWN,
string("getParam(): cannot find requested element ")+sXPathExpr));
} else if (nodes->nodeNr > 1) {
AVG_LOG_WARNING(
"getParam(): expression selects more than one node. Returning the first.");
}
xmlChar* xsRc = xmlNodeGetContent(nodes->nodeTab[0]);
string sValue((char *)xsRc);
xmlFree(xsRc);
xmlXPathFreeObject(xpElement);
return sValue;
}
bool set_chanel_freq_rate (uint8_t channel, uint8_t band,uint8_t bitrate){
printf("Channel amoutn %d, chanel %d",chanelAmount(band, bitrate),channel);
if (channel >= chanelAmount(band, bitrate)) {
//errstate invalid_chanel_freq_rate;
return false;
}
//Program registers R, P, S and Synthesize the RF
PHY_STORAGE.channel=channel;
PHY_STORAGE.band=band;
PHY_STORAGE.bitrate=bitrate;
D_PHY printf("Chanel %d band %d bitrate %d\n", channel, band, bitrate);
set_register(R1CNTREG, rValue());
set_register(P1CNTREG, pValue(band, channel, bitrate));
set_register(S1CNTREG, sValue(band, channel, bitrate));
return true;
}
CStdString RegistryUtils::GetStringValueFromRegistry(const HKEY& hKey, const CStdString& sValueName)
{
if (sValueName.IsEmpty())
{
return _T("");
}
_variant_t vtValue;
if (!GetValueFromRegistry(hKey, sValueName, vtValue))
{
return _T("");
}
if (vtValue.vt != VT_BSTR)
{
return _T("");
}
CStdString sValue(vtValue.bstrVal);
return sValue;
}
const TCHAR * CXmlParser::ParseTag(CXmlNode& Node, TCHAR * pStart, const TCHAR * pEnd)
{
while (pStart < pEnd)
{
// Ищем начало открывающего тэга
const TCHAR * itStartTag = std::find(static_cast< const TCHAR * > (pStart), pEnd, '<');
const TCHAR * itStartTagName = std::find_if(itStartTag, pEnd, boost::algorithm::is_alnum());
// Нашли закрывающий тэг
if (itStartTag == itStartTagName || *(itStartTag + 1) == '/')
return std::find(const_cast< const TCHAR * > (pStart), pEnd, '>') + 1;
// Ищем окончание открывающего тэга
const TCHAR * itEndOpenTag = std::find(itStartTag, pEnd, '>');
// Ищем имя тэга
const TCHAR * itEndName = std::find_if(itStartTagName, itEndOpenTag, !boost::algorithm::is_alnum());
_tstring sTagName = _tstring(itStartTagName, itEndName);
Node.Data[TAG_NAME] = sTagName;
// Ищем тип тэга (?, <--)
_tstring sTagType = _tstring(itStartTag + 1, itStartTagName);
//Находим все атрибуты тэга
_tstring sTagData(itStartTagName, itEndOpenTag);
if (!sTagType.empty())
// Удаляем тип тэга из строки атрибутов
boost::algorithm::replace_all(sTagData, sTagType, "");
GetTagAttributes(Node, sTagData);
/*if (!sTagType.empty())
{
std::find(const_cast< const TCHAR * > (pStart), pEnd, '>') + 1;
}*/
// У тэга нет значения и вложенных тэгов
if (*(itEndOpenTag - 1) == '/')
{
return itEndOpenTag + 1;
}
else
{
// Ищем вложенные узлы
pStart = const_cast< TCHAR * > (std::find(itStartTagName, pEnd, '>'));
while (true)
{
// Находим вложенные узлы и добавляем в Childs
CXmlNode Child;
pStart = const_cast< TCHAR * > (ParseTag(Child, pStart, pEnd));
if (!Child.Data.empty())
Node.Childs.push_back(Child);
if (pStart >= pEnd)
break;
// Ищем закрывающий тэг </tag_name>
TCHAR * itTagEnd = 0;
while (true)
{
itTagEnd = const_cast< TCHAR * > (std::find(static_cast< const TCHAR * > (pStart), pEnd, '/'));
if (*(itTagEnd - 1) == '<' || itTagEnd >= pEnd)
break;
}
const TCHAR * itCloseTagNameEnd = std::find(static_cast< const TCHAR * > (itTagEnd), pEnd, '>');
_tstring sCloseTagName;
if (itTagEnd < itCloseTagNameEnd)
sCloseTagName.assign(itTagEnd + 1, itCloseTagNameEnd);
if (!sCloseTagName.empty() && sCloseTagName == sTagName)
{
_tstring sValue(pStart, itTagEnd - 1);
if (!sValue.empty() && sValue != _T("\n"))
Node.Data[TAG_VALUE] = sValue;
break;
}
}
}
}
return pEnd;
}
// wrapper for ldap_get_values()
//
NS_IMETHODIMP
nsLDAPMessage::GetValues(const char *aAttr, PRUint32 *aCount,
PRUnichar ***aValues)
{
char **values;
#if defined(DEBUG)
// We only want this being logged for debug builds so as not to affect performance too much.
PR_LOG(gLDAPLogModule, PR_LOG_DEBUG,
("nsLDAPMessage::GetValues(): called with aAttr = '%s'", aAttr));
#endif
values = ldap_get_values(mConnectionHandle, mMsgHandle, aAttr);
// bail out if there was a problem
//
if (!values) {
PRInt32 lderrno = ldap_get_lderrno(mConnectionHandle, 0, 0);
if ( lderrno == LDAP_DECODING_ERROR ) {
// this may not be an error; it could just be that the
// caller has asked for an attribute that doesn't exist.
//
PR_LOG(gLDAPLogModule, PR_LOG_WARNING,
("nsLDAPMessage::GetValues(): ldap_get_values returned "
"LDAP_DECODING_ERROR"));
return NS_ERROR_LDAP_DECODING_ERROR;
} else if ( lderrno == LDAP_PARAM_ERROR ) {
NS_ERROR("nsLDAPMessage::GetValues(): internal error: 1");
return NS_ERROR_UNEXPECTED;
} else {
NS_ERROR("nsLDAPMessage::GetValues(): internal error: 2");
return NS_ERROR_UNEXPECTED;
}
}
// count the values
//
PRUint32 numVals = ldap_count_values(values);
// create an array of the appropriate size
//
*aValues = static_cast<PRUnichar **>(nsMemory::Alloc(numVals * sizeof(PRUnichar *)));
if (!*aValues) {
ldap_value_free(values);
return NS_ERROR_OUT_OF_MEMORY;
}
// clone the array (except for the trailing NULL entry) using the
// shared allocator for XPCOM correctness
//
PRUint32 i;
for ( i = 0 ; i < numVals ; i++ ) {
nsDependentCString sValue(values[i]);
if (IsUTF8(sValue))
(*aValues)[i] = ToNewUnicode(NS_ConvertUTF8toUTF16(sValue));
else
(*aValues)[i] = ToNewUnicode(NS_ConvertASCIItoUTF16(sValue));
if ( ! (*aValues)[i] ) {
NS_FREE_XPCOM_ALLOCATED_POINTER_ARRAY(i, aValues);
ldap_value_free(values);
return NS_ERROR_OUT_OF_MEMORY;
}
}
// now free our value array since we already cloned the values array
// to the 'aValues' results array.
ldap_value_free(values);
*aCount = numVals;
return NS_OK;
}
ret_ CXMLLoaderActions::LoadDataBlock(CData &Data,
const DOMElement *pElement)
{
#ifdef _DEBUG_
if (!pElement)
return PARAMETER_NULL | PARAMETER_2;
#endif
DOMElement *pChild = (DOMElement *)pElement->getFirstChild();
if (!pChild)
return XML_LOADER_ERROR;
auto_xerces_str wsObject ("v_object");
auto_xerces_str wsB1 ("v_b_1");
auto_xerces_str wsUB1 ("v_ub_1");
auto_xerces_str wsB2 ("v_b_2");
auto_xerces_str wsUB2 ("v_ub_2");
auto_xerces_str wsB4 ("v_b_4");
auto_xerces_str wsUB4 ("v_ub_4");
auto_xerces_str wsB8 ("v_b_8");
auto_xerces_str wsUB8 ("v_ub_8");
auto_xerces_str wsFB4 ("v_fb_4");
auto_xerces_str wsFB8 ("v_fb_8");
auto_xerces_str wsString ("v_string");
auto_xerces_str wsGroup ("v_group");
auto_xerces_str wsName ("name");
auto_xerces_str wsValue ("value");
while (pChild)
{
if (0 == XMLString::compareString(pChild->getNodeName(), wsObject))
{
auto_xerces_str sName (pChild->getAttribute(wsName));
auto_xerces_str sValue (pChild->getAttribute(wsValue));
if (false_v == Data.Define(sName, (obj_)null_v))
return XML_LOADER_ERROR;
}
else if (0 == XMLString::compareString(pChild->getNodeName(), wsB1))
{
auto_xerces_str sName (pChild->getAttribute(wsName));
auto_xerces_str sValue (pChild->getAttribute(wsValue));
if (0 == strcmp(sValue, SIGN_UNBOUNDED))
{
if (false_v == Data.Define(sName, B_1))
return XML_LOADER_ERROR;
}
else
{
if (false_v == Data.Define(sName, B_1, (b_4)atoi(sValue)))
return XML_LOADER_ERROR;
}
}
else if (0 == XMLString::compareString(pChild->getNodeName(), wsUB1))
{
auto_xerces_str sName (pChild->getAttribute(wsName));
auto_xerces_str sValue (pChild->getAttribute(wsValue));
if (0 == strcmp(sValue, SIGN_UNBOUNDED))
{
if (false_v == Data.Define(sName, UB_1))
return XML_LOADER_ERROR;
}
else
{
if (false_v == Data.Define(sName, UB_1, (b_4)atoi(sValue)))
return XML_LOADER_ERROR;
}
}
else if (0 == XMLString::compareString(pChild->getNodeName(), wsB2))
{
auto_xerces_str sName (pChild->getAttribute(wsName));
auto_xerces_str sValue (pChild->getAttribute(wsValue));
if (0 == strcmp(sValue, SIGN_UNBOUNDED))
{
if (false_v == Data.Define(sName, B_2))
return XML_LOADER_ERROR;
}
else
{
if (false_v == Data.Define(sName, B_2, (b_4)atoi(sValue)))
return XML_LOADER_ERROR;
}
}
else if (0 == XMLString::compareString(pChild->getNodeName(), wsUB2))
{
auto_xerces_str sName (pChild->getAttribute(wsName));
auto_xerces_str sValue (pChild->getAttribute(wsValue));
if (0 == strcmp(sValue, SIGN_UNBOUNDED))
{
if (false_v == Data.Define(sName, UB_2))
return XML_LOADER_ERROR;
}
else
{
if (false_v == Data.Define(sName, UB_2, (b_4)atoi(sValue)))
return XML_LOADER_ERROR;
}
}
else if (0 == XMLString::compareString(pChild->getNodeName(), wsB4))
{
auto_xerces_str sName (pChild->getAttribute(wsName));
auto_xerces_str sValue (pChild->getAttribute(wsValue));
if (0 == strcmp(sValue, SIGN_UNBOUNDED))
{
if (false_v == Data.Define(sName, B_4))
return XML_LOADER_ERROR;
}
else
{
if (false_v == Data.Define(sName, B_4, (b_4)atoi(sValue)))
return XML_LOADER_ERROR;
}
}
else if (0 == XMLString::compareString(pChild->getNodeName(), wsUB4))
{
auto_xerces_str sName (pChild->getAttribute(wsName));
auto_xerces_str sValue (pChild->getAttribute(wsValue));
if (0 == strcmp(sValue, SIGN_UNBOUNDED))
{
if (false_v == Data.Define(sName, UB_4))
return XML_LOADER_ERROR;
}
else
{
if (false_v == Data.Define(sName, UB_4, (b_4)atoi(sValue)))
return XML_LOADER_ERROR;
}
}
else if (0 == XMLString::compareString(pChild->getNodeName(), wsB8))
{
auto_xerces_str sName (pChild->getAttribute(wsName));
auto_xerces_str sValue (pChild->getAttribute(wsValue));
if (0 == strcmp(sValue, SIGN_UNBOUNDED))
{
if (false_v == Data.Define(sName, B_8))
return XML_LOADER_ERROR;
}
else
{
if (false_v == Data.Define(sName, B_8, (b_8)atoll(sValue)))
return XML_LOADER_ERROR;
}
}
else if (0 == XMLString::compareString(pChild->getNodeName(), wsUB8))
{
auto_xerces_str sName (pChild->getAttribute(wsName));
auto_xerces_str sValue (pChild->getAttribute(wsValue));
if (0 == strcmp(sValue, SIGN_UNBOUNDED))
{
if (false_v == Data.Define(sName, UB_8))
return XML_LOADER_ERROR;
}
else
{
if (false_v == Data.Define(sName, UB_8, (ub_8)atoll(sValue)))
return XML_LOADER_ERROR;
}
}
else if (0 == XMLString::compareString(pChild->getNodeName(), wsFB4))
{
auto_xerces_str sName (pChild->getAttribute(wsName));
auto_xerces_str sValue (pChild->getAttribute(wsValue));
if (0 == strcmp(sValue, SIGN_UNBOUNDED))
{
if (false_v == Data.Define(sName, FB_4))
return XML_LOADER_ERROR;
}
else
{
if (false_v == Data.Define(sName, (fb_4)atof(sValue)))
return XML_LOADER_ERROR;
}
}
else if (0 == XMLString::compareString(pChild->getNodeName(), wsFB8))
{
auto_xerces_str sName (pChild->getAttribute(wsName));
auto_xerces_str sValue (pChild->getAttribute(wsValue));
if (0 == strcmp(sValue, SIGN_UNBOUNDED))
{
if (false_v == Data.Define(sName, FB_8))
return XML_LOADER_ERROR;
}
else
{
if (false_v == Data.Define(sName, (fb_8)atof(sValue)))
return XML_LOADER_ERROR;
}
}
else if (0 == XMLString::compareString(pChild->getNodeName(), wsString))
{
auto_xerces_str sName (pChild->getAttribute(wsName));
auto_xerces_str sValue (pChild->getAttribute(wsValue));
if (0 == strcmp(sValue, SIGN_UNBOUNDED))
{
if (false_v == Data.Define(sName, (ch_1 *)""))
return XML_LOADER_ERROR;
}
else
{
if (false_v == Data.Define(sName, sValue))
return XML_LOADER_ERROR;
}
}
else if (0 == XMLString::compareString(pChild->getNodeName(), wsGroup))
{
auto_xerces_str wsNormal("normal");
auto_xerces_str wsFloat ("float");
auto_xerces_str wsString("string");
auto_xerces_str wsName ("name");
auto_xerces_str wsLength("length");
auto_xerces_str wsSigned("signed");
auto_xerces_str wsSize ("size");
auto_xerces_str sName (pChild->getAttribute(wsName));
auto_xerces_str sSize (pChild->getAttribute(wsSize));
CFieldGroupDefined *pGroupField = new CFieldGroupDefined(
sName,
sSize);
DOMElement *pSub = (DOMElement *)pChild->getFirstChild();
if (!pSub)
return XML_LOADER_ERROR;
while (pSub)
{
if (0 == XMLString::compareString(pSub->getNodeName(),
wsNormal))
{
auto_xerces_str sName (pElement->getAttribute(wsName));
auto_xerces_str sLength(pElement->getAttribute(wsLength));
auto_xerces_str sSigned(pElement->getAttribute(wsSigned));
EFieldType Type;
GetFieldType(
FIELD_NORMAL_STYLE,
atoi(sLength),
0 == strcmp(sSigned, "true") ? true_v : false_v,
Type);
CFieldNumber *pField = new CFieldNumber(sName,
Type,
pGroupField);
pGroupField->SetSubField(pField);
}
else if (0 == XMLString::compareString(pSub->getNodeName(),
wsFloat))
{
auto_xerces_str sName (pElement->getAttribute(wsName));
auto_xerces_str sLength(pElement->getAttribute(wsLength));
EFieldType Type;
GetFieldType(FIELD_FLOAT_STYLE,
atoi(sLength),
false_v,
Type);
CFieldNumber *pField = new CFieldNumber(sName,
Type,
pGroupField);
pGroupField->SetSubField(pField);
}
else if (0 == XMLString::compareString(pSub->getNodeName(),
wsString))
{
auto_xerces_str sName (pElement->getAttribute(wsName));
auto_xerces_str sLength(pElement->getAttribute(wsLength));
auto_xerces_str sSize(pElement->getAttribute(wsSize));
CFieldString *pField = new CFieldString(sName,
atoi(sSize),
pGroupField);
pGroupField->SetSubField(pField);
}
pSub = (DOMElement *)pSub->getNextSibling();
}
if (false_v == Data.Define(pGroupField))
return XML_LOADER_ERROR;
}
pChild = (DOMElement *)pChild->getNextSibling();
}
return SUCCESS;
}
bool Settings::TSettingsGroup::ItlReadGroupFromXML(TiXmlElement *pElement)
{
// flag to show if everything was fine
bool bOk = true;
// get first child element
TiXmlElement* pChildElement = pElement->FirstChildElement();
// if element has no children, return with success
if (pChildElement == NULL)
return true;
do
{
// make sure that we got a valid pointer
assert (pChildElement != NULL);
// get tag name
std::string sTagName(pChildElement->Value());
// if it is a <group> tag ...
if (sTagName.compare("group")==0)
{
std::string sName;
// get name of group
pChildElement->QueryStringAttribute("name", &sName);
// check if group has a valid name
bOk = (sName.length() > 0);
assert (bOk);
// if everything was fine, read group from xml element
if (bOk)
bOk = GetGroup(sName)->ItlReadGroupFromXML(pChildElement);
assert (bOk);
}
// else, if it is a <value> tag ...
else if (sTagName.compare("value")==0)
{
std::string sName;
std::string sType;
// get name attribute
pChildElement->QueryStringAttribute("name", &sName);
// get type attribute
pChildElement->QueryStringAttribute("type", &sType);
// check if the values are valid
bOk &= (sName.length() > 0);
bOk &= (sType.length() > 0);
assert (bOk);
// get inner value of the tag (<xy>I_MEAN_THIS_TEXT</xy>)
const char *szValue = pChildElement->GetText();
// make sure that we got a valid pointer
if (szValue != NULL)
{
// convert to stl string
std::string sValue(szValue);
// parse value (and store in group)
bOk = ItlParseValue(sName, sType, sValue);
}
else // something went wrong
bOk = false;
assert (bOk);
}
else
{
assert (!"unknown entity");
bOk = false;
}
}
while (bOk && (pChildElement = pChildElement->NextSiblingElement()));
return bOk;
}
/*
Generate a value given a floating point number, using formatting defined within this class.
The formatting mainly applies if formatting as a string. For example, was is
the number base? should a sign always be included? are leading zeros requried?
The formatting could include properties related to other types. For example, generate
an error if attempting to convert a negative floating point number to an unsigned integer.
*/
QVariant QEFloatingFormatting::formatValue( const double &floatingValue, generic::generic_types valueType ) {
switch( valueType ) {
case generic::GENERIC_DOUBLE :
case generic::GENERIC_FLOAT :
{
QVariant dValue( floatingValue );
return dValue;
}
case generic::GENERIC_LONG :
{
qlonglong integerValue;
if( floatingValue < (double)LONG_MIN )
integerValue = LONG_MIN;
else if( floatingValue > (double)LONG_MAX )
integerValue = LONG_MAX;
else
integerValue = (qlonglong)floatingValue;
QVariant lValue( integerValue );
return lValue;
}
case generic::GENERIC_SHORT :
{
qlonglong integerValue;
if( floatingValue < (double)SHRT_MIN )
integerValue = SHRT_MIN;
else if( floatingValue > (double)SHRT_MAX )
integerValue = SHRT_MAX;
else
integerValue = (qlonglong)floatingValue;
QVariant lValue( integerValue );
return lValue;
}
case generic::GENERIC_UNSIGNED_LONG :
{
qulonglong unsignedIntegerValue;
if( floatingValue < 0 )
unsignedIntegerValue = 0;
else if( floatingValue > (double)ULONG_MAX )
unsignedIntegerValue = ULONG_MAX;
else
unsignedIntegerValue = (qulonglong)floatingValue;
QVariant ulValue( unsignedIntegerValue );
return ulValue;
}
case generic::GENERIC_UNSIGNED_SHORT :
{
qulonglong unsignedIntegerValue;
if( floatingValue < 0 )
unsignedIntegerValue = 0;
else if( floatingValue > (double)USHRT_MAX )
unsignedIntegerValue = USHRT_MAX;
else
unsignedIntegerValue = (qulonglong)floatingValue;
QVariant ulValue( unsignedIntegerValue );
return ulValue;
}
case generic::GENERIC_UNSIGNED_CHAR :
{
qulonglong unsignedIntegerValue;
if( floatingValue < 0 )
unsignedIntegerValue = 0;
else if( floatingValue > (double)UCHAR_MAX )
unsignedIntegerValue = UCHAR_MAX;
else
unsignedIntegerValue = (qulonglong)floatingValue;
QVariant ulValue( unsignedIntegerValue );
return ulValue;
}
case generic::GENERIC_STRING :
{
QString string = QString::number( floatingValue, getFormatChar(), precision );
QVariant sValue( string );
return sValue;
}
case generic::GENERIC_UNKNOWN :
{
}
default :
{
//qDebug() << "QEFloatingFormatting::formatValue() Unknown value 'Generic' type: " << valueType;
QVariant unknown;
return unknown;
}
}
//qDebug() << "QEFloatingFormatting::formatValue() Unknown value 'Generic' type: " << valueType;
QVariant unknown;
return unknown;
}
CWideString RTFuserprops::GetOriginalSource()
{
CWideString sValue("");
FindProp( DELTAVIEW_ORIGINAL_SOURCE, NULL, &sValue );
return sValue;
}
void Settings::TSettingsGroup::SetValue(std::string sName, const char * szValue)
{
std::string sValue(szValue);
SetValue(sName, sValue);
}
CWideString RTFuserprops::GetDateSent()
{
CWideString sValue("");
FindProp( DELTAVIEW_DATESENT, NULL, &sValue );
return sValue;
}
CWideString RTFuserprops::GetDeltaViewFileSender()
{
CWideString sValue("");
FindProp( DELTAVIEW_SENDER, NULL, &sValue );
return sValue;
}
// virtual
CXMLHandler * ParameterHandler::processStart(const XML_Char * pszName,
const XML_Char ** papszAttrs)
{
CXMLHandler * pHandlerToCall = NULL;
const char * cValue = NULL;
const char * cType = NULL;
std::string name;
std::string sValue("");
bool UnmappedKey = false;
void * pValue = NULL;
CCopasiParameter::Type type;
C_FLOAT64 d;
C_INT32 i;
size_t ui;
bool b;
switch (mCurrentElement.first)
{
case Parameter:
// Parameter has attributes name, type and value
name = mpParser->getAttributeValue("name", papszAttrs);
cType = mpParser->getAttributeValue("type", papszAttrs);
type = toEnum(cType, CCopasiParameter::XMLType, CCopasiParameter::INVALID);
cValue = mpParser->getAttributeValue("value", papszAttrs);
if (cValue != NULL)
{
sValue = cValue;
}
switch (type)
{
case CCopasiParameter::DOUBLE:
d = CCopasiXMLInterface::DBL(sValue.c_str());
pValue = &d;
break;
case CCopasiParameter::UDOUBLE:
d = CCopasiXMLInterface::DBL(sValue.c_str());
pValue = &d;
break;
case CCopasiParameter::INT:
i = strToInt(sValue.c_str());
pValue = &i;
break;
case CCopasiParameter::UINT:
ui = strToUnsignedInt(sValue.c_str());
pValue = &ui;
break;
case CCopasiParameter::BOOL:
if (sValue == "0" || sValue == "false")
{
b = false;
}
else
{
b = true;
}
pValue = &b;
break;
case CCopasiParameter::STRING:
case CCopasiParameter::FILE:
case CCopasiParameter::CN:
pValue = &sValue;
break;
case CCopasiParameter::KEY:
{
if (sValue != "" &&
CKeyFactory::isValidKey(sValue))
{
CCopasiObject * pObject = mpData->mKeyMap.get(sValue);
if (pObject)
{
sValue = pObject->getKey();
}
else
{
UnmappedKey = true;
}
}
pValue = &sValue;
}
break;
default:
CCopasiMessage(CCopasiMessage::ERROR, MCXML + 16, name.c_str(), cType, mpParser->getCurrentLineNumber());
pValue = NULL;
break;
}
mpData->pCurrentParameter = new CCopasiParameter(name, type, pValue);
if (UnmappedKey)
{
mpData->UnmappedKeyParameters.push_back(mpData->pCurrentParameter->getKey());
}
break;
default:
CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 2,
mpParser->getCurrentLineNumber(), mpParser->getCurrentColumnNumber(), pszName);
break;
}
return pHandlerToCall;
}
CWideString RTFuserprops::GetModifiedSource()
{
CWideString sValue("");
FindProp( DELTAVIEW_MODIFIED_SOURCE, NULL, &sValue );
return sValue;
}
void CNumEdit::OnUpdate()
{
if (! myRejectingChange)
{
bool isneg = false;
CString aValue;
GetWindowText(aValue);
if (aValue == "")
{
aValue = "1";
//myRejectingChange = true;
SetWindowText(aValue);
//myRejectingChange = false;
SetSel(-1);
return;
}
else if (aValue != "0")
{
// remove leading 0
std::string sValue(aValue);
int nz = sValue.find_first_not_of('0');
sValue.erase(0, nz);
aValue = sValue.c_str();
if (nz > 0)
{
//myRejectingChange = true;
SetWindowText(aValue);
//myRejectingChange = false;
SetSel(myLastSel);
return;
}
}
LPTSTR aEndPtr;
union
{
long aLongValue;
double aDoubleValue;
};
errno = 0;
switch (myType)
{
case TypeLong:
aLongValue = _tcstol(aValue, &aEndPtr, 10);
if (aLongValue < 1 && blockneg)
isneg = true;
break;
case TypeDouble:
aDoubleValue = _tcstod(aValue, &aEndPtr);
if (aDoubleValue < 1 && blockneg)
isneg = true;
break;
}
if ((!(*aEndPtr)) && (errno != ERANGE) && (!isneg))
{
myLastValidValue = aValue;
}
else
{
myRejectingChange = true;
SetWindowText(myLastValidValue);
myRejectingChange = false;
SetSel(myLastSel);
}
}
}
void CModelReaderNode093_Triangle::OnAttribute(_In_z_ const nfWChar * pAttributeName, _In_z_ const nfWChar * pAttributeValue)
{
__NMRASSERT(pAttributeName);
__NMRASSERT(pAttributeValue);
nfInt32 nValue;
if (wcscmp(pAttributeName, XML_3MF_ATTRIBUTE_TRIANGLE_V1) == 0) {
nValue = fnWStringToInt32(pAttributeValue);
if ((nValue >= 0) && (nValue < XML_3MF_MAXRESOURCEINDEX))
m_nIndex1 = nValue;
}
if (wcscmp(pAttributeName, XML_3MF_ATTRIBUTE_TRIANGLE_V2) == 0) {
nValue = fnWStringToInt32(pAttributeValue);
if ((nValue >= 0) && (nValue < XML_3MF_MAXRESOURCEINDEX))
m_nIndex2 = nValue;
}
if (wcscmp(pAttributeName, XML_3MF_ATTRIBUTE_TRIANGLE_V3) == 0) {
nValue = fnWStringToInt32(pAttributeValue);
if ((nValue >= 0) && (nValue < XML_3MF_MAXRESOURCEINDEX))
m_nIndex3 = nValue;
}
if (wcscmp(pAttributeName, XML_3MF_ATTRIBUTE_TRIANGLE_CV1) == 0) {
nValue = fnWStringToInt32(pAttributeValue);
if ((nValue >= 0) && (nValue < XML_3MF_MAXRESOURCEINDEX))
m_nTextureIndex1 = nValue;
}
if (wcscmp(pAttributeName, XML_3MF_ATTRIBUTE_TRIANGLE_CV2) == 0) {
nValue = fnWStringToInt32(pAttributeValue);
if ((nValue >= 0) && (nValue < XML_3MF_MAXRESOURCEINDEX))
m_nTextureIndex2 = nValue;
}
if (wcscmp(pAttributeName, XML_3MF_ATTRIBUTE_TRIANGLE_CV3) == 0) {
nValue = fnWStringToInt32(pAttributeValue);
if ((nValue >= 0) && (nValue < XML_3MF_MAXRESOURCEINDEX))
m_nTextureIndex3 = nValue;
}
if (wcscmp(pAttributeName, XML_3MF_ATTRIBUTE_TRIANGLE_COLORID) == 0) {
std::wstring sValue(pAttributeValue);
std::wstring sSubStr = sValue.substr(0, 4);
if (sSubStr == L"tex(") {
if (sValue.length() > 4) {
std::wstring sTexID = sValue.substr(4, sValue.length() - sSubStr.length() - 1);
nfInt32 nValue = fnWStringToInt32(sTexID.c_str());
if ((nValue < 0) || (nValue >= XML_3MF_MAXRESOURCEINDEX))
throw CNMRException(NMR_ERROR_INVALIDTEXTUREREFERENCE);
m_nTextureID = nValue + 1;
}
else {
throw CNMRException(NMR_ERROR_INVALIDTEXTUREREFERENCE);
}
}
else {
const wchar_t * pCommaValue = wcschr(pAttributeValue, L',');
// Check, if we have a single value
if (pCommaValue == nullptr) {
nValue = fnWStringToInt32(pAttributeValue);
if ((nValue >= 0) && (nValue < XML_3MF_MAXRESOURCEINDEX)) {
m_nColorID1 = nValue + 1;
m_nColorID2 = nValue + 1;
m_nColorID3 = nValue + 1;
}
}
else {
// Check, if we have a color triplet
nfInt32 nColorID1 = -1;
nfInt32 nColorID2 = -1;
nfInt32 nColorID3 = -1;
fnStringToCommaSeparatedIntegerTriplet(pAttributeValue, nColorID1, nColorID2, nColorID3);
if ((nColorID1 >= 0) && (nColorID1 < XML_3MF_MAXRESOURCEINDEX))
m_nColorID1 = nColorID1 + 1;
if ((nColorID2 >= 0) && (nColorID2 < XML_3MF_MAXRESOURCEINDEX))
m_nColorID2 = nColorID2 + 1;
if ((nColorID3 >= 0) && (nColorID3 < XML_3MF_MAXRESOURCEINDEX))
m_nColorID3 = nColorID3 + 1;
}
}
}
if (wcscmp(pAttributeName, XML_3MF_ATTRIBUTE_TRIANGLE_MATERIALID) == 0) {
nValue = fnWStringToInt32(pAttributeValue);
if ((nValue >= 0) && (nValue < XML_3MF_MAXRESOURCEINDEX))
m_nMaterialID = nValue + 1;
}
}
