void CNcdPreminetProtocolDataBlocksParser::OnStartElementL( const Xml::RTagInfo& aElement,
const Xml::RAttributeArray& aAttributes,
TInt aErrorCode )
{
CNcdSubParser::OnStartElementL( aElement, aAttributes, aErrorCode );
TPtrC8 tag( aElement.LocalName().DesC() );
DLTRACE(("dataBlocks tag=%S error=%d depth=%d",&aElement.LocalName().DesC(),aErrorCode,iDepth));
if( iSubParser )
{
// Use existing subparser.
iSubParser->OnStartElementL( aElement, aAttributes, aErrorCode );
}
else if( tag == KTagDataBlock )
{
iCurrentDataBlock = CNcdPreminetProtocolDataBlockImpl::NewL();
// data block attributes
// id
NcdProtocolUtils::AssignDesL( iCurrentDataBlock->iId, AttributeValue( KAttrId, aAttributes ) );
// name space
NcdProtocolUtils::AssignDesL( iCurrentDataBlock->iNameSpace, AttributeValue( KAttrNamespace, aAttributes ) );
}
else
{
iSubParser = CNcdUnknownParser::NewL( *iObservers, *this, iDepth+1, aElement, aAttributes );
}
}
void CNcdPreminetProtocolPurchaseInformationParser::ConstructL(
const Xml::RTagInfo& aElement,
const Xml::RAttributeArray& aAttributes,
const TDesC& /*aParentId*/ )
{
CNcdSubParser::ConstructL( aElement );
DLTRACEIN(("depth=%d tag=%S",iDepth,iTag));
//DLINFO((_L("parent=%S"),&aParentId));
if (!iInformation)
{
iInformation = CNcdPreminetProtocolPurchaseInformationImpl::NewL();
}
// read attributes here
TPtrC8 uri = AttributeValue( KAttrUri, aAttributes );
NcdProtocolUtils::AssignDesL(iInformation->iUri, uri);
TPtrC8 ns = AttributeValue( KAttrNamespace, aAttributes );
NcdProtocolUtils::AssignDesL(iInformation->iNamespace, ns);
TPtrC8 initiateSession =
AttributeValue( KAttrInitiateSession, aAttributes );
NcdProtocolUtils::DesToBool(iInformation->iInitiateSession, initiateSession);
}
static inline AttributeValue binop(AttributeValue const& lhs, AttributeValue const& rhs, char op) {
if (!lhs.text.empty()) return lhs;
if (!rhs.text.empty()) return rhs;
switch (op) {
case '+': return lhs + rhs;
case '-': return lhs - rhs;
case '*': return lhs * rhs;
case '/': return lhs / rhs;
case '>': return (lhs.max > rhs.max ? 1.0 : 0.0);
case '<': return (lhs.max < rhs.max ? 1.0 : 0.0);
case funcMin: return AttributeValue(std::min(lhs.min, rhs.min), std::min(lhs.max, rhs.max));
case funcMax: return AttributeValue(std::max(lhs.min, rhs.min), std::max(lhs.max, rhs.max));
case funcTable:
if (lhs.table == nullptr) {
return 0;
} else {
int imin = static_cast<int>(rhs.min);
int imax = static_cast<int>(rhs.max);
if (imin < 0 || imax > 75) return 0;
return AttributeValue(std::min(lhs.table[imin], lhs.table[imax]),
std::max(lhs.table[imin], lhs.table[imax]));
}
break;
default: return AttributeValue();
}
}
void CNcdPreminetProtocolRightsParser::ConstructL(
const Xml::RTagInfo& aElement,
const Xml::RAttributeArray& aAttributes,
const TDesC& /*aParentId*/ )
{
CNcdSubParser::ConstructL( aElement );
DLTRACEIN(("depth=%d tag=%S",iDepth,iTag));
//DLINFO((_L("parent=%S"),&aParentId));
if (!iRights)
{
iRights = CNcdPreminetProtocolRightsImpl::NewL();
}
// read attributes here
TPtrC8 activationKey = AttributeValue( KAttrActivationKey, aAttributes );
NcdProtocolUtils::AssignDesL(iRights->iActivationKey, activationKey);
TPtrC8 issuerUri = AttributeValue( KAttrIssuerUri, aAttributes );
NcdProtocolUtils::AssignDesL(iRights->iIssuerUri, issuerUri);
TPtrC8 uri = AttributeValue( KAttrUri, aAttributes );
NcdProtocolUtils::AssignDesL(iRights->iUri, uri);
TPtrC8 type = AttributeValue( KAttrType, aAttributes );
NcdProtocolUtils::AssignDesL(iRights->iType, type);
TPtrC8 name = AttributeValue( KAttrName, aAttributes );
NcdProtocolUtils::AssignDesL(iRights->iName, name);
}
void CNcdPreminetProtocolRightsParser::OnStartElementL(
const Xml::RTagInfo& aElement,
const Xml::RAttributeArray& aAttributes,
TInt aErrorCode)
{
CNcdSubParser::OnStartElementL( aElement, aAttributes, aErrorCode );
DLTRACEIN(("rights start tag=%S error=%d depth=%d",
&aElement.LocalName().DesC(),aErrorCode,iDepth));
TPtrC8 tag( aElement.LocalName().DesC() );
if ( iSubParser )
{
iSubParser->OnStartElementL( aElement, aAttributes, aErrorCode );
}
else if ( tag == KTagRightsObject && iRights )
{
TPtrC8 dataBlock = AttributeValue( KAttrDataBlock, aAttributes );
NcdProtocolUtils::AssignDesL(iRights->iRightsObjectDataBlock, dataBlock);
TPtrC8 mime = AttributeValue( KAttrMime, aAttributes );
NcdProtocolUtils::AssignDesL(iRights->iRightsObjectMime, mime);
// data saved in OnEndElementL
}
else
{
iSubParser = CNcdUnknownParser::NewL(
*iObservers, *this, iDepth+1, aElement, aAttributes );
}
}
void VariableExpression::evaluateTo( const text::Transition * currentAnnotation, const matchers::Variable currentVar, const Context & ctx, ValueList & results ) const {
Context::ConstRange range = ctx.getValues( variable );
for ( Context::ConstIterator it = range.first; it != range.second; ++ it )
results.push_back( AttributeValue( *it->second ) );
if ( currentVar == variable )
results.push_back( AttributeValue( *currentAnnotation ) );
}
QScriptValue ScriptedMetavoxelGuide::visit(QScriptContext* context, QScriptEngine* engine) {
ScriptedMetavoxelGuide* guide = static_cast<ScriptedMetavoxelGuide*>(context->callee().data().toVariant().value<void*>());
// start with the basics, including inherited attribute values
QScriptValue infoValue = context->argument(0);
QScriptValue minimum = infoValue.property(guide->_minimumHandle);
MetavoxelInfo info = {
glm::vec3(minimum.property(0).toNumber(), minimum.property(1).toNumber(), minimum.property(2).toNumber()),
infoValue.property(guide->_sizeHandle).toNumber(), guide->_visitation->info.inputValues,
guide->_visitation->info.outputValues, infoValue.property(guide->_isLeafHandle).toBool() };
// extract and convert the values provided by the script
QScriptValue inputValues = infoValue.property(guide->_inputValuesHandle);
const QVector<AttributePointer>& inputs = guide->_visitation->visitor.getInputs();
for (int i = 0; i < inputs.size(); i++) {
QScriptValue attributeValue = inputValues.property(i);
if (attributeValue.isValid()) {
info.inputValues[i] = AttributeValue(inputs.at(i),
inputs.at(i)->createFromScript(attributeValue, engine));
}
}
QScriptValue result = guide->_visitation->visitor.visit(info);
// destroy any created values
for (int i = 0; i < inputs.size(); i++) {
if (inputValues.property(i).isValid()) {
info.inputValues[i].getAttribute()->destroy(info.inputValues[i].getValue());
}
}
return result;
}
void CNcdConfigurationProtocolErrorParser::ConstructL( const Xml::RTagInfo& aElement,
const Xml::RAttributeArray& aAttributes )
{
CNcdSubParser::ConstructL( aElement );
iError = new(ELeave) CNcdPreminetProtocolErrorImpl();
// attributes
// code
TPtrC8 code = AttributeValue( KAttrCode, aAttributes );
if( code != KNullDesC8 )
{
iError->iCode = NcdProtocolUtils::DesDecToIntL( code );
}
// id
NcdProtocolUtils::AssignDesL( iError->iId, AttributeValue( KAttrId, aAttributes ) );
}
void CNcdPreminetProtocolPurchaseInformationParser::OnStartElementL(
const Xml::RTagInfo& aElement,
const Xml::RAttributeArray& aAttributes,
TInt aErrorCode)
{
CNcdSubParser::OnStartElementL( aElement, aAttributes, aErrorCode );
TPtrC8 tag( aElement.LocalName().DesC() );
if( iSubParser == 0 )
{
DLTRACEIN(("purchaseInformation start tag=%S error=%d depth=%d",
&aElement.LocalName().DesC(),aErrorCode,iDepth));
if( tag == KTagPayments )
{
// skip this tag
}
else if( tag == KTagPayment )
{
iSubParser = CNcdPreminetProtocolPaymentParser::NewL(
*iObservers, *this, iDepth+1, aElement, aAttributes,
KNullDesC /*no parent id*/ );
}
else if( tag == KTagDisclaimer )
{
iSubParser = CNcdConfigurationProtocolQueryParser::NewL(
*iObservers, *this, iDepth+1, aElement, aAttributes );
}
else if( tag == KTagTotalPrice )
{
TPtrC8 currency = AttributeValue( KAttrCurrency, aAttributes );
NcdProtocolUtils::AssignDesL(
iInformation->iTotalPriceCurrency, currency);
// parsing myself
}
else if( tag == KTagEntities )
{
// skip this tag
}
else if( tag == KTagEntity )
{
iSubParser = CNcdPreminetProtocolPurchaseEntityParser::NewL(
*iObservers, *this, iDepth+1, aElement, aAttributes,
KNullDesC /*no parent id*/ );
}
else
{
iSubParser = CNcdUnknownParser::NewL(
*iObservers, *this, iDepth+1, aElement, aAttributes );
}
}
else
{
iSubParser->OnStartElementL( aElement, aAttributes, aErrorCode );
}
}
//---------------------------------------------------------------------------
const std::vector<double> ChessGame::AttributeValues(
const std::vector<ChessMove>& moves) const
{
const int nMoves = moves.size();
std::vector<double> v(nMoves,0.0);
for (int i=0; i!=nMoves; ++i)
{
v[i] = AttributeValue(moves[i]);
}
return v;
}
char*
XMLEntity::ToString(bool encoded, int level)
{
string text = "";
string indent = "";
string character_data = EscapeText(CharacterData());
for(int i=0; i<level; ++i) indent += "\t";
text = indent;
text += "<";
text += Name();
for(int i=0; i < CountAttributes(); ++i) {
text += " ";
text += AttributeKey(i);
text += "=";
text += "\"";
text += EscapeText(AttributeValue(i));
text += "\"";
}
if (character_data.size() == 0 && CountChildren() == 0) text += "/";
text += ">";
text += character_data;
if (CountChildren() > 0)
{
text += "\n";
for (int i=0; i < CountChildren(); ++i)
{
char *str = Child(i)->ToString(encoded, level + 1);
if (str)
{
text += str;
free(str);
}
}
text += indent;
}
if (CountChildren() > 0 || character_data.size() > 0)
{
text += "</";
text += Name();
text += ">";
}
text += "\n";
return strdup(text.c_str());
}
void GenerateGems(json::Value& value, json::Value& data) {
TranslateJson(value, data);
auto names = Strings::list("Items");
auto powers = Strings::list("ItemPassivePowerDescriptions");
for (auto& kv : value["gemColors"].getMap()) {
std::string id = kv.first;
id[0] = toupper(id[0]);
size_t levels = value["gemQualities"].length();
auto& dst = value["gemColors"][kv.first]["names"];
for (size_t level = 1; level <= levels; ++level) {
dst.append(names.getfmt("x1_%s_%02d", id.c_str(), level));
}
}
for (auto& gem : data["legendaryGems"].getMap()) {
std::string id = gem.second["id"].getString();
auto* item = ItemLibrary::get(id);
if (!names.has(id) || !item) {
Logger::log("Item not found: %s", id.c_str());
continue;
}
auto& dst = value["legendaryGems"][gem.first];
dst["name"] = names[id];
if (gem.second.has("effects")) {
if (gem.second["effects"].has("0") && gem.second["effects"]["0"].has("format")) {
char const* name = Power::name(item->x4B8_AttributeSpecifier.x04_Param);
auto* tag = PowerTags::getraw(item->x4B8_AttributeSpecifier.x04_Param);
if (!name || !tag || !powers.has(name)) {
Logger::log("Power(0) not found for %s", id.c_str());
} else {
std::string fmt = powers[name];
auto values = GameAffixes::defaultMap();
values["value1"] = AttributeValue("%");
dst["effects"]["0"]["format"] = FormatDescription(powers[name], FormatTags, values, tag);
}
}
if (gem.second["effects"].has("1") && gem.second["effects"]["1"].has("format")) {
std::vector<AttributeSpecifier> specs;
specs.emplace_back(item->x4D0_AttributeSpecifier);
auto format = GameAffixes::format(specs, FormatTags);
if (format.empty()) {
Logger::log("Unknown power(1) for %s", id.c_str());
} else {
dst["effects"]["1"]["format"] = format[0];
}
}
}
}
}
void MetavoxelSystem::init() {
if (!_program.isLinked()) {
switchToResourcesParentIfRequired();
_program.addShaderFromSourceFile(QGLShader::Vertex, "resources/shaders/metavoxel_point.vert");
_program.link();
_pointScaleLocation = _program.uniformLocation("pointScale");
}
AttributeRegistry::getInstance()->configureScriptEngine(&_scriptEngine);
QFile scriptFile("resources/scripts/sphere.js");
scriptFile.open(QIODevice::ReadOnly);
QScriptValue guideFunction = _scriptEngine.evaluate(QTextStream(&scriptFile).readAll());
_data.setAttributeValue(MetavoxelPath(), AttributeValue(AttributeRegistry::getInstance()->getGuideAttribute(),
encodeInline(PolymorphicDataPointer(new ScriptedMetavoxelGuide(guideFunction)))));
_buffer.setUsagePattern(QOpenGLBuffer::DynamicDraw);
_buffer.create();
}
FormulaParser::Value FormulaParser::eval() {
int digits = 0;
bool plus = false;
EvalStack stack;
stack.ops.push('{');
while (int type = fnext()) {
if (type == tChar && chr == ']') break;
if (type == tChar && chr == '|') {
type = fnext();
if (type == tNum) {
digits = static_cast<int>(val);
} else if (type == tChar && chr == '+') {
plus = true;
}
fnext();
} else if (type == tName) {
std::vector<std::string> parts;
bool isfunc = false;
while (type == tName) {
parts.push_back(tag);
size_t prev = pos;
if ((type = fnext()) != tChar || chr != '.') {
if (type == tChar && chr == '(') {
isfunc = true;
} else {
pos = prev;
}
break;
}
type = fnext();
}
std::string result = "";
for (auto& part : parts) {
if (!result.empty()) result.push_back('.');
result.append(part);
}
if (isfunc) {
char funcId = getFunction(result);
OpInfo const& op = opInfo(funcId);
while (stack.ops.size() && opInfo(stack.ops.top()).rprio >= op.lprio) {
stack.exec(stack.ops.top());
stack.ops.pop();
}
stack.ops.push(funcId);
stack.needval = op.rval;
} else if (!stack.ops.empty() && stack.ops.top() == funcTable) {
stack.vals.push(AttributeValue(PowerTags::table(result)));
} else {
static re::Prog sfid("sf_(\\d+)", -1, re::Prog::CaseInsensitive);
static re::Prog sftag(R"/(powertag.(\w+)."(.*)")/", -1, re::Prog::CaseInsensitive);
//static re::Prog lookup(R"(table.(\w+).(\w+))", -1, re::Prog::CaseInsensitive);
std::vector<std::string> match;
if (context && sfid.match(result, &match)) {
stack.vals.emplace(context->get(atoi(match[1].c_str()), values));
} else if (sftag.match(result, &match)) {
stack.vals.emplace(PowerTags::get(match[1], match[2], values));
} else {
auto it = values.find(result);
stack.vals.push(it == values.end() ? 0.0 : it->second);
}
}
stack.needval = 0;
} else if (type == tTag) {
auto it = values.find(tag);
if (it != values.end()) {
prevtag = it->second;
} else if (context) {
prevtag = context->get(tag, values);
} else {
prevtag = 0.0;
}
stack.vals.push(prevtag);
stack.needval = 0;
} else if (type == tNum) {
stack.vals.push(val);
stack.needval = 0;
} else if (type == tChar) {
if (chr == '-' && stack.needval) chr = '~';
OpInfo const& op = opInfo(chr);
while (stack.ops.size() && opInfo(stack.ops.top()).rprio >= op.lprio) {
char top = stack.ops.top();
stack.exec(top);
stack.ops.pop();
if (opInfo(top).rprio == 0) break;
}
if (chr != ')') stack.ops.push(chr);
stack.needval = op.rval;
}
}
OpInfo const& op = opInfo('}');
while (stack.ops.size() && opInfo(stack.ops.top()).rprio >= op.lprio) {
stack.exec(stack.ops.top());
stack.ops.pop();
}
AttributeValue res;
if (stack.vals.size()) res = stack.vals.top();
return Value(res, digits, plus);
}
std::string FormulaParser::parse() {
std::string result;
int newlines = 0;
while (int type = next()) {
if ((flags & FormatHTML) && newlines && (type != tChar || chr != '\n')) {
if (newlines == 1) {
result.append("<br/>");
} else {
result.append("</p><p>");
}
newlines = 0;
}
switch (type) {
case tChar:
if (chr == '[') {
result.append(eval().format());
} else if (chr == '|') {
next(); // 4
std::string lhs, rhs;
while (next() == tChar && chr != ':') {
lhs.push_back(chr);
}
while (next() == tChar && chr != ';') {
rhs.push_back(chr);
}
if (prevtag.min != 1 || prevtag.max != 1) {
result.append(rhs);
} else {
result.append(lhs);
}
} else if (chr == '\n' && (flags & FormatHTML)) {
++newlines;
} else {
if (flags & FormatTags) {
if (chr == ' ' && (result.empty() || result.back() == '\n')) {
break;
}
if (chr == '%') {
result.push_back('%');
}
}
result.push_back(chr);
}
break;
case tTag:
if (tag.substr(0, 2) == "/c" || tag.substr(0, 2) == "c:" || pretags.find(tag) != pretags.end()) {
if (flags & FormatHTML) {
if (tag.substr(0, 2) == "/c") {
result.append("</span>");
} else if (tag.substr(0, 2) == "c:") {
result.append(fmtstring("<span style=\"color: #%s\">", tag.substr(4).c_str()));
} else {
result.append(pretags[tag]);
}
} else if ((flags & FormatTags) && tag == "icon:bullet") {
result.push_back('*');
}
} else {
auto it = values.find(tag);
if (it != values.end()) {
prevtag = it->second;
} else if (context) {
prevtag = context->get(tag, values);
} else {
prevtag = 0.0;
}
result.append(Value(prevtag).format());
}
break;
}
AttributeValue SpannerQRgbAttribute::inherit(const AttributeValue& parentValue) const {
return AttributeValue(parentValue.getAttribute());
}
AttributeValue MetavoxelNode::getAttributeValue(const AttributePointer& attribute) const {
return AttributeValue(attribute, _attributeValue);
}
void DefaultMetavoxelGuide::guide(MetavoxelVisitation& visitation) {
visitation.info.isLeaf = visitation.allInputNodesLeaves();
bool keepGoing = visitation.visitor.visit(visitation.info);
for (int i = 0; i < visitation.outputNodes.size(); i++) {
AttributeValue& value = visitation.info.outputValues[i];
if (!value.getAttribute()) {
continue;
}
MetavoxelNode*& node = visitation.outputNodes[i];
if (node && node->isLeaf() && value.getAttribute()->equal(value.getValue(), node->getAttributeValue())) {
// "set" to same value; disregard
value = AttributeValue();
} else {
node = new MetavoxelNode(value);
}
}
if (!keepGoing) {
return;
}
MetavoxelVisitation nextVisitation = { &visitation, visitation.visitor,
QVector<MetavoxelNode*>(visitation.inputNodes.size()), QVector<MetavoxelNode*>(visitation.outputNodes.size()),
{ glm::vec3(), visitation.info.size * 0.5f, QVector<AttributeValue>(visitation.inputNodes.size()),
QVector<AttributeValue>(visitation.outputNodes.size()) } };
for (int i = 0; i < MetavoxelNode::CHILD_COUNT; i++) {
for (int j = 0; j < visitation.inputNodes.size(); j++) {
MetavoxelNode* node = visitation.inputNodes.at(j);
MetavoxelNode* child = node ? node->getChild(i) : NULL;
nextVisitation.info.inputValues[j] = ((nextVisitation.inputNodes[j] = child)) ?
child->getAttributeValue(visitation.info.inputValues[j].getAttribute()) :
visitation.info.inputValues[j];
}
for (int j = 0; j < visitation.outputNodes.size(); j++) {
MetavoxelNode* node = visitation.outputNodes.at(j);
MetavoxelNode* child = node ? node->getChild(i) : NULL;
nextVisitation.outputNodes[j] = child;
}
nextVisitation.info.minimum = visitation.info.minimum + glm::vec3(
(i & X_MAXIMUM_FLAG) ? nextVisitation.info.size : 0.0f,
(i & Y_MAXIMUM_FLAG) ? nextVisitation.info.size : 0.0f,
(i & Z_MAXIMUM_FLAG) ? nextVisitation.info.size : 0.0f);
static_cast<MetavoxelGuide*>(nextVisitation.info.inputValues.last().getInlineValue<
PolymorphicDataPointer>().data())->guide(nextVisitation);
for (int j = 0; j < nextVisitation.outputNodes.size(); j++) {
AttributeValue& value = nextVisitation.info.outputValues[j];
if (!value.getAttribute()) {
continue;
}
// replace the child
AttributeValue& parentValue = visitation.info.outputValues[j];
if (!parentValue.getAttribute()) {
// shallow-copy the parent node on first change
parentValue = value;
MetavoxelNode*& node = visitation.outputNodes[j];
if (node) {
node = new MetavoxelNode(value.getAttribute(), node);
} else {
// create leaf with inherited value
node = new MetavoxelNode(visitation.getInheritedOutputValue(j));
}
}
MetavoxelNode* node = visitation.outputNodes.at(j);
MetavoxelNode* child = node->getChild(i);
if (child) {
child->decrementReferenceCount(value.getAttribute());
} else {
// it's a leaf; we need to split it up
AttributeValue nodeValue = node->getAttributeValue(value.getAttribute());
for (int k = 1; k < MetavoxelNode::CHILD_COUNT; k++) {
node->setChild((i + k) % MetavoxelNode::CHILD_COUNT, new MetavoxelNode(nodeValue));
}
}
node->setChild(i, nextVisitation.outputNodes.at(j));
value = AttributeValue();
}
}
for (int i = 0; i < visitation.outputNodes.size(); i++) {
AttributeValue& value = visitation.info.outputValues[i];
if (value.getAttribute()) {
MetavoxelNode* node = visitation.outputNodes.at(i);
node->mergeChildren(value.getAttribute());
value = node->getAttributeValue(value.getAttribute());
}
}
}
void CurrentAnnotationExpression::evaluateTo( const text::Transition * currentAnnotation, const matchers::Variable currentVar, const Context & ctx, ValueList & results ) const {
results.push_back( AttributeValue( *currentAnnotation ) );
}
AttributeValue Transition::getAttribute( AttributeKey key ) const {
if ( key == AttributeKey::TEXT ) // Если запрашиваемый аттрибут - текст
return AttributeValue( getRangeString() ); // Возвращаем текст, как строковый аттрибут
return AttributeValue::UNDEFINED;
}
std::string FormatTag(std::string const& src, json::Value& data) {
if (src.empty()) return src;
if (src[0] == '$' && src.back() == '$') return src;
size_t slash = src.find('/');
if (slash == std::string::npos) return src;
auto list = Strings::list(src.substr(0, slash));
if (!list) {
Logger::log("StringList not found: %s", src.substr(0, slash).c_str());
return src;
}
size_t at = src.find('@', slash);
std::string text = src.substr(slash + 1, at == std::string::npos ? at : at - slash - 1);
if (!list.has(text)) {
Logger::log("String not found: %s", src.substr(0, at).c_str());
return src;
}
text = list[text];
if (at != std::string::npos) {
size_t quest = src.find('?', at);
if (quest == std::string::npos) quest = src.length();
FormatFlags flags = FormatTags;
PowerTag* context = nullptr;
AttributeMap values = GameAffixes::defaultMap();
if (quest > at + 1) {
flags = FormatHTML;
context = PowerTags::get(src.substr(at + 1, quest - at - 1));
if (!context) {
Logger::log("PowerTag not found: %s", src.substr(at + 1, quest - at - 1).c_str());
}
} else {
values["value"] = AttributeValue("%");
values["value1"] = AttributeValue("%");
values["value2"] = AttributeValue("%");
values["value3"] = AttributeValue("%");
}
std::map<std::string, std::string> replace;
if (quest < src.length()) {
std::vector<std::string> parts = split(src.substr(quest + 1), '&');
for (auto& p : parts) {
size_t eq = p.find('=');
if (eq == std::string::npos) continue;
std::string key = p.substr(0, eq);
std::string value = p.substr(eq + 1);
if (!testString(key, isalnum)) {
size_t pos = text.find(key);
if (pos == std::string::npos) continue;
std::string rval = fmtstring("@%d", replace.size() + 1);
replace.emplace(rval, value);
text.replace(pos, key.length(), rval);
continue;
}
if (testString(value, isdigit)) {
values.emplace(key, atof(value.c_str()));
continue;
}
size_t ss = value.find('/');
if (ss == std::string::npos) {
values[key] = AttributeValue(value);
} else {
std::string listname = value.substr(0, ss);
if (!testString(listname, isalpha)) {
values[key] = AttributeValue(value); continue;
}
auto sublist = Strings::list(listname);
if (!sublist) {
Logger::log("StringList not found: %s", listname.c_str());
continue;
}
std::string subtext = value.substr(ss + 1);
if (!sublist.has(subtext)) {
Logger::log("String not found: %s", value.c_str());
continue;
}
values[key] = AttributeValue(sublist[subtext]);
}
}
}
text = FormatDescription(text, flags, values, context);
for (auto& kv : replace) {
size_t pos = text.find(kv.first);
if (pos == std::string::npos) continue;
text.replace(pos, kv.first.length(), kv.second);
}
}
return text;
}
void GenerateItems(json::Value& value, json::Value& data) {
auto names = Strings::list("Items");
auto powers = Strings::list("ItemPassivePowerDescriptions");
uint32 powId = fixAttrId(1270, true);
std::map<std::string, std::string> powerFix;
powerFix.emplace("Unique_Amulet_109_x1_210", "ItemPassive_x1_Amulet_norm_unique_25_DemonHunter");
std::map<uint32, GameBalance::Type::AffixTableEntry*> affixes;
SnoFile<GameBalance> affixFile("1xx_AffixList");
for (auto& afx : affixFile->x078_AffixTable) {
affixes.emplace(HashNameLower(afx.x000_Text), &afx);
}
for (auto& rcp : SnoLoader::All<Recipe>()) {
std::string item = rcp->x0C_ItemSpecifierData.x00_ItemsGameBalanceId.name();
if (item.empty()) continue;
uint32 power = 0;
for (auto& id : rcp->x0C_ItemSpecifierData.x08_GameBalanceIds) {
if (affixes.count(id)) {
for (auto& attr : affixes[id]->x260_AttributeSpecifiers) {
if (attr.x00_Type == powId) {
power = attr.x04_Param;
break;
}
}
}
if (power) break;
}
char const* pname = (power ? Power::name(power) : nullptr);
if (pname) powerFix.emplace(item, pname);
}
for (auto& kv : data["itemById"].getMap()) {
if (kv.second.has("required")) {
std::string key = kv.second["required"]["custom"]["id"].getString();
data["legendaryMap"][key] = kv.first;
}
auto* item = ItemLibrary::get(kv.first);
if (!names.has(kv.first) || !item) {
if (kv.first != "Unique_Ring_017_p4") {
Logger::log("Item not found: %s", kv.first.c_str());
continue;
}
}
auto& dst = value["itemById"][kv.first];
dst["name"] = names[kv.first == "Unique_Ring_017_p4" ? "Unique_Ring_017_p2" : kv.first];
if (kv.second.has("required")) {
std::string key = kv.second["required"]["custom"]["id"].getString();
data["stringlist"]["Items"][key]["text"] = kv.second["required"]["custom"]["name"];
data["stringlist"]["Items"][key]["tip"] = names[kv.first] + " (short effect name)";
dst["required"]["custom"]["name"] = fmtstring("$Items/%s$", key.c_str());
bool found = false;
for (auto& attr : item->x1F8_AttributeSpecifiers) {
if (attr.x00_Type != powId) continue;
char const* name = Power::name(attr.x04_Param);
auto* tag = PowerTags::getraw(attr.x04_Param);
if (!name || !tag || !powers.has(name)) {
Logger::log("Power not found for %s", kv.first.c_str());
continue;
}
auto values = GameAffixes::defaultMap();
AttributeValue value = ExecFormula(
reinterpret_cast<uint32 const*>(attr.x08_Data.begin()),
reinterpret_cast<uint32 const*>(attr.x08_Data.end()),
values);
if (value.min != value.max) {
values["value1"] = AttributeValue("%");
} else {
values["value1"] = value;
}
dst["required"]["custom"]["format"] = FormatDescription(powers[name], FormatTags, values, tag);
found = true;
break;
}
if (!found) {
if (powerFix.count(kv.first)) {
auto* tag = PowerTags::get(powerFix[kv.first]);
auto values = GameAffixes::defaultMap();
values["value1"] = AttributeValue("%");
dst["required"]["custom"]["format"] = FormatDescription(powers[powerFix[kv.first]], FormatTags, values, tag);
} else if (kv.first == "x1_Amulet_norm_unique_25") {
// hellfire
std::string x = powers["ItemPassive_Unique_Ring_770_x1"];
std::string y = Strings::get("Powers", "Trait_PoundOfFlesh");
size_t pos = x.find(y);
if (pos != std::string::npos) {
x.replace(pos, y.length(), "%p");
dst["required"]["custom"]["format"] = x;
}
} else {
Logger::log("Power not found for %s", kv.first.c_str());
}
}
if (dst["required"]["custom"].has("format")) {
data["locale_tips"]["Items"][key] = dst["required"]["custom"]["format"];
}
}
}
}
/* ----------------------------------------------------------------------
TtaAttachAttribute
Attaches an attribute to an element.
Parameters:
element: the element to which the attribute has to be attached.
attribute: the attribute to be attached.
document: the document to which the element belongs.
---------------------------------------------------------------------- */
void TtaAttachAttribute (Element element, Attribute attribute, Document document)
{
PtrAttribute pAttr;
PtrDocument pDoc;
ThotBool obligatory;
UserErrorCode = 0;
if (element == NULL || attribute == NULL ||
((PtrElement) element)->ElStructSchema == NULL)
TtaError (ERR_invalid_parameter);
else if (document < 1 || document > MAX_DOCUMENTS)
TtaError (ERR_invalid_document_parameter);
else
{
pDoc = LoadedDocument[document - 1];
if (pDoc == NULL)
TtaError (ERR_invalid_document_parameter);
else if (AttributeValue ((PtrElement) element,
(PtrAttribute) attribute) != NULL)
/* parameter document is correct */
/* has the element an attribute of the same type ? */
/* yes, error */
TtaError (ERR_duplicate_attribute);
else if ((pDoc)->DocCheckingMode & STR_CHECK_MASK &&
!CanAssociateAttr ((PtrElement) element, NULL,
(PtrAttribute) attribute, &obligatory))
/* can wa apply the attribute to the element ? */
/* no, error */
TtaError (ERR_attribute_element_mismatch);
else
{
#ifndef NODISPLAY
UndisplayInheritedAttributes ((PtrElement) element,
(PtrAttribute) attribute, document, FALSE);
#endif
if (((PtrElement) element)->ElFirstAttr == NULL)
((PtrElement) element)->ElFirstAttr = (PtrAttribute) attribute;
else
{
pAttr = ((PtrElement) element)->ElFirstAttr;
while (pAttr->AeNext != NULL)
pAttr = pAttr->AeNext;
pAttr->AeNext = (PtrAttribute) attribute;
}
/* update the menu attributes */
if (pDoc == SelectedDocument &&
(PtrElement) element == FirstSelectedElement)
if (ThotLocalActions[T_chattr] != NULL)
(*(Proc1)ThotLocalActions[T_chattr]) ((void *)pDoc);
pAttr = (PtrAttribute) attribute;
pAttr->AeNext = NULL;
pAttr->AeDefAttr = FALSE;
if (pAttr->AeAttrType == AtReferenceAttr)
if (pAttr->AeAttrReference != NULL)
pAttr->AeAttrReference->RdElement = (PtrElement) element;
#ifndef NODISPLAY
DisplayAttribute ((PtrElement) element, pAttr, document);
#endif
}
}
}
Expression * CreateStringLiteralExpressionImpl::operator()( const char * start, const char * end ) const {
return new ConstantExpression( AttributeValue( Morphology::instance().upcase( start, end ) ) );
}
int DPM_session::Initialize( xmlNode *SessionNode ) {
double tstart = 0.0;
double tstop = DBL_MAX;
double frequency = DBL_MAX;
int n_product_files, n_runs;
if (SessionNode == NULL) {
std::cerr << "ERROR: DPM_session::Initialize: Bad parameters." << std::endl;
return -1;
}
if (strcmp((char*) SessionNode->name, "session") != 0) {
std::cerr << "ERROR: Expected <session> specification but alas didnt find it." << std::endl;
return -1;
}
if ( !strcasecmp(AttributeValue("presentation") , "stream" ) ) {
if ( AttributeValue("machine") == NULL ) {
std::cerr << "ERROR: Expected attribute \"machine\" when using stream presentation" << std::endl;
return -1;
}
if ( AttributeValue("port") == NULL ) {
std::cerr << "ERROR: Expected attribute \"port\" when using stream presentation" << std::endl;
return -1;
}
}
if (AttributeValue("device") != NULL) {
if (setDevice((char*)AttributeValue("device")) < 0) {
return -1;
}
} else {
sessionDevice = DPM_session::TERMINAL;
}
/* Process children */
xmlNode *current_node = SessionNode->children;
while (current_node != NULL) {
if (current_node->type == XML_ELEMENT_NODE) {
if ( strcmp( (char *)current_node->name, "run") == 0) {
DPM_run *run;
try {
run = new DPM_run( this, current_node);
} catch (std::invalid_argument) {
run = NULL;
std::cerr << "ERROR: one of this <session>s <run>s is invalid." << std::endl;
}
if (run != NULL) {
run_list.push_back( run);
}
} else if ( strcmp( (char*)current_node->name, "product_files") == 0) {
xmlNode *current_child_node;
current_child_node = current_node->children;
while (current_child_node != NULL) {
if (current_child_node->type == XML_ELEMENT_NODE) {
if ( strcmp( (const char *)current_child_node->name, "file") == 0) {
char *product_file;
xmlNode *text_node = current_child_node->children;
product_file = strdup( (const char *)text_node->content);
if (product_file != NULL) {
product_file_list.push_back( product_file);
}
} else {
std::cerr << "WARNING: <product_files> specification contains an unknown element \"<" <<
current_child_node->name << ">\". Skipping." << std::endl;
}
}
current_child_node = current_child_node->next;
}
} else if ( strcmp( (const char *)current_node->name, "tstart") == 0) {
xmlNode *text_node = current_node->children;
tstart = strtod((const char *)text_node->content,(char **)NULL);
} else if ( strcmp( (const char *)current_node->name, "tstop") == 0) {
xmlNode *text_node = current_node->children;
tstop = strtod((const char *)text_node->content,(char **)NULL);
} else if ( strcmp( (const char *)current_node->name, "frequency") == 0) {
xmlNode *text_node = current_node->children;
frequency = strtod((const char *)text_node->content,(char**)NULL);
} else {
std::cerr << "WARNING: <session> specification contains an unknown element \"<" <<
current_node->name << ">\". Skipping." << std::endl;
}
}
current_node = current_node->next;
}
time_constraints = new DPM_time_constraints(tstart, tstop, frequency);
// Validation criteria:
// 1. Session requires at least one RUN directory.
// 2. Session requires at least one Product file.
n_product_files = (int)product_file_list.size();
if (n_product_files < 1) {
std::cerr << "ERROR: <session> requires at least one product file." << std::endl;
return -1;
}
n_runs = (int)run_list.size();
if (n_runs < 1) {
std::cerr << "ERROR: <session> requires at least one RUN." << std::endl;
return -1;
}
return 0;
}
void CNcdPreminetProtocolEntityRefParser::ConstructL( const Xml::RTagInfo& aElement,
const Xml::RAttributeArray& aAttributes,
const TDesC& aParentId,
const TDesC& aParentNamespace )
{
CNcdSubParser::ConstructL( aElement );
DLTRACEIN(("depth=%d tag=%S",iDepth,iTag));
DLINFO((_L("parent=%S namespace=%S"),&aParentId,&aParentNamespace));
NcdProtocolUtils::AssignDesL( iParentNamespace, aParentNamespace );
TPtrC8 type = AttributeValue( KAttrType, aAttributes );
if( type == KNullDesC8 )
{
type.Set( AttributePrefix( KAttrXsiType, aAttributes ) );
}
if( type == KValueFolderRef )
{
CNcdPreminetProtocolFolderRefImpl* folderRef = CNcdPreminetProtocolFolderRefImpl::NewL();
iFolderRef = folderRef;
DLINFO(("New Folder ref!"));
TPtrC8 count = AttributeValue( KAttrCount, aAttributes );
if( count != KNullDesC8 )
{
folderRef->iCount = NcdProtocolUtils::DesDecToIntL( count );
}
TPtrC8 authorizedCount = AttributeValue( KAttrAuthorizedCount, aAttributes );
if( count != KNullDesC8 )
{
folderRef->iAuthorizedCount = NcdProtocolUtils::DesDecToIntL( count );
}
// @ Description
NcdProtocolUtils::AssignDesL( iFolderRef->iParentId, aParentId );
NcdProtocolUtils::AssignDesL( iFolderRef->iId, AttributeValue( KAttrId, aAttributes ) );
NcdProtocolUtils::AssignDesL( iFolderRef->iNamespace, AttributeValue( KAttrNamespace, aAttributes ) );
NcdProtocolUtils::AssignDesL( iFolderRef->iTimestamp, AttributeValue( KAttrTimestamp, aAttributes ) );
NcdProtocolUtils::AssignDesL( iFolderRef->iServerUri, iObservers->SessionOrigin() );
NcdProtocolUtils::AssignDesL( iFolderRef->iParentNamespace, *iParentNamespace );
NcdProtocolUtils::AssignDesL( iFolderRef->iRemoteUri, AttributeValue( KAttrUri, aAttributes ) );
if( *iFolderRef->iNamespace == KNullDesC )
{
// Namespace was not set, use parent.
NcdProtocolUtils::AssignDesL( iFolderRef->iNamespace, *iParentNamespace );
}
}
else if( type == KValueItemRef || type == KValueActionRef )
{
DLINFO(("New Item ref!"));
iItemRef = CNcdPreminetProtocolItemRefImpl::NewL();
// @ Description
NcdProtocolUtils::AssignDesL( iItemRef->iParentId, aParentId );
NcdProtocolUtils::AssignDesL( iItemRef->iId, AttributeValue( KAttrId, aAttributes ) );
NcdProtocolUtils::AssignDesL( iItemRef->iNamespace, AttributeValue( KAttrNamespace, aAttributes ) );
NcdProtocolUtils::AssignDesL( iItemRef->iTimestamp, AttributeValue( KAttrTimestamp, aAttributes ) );
NcdProtocolUtils::AssignDesL( iItemRef->iServerUri, iObservers->SessionOrigin() );
NcdProtocolUtils::AssignDesL( iItemRef->iParentNamespace, *iParentNamespace );
NcdProtocolUtils::AssignDesL( iItemRef->iRemoteUri, AttributeValue( KAttrUri, aAttributes ) );
if( *iItemRef->iNamespace == KNullDesC )
{
// Namespace was not set, use parent.
NcdProtocolUtils::AssignDesL( iItemRef->iNamespace, *iParentNamespace );
}
}
else
{
// unknown type!
DLERROR(("Unknown item type=%S",&type));
// Should there be more some informatic error?
}
DLTRACEOUT((""));
}
AttributeValue SpannerPackedNormalAttribute::inherit(const AttributeValue& parentValue) const {
return AttributeValue(parentValue.getAttribute());
}
TEST_F(ConfigNodeTest, AttributeValue)
{
const auto node = config.LoadFromStringAndGetFirstChild(ConfigNodeData_1);
EXPECT_EQ("hello", node.AttributeValue("id"));
}
void CNcdPreminetProtocolEntityRefParser::OnStartElementL( const Xml::RTagInfo& aElement,
const Xml::RAttributeArray& aAttributes,
TInt aErrorCode)
{
DLTRACE((""));
if( iSubParser )
{
// Use existing subparser.
iSubParser->OnStartElementL( aElement, aAttributes, aErrorCode );
}
else if( iFolderRef == 0 && iItemRef == 0 )
{
// Skip everything if there was no supported type found earlier.
DLERROR(("Skipping unknown entityref"));
iSubParser = CNcdUnknownParser::NewL( *iObservers, *this, iDepth+1, aElement, aAttributes );
}
else
{
// If there is no subparser, we should handle all tags ourselves.
TPtrC8 tag( aElement.LocalName().DesC() );
DLTRACE(("entity start tag=%S error=%d depth=%d",&aElement.LocalName().DesC(),aErrorCode,iDepth));
// First handle simple tags if we can.
if( tag == KTagValidUntil )
{
DLTRACE(("validuntil delta=%S",&AttributeValue(KAttrDelta,aAttributes)));
if( iItemRef )
{
iItemRef->iValidUntilDelta =
NcdProtocolUtils::DesDecToIntL( AttributeValue( KAttrDelta, aAttributes ) );
iItemRef->iValidUntilAutoUpdate = EFalse;
NcdProtocolUtils::DesToBool( iItemRef->iValidUntilAutoUpdate,
AttributeValue( KAttrAutoUpdate, aAttributes ) );
}
else
{
DASSERT( iFolderRef );
iFolderRef->iValidUntilDelta =
NcdProtocolUtils::DesDecToIntL( AttributeValue( KAttrDelta, aAttributes ) );
iFolderRef->iValidUntilAutoUpdate = EFalse;
NcdProtocolUtils::DesToBool( iFolderRef->iValidUntilAutoUpdate,
AttributeValue( KAttrAutoUpdate, aAttributes ) );
}
}
else if( tag == KTagQueries )
{
DLTRACE(("queries"));
// We don't really need to handle this tag at all, it suffices to react to
// individual <query> tags. This assumes that <query> tags don't come anywhere else
// in this entity.
}
else if( tag == KTagQuery )
{
TInt queryId = NcdProtocolUtils::DesDecToIntL( AttributeValue( KAttrId, aAttributes ) );
DLTRACE(("query id=%d",queryId));
if( iItemRef )
{
User::LeaveIfError( iItemRef->iQueries.Append( queryId ) );
}
else
{
User::LeaveIfError( iFolderRef->iQueries.Append( queryId ) );
}
}
else if( tag == KTagEntity && iFolderRef )
{
DLTRACE(("subentity for folder"));
// Subentities, this is allowed for folderrefs.
// : Observer callback here, the parent entity is finished?
// This might result in child entities finishing before the parent?
iSubParser = CNcdPreminetProtocolEntityRefParser::NewL( *iObservers, *this, iDepth+1, aElement, aAttributes,
iFolderRef->Id() /*parent entity id*/, *iParentNamespace );
}
else
{
iSubParser = CNcdUnknownParser::NewL( *iObservers, *this, iDepth+1, aElement, aAttributes );
}
}
}
