XMLElem ComplexXMLParser10x::convertRMAToXML(
const RMA* rma,
XMLElem parent) const
{
XMLElem rmaXML = newElement("RMA", parent);
createString("RMAlgoType", six::toString<six::RMAlgoType>(rma->algoType),
rmaXML);
if (rma->rmat.get() && !rma->rmcr.get() && !rma->inca.get())
{
convertRMATToXML(rma->rmat.get(), rmaXML);
}
else if (!rma->rmat.get() && rma->rmcr.get() && !rma->inca.get())
{
convertRMCRToXML(rma->rmcr.get(), rmaXML);
}
else if (!rma->rmat.get() && !rma->rmcr.get() && rma->inca.get())
{
convertINCAToXML(rma->inca.get(), rmaXML);
}
else
{
throw except::Exception(Ctxt(
"One of RMAT, RMCR or INCA must be defined in SICD 1.0."));
}
return rmaXML;
}
// 写入场景
void XMLSceneSerializer::writeScene(TiXmlElement *parent)
{
// 开始包
TiXmlElement *sceneElement = newElement(parent , "Scene");
ISceneObject *obj = m_scene->getRootObject();
writeSceneObjectChilds(sceneElement , obj);
}
///////////////////////////////////////////////////////////////////////////////////////
/// Callback functions called by the XML parser. It creates and push a new element node.
/// This is the start handler of Parser. XML_Parse() starts from here.
///
///\param context
///\param elm The element
///\param attr The attributes
///////////////////////////////////////////////////////////////////////////////////////
static void XMLCALL startElement(void *context, const char *elm, const char **attr) {
Elm el;
void* e;
int size;
el = checkElement(elm); //Get the index of element
printfDebug("startElement():%s\n", elm);
printfDebug("*** starting element %s\n", elmNames[el]);
if (el==-1) {
printDebug("Error!");
return; // error
}
skipData = (el != elm_Name); // skip element content for all elements but Name
switch(getAstNodeType(el)){
case astElement: size = sizeof(Element); break;
case astListElement: size = sizeof(ListElement); break;
case astType: size = sizeof(Type); break;
case astScalarVariable: size = sizeof(ScalarVariable); break;
case astModelDescription: size = sizeof(ModelDescription); break;
default: assert(0); // Error message if there is no matching element,
}
printfIntDebug("Start to created a new element with size: %d\n", size);
e = newElement(el, size, attr); // Create a new element
printDebug("Created a new element");
if(checkPointer(e)) assert(0); // Check the validity of the new element
printDebug("startElement(): Start to stack push.");
stackPush(stack, e); // Add the element to stack and grow the stack if necessary
}
void XML::parseChildren(xmlDocPtr doc, xmlNodePtr child, DomElement *parent) {
xmlNode *cur_node = NULL;
XMLElement *new_element = NULL;
xmlAttrPtr attr;
for(cur_node = child ; cur_node ; cur_node = cur_node->next ) {
if( cur_node->type == XML_ELEMENT_NODE) {
if(!parent) {
new_element = newElement((char *)cur_node->name);
} else {
new_element = (XMLElement *)parent->newElement((char *)cur_node->name);
}
} else if (cur_node->type == XML_TEXT_NODE && xmlIsBlankNode(cur_node)==0) {
parent->setValue((char *)cur_node->content);
}
parseChildren(doc,cur_node->children,new_element);
attr = cur_node->properties;
while(attr) {
std::string name = (char *)attr->name;
std::string value = (char *)attr->children->content;
new_element->setAttribute(name,value);
attr = attr->next;
}
}
}
static xmlNodePtr PODContainerToXml(const std::string &rootName, Iterator begin, Iterator end)
{
xmlNodePtr root = xmlNewNode(NULL, xmlStrdup( BAD_CAST rootName.c_str() ) );
if (typeid( typename Iterator::value_type) == typeid(std::string))
{
addProp(root, "item_type", "std::string");
}
else
{
addProp(root, "item_type", ::fwCore::TypeDemangler< typename Iterator::value_type >().getLeafClassname());
}
if ( begin == end)
{
return root;
}
for ( Iterator i=begin ; i!= end ; ++i )
{
xmlNodePtr node = newElement( "item", *i );
xmlAddChild(root,node);
}
return root;
}
Elem* treeInsert(Elem* Tree, int value)
{
Elem* newEl = newElement();
newEl->key = value;
Elem* newElParent = NULL;
Elem* node = Tree; // first element of Tree is root
while (node != NULL)
{ // find place for new element
newElParent = node;
node = (newEl->key < node->key) ? node->left : node-> right;
}
newEl->parent = newElParent;
if (newElParent == NULL)
{
Tree = newEl; // Tree is empty
}
else if (newEl->key < newElParent->key)
{
newElParent->left = newEl;
}
else
{
newElParent->right = newEl;
}
return newEl;
}
int
asyncMakeHandle (
AsyncHandle *handle,
Element *(*newElement) (const void *parameters),
const void *parameters
) {
if (handle) {
if (!(*handle = malloc(sizeof(**handle)))) {
logMallocError();
return 0;
}
}
{
Element *element = newElement(parameters);
if (element) {
if (handle) {
memset(*handle, 0, sizeof(**handle));
(*handle)->element = element;
(*handle)->identifier = getElementIdentifier(element);
(*handle)->tsd = asyncGetThreadSpecificData();
}
return 1;
}
}
if (handle) free(*handle);
return 0;
}
void C::List::h_push(const W::Event& ev)
{
const W::Vocabulary& vc = static_cast<const W::Vocabulary&>(ev.getData());
const W::Object& el = vc.at(u"data");
data.push(el);
emit newElement(el);
}
void mitk::NavigationDataEvaluationFilter::CreateMembersForAllInputs()
{
while (this->m_LoggedPositions.size() < this->GetNumberOfInputs())
{
std::pair<std::size_t, std::vector<mitk::Point3D> > newElement(m_LoggedPositions.size(), std::vector<mitk::Point3D>());
m_LoggedPositions.insert(newElement);
}
while (this->m_LoggedQuaternions.size() < this->GetNumberOfInputs())
{
std::pair<std::size_t, std::vector<mitk::Quaternion> > newElement(m_LoggedQuaternions.size(), std::vector<mitk::Quaternion>());
m_LoggedQuaternions.insert(newElement);
}
while (this->m_InvalidSamples.size() < this->GetNumberOfInputs())
{
std::pair<std::size_t, int> newElement(m_InvalidSamples.size(), 0);
m_InvalidSamples.insert(newElement);
}
}
void XMLUtils::SetString(TiXmlNode* pRootNode, const char *strTag, const CStdString& strValue)
{
TiXmlElement newElement(strTag);
TiXmlNode *pNewNode = pRootNode->InsertEndChild(newElement);
if (pNewNode)
{
TiXmlText value(strValue);
pNewNode->InsertEndChild(value);
}
}
void OpenNIUser::updateFeatures()
{
if (user->getJoint(JOINT_TORSO).getWorldPosition() == ofPoint(0,0,0)) return;
if (elements_.empty())
{
for (int j = 0; j < user->getNumJoints(); j++) {
MocapElement newElement(j, depth_);
elements_.push_back(newElement);
}
}
ofPoint headPos = user->getJoint(JOINT_HEAD).getWorldPosition();
ofPoint torsoPos = user->getJoint(JOINT_TORSO).getWorldPosition();
//for CI
float xMax = numeric_limits<float>::min();
float yMax = numeric_limits<float>::min();
float zMax = numeric_limits<float>::min();
float xMin = numeric_limits<float>::max();
float yMin = numeric_limits<float>::max();
float zMin = numeric_limits<float>::max();
float headTorsoDist = headPos.distance(torsoPos);
float meanVel = 0.0; //for qom
for (int j = 0; j < user->getNumJoints(); j++)
{
computeJointDescriptors(j, user->getJoint((Joint) j).getWorldPosition(), headTorsoDist);
//qom
meanVel += getVelocityMagnitude(j);
//ci
xMin = min(xMin, getPositionFiltered(j).x);
yMin = min(yMin, getPositionFiltered(j).y);
zMin = min(zMin, getPositionFiltered(j).z);
xMax = max(xMax, getPositionFiltered(j).x);
yMax = max(yMax, getPositionFiltered(j).y);
zMax = max(zMax, getPositionFiltered(j).z);
}
// Add position to history
if (meanVels_.size() <= depth_) {
meanVels_.insert(meanVels_.begin(), meanVel / user->getNumJoints());
}
if (meanVels_.size() > depth_) {
meanVels_.pop_back();
}
qom_ = accumulate(meanVels_.begin(), meanVels_.end(), 0.0) / (meanVels_.size());
ci_ = ( -4.0 + (( abs(xMax-xMin) + abs(yMax-yMin) + abs(zMax-zMin) ) / headTorsoDist) ) / 6.0;
symmetry_ = 1.0 - (0.5 * (abs(sqrt(getDistanceToTorso(JOINT_RIGHT_HAND))-sqrt(getDistanceToTorso(JOINT_LEFT_HAND))) + abs(sqrt(getDistanceToTorso(JOINT_RIGHT_ELBOW))-sqrt(getDistanceToTorso(JOINT_LEFT_ELBOW)))) / headTorsoDist);
yMaxHands_ = max(getRelativePositionToTorso(JOINT_RIGHT_HAND).y, getRelativePositionToTorso(JOINT_LEFT_HAND).y);
}
XMLElem ComplexXMLParser10x::convertWeightTypeToXML(
const WeightType& obj,
XMLElem parent) const
{
XMLElem weightTypeXML = newElement("WgtType", parent);
createString("WindowName", obj.windowName, weightTypeXML);
common().addParameters("Parameter", obj.parameters, weightTypeXML);
return weightTypeXML;
}
Token *mqlProc_Elm(State *s, Token *tk){
Element *elm = NULL;
if(tk->type == TT_INT){
long int x = strtol(tk->s, NULL, 0);
elm = newElement(ET_INTEGER, NULL);
elm->ival = x;
}else if(tk->type == TT_FLOAT){
double x = strtod(tk->s, NULL);
elm = newElement(ET_DECIMAL, NULL);
elm->dval = x;
}else if(tk->type == TT_STRING){
elm = newElement(ET_STRING, (void*)dup(tk->s));
}else{
s->invalid = 1;
s->errStr = dup("Invalid token reached in mqlProc_Elm");
}
s->stack = stackPush(s->stack, elm);
return tk->next;
}
void XMLUtils::SetPath(TiXmlNode* pRootNode, const char *strTag, const CStdString& strValue)
{
TiXmlElement newElement(strTag);
newElement.SetAttribute("pathversion", path_version);
TiXmlNode *pNewNode = pRootNode->InsertEndChild(newElement);
if (pNewNode)
{
TiXmlText value(strValue);
pNewNode->InsertEndChild(value);
}
}
bool CViewStateSettings::Save(TiXmlNode *settings) const
{
if (settings == NULL)
return false;
CSingleLock lock(m_critical);
// add the <viewstates> tag
TiXmlElement xmlViewStateElement(XML_VIEWSTATESETTINGS);
TiXmlNode *pViewStateNode = settings->InsertEndChild(xmlViewStateElement);
if (pViewStateNode == NULL)
{
CLog::Log(LOGWARNING, "CViewStateSettings: could not create <viewstates> tag");
return false;
}
for (std::map<std::string, CViewState*>::const_iterator viewState = m_viewStates.begin(); viewState != m_viewStates.end(); ++viewState)
{
TiXmlElement newElement(viewState->first);
TiXmlNode *pNewNode = pViewStateNode->InsertEndChild(newElement);
if (pNewNode == NULL)
continue;
XMLUtils::SetInt(pNewNode, XML_VIEWMODE, viewState->second->m_viewMode);
XMLUtils::SetInt(pNewNode, XML_SORTMETHOD, (int)viewState->second->m_sortDescription.sortBy);
XMLUtils::SetInt(pNewNode, XML_SORTORDER, (int)viewState->second->m_sortDescription.sortOrder);
XMLUtils::SetInt(pNewNode, XML_SORTATTRIBUTES, (int)viewState->second->m_sortDescription.sortAttributes);
}
TiXmlNode *generalNode = settings->FirstChild(XML_GENERAL);
if (generalNode == NULL)
{
TiXmlElement generalElement(XML_GENERAL);
generalNode = settings->InsertEndChild(generalElement);
if (generalNode == NULL)
return false;
}
XMLUtils::SetInt(generalNode, XML_SETTINGLEVEL, (int)m_settingLevel);
TiXmlNode *eventLogNode = generalNode->FirstChild(XML_EVENTLOG);
if (eventLogNode == NULL)
{
TiXmlElement eventLogElement(XML_EVENTLOG);
eventLogNode = generalNode->InsertEndChild(eventLogElement);
if (eventLogNode == NULL)
return false;
}
XMLUtils::SetInt(eventLogNode, XML_EVENTLOG_LEVEL, (int)m_eventLevel);
XMLUtils::SetBoolean(eventLogNode, XML_EVENTLOG_LEVEL_HIGHER, (int)m_eventShowHigherLevels);
return true;
}
void C::List::h_get(const W::Event& ev)
{
emit clear();
const W::Vocabulary& vc = static_cast<const W::Vocabulary&>(ev.getData());
data = static_cast<const W::Vector&>(vc.at(u"data"));
int size = data.size();
for (int i = 0; i < size; ++i) {
emit newElement(data.at(i));
}
}
int FEM_Adapt::edge_bisect_help(int e1, int e2, int n1, int n2, int e1_n1,
int e1_n2, int e1_n3, int n3, int edge1,
int e1nbr)
{
int n5 = newNode();
int e3 = newElement();
theMesh->setMeshSizing(e3, getMeshSizing(e1));
localEdgeBisect(n1, n2, e1, e2, e3, e1_n1, e1_n2, e1_n3, e1nbr, n3, n5);
if (e2 != -1) {
int e2_n1, e2_n2, e2_n3, n4, edge2, e2nbr;
findAdjData(n1, n2, e2, &e2_n1, &e2_n2, &e2_n3, &n4, &edge2, &e2nbr);
int e4 = newElement();
theMesh->setMeshSizing(e4, getMeshSizing(e2));
localEdgeBisect(n1, n2, e2, e1, e4, e2_n1, e2_n2, e2_n3, e2nbr, n4, n5);
theMesh->n2n_remove(n5, n1);
theMesh->n2n_remove(n5, n2);
theMesh->e2e_replace(e3, -1, e4);
theMesh->e2e_replace(e4, -1, e3);
}
return n5;
}
/**
* Creates a brand new control client, adds it to the list and starts a thread for it.
* @param addr the inet address of the client
* @param sockfd the socket descriptor this client is communicating via
*/
static void createControlClient(int addr, SOCKET sockfd) {
ClientElem_t *pClient = newElement();
pClient->sockfd = sockfd;
pClient->type = TYPE_CONTROL;
pClient->thread =
CreateThread(NULL, //Choose default security
0, //Default stack size
ctrlClientFunc,
pClient, //Thread parameter
0, //Immediately run the thread
NULL);
g_liveClients++;
}
XMLElem ComplexXMLParser10x::convertGeoInfoToXML(
const GeoInfo *geoInfo,
XMLElem parent) const
{
//! 1.0.x has ordering (1. Desc, 2. choice, 3. GeoInfo)
XMLElem geoInfoXML = newElement("GeoInfo", parent);
common().addParameters("Desc", geoInfo->desc, geoInfoXML);
const size_t numLatLons = geoInfo->geometryLatLon.size();
if (numLatLons == 1)
{
common().createLatLon("Point", geoInfo->geometryLatLon[0], geoInfoXML);
}
else if (numLatLons >= 2)
{
XMLElem linePolyXML = newElement(numLatLons == 2 ? "Line" : "Polygon",
geoInfoXML);
setAttribute(linePolyXML, "size", str::toString(numLatLons));
for (size_t ii = 0; ii < numLatLons; ++ii)
{
XMLElem v = common().createLatLon(numLatLons == 2 ? "Endpoint" : "Vertex",
geoInfo->geometryLatLon[ii], linePolyXML);
setAttribute(v, "index", str::toString(ii + 1));
}
}
if (!geoInfo->name.empty())
setAttribute(geoInfoXML, "name", geoInfo->name);
for (size_t ii = 0; ii < geoInfo->geoInfos.size(); ++ii)
{
convertGeoInfoToXML(geoInfo->geoInfos[ii].get(), geoInfoXML);
}
return geoInfoXML;
}
XMLElem ComplexXMLParser10x::convertRMATToXML(
const RMAT* rmat,
XMLElem rmaXML) const
{
createString("ImageType", "RMAT", rmaXML);
XMLElem rmatXML = newElement("RMAT", rmaXML);
common().createVector3D("PosRef", rmat->refPos, rmatXML);
common().createVector3D("VelRef", rmat->refVel, rmatXML);
createDouble("DopConeAngRef", rmat->dopConeAngleRef, rmatXML);
return rmatXML;
}
bool MemcheckParser::startElement()
{
m_buffer.clear();
State newState = Unknown;
if (name() == QStringLiteral("valgrindoutput"))
newState = Session;
else if (name() == QStringLiteral("status"))
newState = Status;
else if (name() == QStringLiteral("preamble"))
newState = Preamble;
else if (name() == QStringLiteral("error")) {
newState = Error;
emit newElement(Model::startError);
}
else if (name() == QStringLiteral("stack")) {
newState = Stack;
emit newElement(Model::startStack);
}
else if (name() == QStringLiteral("frame")) {
newState = Frame;
emit newElement(Model::startFrame);
}
else {
m_stateStack.push(m_stateStack.top());
return true;
}
m_stateStack.push(newState);
return true;
}
/* Set a new listener, replacing an existen one or adding it to the list. */
bool ManageListener::setListener(Listener* listener, ArrayList &list) {
ListenerElement *l=NULL;
for(l = (ListenerElement*)list.front(); l; l = (ListenerElement*)list.next()) {
if (l->get()->getName() == listener->getName()) {
l->set(listener);
return false; // Element already in the list, just change it
}
}
// Not found, add it to the list
ListenerElement newElement(listener);
list.add(newElement);
return true;
}
SerializerElement& SerializerElement::AddChild(gd::String name) {
if (!arrayOf.empty()) {
if (name != arrayOf) {
std::cout << "WARNING: Adding a child, to a SerializerElement which is "
"considered as an array, with a name ("
<< name << ") which is not the same as the array elements ("
<< arrayOf << "). Child was renamed." << std::endl;
name = arrayOf;
}
}
std::shared_ptr<SerializerElement> newElement(new SerializerElement);
children.push_back(std::make_pair(name, newElement));
return *newElement;
}
/* add an element at the beginning of the list */
t_list * addFirst(t_list *list, void * data)
{
t_list *result;
/* initialize the value of `result' */
result = newElement(data);
if (list == NULL)
return result;
/* postconditions */
SET_PREV(list, result);
SET_NEXT(result, list);
/* return the new head of the list */
return result;
}
XMLElem ComplexXMLParser040::convertRMATToXML(
const RMAT* rmat,
XMLElem rmaXML) const
{
createString("ImageType", "RMAT", rmaXML);
XMLElem rmatXML = newElement("RMAT", rmaXML);
createDouble("RMRefTime", rmat->refTime, rmatXML);
common().createVector3D("RMPosRef", rmat->refPos, rmatXML);
common().createVector3D("RMVelRef", rmat->refVel, rmatXML);
common().createPoly2D("CosDCACOAPoly", rmat->cosDCACOAPoly, rmatXML);
createDouble("Kx1", rmat->kx1, rmatXML);
createDouble("Kx2", rmat->kx2, rmatXML);
createDouble("Ky1", rmat->ky1, rmatXML);
createDouble("Ky2", rmat->ky2, rmatXML);
return rmatXML;
}
// Create and push a new element node
static void XMLCALL startElement(void *context, const char *elm, const char **attr) {
Elm el;
void* e;
int size;
el = checkElement(elm);
if (el==-1) return; // error
skipData = (el != elm_Name); // skip element content for all elements but Name
switch(getAstNodeType(el)){
case astElement: size = sizeof(Element); break;
case astListElement: size = sizeof(ListElement); break;
case astType: size = sizeof(Type); break;
case astScalarVariable: size = sizeof(ScalarVariable); break;
case astModelDescription: size = sizeof(ModelDescription); break;
default: assert(0);
}
e = newElement(el, size, attr);
checkPointer(e);
stackPush(stack, e);
}
Element *dupElement(Element *elm){
Element *ret = newElement(elm->type, NULL);
if(ret->type == ET_STRING){
ret->data = (void*)dup((char*)elm->data);
}else if(ret->type == ET_INTEGER || ret->type == ET_DECIMAL){
ret->dval = elm->dval;
ret->ival = elm->ival;
}else if(ret->type == ET_VECTOR){
Vector *v = (Vector*)elm->data;
Vector *vnew = newVector();
for(int i=0; i<v->len; ++i){
vectorPushBack(vnew, dupElement(v->data[i]));
}
ret->data = (void*)vnew;
}
cloneOps(ret, elm);
return ret;
}
int main(int argc, char const *argv[])
{
Elem* root = newElement();
Elem* randomNode;
treeInsert(root, 4);
treeInsert(root, 2);
treeInsert(root, 5);
randomNode = treeInsert(root, 9);
treePrintInOrder(root);
treeRemove(root, randomNode);
putchar('\n');
treePrintInOrder(root);
putchar('\n');
return 0;
}
XMLElem ComplexXMLParser10x::convertAntennaParamArrayToXML(
const std::string& name,
const GainAndPhasePolys* array,
XMLElem apXML) const
{
//! mandatory field in 1.0
if (array)
{
XMLElem arrXML = newElement("Array", apXML);
common().createPoly2D("GainPoly", array->gainPoly, arrXML);
common().createPoly2D("PhasePoly", array->phasePoly, arrXML);
return arrXML;
}
else
{
throw except::Exception(Ctxt(FmtX(
"[Array] is a mandatory field in AntennaParams of [%s] in 1.0",
name.c_str())));
}
}
void VertexDataDesc::addVertElem(VertexElementType type, VertexElementSemantic semantic, UINT32 semanticIdx,
UINT32 streamIdx, UINT32 instanceStepRate)
{
clearIfItExists(type, semantic, semanticIdx, streamIdx);
VertexElement newElement(streamIdx, 0, type, semantic, semanticIdx, instanceStepRate);
// Insert it so it is sorted by stream
UINT32 insertToIndex = (UINT32)mVertexElements.size();
UINT32 idx = 0;
for(auto& elem : mVertexElements)
{
if(elem.getStreamIdx() > streamIdx)
{
insertToIndex = idx;
break;
}
idx++;
}
mVertexElements.insert(mVertexElements.begin() + insertToIndex, newElement);
}
