C++ (Cpp) NODE_LIST::begin Examples

Example #1

File: x3dmodelparser.cpp Project: Caerbannog/kicad-git-bzr

void X3D_MODEL_PARSER::readTransform( wxXmlNode* aTransformNode )
{
    NODE_LIST childnodes;

    GetChildsByName( aTransformNode, wxT( "Material" ), childnodes );

    for( NODE_LIST::iterator node = childnodes.begin();
         node != childnodes.end();
         node++ )
    {
        readMaterial( *node );
    }

    childnodes.clear();

    PROPERTY_MAP properties;

    GetNodeProperties( aTransformNode, properties );



    GetChildsByName( aTransformNode, wxT( "IndexedFaceSet" ), childnodes );

    for( NODE_LIST::iterator node = childnodes.begin();
         node != childnodes.end();
         node++ )
    {
        readIndexedFaceSet( *node, properties );
    }

    childnodes.clear();
}

Example #2

File: patricia_trie_codeproject.hpp Project: kayw/CareerInterview

PatriciaTrieNode<S,T>* PatriciaTrie<S,T>::find_bitindex_node (PatriciaTrieNode<S,T>* root, int bitindex) {
  
  //
  // is the head-pseudo-node requested?
  //

  if (bitindex == -1)
    return head;

  //
  // check all the normal nodes
  //

  NODE_LIST nodes = GetNodeList (root);
  
  NODE_LIST_ITERATOR i  = nodes.begin ();
  NODE_LIST_ITERATOR iend = nodes.end   ();

  for ( ; i != iend; i++) {
    PatriciaTrieNode<S,T>* node = *i;
    if (node->bit_index == bitindex) return node;
  }

  return NULL;
}

Example #3

File: x3dmodelparser.cpp Project: Caerbannog/kicad-git-bzr

bool X3D_MODEL_PARSER::Load( const wxString& aFilename )
{
    wxLogTrace( traceX3DParser, wxT( "Loading: %s" ), GetChars( aFilename ) );

    wxXmlDocument doc;

    if( !doc.Load( aFilename ) )
    {
        wxLogTrace( traceX3DParser, wxT( "Error while parsing file: %s" ), GetChars( aFilename ) );
        return false;
    }

    if( doc.GetRoot()->GetName() != wxT( "X3D" ) )
    {
        wxLogTrace( traceX3DParser, wxT( "Filetype is not X3D: %s" ), GetChars( aFilename ) );
        return false;
    }

    // Switch the locale to standard C (needed to print floating point numbers)
    LOCALE_IO toggle;

    childs.clear();

    // Shapes are inside of Transform nodes
    // Transform node contains information about
    // transition, scale and rotation of the shape
    NODE_LIST transforms;
    GetChildsByName( doc.GetRoot(), wxT( "Transform" ), transforms );

    for( NODE_LIST::iterator node_it = transforms.begin();
         node_it != transforms.end();
         node_it++ )
    {
        m_model.reset( new S3D_MESH() );
        childs.push_back( m_model );

        wxXmlNode* node = *node_it;
        wxXmlAttribute* prop = node->GetAttributes();

        wxLogTrace( traceX3DParser, wxT( "Transform: %s %s" ), prop->GetName(), prop->GetValue() );

        readTransform( node );


    }

    return true;
}

Example #4

File: patricia_trie_codeproject.hpp Project: kayw/CareerInterview

PatriciaTrie<S,T>* PatriciaTrie<S,T>::Copy (PatriciaTrieNode<S,T>* root) {

  PatriciaTrieNode<S,T>* newNode = new PatriciaTrieNode<S,T> ();
  bool recursiveHead = (root == NULL);
  if (root == NULL) root = head;

  newNode->bit_index  = root->bit_index;
  newNode->data   = root->data;
  newNode->key    = root->key;

  //
  // create the subtrees and wire my children to it
  // or (if there are no subtrees) wire the children to myself
  // later we will wire the children correctly with some backedges
  //

  if (root->left != NULL && root->left->bit_index > root->bit_index) {
    PatriciaTrie<S,T>* leftTrie = Copy (root->left);
    newNode->left = leftTrie->head;
    leftTrie->head = NULL;
    delete leftTrie;
  } else {
    newNode->left = newNode;
  }

  if (root->right != NULL && root->right->bit_index > root->bit_index) {
    PatriciaTrie<S,T>* rightTrie = Copy (root->right);
    newNode->right = rightTrie->head;
    rightTrie->head = NULL;
    delete rightTrie;
  } else {
    newNode->right = newNode;
  }

  PatriciaTrie<S,T>* newTrie = new PatriciaTrie<S,T> ();
  newTrie->head = newNode;

  //
  // need to adapt the back edges
  //

  if (recursiveHead) {

    NODE_LIST origNodes = GetNodeList ();
    NODE_LIST newNodes  = newTrie->GetNodeList ();

    assert (origNodes.size() == newNodes.size());

    NODE_LIST_ITERATOR iorigBegin = origNodes.begin ();
    NODE_LIST_ITERATOR iorigEnd   = origNodes.end   ();
    NODE_LIST_ITERATOR inewBegin  = newNodes.begin  ();
    NODE_LIST_ITERATOR inewEnd    = newNodes.end    ();

    for ( ; iorigBegin != iorigEnd && inewBegin != inewEnd; iorigBegin++, inewBegin++) {
      
      PatriciaTrieNode<S,T>* origNode = *iorigBegin;
      PatriciaTrieNode<S,T>* newNode  = *inewBegin;

      //
      // make some checks that everything went fine
      //

      assert (origNode      != newNode        && 
          origNode->key     == newNode->key     &&
          origNode->bit_index == newNode->bit_index &&
          origNode->data      == newNode->data    );

      //
      // if the original node has backedges:
      // find the correct backedge node in the new trie
      // and wire the children correctly
      //

      if (origNode->left->bit_index < origNode->bit_index)
        newNode->left = newTrie->find_bitindex_node (newTrie->head, origNode->left->bit_index); 
      
      if (origNode->right->bit_index < origNode->bit_index)
        newNode->right = newTrie->find_bitindex_node (newTrie->head, origNode->right->bit_index); 
    
    } // for ( ; iorigBegin != iorigEnd && inewBegin != inewEnd; iorigBegin++, inewBegin++) 
  
  } // if (recursiveHead)

  return newTrie;
}