indri::xml::XMLNode* Packer::_getNodeReference( class indri::lang::Node* node, const ::std::string& name ) { if( !node ) return 0; indri::xml::XMLNode* reference = new indri::xml::XMLNode( name, node->nodeName() ); if( _getElement(node)->flushed == false ) { node->pack(*this); } return reference; }
static void _getEigenVectors(Mat4* vout, Vec3* dout, Mat4 a) { int n = 3; int j,iq,ip,i; double tresh, theta, tau, t, sm, s, h, g, c; int nrot; Vec3 b; Vec3 z; Mat4 v; Vec3 d; v = Mat4::IDENTITY; for(ip = 0; ip < n; ip++) { _getElement(b, ip) = a.m[ip + 4 * ip]; _getElement(d, ip) = a.m[ip + 4 * ip]; _getElement(z, ip) = 0.0; } nrot = 0; for(i = 0; i < 50; i++) { sm = 0.0; for(ip = 0; ip < n; ip++) for(iq = ip+1; iq < n; iq++) sm += fabs(a.m[ip + 4 * iq]); if( fabs(sm) < FLT_EPSILON ) { v.transpose(); *vout = v; *dout = d; return; } if (i < 3) tresh = 0.2 * sm / (n*n); else tresh = 0.0; for(ip = 0; ip < n; ip++) { for(iq = ip + 1; iq < n; iq++) { g = 100.0 * fabs(a.m[ip + iq * 4]); float dmip = _getElement(d, ip); float dmiq = _getElement(d, iq); if( i>3 && fabs(dmip) + g == fabs(dmip) && fabs(dmiq) + g == fabs(dmiq) ) { a.m[ip + 4 * iq] = 0.0; } else if (fabs(a.m[ip + 4 * iq]) > tresh) { h = dmiq - dmip; if (fabs(h) + g == fabs(h)) { t=(a.m[ip + 4 * iq])/h; } else { theta = 0.5 * h / (a.m[ip + 4 * iq]); t=1.0 / (fabs(theta) + sqrt(1.0 + theta * theta)); if (theta < 0.0) t = -t; } c = 1.0 / sqrt(1+t*t); s = t*c; tau = s / (1.0+c); h = t * a.m[ip + 4 * iq]; _getElement(z, ip) -= (float)h; _getElement(z, iq) += (float)h; _getElement(d, ip) -= (float)h; _getElement(d, iq) += (float)h; a.m[ip + 4 * iq]=0.0; for(j = 0; j < ip; j++) { ROTATE(a,j,ip,j,iq); } for(j = ip + 1; j < iq; j++) { ROTATE(a,ip,j,j,iq); } for(j = iq + 1; j < n; j++) { ROTATE(a,ip,j,iq,j); } for(j = 0; j < n; j++) { ROTATE(v,j,ip,j,iq); } nrot++; } } } for(ip = 0; ip < n; ip++) { _getElement(b, ip) += _getElement(z, ip); _getElement(d, ip) = _getElement(b, ip); _getElement(z, ip) = 0.0f; } } v.transpose(); *vout = v; *dout = d; return; }
void Packer::before( class indri::lang::Node* someNode ) { node_element* element = _getElement(someNode); _stack.push( element ); }
void Packer::pack( class indri::lang::Node* root ) { node_element* element = _getElement( root ); element->xmlNode->addAttribute( "root", "true" ); root->pack(*this); }
Boolean XmlParser::_next( XmlEntry& entry, Boolean includeComment) { if (!_putBackStack.isEmpty()) { entry = _putBackStack.top(); _putBackStack.pop(); return true; } // If a character was overwritten with a null-terminator the last // time this routine was called, then put back that character. Before // exiting of course, restore the null-terminator. char* nullTerminator = 0; if (_restoreChar && !*_current) { nullTerminator = _current; *_current = _restoreChar; _restoreChar = '\0'; } entry.attributes.clear(); if (_supportedNamespaces) { // Remove namespaces of a deeper scope level from the stack. while (!_nameSpaces.isEmpty() && _nameSpaces.top().scopeLevel > _stack.size()) { _nameSpaces.pop(); } } // Loop until we are done with comments if includeComment is false. do { // Skip over any whitespace: _skipWhitespace(_line, _current); if (!*_current) { if (nullTerminator) *nullTerminator = '\0'; if (!_stack.isEmpty()) throw XmlException(XmlException::UNCLOSED_TAGS, _line); return false; } // Either a "<...>" or content begins next: if (*_current == '<') { _current++; _getElement(_current, entry); if (nullTerminator) *nullTerminator = '\0'; if (entry.type == XmlEntry::START_TAG) { if (_stack.isEmpty() && _foundRoot) throw XmlException(XmlException::MULTIPLE_ROOTS, _line); _foundRoot = true; _stack.push((char*)entry.text); } else if (entry.type == XmlEntry::END_TAG) { if (_stack.isEmpty()) throw XmlException(XmlException::START_END_MISMATCH, _line); if (strcmp(_stack.top(), entry.text) != 0) throw XmlException(XmlException::START_END_MISMATCH, _line); _stack.pop(); } } else { // Normalize the content: char* start = _current; Uint32 textLen; _normalizeElementValue(_line, _current, textLen); // Get the content: entry.type = XmlEntry::CONTENT; entry.text = start; entry.textLen = textLen; // Overwrite '<' with a null character (temporarily). _restoreChar = *_current; *_current = '\0'; if (nullTerminator) *nullTerminator = '\0'; } } while (!includeComment && entry.type == XmlEntry::COMMENT); if (_supportedNamespaces && (entry.type == XmlEntry::START_TAG || entry.type == XmlEntry::EMPTY_TAG || entry.type == XmlEntry::END_TAG)) { // Determine the namespace type for this entry if (entry.type == XmlEntry::START_TAG || entry.type == XmlEntry::EMPTY_TAG) { // Process namespace declarations and determine the namespace type // for the attributes. Uint32 scopeLevel = _stack.size(); if (entry.type == XmlEntry::EMPTY_TAG) { // Empty tags are deeper scope, but not pushed onto the stack scopeLevel++; } for (Uint32 i = 0, n = entry.attributes.size(); i < n; i++) { XmlAttribute& attr = entry.attributes[i]; if ((strncmp(attr.name, "xmlns:", 6) == 0) || (strcmp(attr.name, "xmlns") == 0)) { // Process a namespace declaration XmlNamespace ns; if (attr.name[5] == ':') { ns.localName = attr.localName; } else { // Default name space has no local name ns.localName = 0; } ns.extendedName = attr.value; ns.scopeLevel = scopeLevel; ns.type = _getSupportedNamespaceType(ns.extendedName); // If the namespace is not supported, assign it a unique // negative identifier. if (ns.type == -1) { ns.type = _currentUnsupportedNSType--; } _nameSpaces.push(ns); } else { // Get the namespace type for this attribute. attr.nsType = _getNamespaceType(attr.name); } } } entry.nsType = _getNamespaceType(entry.text); } else { entry.nsType = -1; } return true; }