// construct an ebucore skeleton
ebucoreParser::ElementStruct ebucoreParser::constructSchema(xercesc::DOMElement * el) {
// prepare the element information
std::string str (xercesc::XMLString::transcode(el->getAttribute (xercesc::XMLString::transcode("name"))));
std::string type (xercesc::XMLString::transcode(el->getAttribute (xercesc::XMLString::transcode("type"))));
std::string ref (xercesc::XMLString::transcode(el->getAttribute (xercesc::XMLString::transcode("ref"))));
std::string minimum (xercesc::XMLString::transcode(el->getAttribute (xercesc::XMLString::transcode("minOccurs"))));
std::string maximum (xercesc::XMLString::transcode(el->getAttribute (xercesc::XMLString::transcode("maxOccurs"))));
// instantiate a new root
ebucoreParser::ElementStruct root;
// grab the name, the cardinalities, the type, attributes and children
root.name = (str.size()>0)?str:ref;
root.minCardinality = ((minimum.size()>0)?atoi(minimum.c_str()):1);
root.maxCardinality = ((maximum.size()>0)?isUnbounded(maximum):1);
root.type = ((type.size()>0)?type:"undefined");
// store the current element type inside the stack to avoid infinite loops
ebucoreStack.push_back(root.type);
// generate the attributes of the current element
root.attribute = ebucoreParser::generateAttributes(removePrefix (type, ":"), el);
// generate the children of the current element
root.children = generateChildren(removePrefix (type, ":"), el,1);
// pop the current element type outside of the stack
ebucoreStack.pop_back();
return root;
}
const int BoardNode::generateChildren(const int depth)
{
if(depth == 0 || b.won() != NULL)
{
children = NULL;
return 0;
}
if(children != NULL)
return generateChildren(depth - 1);
children = new CHILD_LIST();
vector<Piece> &pieces = b.getPieceList(b.whosTurn());
for(auto i = pieces.begin(); i != pieces.end(); i++)
{
if(b.nextIn(b.whosTurn()))
{
if(b.nextIn(b.whosTurn()))
continue;
}
auto validLocations = b.getValid(&*i);
for(auto c = validLocations.begin(); c != validLocations.end(); c++)
{
((*children)[Move(&*i, *c)] = new BoardNode(b, pov));
auto temp = children->emplace(Move(&*i, *c, &b), new BoardNode(b, pov)).first;
temp->first.changeBoard(temp->second->b);
if(!temp->first.doMove())
return -1;
}
}
return 0;
}
// include external elements (from groups)
void ebucoreParser::generateGroupChildren(std::list<ElementStruct> children, std::string father, xercesc::DOMElement * el) {
// store the current position of xercesc pointer
xercesc::DOMElement * tmpEl = el;
// looking for the group who contains the other elements with the father name
while (tmpEl != 0 && !((std::string)(xercesc::XMLString::transcode(tmpEl->getTagName())) == "group" && xercesc::XMLString::transcode(tmpEl->getAttribute (xercesc::XMLString::transcode("name"))) == removePrefix(father,":") )) {
tmpEl = tmpEl->getNextElementSibling();
}
// enter inside the group
tmpEl=tmpEl->getFirstElementChild();
// looking for the sequence
while (tmpEl != 0 && (std::string)(xercesc::XMLString::transcode(tmpEl->getTagName())) != "sequence") {
tmpEl = tmpEl->getNextElementSibling();
}
// if pointer not null, grab the first child
if (tmpEl != 0) {
tmpEl=tmpEl->getFirstElementChild();
}
// while xerces pointer not null,
while (tmpEl != 0) {
// if it's an element
if ((std::string)(xercesc::XMLString::transcode(tmpEl->getTagName())) == "element") {
// prepare the element informations
std::string name (xercesc::XMLString::transcode(tmpEl->getAttribute (xercesc::XMLString::transcode("name"))));
std::string type (xercesc::XMLString::transcode(tmpEl->getAttribute (xercesc::XMLString::transcode("type"))));
std::string ref (xercesc::XMLString::transcode(tmpEl->getAttribute (xercesc::XMLString::transcode("ref"))));
std::string minimum (xercesc::XMLString::transcode(tmpEl->getAttribute (xercesc::XMLString::transcode("minOccurs"))));
std::string maximum (xercesc::XMLString::transcode(tmpEl->getAttribute (xercesc::XMLString::transcode("maxOccurs"))));
// instantiate the list of children
ebucoreParser::ElementStruct internalChildren;
// identify the element name
internalChildren.name = (name.size()>0)?name:ref;
// identify the cardinality and type
internalChildren.minCardinality = ((minimum.size()>0)?atoi(minimum.c_str()):1);
internalChildren.maxCardinality = ((maximum.size()>0)?isUnbounded(maximum):1);
internalChildren.type = ( (type.size()>0) ? type : "" );
// if it is not a standard type
if (!isStandardType(type)) {
// and if type is not null
if (type.size()>0) {
// generate attributes
internalChildren.attribute = (isDCSimpleType(type)) ? DCAttr : generateAttributes(removePrefix(internalChildren.type, ":"), tmpEl);
// and correct the type is required
internalChildren.type = ( (isDCSimpleType(type)) ? DCType() : internalChildren.type );
} else {
// generate attributes and correct the type is required
internalChildren.attribute = (isDCSimpleType(internalChildren.name))? DCAttr : generateAttributes("", tmpEl);
internalChildren.type = ( (isDCSimpleType(internalChildren.name)) ? DCType() : "") ;
}
}
// if it is an ebucore element and the type of this element is not present in the element type stack
if (isEBUCoreType(internalChildren.type) && !groupExist(internalChildren.type)) {
// push the type
ebucoreStack.push_back(internalChildren.type);
// generate children
internalChildren.children = generateChildren(removePrefix(internalChildren.type,":"), el, 1);
// pop the type
ebucoreStack.pop_back();
}
//push the internal child
children.push_back(internalChildren);
}
// next
tmpEl = tmpEl->getNextElementSibling();
}
}
// generate the children of an elements
std::list<ebucoreParser::ElementStruct> ebucoreParser::generateChildren(std::string father, xercesc::DOMElement * el, int level) {
// instantiate the children list
std::list<ebucoreParser::ElementStruct> children;
// copy the current position of xercesc pointer
xercesc::DOMElement * tmpEl = el;
// while xercesc pointer not null, element different of complexType with the proper name
while (tmpEl != 0 && ((std::string)(xercesc::XMLString::transcode(tmpEl->getTagName())) != "complexType" || xercesc::XMLString::transcode(tmpEl->getAttribute (xercesc::XMLString::transcode("name"))) != father )) {
tmpEl = tmpEl->getNextElementSibling();// next
}
// grab the first child of proper element
tmpEl=tmpEl->getFirstElementChild();
// looking for the sequence of elements
while (tmpEl != 0 && (std::string)(xercesc::XMLString::transcode(tmpEl->getTagName())) != "sequence") {
tmpEl = tmpEl->getNextElementSibling(); // next
}
// if pointer not null, grab the first child of the current element
if (tmpEl != 0) {
tmpEl=tmpEl->getFirstElementChild();
}
// while xerces point not null, loop
while (tmpEl != 0) {
// if current tag kind is element
if ((std::string)(xercesc::XMLString::transcode(tmpEl->getTagName())) == "element") {
// prepare the element information
std::string name (xercesc::XMLString::transcode(tmpEl->getAttribute (xercesc::XMLString::transcode("name"))));
std::string type (xercesc::XMLString::transcode(tmpEl->getAttribute (xercesc::XMLString::transcode("type"))));
std::string ref (xercesc::XMLString::transcode(tmpEl->getAttribute (xercesc::XMLString::transcode("ref"))));
std::string minimum (xercesc::XMLString::transcode(tmpEl->getAttribute (xercesc::XMLString::transcode("minOccurs"))));
std::string maximum (xercesc::XMLString::transcode(tmpEl->getAttribute (xercesc::XMLString::transcode("maxOccurs"))));
// instantiate the children struct
ebucoreParser::ElementStruct internalChildren;
// grab the right name/references
internalChildren.name = (name.size()>0)?name:ref;
// identify the cardinality and the type of element
internalChildren.minCardinality = ((minimum.size()>0)?atoi(minimum.c_str()):1);
internalChildren.maxCardinality = ((maximum.size()>0)?isUnbounded(maximum):1);
internalChildren.type = ( (type.size()>0) ? type : "" );
// if type is not standard
if (!isStandardType(type)) {
// if type is not null
if (type.size()>0) {
//generate the attribute list of the current element
internalChildren.attribute = (isDCSimpleType(type)) ? DCAttr : generateAttributes(removePrefix(internalChildren.type, ":"), tmpEl);
// and correct his type if required
internalChildren.type = ( (isDCSimpleType(type)) ? DCType() : internalChildren.type );
} else {
// generate the attribute list of the current element and correct his type if required
internalChildren.attribute = (isDCSimpleType(internalChildren.name))? DCAttr : generateAttributes("", tmpEl);
internalChildren.type = ( (isDCSimpleType(internalChildren.name)) ? DCType() : "") ;
}
}
// if element type is ebucore and the type not present in the stack, then
if (isEBUCoreType(internalChildren.type) && !groupExist(internalChildren.type)) {
ebucoreStack.push_back(internalChildren.type); // push the type
// generate the children
internalChildren.children = generateChildren(removePrefix(internalChildren.type,":"), el, level+1);
ebucoreStack.pop_back(); // pop the type
}
// push the children list
children.push_back(internalChildren);
// if the current tag king is group, then
} else if ((std::string)(xercesc::XMLString::transcode(tmpEl->getTagName())) == "group") {
// generate the children of this group and then add it to current list of children
generateGroupChildren(children, xercesc::XMLString::transcode(tmpEl->getAttribute (xercesc::XMLString::transcode("ref"))), el);
}
tmpEl = tmpEl->getNextElementSibling(); // next
}
return children;
}
/*!
This implements typical action traversal for an SoComplexShape node
*/
void
SoComplexShape::doAction(SoAction *action)
{
// Make sure all the children exist
if (children->getLength() == 0) { generateChildren(); }
// SoAction has a method called "getPathCode()" that returns
// a code indicating how this node is related to the path(s)
// the action is being applied to. This code is one of the
// following:
//
// NO_PATH = Not traversing a path (action was applied
// to a node)
// IN_PATH = This node is in the path chain, but is not
// the tail node
// BELOW_PATH = This node is the tail of the path chain or
// is below the tail
// OFF_PATH = This node is off to the left of some node in
// the path chain
//
// If getPathCode() returns IN_PATH, it returns (in its two
// arguments) the indices of the next nodes in the paths.
// (Remember that an action can be applied to a list of
// paths.)
// For the IN_PATH case, these will be set by getPathCode()
// to contain the number of child nodes that are in paths and
// the indices of those children, respectively. In the other
// cases, they are not meaningful.
int numIndices;
const int *indices;
// This will be set to the index of the last (rightmost)
// child to traverse
int lastChildIndex;
// If this node is in a path, see which of our children are
// in paths, and traverse up to and including the rightmost
// of these nodes (the last one in the "indices" array).
if (action->getPathCode(numIndices, indices) ==
SoAction::IN_PATH) {
lastChildIndex = indices[numIndices - 1];
}
// Otherwise, consider all of the children
else {
lastChildIndex = children->getLength() - 1;
}
// Now we are ready to traverse the children, skipping every
// other one. For the SoGetBoundingBoxAction, however, we
// have to do some extra work in between each pair of
// children - we have to make sure the center points get
// averaged correctly.
if (action->isOfType(
SoGetBoundingBoxAction::getClassTypeId())) {
SoGetBoundingBoxAction *bba =
(SoGetBoundingBoxAction *) action;
SbVec3f totalCenter(0.0, 0.0, 0.0);
int numCenters = 0;
for (int i = 0; i <= lastChildIndex; i++) {
children->traverse(bba, i);
// If the traversal set a center point in the action,
// add it to the total and reset for the next child.
if (bba->isCenterSet()) {
totalCenter += bba->getCenter();
numCenters++;
bba->resetCenter();
}
}
// Now, set the center to be the average. Since the
// centers were already transformed, there's no need to
// transform the average.
if (numCenters != 0) {
bba->setCenter(totalCenter / (float)numCenters, FALSE);
}
}
// For all other actions, just traverse every child
else
for (int i = 0; i <= lastChildIndex; i++) {
children->traverse(action, i);
}
}
int Principal::profundidade(vector<vector<int> > start, vector<vector<int> > goal){
vector<pair < vector <vector<int> > , int > > open;
vector<pair < vector <vector<int> > , int > > closed;
pair < vector <vector<int> > , int > X;
vector<vector<vector <int> > > children;
vector<vector<vector <int> > > temp;
int id_pai = -1;
int flag;
int cont = 0;
closed.clear();
open.push_back(make_pair(start, id_pai));
while(open.empty() == false){
X = open.front();
open.erase(open.begin());
if(matriz_cmp(X.first, goal)){
this->setLog(QString("Algoritmo: Busca em profundidade."));
this->setLog(QString("Executando Movimentos..."));
temp.push_back(X.first);
while(X.second >= 0){
X.first = closed.at(X.second).first;
X.second = closed.at(X.second).second;
temp.push_back(X.first);
cont++;
}
for(int a = temp.size()-1; a >= 0; a--){
printMatriz(temp.at(a));
}
this->setLog(QString("Numero de Estados: "+ QString("%1").arg(cont) ) );
this->setLog(QString("Numero Total de Estados Visitados: "+QString("%1").arg( id_pai+1) ) );
return 0;
} else {
children = generateChildren(X.first);
closed.push_back(X);
//printMatriz(X.first);
id_pai++;
flag = 0;
int i = 0;
int j = 0;
for( i = children.size() - 1; i >= 0; i--){
for(j=0;j<open.size(); j++){
if(matriz_cmp(children.at(i), open.at(j).first)){
flag = 1;
}
}
for(j = 0; j < closed.size(); j++){
if(matriz_cmp(children.at(i), closed.at(j).first)){
flag = 1;
}
}
if(flag == 0){
open.insert(open.begin(), make_pair(children.at(i), id_pai));
}
flag = 0;
}
}
}
this->setLog(QString("Fail"));
return 1;
}
