/*
* Adds node to routing table
*/
bool KBucket::insert(const Node::Ptr& node)
{
if(node->isInList)
return true; // node is already in the table
string ip = node->getIdentity().getIp();
string port = node->getIdentity().getUdpPort();
// allow only one same IP:port
bool isAcceptable = (ipMap.find(ip + ":" + port) == ipMap.end());
if((nodes.size() < (K * ID_BITS)) && isAcceptable)
{
nodes.push_back(node);
node->isInList = true;
ipMap.insert(ip + ":" + port);
if(DHT::getInstance())
DHT::getInstance()->setDirty();
return true;
}
return isAcceptable;
}
void XercesUpdateFactory::addToPutSet(const Node::Ptr &node, const LocationInfo *location, DynamicContext *context)
{
Node::Ptr root = node->root(context);
Sequence docURISeq = root->dmDocumentURI(context);
const XMLCh *docuri = 0;
if(!docURISeq.isEmpty()) {
docuri = docURISeq.first()->asString(context);
}
PutItem item(docuri, root, location, context);
std::pair<PutSet::iterator, bool> res = putSet_.insert(item);
if(!res.second && !res.first->node->equals(item.node)) {
if(context->getMessageListener() != 0) {
context->getMessageListener()->warning(X("In the context of this expression"), res.first->location);
}
XMLBuffer buf;
buf.append(X("Document writing conflict for URI \""));
buf.append(item.uri);
buf.append(X("\""));
XQThrow3(ASTException, X("XercesUpdateFactory::addToPutSet"), buf.getRawBuffer(), location);
}
}
/*
* Sends request to create connection with me
*/
void ConnectionManager::revConnectToMe(const Node::Ptr& node, const AdcCommand& cmd)
{
// don't allow connection if we didn't proceed a handshake
//if(!node->isOnline())
// return;
// this is valid for active-passive connections only
if(!ClientManager::getInstance()->isActive())
return;
const string& protocol = cmd.getParam(1);
const string& token = cmd.getParam(2);
bool secure;
if(protocol == CLIENT_PROTOCOL)
{
secure = false;
}
else if(protocol == SECURE_CLIENT_PROTOCOL_TEST && CryptoManager::getInstance()->TLSOk())
{
secure = true;
}
else
{
AdcCommand sta(AdcCommand::SEV_FATAL, AdcCommand::ERROR_PROTOCOL_UNSUPPORTED, "Protocol unknown", AdcCommand::TYPE_UDP);
sta.addParam("PR", protocol);
sta.addParam("TO", token);
DHT::getInstance()->send(sta, node->getIdentity().getIp(), static_cast<uint16_t>(Util::toInt(node->getIdentity().getUdpPort())),
node->getUser()->getCID(), node->getUdpKey());
return;
}
connect(node, token, secure);
}
Sequence FunctionLocalname::createSequence(DynamicContext* context, int flags) const
{
XPath2MemoryManager* memMgr = context->getMemoryManager();
Node::Ptr ctxNode;
if(getNumArgs() == 1) {
Sequence arg=getParamNumber(1,context)->toSequence(context);
if(arg.isEmpty())
return Sequence(context->getItemFactory()->createString(XERCES_CPP_NAMESPACE_QUALIFIER XMLUni::fgZeroLenString, context), memMgr);
ctxNode=arg.first();
}
else {
const Item::Ptr item = context->getContextItem();
if(item==NULLRCP)
XQThrow(FunctionException, X("FunctionLocalName::createSequence"),X("Undefined context item in fn:local-name [err:XPDY0002]"));
if(!item->isNode())
XQThrow(FunctionException, X("FunctionLocalName::createSequence"),X("The context item is not a node [err:XPTY0004]"));
ctxNode=item;
}
ATQNameOrDerived::Ptr name = ctxNode->dmNodeName(context);
if(name.notNull())
return Sequence(context->getItemFactory()->createString(((const ATQNameOrDerived*)name.get())->getName(), context), memMgr);
return Sequence(context->getItemFactory()->createString(XERCES_CPP_NAMESPACE_QUALIFIER XMLUni::fgZeroLenString, context), memMgr);
}
Item::Ptr UTransform::TransformResult::next(DynamicContext *context)
{
context->testInterrupt();
AutoVariableStoreReset reset(context, &scope_);
if(toDo_) {
toDo_ = false;
NodeSet copiedNodes = NodeSet(nodecompare(context));
VectorOfCopyBinding::const_iterator end = transform_->getBindings()->end();
for(VectorOfCopyBinding::const_iterator it = transform_->getBindings()->begin();
it != end; ++it) {
if((*it)->qname_ == 0) continue;
Sequence values = (*it)->expr_->createResult(context)->toSequence(context);
// Keep a record of the nodes that have been copied
Result valIt = values;
Item::Ptr val;
while((val = valIt->next(context)).notNull()) {
copiedNodes.insert((Node*)val.get());
}
scope_.setVar((*it)->uri_, (*it)->name_, values);
}
// Get the pending update list
PendingUpdateList pul = transform_->getModifyExpr()->createUpdateList(context);
// Check that the targets of the pending updates are copied nodes
for(PendingUpdateList::const_iterator i = pul.begin(); i != pul.end(); ++i) {
Node::Ptr target = i->getTarget();
while(copiedNodes.find(target) == copiedNodes.end()) {
target = target->dmParent(context);
if(target.isNull()) {
XQThrow3(StaticErrorException,X("UTransform::staticTyping"),
X("The target node of an update expression in the transform expression is not a node from the copy clauses [err:XUDY0014]"), &(*i));
}
}
}
// Apply the updates
AutoDelete<UpdateFactory> ufactory(context->createUpdateFactory());
ufactory->applyUpdates(pul, context, transform_->getRevalidationMode());
// Execute the return expression
result_ = transform_->getReturnExpr()->createResult(context);
}
Item::Ptr result = result_->next(context);
if(result.isNull()) {
result_ = 0;
return 0;
}
return result;
}
PendingUpdateList UInsertAsLast::createUpdateList(DynamicContext *context) const
{
Node::Ptr node = (Node*)target_->createResult(context)->next(context).get();
if(node->dmNodeKind() != Node::element_string &&
node->dmNodeKind() != Node::document_string)
XQThrow(XPath2TypeMatchException,X("UInsertAsLast::createUpdateList"),
X("It is a type error for the target expression of an insert as last expression not to be a single element "
"or document [err:XUTY0005]"));
Sequence alist(context->getMemoryManager());
Sequence clist(context->getMemoryManager());
Result value = source_->createResult(context);
Item::Ptr item;
while((item = value->next(context)).notNull()) {
if(((Node*)item.get())->dmNodeKind() == Node::attribute_string) {
if(!clist.isEmpty())
XQThrow(ASTException,X("UInsertAsLast::createUpdateList"),
X("Attribute nodes must occur before other nodes in the source expression for an insert as last expression [err:XUTY0004]"));
// b. No attribute node in $alist may have a QName whose implied namespace binding conflicts with a namespace
// binding in the "namespaces" property of $target [err:XUDY0023].
ATQNameOrDerived::Ptr qname = ((Node*)item.get())->dmNodeName(context);
if(qname->getURI() != 0 && *(qname->getURI()) != 0) {
ATAnyURIOrDerived::Ptr uri = FunctionNamespaceURIForPrefix::uriForPrefix(qname->getPrefix(), node, context, this);
if(uri.notNull() && !XPath2Utils::equals(uri->asString(context), qname->getURI())) {
XMLBuffer buf;
buf.append(X("Implied namespace binding for the insert as last expression (\""));
buf.append(qname->getPrefix());
buf.append(X("\" -> \""));
buf.append(qname->getURI());
buf.append(X("\") conflicts with those already existing on the parent element of the target attribute [err:XUDY0023]"));
XQThrow3(DynamicErrorException, X("UInsertInto::createUpdateList"), buf.getRawBuffer(), this);
}
}
alist.addItem(item);
}
else
clist.addItem(item);
}
PendingUpdateList result;
if(!alist.isEmpty()) {
// 3. If $alist is not empty and into is specified, the following checks are performed:
// a. $target must be an element node [err:XUTY0022].
if(node->dmNodeKind() == Node::document_string)
XQThrow(XPath2TypeMatchException,X("UInsertInto::createUpdateList"),
X("It is a type error if an insert expression specifies the insertion of an attribute node into a document node [err:XUTY0022]"));
result.addUpdate(PendingUpdate(PendingUpdate::INSERT_ATTRIBUTES, node, alist, this));
}
if(!clist.isEmpty()) {
result.addUpdate(PendingUpdate(PendingUpdate::INSERT_INTO_AS_LAST, node, clist, this));
}
return result;
}
PendingUpdateList UReplaceValueOf::createUpdateList(DynamicContext *context) const
{
Node::Ptr node = (Node*)target_->createResult(context)->next(context).get();
if(node->dmNodeKind() == Node::document_string)
XQThrow(XPath2TypeMatchException,X("UReplaceValueOf::createUpdateList"),
X("The target expression of a replace expression does not return a single "
"node that is not a document node [err:XUTY0008]"));
XMLBuffer buf;
XQDOMConstructor::getStringValue(expr_, buf, context);
// If $target is a comment node, and $string contains two adjacent hyphens or ends with a hyphen, a dynamic error is raised [err:XQDY0072].
if(node->dmNodeKind() == Node::comment_string) {
bool foundOne = false;
for(const XMLCh *str = buf.getRawBuffer(); *str; ++str) {
if(*str == '-') {
if(foundOne) {
XQThrow(DynamicErrorException,X("UReplaceValueOf::createUpdateList"),
X("The replace value of expression would result in a comment node whose content contains two adjacent hyphens [err:XQDY0072]"));
}
else foundOne = true;
}
else {
foundOne = false;
}
}
if(foundOne) {
XQThrow(DynamicErrorException,X("UReplaceValueOf::createUpdateList"),
X("The replace value of expression would result in a comment node whose content ends with a hyphen [err:XQDY0072]"));
}
}
// If $target is a processing instruction node, and $string contains the substring "?>", a dynamic error is raised [err:XQDY0026].
else if(node->dmNodeKind() == Node::processing_instruction_string) {
bool foundQuestion = false;
for(const XMLCh *str = buf.getRawBuffer(); *str; ++str) {
if(*str == '?') {
foundQuestion = true;
}
else {
if(foundQuestion && *str == '>') {
XQThrow(DynamicErrorException,X("UReplaceValueOf::createUpdateList"),
X("The replace value of expression would result in a processing instruction node whose content includes the string \"?>\" [err:XQDY0026]"));
}
foundQuestion = false;
}
}
}
Item::Ptr value = context->getItemFactory()->createString(buf.getRawBuffer(), context);
if(node->dmNodeKind() == Node::element_string) {
return PendingUpdate(PendingUpdate::REPLACE_ELEMENT_CONTENT, node, value, this);
}
else {
return PendingUpdate(PendingUpdate::REPLACE_VALUE, node, value, this);
}
}
bool operator()(const Node::Ptr& lhs, const Node::Ptr& rhs)
{
auto costFgv1 = lhs->costFgv();
auto costFgv2 = rhs->costFgv();
if (costFgv1 == costFgv2) {
return lhs->time < rhs->time;
}
return costFgv1 > costFgv2;
}
void ConnectionManager::connect(const Node::Ptr& node, const string& token, bool secure)
{
// don't allow connection if we didn't proceed a handshake
if(!node->isOnline())
{
// do handshake at first
DHT::getInstance()->info(node->getIdentity().getIp(), node->getIdentity().getUdpPort(),
DHT::PING | DHT::MAKE_ONLINE, node->getUser()->getCID(), node->getUdpKey());
return;
}
bool active = ClientManager::getInstance()->isActive();
// if I am not active, send reverse connect to me request
AdcCommand cmd(active ? AdcCommand::CMD_CTM : AdcCommand::CMD_RCM, AdcCommand::TYPE_UDP);
cmd.addParam(secure ? SECURE_CLIENT_PROTOCOL_TEST : CLIENT_PROTOCOL);
if(active)
{
string port = secure ? dcpp::ConnectionManager::getInstance()->getSecurePort() : dcpp::ConnectionManager::getInstance()->getPort();
cmd.addParam(port);
}
cmd.addParam(token);
DHT::getInstance()->send(cmd, node->getIdentity().getIp(), node->getIdentity().getUdpPort(),
node->getUser()->getCID(), node->getUdpKey());
}
bool SequenceType::ItemType::matchesSchemaElement(const Node::Ptr &toBeTested, const DynamicContext* context) const
{
// retrieve the type of the element name
assert(m_pName!=NULL);
const XMLCh* elementNS=m_NameURI;
const XMLCh* elementName=m_pName->getName();
SchemaElementDecl *elemDecl=context->getDocumentCache()->getElementDecl(elementNS, elementName);
assert(elemDecl != NULL);
// 1. The name of the candidate node matches the specified ElementName or matches the name of an element in a
// substitution group headed by an element named ElementName.
ATQNameOrDerived::Ptr name = toBeTested->dmNodeName(context);
if(name.isNull()) return false;
const XMLCh *node_uri = ((const ATQNameOrDerived*)name.get())->getURI();
const XMLCh *node_name = ((const ATQNameOrDerived*)name.get())->getName();
if(!(XPath2Utils::equals(elementName, node_name)) ||
!(XPath2Utils::equals(elementNS, node_uri)))
{
// the node doesn't match the ElementName; check if it is in its substitution group
SchemaElementDecl* thisElemDecl=context->getDocumentCache()->getElementDecl(node_uri, node_name);
if(thisElemDecl==NULL) // the node to be tested has no type info
return false;
SchemaElementDecl* rootElemDecl=thisElemDecl->getSubstitutionGroupElem();
bool foundIt=false;
while (rootElemDecl)
{
if (XPath2Utils::equals(rootElemDecl->getBaseName(), elementName) &&
XPath2Utils::equals(context->getDocumentCache()->getSchemaUri(rootElemDecl->getURI()), elementNS))
{
foundIt = true;
break;
}
rootElemDecl = rootElemDecl->getSubstitutionGroupElem();
}
if(!foundIt)
return false;
}
// 2. derives-from(AT, ET) is true, where AT is the type of the candidate node and ET is the type declared for
// element ElementName in the in-scope element declarations.
ComplexTypeInfo* pTypeInfo=elemDecl->getComplexTypeInfo();
if(pTypeInfo && !toBeTested->hasInstanceOfType(pTypeInfo->getTypeUri(), pTypeInfo->getTypeLocalName(), context))
return false;
// 3. Either the nilled property of the candidate node is false, or the element declaration for ElementName in
// the in-scope element declarations is nillable.
if(toBeTested->dmNilled(context).get()->isTrue() &&
!(elemDecl->getMiscFlags() & SchemaSymbols::XSD_NILLABLE))
return false;
return true;
}
bool BoundFactsCalculator::HasIncomingEdgesFromLowerLevel(int curOrder, vector<Node::Ptr>& curNodes) {
for (auto nit = curNodes.begin(); nit != curNodes.end(); ++nit) {
Node::Ptr cur = *nit;
NodeIterator nbegin, nend;
cur->ins(nbegin, nend);
for (; nbegin != nend; ++nbegin)
if (analysisOrder[*nbegin] < curOrder) return true;
}
return false;
}
bool XercesURIResolver::resolveDocument(Sequence &result, const XMLCh* uri, DynamicContext* context, const QueryPathNode *projection)
{
Node::Ptr doc;
// Resolve the uri against the base uri
const XMLCh *systemId = uri;
XMLURL urlTmp(context->getMemoryManager());
if(urlTmp.setURL(context->getBaseURI(), uri, urlTmp)) {
systemId = context->getMemoryManager()->getPooledString(urlTmp.getURLText());
} else {
systemId = context->getMemoryManager()->getPooledString(uri);
}
// Check in the cache
DOMDocument *found = _documentMap.get((void*)systemId);
// Check to see if we can locate and parse the document
if(found == 0) {
try {
doc = const_cast<DocumentCache*>(context->getDocumentCache())->loadDocument(uri, context, projection);
found = (DOMDocument*)((DOMNode*)doc->getInterface(XercesConfiguration::gXerces));
_documentMap.put((void*)systemId, found);
_uriMap.put((void*)found, const_cast<XMLCh*>(systemId));
}
catch(const XMLParseException& e) {
XMLBuffer errMsg;
errMsg.set(X("Error parsing resource: "));
errMsg.append(uri);
errMsg.append(X(". Error message: "));
errMsg.append(e.getError());
errMsg.append(X(" [err:FODC0002]"));
XQThrow2(XMLParseException,X("XercesContextImpl::resolveDocument"), errMsg.getRawBuffer());
}
}
else {
doc = new XercesNodeImpl(found, (XercesURIResolver*)context->getDefaultURIResolver());
}
if(doc.notNull()) {
result.addItem(doc);
return true;
}
XMLBuffer errMsg;
errMsg.set(X("Error retrieving resource: "));
errMsg.append(uri);
errMsg.append(X(" [err:FODC0002]"));
XQThrow2(XMLParseException,X("XercesContextImpl::resolveDocument"), errMsg.getRawBuffer());
return false;
}
void DbXmlUpdateFactory::applyInsertBefore(const PendingUpdate &update, DynamicContext *context)
{
const DbXmlNodeImpl *next = (const DbXmlNodeImpl*)update.getTarget().get();
if (!next->isUpdateAble())
return;
Node::Ptr parent = next->dmParent(context);
NsDomNodeRef nextRef = next->getNsDomNode();
applyInserts(update,
(const DbXmlNodeImpl *)parent->getInterface(DbXmlNodeImpl::gDbXml),
nextRef.get(),
context,
false);
}
static
std::string
getDotLabel(Node::Ptr node)
{
if (node)
{
return node->name() == "unnamed" || node->name().find("AutoName$") != std::string::npos
? "\"\""
: "\"" + node->name() + "\"";
}
else
return "\"\"";
}
void DbXmlUpdateFactory::applyReplaceNode(const PendingUpdate &update, DynamicContext *context)
{
const DbXmlNodeImpl *target = (const DbXmlNodeImpl*)update.getTarget().get();
if (!target->isUpdateAble())
return;
Node::Ptr parent = target->dmParent(context);
// insert all new nodes *before* the target, then
// mark target for deletion
NsDomNodeRef targetRef = target->getNsDomNode();
applyInserts(update,
(const DbXmlNodeImpl *)parent->getInterface(DbXmlNodeImpl::gDbXml),
targetRef.get(),
context, false);
forDeletion_.insert(target);
}
PendingUpdateList URename::createUpdateList(DynamicContext *context) const
{
Node::Ptr node = (Node*)target_->createResult(context)->next(context).get();
if(node->dmNodeKind() != Node::element_string &&
node->dmNodeKind() != Node::attribute_string &&
node->dmNodeKind() != Node::processing_instruction_string)
XQThrow(XPath2TypeMatchException,X("URename::createUpdateList"),
X("It is a type error for the target expression of a rename expression not to be a single element, "
"attribute or processing instruction [err:XUTY0012]"));
ATQNameOrDerived::Ptr qname = (ATQNameOrDerived*)name_->createResult(context)->next(context).get();
// 3. The following checks are performed for error conditions:
// a. If $target is an element node, the "namespaces" property of $target must not include any namespace binding that conflicts
// with the implied namespace binding of $QName [err:XUDY0023].
if(node->dmNodeKind() == Node::element_string) {
ATAnyURIOrDerived::Ptr uri = FunctionNamespaceURIForPrefix::uriForPrefix(qname->getPrefix(), node, context, this);
if(uri.notNull() && !XPath2Utils::equals(uri->asString(context), qname->getURI())) {
XMLBuffer buf;
buf.append(X("Implied namespace binding for the rename expression (\""));
buf.append(qname->getPrefix());
buf.append(X("\" -> \""));
buf.append(qname->getURI());
buf.append(X("\") conflicts with those already existing on the target element [err:XUDY0023]"));
XQThrow3(DynamicErrorException, X("URename::createUpdateList"), buf.getRawBuffer(), this);
}
}
// b. If $target is an attribute node that has a parent, the "namespaces" property of parent($target) must not include any
// namespace binding that conflicts with the implied namespace binding of $QName [err:XUDY0023].
else if(node->dmNodeKind() == Node::attribute_string) {
Node::Ptr parentNode = node->dmParent(context);
if(parentNode.notNull() && qname->getURI() != 0 && *(qname->getURI()) != 0) {
ATAnyURIOrDerived::Ptr uri = FunctionNamespaceURIForPrefix::uriForPrefix(qname->getPrefix(), parentNode, context, this);
if(uri.notNull() && !XPath2Utils::equals(uri->asString(context), qname->getURI())) {
XMLBuffer buf;
buf.append(X("Implied namespace binding for the rename expression (\""));
buf.append(qname->getPrefix());
buf.append(X("\" -> \""));
buf.append(qname->getURI());
buf.append(X("\") conflicts with those already existing on the parent element of the target attribute [err:XUDY0023]"));
XQThrow3(DynamicErrorException, X("URename::createUpdateList"), buf.getRawBuffer(), this);
}
}
}
// c. If $target is processing instruction node, $QName must not include a non-empty namespace prefix. [err:XUDY0025].
else if(node->dmNodeKind() == Node::processing_instruction_string && !XPath2Utils::equals(qname->getPrefix(), XMLUni::fgZeroLenString))
XQThrow(XPath2TypeMatchException,X("URename::createUpdateList"),
X("The target of a rename expression is a processing instruction node, and the new name "
"expression returned a QName with a non-empty namespace prefix [err:XUDY0025]"));
return PendingUpdate(PendingUpdate::RENAME, node, qname, this);
}
void
addStar(Node::Ptr root, file::AssetLibrary::Ptr assets, std::vector<Star>& stars)
{
const unsigned int MAX_NUM_STARS = 20;
if (stars.size() == MAX_NUM_STARS)
{
std::cerr << "cannot add more stars." << std::endl;
return;
}
unsigned int numBranches = 4 + rand() % 4;
float outRadius = 0.9f + 0.2f * (rand() / float(RAND_MAX) - 0.5f);
float inRadius = outRadius * (0.5f + 0.1f * (rand() / float(RAND_MAX) - 0.5f));
auto starNode = Node::create("star_" + std::to_string(stars.size()))
->addComponent(Surface::create(
createStarLineGeometry(numBranches, inRadius, outRadius, assets->context()),
material::Material::create("material")
->set("diffuseColor", Color::hslaToRgba(rand() / float(RAND_MAX), 0.75f, 0.6f, 1.0f))
->set("lineThickness", 1.0f + 3.0f * (rand() / float(RAND_MAX))),
assets->effect("line")
))
->addComponent(Transform::create(Matrix4x4::create()->appendRotationZ(2.0f * float(M_PI) * rand() / (float) RAND_MAX)));
stars.push_back(Star());
stars.back().node = starNode;
stars.back().angRate = 0.01f + 0.05f * (rand() / float(RAND_MAX));
root->addChild(stars.back().node);
}
void
explodeModel(float magnitude,
float previousMagnitude,
Node::Ptr node)
{
assert(fabsf(magnitude) > 1e-6f);
assert(fabsf(previousMagnitude) > 1e-6f);
for (auto& child : node->children())
{
if (child->component<Transform>())
{
auto transform = child->component<Transform>()->matrix();
auto direction = transform->translation();
transform->appendTranslation(direction * (magnitude - previousMagnitude));
explodeModel(magnitude * 0.8f, previousMagnitude * 0.8f, child);
}
else
{
explodeModel(magnitude, previousMagnitude, child);
}
}
}
boost::optional<EntityCollection<Cell>>
NodeConnectivity::getCellsAttachedToNode(Node::Ptr const & vertex) const {
NodeCell_t::const_iterator it = node_cells_.find(vertex->id());
if (it == node_cells_.end())
return boost::optional<EntityCollection<Cell>>();
return boost::optional<EntityCollection<Cell>>(it->second);
}
void XercesUpdateFactory::applyReplaceAttribute(const PendingUpdate &update, DynamicContext *context)
{
const XercesNodeImpl *nodeImpl = (const XercesNodeImpl*)update.getTarget()->getInterface(Item::gXQilla);
DOMAttr *domnode = (DOMAttr*)nodeImpl->getDOMNode();
Node::Ptr parentNode = nodeImpl->dmParent(context);
DOMElement *element = domnode->getOwnerElement();
DOMDocument *doc = element->getOwnerDocument();
bool untyped = parentNode->dmNodeKind() == Node::element_string &&
XPath2Utils::equals(parentNode->getTypeName(), DocumentCache::g_szUntyped) &&
XPath2Utils::equals(parentNode->getTypeURI(), SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
Result children = update.getValue();
Item::Ptr item;
while((item = children->next(context)).notNull()) {
const XercesNodeImpl *childImpl = (const XercesNodeImpl*)item->getInterface(Item::gXQilla);
DOMNode *newChild = importNodeFix(doc, const_cast<DOMNode*>(childImpl->getDOMNode()), /*deep*/true);
// 1. Error checks:
// a. If the QNames of any two attribute nodes in $replacement have implied namespace bindings that conflict with
// each other, a dynamic error is raised [err:XUDY0024].
// b. If the QName of any attribute node in $replacement has an implied namespace binding that conflicts with a
// namespace binding in the "namespaces" property of parent($target), a dynamic error is raised [err:XUDY0024].
// Checks performed by UpdateFactory
// 2b. If the type-name property of parent($target) is xs:untyped, then upd:setToUntyped() is invoked
// on each element node in $replacement.
if(!untyped) setTypes(newChild, childImpl->getDOMNode());
// 2a. For each node in $replacement, the parent property is set to parent($target).
// 4a. If $target is an attribute node, the attributes property of parent($target) is modified by removing $target
// and adding the nodes in $replacement (if any).
// 4b. If $target is an attribute node, the namespaces property of parent($target) is modified to include namespace
// bindings for any attribute namespace prefixes in $replacement that did not already have bindings.
element->setAttributeNode((DOMAttr*)newChild);
}
// 3a. $target is marked for deletion.
forDeletion_.insert(domnode);
// 4d. upd:removeType(parent($target)) is invoked.
removeType(element);
// Use parentNode, since the attr replace could have removed the original attr
addToPutSet(parentNode, &update, context);
}
boost::optional<EntityCollection<Node>>
NodeConnectivity::getNodeNeighbors(Node::Ptr const & vertex) const {
NodeNeighbor_t::const_iterator it = node_neighbors_.find(vertex->id());
if (it == node_neighbors_.end())
return boost::optional<EntityCollection<Node>>();
return boost::optional<EntityCollection<Node>>(it->second);
}
void
bullet::PhysicsWorld::targetAddedHandler(AbstractComponent::Ptr controller,
Node::Ptr target)
{
if (targets().size() > 1)
throw std::logic_error("The same PhysicsWorld cannot be used twice.");
setSceneManager(target->root()->component<SceneManager>());
}
void BoundFactsCalculator::ReverseDFS(Node::Ptr cur) {
nodeColor[cur] = 1;
analysisOrder[cur] = orderStamp;
NodeIterator nbegin, nend;
cur->ins(nbegin, nend);
for (; nbegin != nend; ++nbegin)
if (nodeColor.find(*nbegin) == nodeColor.end())
ReverseDFS(*nbegin);
}
void XercesUpdateFactory::applyInsertAfter(const PendingUpdate &update, DynamicContext *context)
{
const XercesNodeImpl *nodeImpl = (const XercesNodeImpl*)update.getTarget()->getInterface(Item::gXQilla);
DOMNode *domnode = const_cast<DOMNode*>(nodeImpl->getDOMNode());
DOMNode *before = domnode->getNextSibling();
Node::Ptr parentNode = nodeImpl->dmParent(context);
DOMNode *parent = domnode->getParentNode();
DOMDocument *doc = const_cast<DOMDocument*>(XPath2Utils::getOwnerDoc(domnode));
bool untyped = parentNode->dmNodeKind() == Node::element_string &&
XPath2Utils::equals(parentNode->getTypeName(), DocumentCache::g_szUntyped) &&
XPath2Utils::equals(parentNode->getTypeURI(), SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
bool containsElementOrText = false;
Result children = update.getValue();
Item::Ptr item;
while((item = children->next(context)).notNull()) {
const XercesNodeImpl *childImpl = (const XercesNodeImpl*)item->getInterface(Item::gXQilla);
DOMNode *newChild = importNodeFix(doc, const_cast<DOMNode*>(childImpl->getDOMNode()), /*deep*/true);
if(childImpl->dmNodeKind() == Node::element_string ||
childImpl->dmNodeKind() == Node::text_string) {
containsElementOrText = true;
}
// If the type-name property of parent($target) is xs:untyped, then upd:setToUntyped() is invoked on each
// element or attribute node in $content.
if(!untyped) setTypes(newChild, childImpl->getDOMNode());
// For each node in $content, the parent property is set to parent($target).
// The children property of parent($target) is modified to add the nodes in $content just before $target,
// preserving their order.
parent->insertBefore(newChild, before);
}
// If at least one of the nodes in $content is an element or text node, upd:removeType(parent($target)) is invoked.
if(containsElementOrText) {
removeType(parent);
}
addToPutSet(update.getTarget(), &update, context);
}
/*
* Add new source to tth list
*/
void IndexManager::addSource(const TTHValue& tth, const Node::Ptr& node, uint64_t size, bool partial)
{
Source source;
source.setCID(node->getUser()->getCID());
source.setIp(node->getIdentity().getIp());
source.setUdpPort(node->getIdentity().getUdpPort());
source.setSize(size);
source.setExpires(GET_TICK() + (partial ? PFS_REPUBLISH_TIME : REPUBLISH_TIME));
source.setPartial(partial);
Lock l(cs);
TTHMap::iterator i = tthList.find(tth);
if(i != tthList.end())
{
// no user duplicites
SourceList& sources = i->second;
for(SourceList::iterator s = sources.begin(); s != sources.end(); ++s)
{
if(node->getUser()->getCID() == (*s).getCID())
{
// delete old item
sources.erase(s);
break;
}
}
// old items in front, new items in back
sources.push_back(source);
// if maximum sources reached, remove the oldest one
if(sources.size() > MAX_SEARCH_RESULTS)
sources.pop_front();
}
else
{
// new file
tthList.insert(std::make_pair(tth, SourceList(1, source)));
}
DHT::getInstance()->setDirty();
}
void
AbstractAnimation::targetAddedHandler(AbstractComponent::Ptr cmp,
Node::Ptr node)
{
_addedSlot = node->added()->connect(std::bind(
&AbstractAnimation::addedHandler,
shared_from_this(),
std::placeholders::_1,
std::placeholders::_2,
std::placeholders::_3
));
_removedSlot = node->removed()->connect(std::bind(
&AbstractAnimation::removedHandler,
shared_from_this(),
std::placeholders::_1,
std::placeholders::_2,
std::placeholders::_3
));
}
void BoundFactsCalculator::NaturalDFS(Node::Ptr cur) {
nodeColor[cur] = 1;
NodeIterator nbegin, nend;
cur->outs(nbegin, nend);
for (; nbegin != nend; ++nbegin)
if (nodeColor.find(*nbegin) == nodeColor.end())
NaturalDFS(*nbegin);
reverseOrder.push_back(cur);
}
void DbXmlUpdateFactory::applyInsertAfter(const PendingUpdate &update, DynamicContext *context)
{
const DbXmlNodeImpl *prev = (const DbXmlNodeImpl*)update.getTarget().get();
if (!prev->isUpdateAble())
return;
Node::Ptr parent = prev->dmParent(context);
// in order to preserve order for multiple inserts, insertAfter must turn
// into insertBefore
NsDomNodeRef prevRef = prev->getNsDomNode();
NsDomNodeRef nextRef = prevRef->getNsNextSibling();
if (!nextRef.get()) {
DbXmlConfiguration *conf = GET_CONFIGURATION(context);
prevRef->refreshNode(conf->getOperationContext(), true);
nextRef = prevRef->getNsNextSibling();
}
applyInserts(update,
(const DbXmlNodeImpl *)parent->getInterface(DbXmlNodeImpl::gDbXml),
nextRef.get(),
context,
true);
}
/*
* Processes incoming request to publish file
*/
void IndexManager::processPublishSourceRequest(const Node::Ptr& node, const AdcCommand& cmd)
{
string tth;
if(!cmd.getParam("TR", 1, tth))
return; // nothing to identify a file?
string size;
if(!cmd.getParam("SI", 1, size))
return; // no file size?
string partial;
cmd.getParam("PF", 1, partial);
addSource(TTHValue(tth), node, Util::toInt64(size), partial == "1");
// send response
AdcCommand res(AdcCommand::SEV_SUCCESS, AdcCommand::SUCCESS, "File published", AdcCommand::TYPE_UDP);
res.addParam("FC", "PUB");
res.addParam("TR", tth);
DHT::getInstance()->send(res, node->getIdentity().getIp(), node->getIdentity().getUdpPort(), node->getUser()->getCID(), node->getUdpKey());
}
void
bullet::ColliderDebug::targetAddedHandler(AbstractComponent::Ptr, Node::Ptr target)
{
if (targets().size() > 1)
throw std::logic_error("Collider debugging component cannot be added twice.");
_addedSlot = target->added()->connect(std::bind(
&ColliderDebug::addedHandler,
std::static_pointer_cast<ColliderDebug>(shared_from_this()),
std::placeholders::_1,
std::placeholders::_2,
std::placeholders::_3
));
_removedSlot = target->removed()->connect(std::bind(
&ColliderDebug::removedHandler,
std::static_pointer_cast<ColliderDebug>(shared_from_this()),
std::placeholders::_1,
std::placeholders::_2,
std::placeholders::_3
));
}
