std::string FunctionReference::getDebugName() {
if (getNamespace().size() > 0) {
return getNamespace() + "." + getName();
} else {
return getName();
}
}
void IndexArticle::readEntriesB()
{
try
{
zim::size_type categoryCount[4];
zim::Blob b = getData();
ptrstream data(const_cast<char*>(b.data()), const_cast<char*>(b.end()));
for (unsigned c = 0; c < 4; ++c)
categoryCount[c] = getSizeValue(data);
for (unsigned c = 0; c < 4; ++c)
{
log_debug("read " << categoryCount[c] << " entries for category " << c);
for (unsigned n = 0; n < categoryCount[c]; ++n)
{
Entry entry;
entry.index = getSizeValue(data);
if (getNamespace() == 'X')
entry.pos = getNamespace() ? getSizeValue(data) : 0;
entries[c].push_back(entry);
}
}
}
catch (const Eof&)
{
log_error("end of file when reading index entries for article " << getTitle());
return;
}
}
Status ClusterAggregate::aggPassthrough(OperationContext* txn,
const Namespaces& namespaces,
std::shared_ptr<DBConfig> conf,
BSONObj cmdObj,
BSONObjBuilder* out,
int queryOptions) {
// Temporary hack. See comment on declaration for details.
auto shardStatus = grid.shardRegistry()->getShard(txn, conf->getPrimaryId());
if (!shardStatus.isOK()) {
return shardStatus.getStatus();
}
ShardConnection conn(shardStatus.getValue()->getConnString(), "");
BSONObj result = aggRunCommand(conn.get(), namespaces, cmdObj, queryOptions);
conn.done();
// First append the properly constructed writeConcernError. It will then be skipped
// in appendElementsUnique.
if (auto wcErrorElem = result["writeConcernError"]) {
appendWriteConcernErrorToCmdResponse(shardStatus.getValue()->getId(), wcErrorElem, *out);
}
out->appendElementsUnique(result);
BSONObj responseObj = out->asTempObj();
if (ResolvedView::isResolvedViewErrorResponse(responseObj)) {
auto resolvedView = ResolvedView::fromBSON(responseObj);
auto request = AggregationRequest::parseFromBSON(resolvedView.getNamespace(), cmdObj);
if (!request.isOK()) {
out->resetToEmpty();
return request.getStatus();
}
auto aggCmd = resolvedView.asExpandedViewAggregation(request.getValue());
if (!aggCmd.isOK()) {
out->resetToEmpty();
return aggCmd.getStatus();
}
out->resetToEmpty();
// We pass both the underlying collection namespace and the view namespace here. The
// underlying collection namespace is used to execute the aggregation on mongoD. Any cursor
// returned will be registered under the view namespace so that subsequent getMore and
// killCursors calls against the view have access.
Namespaces nsStruct;
nsStruct.requestedNss = namespaces.requestedNss;
nsStruct.executionNss = resolvedView.getNamespace();
return ClusterAggregate::runAggregate(txn, nsStruct, aggCmd.getValue(), queryOptions, out);
}
return getStatusFromCommandResult(result);
}
bool Multiname::matches(const Multiname* qname) const
{
// For attributes (XML::getprop page 12)
//if (((n.[[Name]].localName == "*") || (n.[[Name]].localName == a.[[Name]].localName)) &&
// ((n.[[Name]].uri == nulll) || (n.[[Name]].uri == a.[[Name]].uri)))
// For regular element props (XML::getprop page 12)
// if (n.localName = "*" OR m2 and (m2.localName == n.localName)
// and (!n.uri) or (m2) and (n.uri == m2.uri)))
//Stringp n1 = core->string(this->name);
if (qname)
{
//Stringp n2 = core->string(m2->name);
if (this->isAttr() != qname->isAttr())
return false;
}
// An anyName that is not qualified matches all properties
if (this->isAnyName() && !this->isQName())
return true;
// Not an anyName, if m2 is valid, verify names are identical
if (!this->isAnyName() && qname && (this->name != qname->getName()))
return false;
if (!qname)
return false;
if (this->isAnyNamespace())
return true;
// find a matching namespace between m2 and this
// if no match return false
Stringp u2 = qname->getNamespace()->getURI();
uint8 type2 = (uint8)(qname->getNamespace()->getType());
//Stringp s2 = core->string(u2);
for (int i = 0; i < this->namespaceCount(); i++)
{
// We'd like to just compare namespace objects but we need
// to check URIs since two namespaces with different prefixes
// are considered a match
Stringp u1 = getNamespace(i)->getURI();
uint8 type1 = (uint8)(getNamespace(i)->getType());
//Stringp s1 = core->string(u1);
if (u1 == u2 && type1 == type2)
return true;
}
return false;
}
//#ifdef AVMPLUS_VERBOSE
// Made available in non-AVMPLUS_VERBOSE builds for describeType
Stringp Multiname::format(AvmCore* core , MultiFormat form) const
{
Stringp attr = this->isAttr() ? core->newString("@") : (Stringp)core->kEmptyString;
Stringp name = this->isAnyName()
? core->newString("*")
: (this->isRtname()
? core->newString("[]")
: getName());
if (isAnyNamespace())
{
return core->concatStrings(attr, core->concatStrings(core->newString("*::"), name));
}
else if (isRtns())
{
return core->concatStrings(attr, core->concatStrings(core->newString("[]::"), name));
}
else if (namespaceCount() == 1 && isQName())
{
return format(core, getNamespace(), core->concatStrings(attr,name), false, false);
}
else
{
// various switches
bool showNs = (form == MULTI_FORMAT_FULL) || (form == MULTI_FORMAT_NS_ONLY);
bool showName = (form == MULTI_FORMAT_FULL) || (form == MULTI_FORMAT_NAME_ONLY);
bool showBrackets = (form == MULTI_FORMAT_FULL);
Stringp s = attr;
if (showNs)
{
if (showBrackets)
s = core->concatStrings(s, core->newString("{"));
for (int i=0,n=namespaceCount(); i < n; i++)
{
if (getNamespace(i)==core->publicNamespace)
s = core->concatStrings(s, core->newString("public"));
else
s = core->concatStrings(s, getNamespace(i)->getURI());
if (i+1 < n)
s = core->concatStrings(s, core->newString(","));
}
if (showBrackets)
s = core->concatStrings(s, core->newString("}::"));
}
if (showName)
s = core->concatStrings(s, name);
return s;
}
}
Status checkAuthForWriteCommand(AuthorizationSession* authzSession,
BatchedCommandRequest::BatchType cmdType,
const OpMsgRequest& request) {
std::vector<Privilege> privileges;
ActionSet actionsOnCommandNSS;
if (shouldBypassDocumentValidationForCommand(request.body)) {
actionsOnCommandNSS.addAction(ActionType::bypassDocumentValidation);
}
NamespaceString cmdNSS;
if (cmdType == BatchedCommandRequest::BatchType_Insert) {
auto op = Insert::parse(IDLParserErrorContext("insert"), request);
cmdNSS = op.getNamespace();
if (!op.getNamespace().isSystemDotIndexes()) {
actionsOnCommandNSS.addAction(ActionType::insert);
} else {
// Special-case indexes until we have a command
const auto swNssToIndex = getIndexedNss(op.getDocuments());
if (!swNssToIndex.isOK()) {
return swNssToIndex.getStatus();
}
const auto& nssToIndex = swNssToIndex.getValue();
privileges.push_back(
Privilege(ResourcePattern::forExactNamespace(nssToIndex), ActionType::createIndex));
}
} else if (cmdType == BatchedCommandRequest::BatchType_Update) {
auto op = Update::parse(IDLParserErrorContext("update"), request);
cmdNSS = op.getNamespace();
actionsOnCommandNSS.addAction(ActionType::update);
// Upsert also requires insert privs
if (containsUpserts(op.getUpdates())) {
actionsOnCommandNSS.addAction(ActionType::insert);
}
} else {
fassert(17251, cmdType == BatchedCommandRequest::BatchType_Delete);
auto op = Delete::parse(IDLParserErrorContext("delete"), request);
cmdNSS = op.getNamespace();
actionsOnCommandNSS.addAction(ActionType::remove);
}
if (!actionsOnCommandNSS.empty()) {
privileges.emplace_back(ResourcePattern::forExactNamespace(cmdNSS), actionsOnCommandNSS);
}
if (authzSession->isAuthorizedForPrivileges(privileges))
return Status::OK();
return Status(ErrorCodes::Unauthorized, "unauthorized");
}
bool Material::parseTechnique(Properties* techniqueProperties)
{
auto technique = Technique::create(this);
_techniques.pushBack(technique);
// first one is the default one
if (!_currentTechnique)
_currentTechnique = technique;
// name
technique->setName(techniqueProperties->getId());
// passes
auto space = techniqueProperties->getNextNamespace();
while (space)
{
const char* name = space->getNamespace();
if (strcmp(name, "pass") == 0)
{
parsePass(technique, space);
}
else if (strcmp(name, "renderState") == 0)
{
parseRenderState(this, space);
}
space = techniqueProperties->getNextNamespace();
}
return true;
}
bool Material::parsePass(Technique* technique, Properties* passProperties)
{
auto pass = Pass::create(technique);
technique->addPass(pass);
// Pass can have 3 different namespaces:
// - one or more "sampler"
// - one "renderState"
// - one "shader"
auto space = passProperties->getNextNamespace();
while (space)
{
const char* name = space->getNamespace();
if (strcmp(name, "shader") == 0)
parseShader(pass, space);
else if (strcmp(name, "renderState") == 0)
parseRenderState(pass, space);
else {
CCASSERT(false, "Invalid namespace");
return false;
}
space = passProperties->getNextNamespace();
}
return true;
}
int NamespaceAddTarget(namespaceref ns, vref name, int index)
{
int existingFunction = NamespaceAddFunction(ns, name, index);
if (existingFunction >= 0)
{
return existingFunction;
}
existingFunction = IntHashMapSet(&getNamespace(ns)->targetIndex, intFromRef(name), index + 1);
assert(!existingFunction);
return -1;
}
void
startVolume()
{
ASSERT(not vol_);
startVolManager();
vol_ = newVolume("volume1",
getNamespace());
ASSERT(vol_);
dStore_ = vol_->getDataStore();
ASSERT(dStore_);
}
void NamespaceDispose(void)
{
Namespace *ns;
const Namespace *limit;
if (initialised)
{
limit = (Namespace*)BVGetPointer(&namespaceData, BVSize(&namespaceData));
for (ns = getNamespace(1); ns < limit; ns++)
{
disposeNamespace(ns);
}
BVDispose(&namespaceData);
IntHashMapDispose(&nameNamespace);
}
}
bool SFXSource::_setStatus( SFXStatus status )
{
if ( mStatus == status )
return false;
mStatus = status;
// Do the callback if we have it.
const char* statusString = SFXStatusToString( mStatus );
if ( mStatusCallback && mStatusCallback[0] )
Con::executef( mStatusCallback, getIdString(), statusString );
else if ( getNamespace() )
Con::executef( this, "onStatusChange", statusString );
return true;
}
namespaceref NamespaceCreate(vref name)
{
Namespace *entry;
namespaceref ref =
refFromSize(BVSize(&namespaceData) / sizeof(Namespace));
BVGrow(&namespaceData, sizeof(Namespace));
entry = getNamespace(ref);
entry->name = name;
IntHashMapInit(&entry->namespaces, 1);
IntHashMapInit(&entry->fieldIndex, 32);
IntHashMapInit(&entry->functionIndex, 32);
IntHashMapInit(&entry->targetIndex, 32);
if (name)
{
IntHashMapAdd(&nameNamespace, intFromRef(name), intFromRef(ref));
}
return ref;
}
bool Material::parseShader(Pass* pass, Properties* shaderProperties)
{
// vertexShader
const char* vertShader = getOptionalString(shaderProperties, "vertexShader", nullptr);
// fragmentShader
const char* fragShader = getOptionalString(shaderProperties, "fragmentShader", nullptr);
// compileTimeDefines
const char* compileTimeDefines = getOptionalString(shaderProperties, "defines", "");
if (vertShader && fragShader)
{
auto glProgramState = GLProgramState::getOrCreateWithShaders(vertShader, fragShader, compileTimeDefines);
pass->setGLProgramState(glProgramState);
// Parse uniforms only if the GLProgramState was created
auto property = shaderProperties->getNextProperty();
while (property)
{
if (isValidUniform(property))
{
parseUniform(glProgramState, shaderProperties, property);
}
property = shaderProperties->getNextProperty();
}
auto space = shaderProperties->getNextNamespace();
while (space)
{
const char* name = space->getNamespace();
if (strcmp(name, "sampler") == 0)
{
parseSampler(glProgramState, space);
}
space = shaderProperties->getNextNamespace();
}
}
return true;
}
void
truncate_sco_in_cache(SCO sconame,
uint64_t size,
bool must_exist = true)
{
CachedSCOPtr sco =
VolManager::get()->getSCOCache()->findSCO(getNamespace(),
sconame);
if (must_exist)
{
ASSERT_TRUE(sco != nullptr);
}
if (sco)
{
ASSERT_TRUE(fs::exists(sco->path()));
FileUtils::truncate(sco->path(),
size);
}
}
bool Material::parseProperties(Properties* materialProperties)
{
setName(materialProperties->getId());
auto space = materialProperties->getNextNamespace();
while (space)
{
const char* name = space->getNamespace();
if (strcmp(name, "technique") == 0)
{
parseTechnique(space);
}
else if (strcmp(name, "renderState") == 0)
{
parseRenderState(this, space);
}
space = materialProperties->getNextNamespace();
}
return true;
}
void CSVWorld::GenericCreator::updateNamespace()
{
std::string namespace_ = getNamespace();
mValidator->setNamespace (namespace_);
int index = mId->text().indexOf ("::");
if (index==-1)
{
// no namespace in old text
mId->setText (QString::fromUtf8 (namespace_.c_str()) + mId->text());
}
else
{
std::string oldNamespace =
Misc::StringUtils::lowerCase (mId->text().left (index).toUtf8().constData());
if (oldNamespace=="project" || oldNamespace=="session")
mId->setText (QString::fromUtf8 (namespace_.c_str()) + mId->text().mid (index+2));
}
}
XSNamespaceItem *XSElementDeclaration::getNamespaceItem()
{
return fXSModel->getNamespaceItem(getNamespace());
}
XSNamespaceItem *XSAttributeDeclaration::getNamespaceItem()
{
return fXSModel->getNamespaceItem(getNamespace());
}
int NamespaceAddFunction(namespaceref ns, vref name, int index)
{
return IntHashMapSet(&getNamespace(ns)->functionIndex, intFromRef(name), index + 1) - 1;
}
void startElement(
const XMLCh* namespaceURI,
const XMLCh* lName,
const XMLCh* qName,
const xercesc::Attributes& attrs)
{
std::shared_ptr<Fragment> fragment;
if (namespaceURI == XS(XMLConstants::XMLSchemaNamespace))
{
if (lName == L"group")
{
fragment = std::make_shared<SchemaGroupCompositor>();
}
else if (lName == L"all")
{
fragment = std::make_shared<SchemaAllCompositor>();
}
else if (lName == L"choice")
{
fragment = std::make_shared<SchemaChoiceCompositor>();
}
else if (lName == L"sequence")
{
fragment = std::make_shared<SchemaSequenceCompositor>();
}
else if (lName == L"complexType")
{
fragment = std::make_shared<TypeDeclaration>();
}
else if (lName == L"simpleType")
{
fragment = std::make_shared<SimpleTypeDeclaration>();
}
else if (lName == L"attribute")
{
fragment = std::make_shared<AttributeDeclaration>();
}
else if (lName == L"attributeGroup")
{
fragment = std::make_shared<AttributeGroupDeclaration>();
}
else if (lName == L"schema")
{
fragment = std::make_shared<Schema>();
setXSModel(constructXSModel());
setTargetNamespace(std::shared_ptr<const XMLCh>(attrs.getValue(L"targetNamespace")));
}
else if (lName == L"element")
{
auto elementName = std::shared_ptr<const XMLCh>(attrs.getValue(L"name"));
if (!getXSModel().get())
{
throw new XBRLException("An XML Schema element declaration was found outside of an XML Schema.");
}
auto targetNamespace = getTargetNamespace();
if (!targetNamespace.get())
{
throw new XBRLException("An XML Schema element was found without a target namespace.");
}
// Find the XS model element declaration for the element that has been started - if one can be found
std::shared_ptr<XSElementDeclaration> declaration;
// Handle anonymous schemas first - these are the tough case
if (targetNamespace.get())
{
// Get the list of namespaces declared in the model
auto nsItemList = std::shared_ptr<XSNamespaceItemList>(getXSModel()->getNamespaceItems());
// For each namespace ...
for (XMLSize_t i=0; i < nsItemList->size(); ++i)
{
auto nsItem = std::shared_ptr<XSNamespaceItem>(nsItemList->elementAt(i));
// Get a candidate element declaration if one exists
auto candidateDeclaration = std::shared_ptr<XSElementDeclaration>(nsItem->getElementDeclaration(elementName.get()));
if (candidateDeclaration.get())
{
// Get the URIs of the documents that were used to create elements in this namespace
auto locations = std::shared_ptr<const StringList>(nsItem->getDocumentLocations());
// Check to see if the current document URI is one of those documents and if so, the candidate could be good
for (XMLSize_t j=0; j < locations->size(); ++j)
{
auto location = locations->elementAt(j);
if (to_string(location) == contentHandler->getURI().toString())
{
// Throw an exception if we find two feasible candidate element declarations in the Schema model
if (declaration.get()) throw new XBRLException("Potentially ambiguous anonymous Schema problem.");
declaration = candidateDeclaration;
}
}
}
}
if (!declaration.get()) throw new XBRLException("An element declaration was found that could not be handled.");
// Handle the easy case where the schema specifies its target namespace
}
else if (elementName.get())
{
declaration =
std::shared_ptr<XSElementDeclaration>(
getXSModel()->getElementDeclaration(elementName.get(),
getTargetNamespace().get()));
}
// Determine what substitution groups the element is in - if any.
if (declaration.get())
{
auto sgDeclaration = std::shared_ptr<XSElementDeclaration>(declaration->getSubstitutionGroupAffiliation());
while (sgDeclaration.get())
{
if (to_string(sgDeclaration->getNamespace()) == XMLConstants::XBRL21Namespace)
{
if (sgDeclaration->getName() == L"item")
{
fragment = std::shared_ptr<Concept>();
break;
}
else if (sgDeclaration->getName() == L"tuple")
{
fragment = std::shared_ptr<Concept>();
break;
}
}
if (to_string(sgDeclaration->getNamespace()) == XMLConstants::XBRL21LinkNamespace)
{
//if (sgDeclaration->getName() == L"part")
// fragment = std::shared_ptr<ReferencePartDeclaration>();
break;
}
sgDeclaration =
std::shared_ptr<XSElementDeclaration>(sgDeclaration->getSubstitutionGroupAffiliation());
}
}
if (!fragment.get())
{
fragment = std::shared_ptr<ElementDeclaration>();
}
}
if (fragment.get())
{
outer.lock()->processFragment(fragment, attrs);
}
}
}
QString
vleSmDT::getData()
{
QString tpl = "/**\n" \
" * @file {{classname}}.cpp\n" \
" * @author ...\n" \
" * ...\n" \
" */\n\n" \
"/*\n" \
" * @@tagdynamic@@\n" \
" * @@tagdepends: vle.discrete-time @@endtagdepends\n" \
"*/\n\n" \
"#include <vle/DiscreteTimeDbg.hpp>\n" \
"#include <vle/devs/DynamicsDbg.hpp>\n\n" \
"{{includes}}" \
"namespace vd = vle::devs;\n\n" \
"namespace vv = vle::value;\n\n" \
"namespace vle {\n" \
"namespace discrete_time {\n" \
"namespace {{namespace}} {\n\n" \
"class {{classname}} : public DiscreteTimeDyn\n" \
"{\n" \
"public:\n" \
"{{classname}}(\n" \
" const vd::DynamicsInit& init,\n" \
" const vd::InitEventList& evts)\n" \
" : DiscreteTimeDyn(init, evts)\n" \
"{\n" \
"{{for i in var}}" \
" {{var^i}}.init(this, \"{{var^i}}\", evts);\n" \
"{{end for}}" \
"{{for i in init_value_var}}" \
" {{init_value_var^i}}.init_value({{init_value_val^i}});\n" \
"{{end for}}" \
"{{construct}}" \
"\n" \
"}\n" \
"\n" \
"virtual ~{{classname}}()\n" \
"{}\n" \
"\n" \
"void compute(const vle::devs::Time& t)\n" \
"{\n" \
"{{compute}}" \
"}\n" \
"\n" \
"{{for i in var}}" \
" Var {{var^i}};\n" \
"{{end for}}" \
"{{userSection}}" \
"};\n\n" \
"} // namespace {{namespace}}\n" \
"} // namespace discrete_time\n" \
"} // namespace vle\n\n" \
"DECLARE_DYNAMICS(" \
"vle::discrete_time::{{namespace}}::{{classname}})\n\n";
vle::utils::Template vleTpl(tpl.toStdString());
vleTpl.stringSymbol().append("classname", getClassName().toStdString());
vleTpl.stringSymbol().append("namespace", getNamespace().toStdString());
vleTpl.listSymbol().append("var");
vleTpl.listSymbol().append("init_value_var");
vleTpl.listSymbol().append("init_value_val");
QDomNodeList variablesXml = variablesFromDoc();
for (int i = 0; i < variablesXml.length(); i++) {
QDomNode variable = variablesXml.item(i);
QString varName = variable.attributes().namedItem("name").nodeValue();
vle::value::Value* val = getInitialValue(varName);
if (val) {
vleTpl.listSymbol().append("init_value_var", varName.toStdString());
vleTpl.listSymbol().append("init_value_val", val->writeToString());
delete val;
}
vleTpl.listSymbol().append("var", varName.toStdString());
}
vleTpl.stringSymbol().append("includes", "");
vleTpl.stringSymbol().append("compute", getComputeBody().toStdString());
vleTpl.stringSymbol().append("construct","");
vleTpl.stringSymbol().append("userSection","");
std::ostringstream out;
vleTpl.process(out);
return QString(out.str().c_str());
}
XSNamespaceItem *XSModelGroupDefinition::getNamespaceItem()
{
return fXSModel->getNamespaceItem(getNamespace());
}
int NamespaceGetTarget(namespaceref ns, vref name)
{
return IntHashMapGet(&getNamespace(ns)->targetIndex, intFromRef(name)) - 1;
}
int NamespaceGetField(namespaceref ns, vref name)
{
return IntHashMapGet(&getNamespace(ns)->fieldIndex, intFromRef(name)) - 1;
}
void RespondElement::enterElement(const Arabica::DOM::Element<std::string>& node) {
// try to get the request id
if (!HAS_ATTR(node, "to")) {
LOG(ERROR) << "Respond element requires to attribute";
return;
}
if (HAS_ATTR(node, "to") && !_interpreter->getDataModel()) {
LOG(ERROR) << "Respond element with to requires datamodel";
return;
}
std::string requestId = _interpreter->getDataModel().evalAsString(ATTR(node, "to"));
// try to get the request object
InterpreterHTTPServlet* servlet = _interpreter->getHTTPServlet();
tthread::lock_guard<tthread::recursive_mutex> lock(servlet->getMutex());
if (servlet->getRequests().find(requestId) == servlet->getRequests().end()) {
LOG(ERROR) << "No matching HTTP request for respond element";
return;
}
assert(servlet->getRequests().find(requestId) != servlet->getRequests().end());
HTTPServer::Request httpReq = servlet->getRequests()[requestId];
assert(httpReq.evhttpReq != NULL);
HTTPServer::Reply httpReply(httpReq);
servlet->getRequests().erase(requestId);
// get the status or default to 200
std::string statusStr = (HAS_ATTR(node, "status") ? ATTR(node, "status") : "200");
if (!isNumeric(statusStr.c_str(), 10)) {
LOG(ERROR) << "Respond element with non-numeric status " << statusStr;
return;
}
httpReply.status = strTo<int>(statusStr);;
// extract the content
Arabica::XPath::NodeSet<std::string> contents = InterpreterImpl::filterChildElements(_interpreter->getNameSpaceInfo().getXMLPrefixForNS(getNamespace()) + "content", node);
if (contents.size() > 0) {
Arabica::DOM::Element<std::string> contentElem = Arabica::DOM::Element<std::string>(contents[0]);
if (HAS_ATTR(contentElem, "expr")) { // -- content is evaluated string from datamodel ------
if (_interpreter->getDataModel()) {
try {
Data contentData = _interpreter->getDataModel().getStringAsData(ATTR(contentElem, "expr"));
if (contentData.atom.length() > 0) {
httpReply.content = contentData.atom;
httpReply.headers["Content-Type"] = "text/plain";
} else if (contentData.binary) {
httpReply.content = std::string(contentData.binary.getData(), contentData.binary.getSize());
httpReply.headers["Content-Type"] = contentData.binary.getMimeType();
} else if (contentData.node) {
std::stringstream ss;
ss << contentData.node;
httpReply.content = ss.str();;
httpReply.headers["Content-Type"] = "application/xml";
} else {
httpReply.content = Data::toJSON(contentData);
httpReply.headers["Content-Type"] = "application/json";
}
} catch (Event e) {
LOG(ERROR) << "Syntax error with expr in content child of Respond element:" << std::endl << e << std::endl;
return;
}
} else {
LOG(ERROR) << "content element has expr attribute but no datamodel is specified.";
return;
}
} else if (HAS_ATTR(contentElem, "file") || HAS_ATTR(contentElem, "fileexpr")) { // -- content is from file ------
URL file;
if (HAS_ATTR(contentElem, "fileexpr")) {
if (_interpreter->getDataModel()) {
try {
file = "file://" + _interpreter->getDataModel().evalAsString(ATTR(contentElem, "fileexpr"));
} catch (Event e) {
LOG(ERROR) << "Syntax error with fileexpr in content child of Respond element:" << std::endl << e << std::endl;
return;
}
}
} else {
file = "file://" + ATTR(contentElem, "fileexpr");
}
if (file) {
httpReply.content = file.getInContent();
size_t lastDot;
if ((lastDot = file.path().find_last_of(".")) != std::string::npos) {
std::string extension = file.path().substr(lastDot + 1);
std::string mimeType = URL::getMimeType(extension);
if (mimeType.length() > 0) {
httpReply.headers["Content-Type"] = mimeType;
}
}
}
} else if (contents[0].hasChildNodes()) { // -- content embedded as child nodes ------
httpReply.content = contents[0].getFirstChild().getNodeValue();
} else {
LOG(ERROR) << "content element does not specify any content.";
return;
}
}
// process headers
Arabica::XPath::NodeSet<std::string> headers = InterpreterImpl::filterChildElements(_interpreter->getNameSpaceInfo().getXMLPrefixForNS(getNamespace()) + "header", node);
for (int i = 0; i < headers.size(); i++) {
Arabica::DOM::Element<std::string> headerElem = Arabica::DOM::Element<std::string>(headers[i]);
std::string name;
if (HAS_ATTR(headerElem, "name")) {
name = ATTR(headerElem, "name");
} else if(HAS_ATTR(headerElem, "nameexpr")) {
if (_interpreter->getDataModel()) {
try {
name = _interpreter->getDataModel().evalAsString(ATTR(headerElem, "nameexpr"));
} catch (Event e) {
LOG(ERROR) << "Syntax error with nameexpr in header child of Respond element:" << std::endl << e << std::endl;
return;
}
} else {
LOG(ERROR) << "header element has nameexpr attribute but no datamodel is specified.";
return;
}
} else {
LOG(ERROR) << "header element has no name or nameexpr attribute.";
return;
}
std::string value;
if (HAS_ATTR(headerElem, "value")) {
value = ATTR(headerElem, "value");
} else if(HAS_ATTR(headerElem, "valueexpr")) {
if (_interpreter->getDataModel()) {
try {
value = _interpreter->getDataModel().evalAsString(ATTR(headerElem, "valueexpr"));
} catch (Event e) {
LOG(ERROR) << "Syntax error with valueexpr in header child of Respond element:" << std::endl << e << std::endl;
return;
}
} else {
LOG(ERROR) << "header element has valueexpr attribute but no datamodel is specified.";
return;
}
} else {
LOG(ERROR) << "header element has no value or valueexpr attribute.";
return;
}
httpReply.headers[name] = value;
}
// send the reply
HTTPServer::reply(httpReply);
servlet->getRequests().erase(requestId);
}
void LocalNode::listenLocalNetwork()
{
NodeNetwork::setupLocalNode(getNamespace(), this->mpImpl);
}
int NamespaceGetFunction(namespaceref ns, vref name)
{
return IntHashMapGet(&getNamespace(ns)->functionIndex, intFromRef(name)) - 1;
}
void Properties::resolveInheritance(const char* id)
{
// Namespaces can be defined like so:
// "name id : parentID { }"
// This method merges data from the parent namespace into the child.
// Get a top-level namespace.
Properties* derived;
if (id)
{
derived = getNamespace(id);
}
else
{
derived = getNextNamespace();
}
while (derived)
{
// If the namespace has a parent ID, find the parent.
if (!derived->_parentID.empty())
{
Properties* parent = getNamespace(derived->_parentID.c_str());
if (parent)
{
resolveInheritance(parent->getId());
// Copy the child.
Properties* overrides = new (std::nothrow) Properties(*derived);
// Delete the child's data.
for (size_t i = 0, count = derived->_namespaces.size(); i < count; i++)
{
CC_SAFE_DELETE(derived->_namespaces[i]);
}
// Copy data from the parent into the child.
derived->_properties = parent->_properties;
derived->_namespaces = std::vector<Properties*>();
std::vector<Properties*>::const_iterator itt;
for (const auto space: parent->_namespaces)
{
derived->_namespaces.push_back(new (std::nothrow) Properties(*space));
}
derived->rewind();
// Take the original copy of the child and override the data copied from the parent.
derived->mergeWith(overrides);
// Delete the child copy.
CC_SAFE_DELETE(overrides);
}
}
// Resolve inheritance within this namespace.
derived->resolveInheritance();
// Get the next top-level namespace and check again.
if (!id)
{
derived = getNextNamespace();
}
else
{
derived = NULL;
}
}
}
XSNamespaceItem *XSComplexTypeDefinition::getNamespaceItem()
{
return fXSModel->getNamespaceItem(getNamespace());
}