/// calls IDispatch methods
virtual HRESULT STDMETHODCALLTYPE Invoke(
DISPID dispid, REFIID /*riid*/, LCID /*lcid*/, WORD wFlags,
DISPPARAMS* pDispParams, VARIANT* /*pVarResult*/,
EXCEPINFO* /*pExcepInfo*/, UINT* /*puArgErr*/) override
{
if (dispid == c_uiExternalStateId)
{
CComVariant varValue(*pDispParams->rgvarg);
if (wFlags == DISPATCH_PROPERTYPUT)
{
T* pT = static_cast<T*>(this);
pT->OnChangedState(varValue.intVal);
}
return S_OK;
}
if (dispid == c_uiExternalErrorId)
{
CComVariant varValue(*pDispParams->rgvarg);
if (wFlags == DISPATCH_PROPERTYPUT)
{
T* pT = static_cast<T*>(this);
pT->OnPlayerError(varValue.intVal);
}
return S_OK;
}
return E_FAIL;
}
void ColorAspect::ShowValues(int agentId, std::vector <char *> & fields,
varValue *values)
{
for (std::vector <char *>::size_type n = 0; n < fields.size();n++)
{
if (strcmp(fields[n], "Color")==0)
values[n] = varValue((*this)[agentId]->Color);
else
values[n] = varValue(0);
}
}
bool SuperastCPP::TraverseFieldDecl(clang::FieldDecl* fieldDecl) {
const std::string varName = fieldDecl->getName().str();
rapidjson::Value varValue(rapidjson::kObjectType);
addId(varValue);
addPos(varValue, fieldDecl);
varValue.AddMember("name",
rapidjson::Value().SetString(varName.c_str(),
varName.size(),
allocator),
allocator);
clang::QualType qualType = fieldDecl->getType().getNonLValueExprType(*context);
varValue.AddMember("data-type", createTypeValue((qualType.getTypePtr())), allocator);
// Will be an array in struct decl. Otherwise, just a call.
if (sonValue.IsArray()) {
sonValue.PushBack(varValue, allocator);
}
else {
sonValue = varValue;
}
return true;
}
void OutputAggregation::startResults()
{
// Initialize results...
_results.clear();
for(vector <double>::size_type n = 0; n < _fieldNames->size(); n++)
{
_results.push_back(varValue(0.0));
_count[n]=0;
}
}
// Traverse VAR DECL
bool SuperastCPP::TraverseVarDecl(clang::VarDecl* var) {
const std::string varName = var->getName().str();
rapidjson::Value varValue(rapidjson::kObjectType);
addId(varValue);
addPos(varValue, var);
// Variable Declaration if it is not a parameter of a function
if (!clang::dyn_cast<clang::ParmVarDecl>(var)) {
varValue.AddMember("type", "variable-declaration", allocator);
}
varValue.AddMember("name",
rapidjson::Value().SetString(varName.c_str(),
varName.size(),
allocator),
allocator);
// NonLValueExpr to remove LValueExpression for references.
// There are more options
clang::QualType qualType = var->getType().getNonLValueExprType(*context);
const clang::Type* type = qualType.getTypePtr();
bool isConst = var->getType().isConstQualified() | qualType.isConstQualified();
//std::cerr << " type: " << type->getCanonicalTypeInternal().getAsString();
varValue.AddMember("data-type", createTypeValue(type), allocator);
varValue.AddMember("is-reference", var->getType()->isReferenceType(), allocator);
varValue.AddMember("is-const", isConst, allocator);
if (var->hasInit() && !type->isStructureType() &&
!isSTLVectorType(type->getCanonicalTypeInternal())) {
rapidjson::Value exprValue(rapidjson::kObjectType);
TRY_TO(TraverseStmt(var->getInit()));
clang::VarDecl::InitializationStyle initStyle = var->getInitStyle();
switch (initStyle) {
case clang::VarDecl::CInit:
case clang::VarDecl::CallInit:
// We don't distinguis between these two initializations
if (!sonValue.IsNull()) {
varValue.AddMember("init", sonValue, allocator);
}
// Call style initializer (int x(1))
break;
case clang::VarDecl::ListInit:
// C++11 Initializer list. Not supported by us.
break;
}
}
sonValue = varValue;
return true;
}
BOOL CXmlManager::WriteNodeAttribInt( IXMLDOMNode* lpNode, LPCTSTR lpszAttrib, INT iValue )
{
CComPtr<IXMLDOMElement> pNodeEle;
CComPtr<IXMLDOMAttribute> pAttribute = NULL;
CComBSTR bstrAttrib(lpszAttrib);
CComVariant varValue(iValue);
lpNode->QueryInterface(IID_IXMLDOMElement, (VOID**)&pNodeEle);
if ( !pNodeEle )
return FALSE;
return SUCCEEDED( pNodeEle->setAttribute(bstrAttrib,varValue) );
}
HRESULT CTU_XMLParser::GetAttributeValue(IXMLDOMNode* spXMLNode, CComBSTR attributeName, CString& attrVal)
{
CComQIPtr<IXMLDOMElement> spXMLChildElement;
spXMLChildElement = spXMLNode;
if (spXMLChildElement.p == NULL)
return S_FALSE;
CComVariant varValue(VT_EMPTY);
HRESULT hr = spXMLChildElement->getAttribute(attributeName, &varValue);
if (hr != S_OK)
return hr;
attrVal = varValue.bstrVal;
return hr;
}
HRESULT CTU_XMLParser::GetNodeValue(IXMLDOMNode* spXMLNode, CComBSTR nodeName, CString& nodeVal)
{
CComPtr<IXMLDOMNode> spXMLChildNode;
CComVariant varValue(VT_EMPTY);
HRESULT hr = spXMLNode->selectSingleNode(nodeName, &spXMLChildNode);
if (hr != S_OK)
return hr;
hr = spXMLChildNode ? spXMLChildNode->get_nodeTypedValue(&varValue) : S_FALSE;
if (hr != S_OK)
return hr;
nodeVal = varValue.bstrVal;
nodeVal.Replace(_T("
x0A"), _T("\r\n"));
return hr;
}
Foam::string& Foam::stringOps::inplaceExpand
(
string& s,
const dictionary& dict,
const bool allowEnvVars,
const bool allowEmpty,
const char sigil
)
{
string::size_type begVar = 0;
// Expand $VAR or ${VAR}
// Repeat until nothing more is found
while
(
(begVar = s.find(sigil, begVar)) != string::npos
&& begVar < s.size()-1
)
{
if (begVar == 0 || s[begVar-1] != '\\')
{
if (s[begVar+1] == '{')
{
// Recursive variable expansion mode
label stringStart = begVar;
begVar += 2;
string varValue
(
expand
(
s,
begVar,
dict,
allowEnvVars,
allowEmpty
)
);
s.std::string::replace
(
stringStart,
begVar - stringStart + 1,
varValue
);
begVar = stringStart+varValue.size();
}
else
{
string::iterator iter = s.begin() + begVar + 1;
// more generous in accepting keywords than for env variables
string::size_type endVar = begVar;
while
(
iter != s.end()
&&
(
isalnum(*iter)
|| *iter == '.'
|| *iter == ':'
|| *iter == '_'
)
)
{
++iter;
++endVar;
}
const word varName
(
s.substr
(
begVar + 1,
endVar - begVar
),
false
);
string varValue
(
getVariable
(
varName,
dict,
allowEnvVars,
allowEmpty
)
);
s.std::string::replace
(
begVar,
varName.size()+1,
varValue
);
begVar += varValue.size();
}
}
else
{
++begVar;
}
}
if (!s.empty())
{
if (s[0] == '~')
{
// Expand initial ~
// ~/ => home directory
// ~OpenFOAM => site/user OpenFOAM configuration directory
// ~user => home directory for specified user
string user;
fileName file;
if ((begVar = s.find('/')) != string::npos)
{
user = s.substr(1, begVar - 1);
file = s.substr(begVar + 1);
}
else
{
user = s.substr(1);
}
// NB: be a bit lazy and expand ~unknownUser as an
// empty string rather than leaving it untouched.
// otherwise add extra test
if (user == "OpenFOAM")
{
s = findEtcFile(file);
}
else
{
s = home(user)/file;
}
}
else if (s[0] == '.')
{
// Expand a lone '.' and an initial './' into cwd
if (s.size() == 1)
{
s = cwd();
}
else if (s[1] == '/')
{
s.std::string::replace(0, 1, cwd());
}
}
}
return s;
}
void XmlHelper::SetAttribute(const CComPtr<IXMLDOMElement>& pElement, const CComBSTR& bstrName, const wstring& strValue)
{
CComVariant varValue(strValue.c_str());
pElement->setAttribute(bstrName, varValue);
}
void XmlHelper::SetAttribute(const CComPtr<IXMLDOMElement>& pElement, const CComBSTR& bstrName, bool bValue)
{
CComVariant varValue(bValue ? L"1" : L"0");
pElement->setAttribute(bstrName, varValue);
}
void XmlHelper::SetAttribute(const CComPtr<IXMLDOMElement>& pElement, const CComBSTR& bstrName, BYTE byValue)
{
CComVariant varValue(boost::str(boost::wformat(L"%1%") % byValue).c_str());
pElement->setAttribute(bstrName, varValue);
}
