C++ TreeNode::children方法代码示例

 inline TreeNode down_heap(TreeNode x, const Compare& comp, ExternalData& edata) {
   while (x.children().size() > 0) {
     typename TreeNode::children_type::iterator 
       child_iter = std::min_element(x.children().begin(),
                                     x.children().end(), 
                                     comp);
     if (comp(*child_iter, x))
       x.swap(*child_iter, edata);
     else
       break;
   }
   return x;
 }

    std::list<std::string> getNodeChildren(const std::string& parentId) const
    {
      std::list<std::string> children;
      if (parentId.empty()) {
        if (this->dataSource_->modelRoot() != NULL) {
          QPersistentModelIndex pindex(this->model_->index(this->dataSource_->modelRoot(), 0));
          this->nodeIndexes_.insert(pindex);

          // Convert uint64 internal id to string.
          QString qstr = QString::number(pindex.internalId());

          children.push_back(qstr.toLocal8Bit().constData());
        }
      } else {
        TreeNode* parentNode = getNode(parentId);
          if (parentNode != NULL) {
          QList<TreeNode*> childNodes = parentNode->children();
          for (int i = 0; i < childNodes.count(); ++i) {
            QPersistentModelIndex pindex(this->model_->index(childNodes[i], 0));
            this->nodeIndexes_.insert(pindex);

            // Convert uint64 internal id to string.
            QString qstr = QString::number(pindex.internalId());

            children.push_back(qstr.toLocal8Bit().constData());
          }
        }
      }
      return children;
    }

Tree<_DATA>& Tree<_DATA>::
save_this(const char* dir) {
    char path[SIZEOF_PATH], * filename;
    std::strcpy(path, dir);
    std::size_t dir_len = std::strlen(path);
    std::size_t file_len;
    if (dir_len > 0 && (path[dir_len - 1] != '/' && path[dir_len - 1] != '\\'))
        path[dir_len++] = '/';
    filename = path + dir_len;
    file_len = SIZEOF_PATH - dir_len;
    std::strcpy(filename, "Tree");
    std::ofstream file(path);
    if (!file.is_open()) {
        std::cerr << "\nFailed opening file: " << path << std::endl;
        return *this;
    }
    unsigned long node_num = 0;
    file << std::setw(16) << std::setfill('0') << node_num << ".node"
         << "    # root" << std::endl;
    file.close();
    std::queue<TreeNode*>     node_pointer;
    std::queue<unsigned long> node_name;
    std::queue<unsigned long> node_parent_name;
    node_pointer.push(root_);
    node_name.push(node_num);
    node_parent_name.push(0);
    while (!node_pointer.empty()) {
        TreeNode*     node        = node_pointer.front();
        unsigned long name        = node_name.front();
        unsigned long parent_name = node_parent_name.front();
        std::snprintf(filename, file_len, "%016lu.node", name);
        file.open(path);
        if (!file.is_open()) {
            std::cerr << "\nFailed opening file: " << path << std::endl;
            return *this;
        }
        file << std::setw(16) << std::setfill('0') << parent_name
             << ".node    # parent\n"
             << node->depth() << "    # depth\n";
        unsigned int n_child = node->num_of_children();
        file << n_child << "    # number of children\n";
        if (n_child) {
            TreeNode** child = node->children();
            for (unsigned int i = 0; i < n_child; ++i) {
                node_pointer.push(child[i]);
                node_name.push(++node_num);
                node_parent_name.push(name);
                file << std::setw(16) << std::setfill('0') << node_num
                     << ".node    # child " << i << "\n";
            }
        }
        file << node->content();
        file.close();
        node_pointer.pop();
        node_name.pop();
        node_parent_name.pop();
    }
    return *this;
}

template<class _DATA> inline 
Tree<_DATA>::~Tree() {
    if (!root_) return;
    std::queue<TreeNode*> breadth_first_traverse;
    breadth_first_traverse.push(root_);
    while (!breadth_first_traverse.empty()) {
        TreeNode*    cur      = breadth_first_traverse.front();
        unsigned int cur_n_ch = cur->num_of_children();
        if (cur_n_ch) {
            TreeNode** cur_ch = cur->children();
            for (unsigned int i = 0; i < cur_n_ch; i++) {
                breadth_first_traverse.push(cur_ch[i]);
            }
        }
        breadth_first_traverse.pop();
        delete cur;
    }
}

void ParticleTreeDustGridStructure::setupSelfBefore()
{
    GenDustGridStructure::setupSelfBefore();

    // Verify property values
    if (_xmax <= 0.0 || _ymax <= 0.0 || _zmax <= 0.0) throw FATALERROR("The maximum extent should be positive");

    // Cache some often used values
    Log* log = find<Log>();
    _eps = 1e-12 * extent().widths().norm();
    DustDistribution* dd = find<DustDistribution>();
    _dmib = dd->interface<DustMassInBoxInterface>();
    DustParticleInterface* dpi = dd->interface<DustParticleInterface>();
    if (!dpi) throw FATALERROR("Can't retrieve particle locations from this dust distribution");
    int numParticles = dpi->numParticles();
    log->info("Constructing tree for " + QString::number(numParticles) + " particles...");

    // Create a list, used only during construction, that contains the index of the particle
    // contained in each leaf node so far created, or -1 if the node is empty
    // (the value is undefined for nonleaf nodes)
    vector<int> particlev;

    // Create the root node (which at this point is an empty leaf) using the requested type
    switch (_treeType)
    {
    default:
    case OctTree:
        _tree.push_back(new OctTreeNode(0,0,extent()));
        break;
    case BinTree:
        _tree.push_back(new BinTreeNode(0,0,extent()));
        break;
    }
    particlev.push_back(-1);
    int maxlevel = 0;

    // Add particles one by one, subdividing if the leaf node containing the new particle
    // already contains another particle
    for (int i=0; i<numParticles; i++)
    {
        if (i%50000 == 0) log->info("Adding particle number " + QString::number(i) +
                                    " (" + QString::number(i*100/numParticles) + "%)...");
        int level = addParticleToNode(i, root(), dpi, particlev, _tree);
        maxlevel = max(maxlevel, level);
    }

    // Perform additional subdivisions as requested
    if (_extraLevels>0)
    {
        log->info("Performing additional subdivisions...");
        maxlevel += _extraLevels;
        for (int e=0; e<_extraLevels; e++)
        {
            int Nnodes = _tree.size();
            for (int l=0; l<Nnodes; l++)
            {
                TreeNode* node = _tree[l];
                if (node->ynchildless())
                {
                    node->createchildren(_tree.size());
                    _tree.insert(_tree.end(), node->children().begin(), node->children().end());
                }
            }
        }
    }

    // Construction of a vector _idv that contains the node IDs of all
    // leaves. This is the actual dust cell vector (only the leaves will
    // eventually become valid dust cells). We also create a vector
    // _cellnumberv with the cell numbers of all the nodes (i.e. the
    // rank m of the node in the vector _idv if the node is a leaf, and
    // -1 if the node is not a leaf).
    int Nnodes = _tree.size();
    int m = 0;
    _cellnumberv.resize(Nnodes,-1);
    for (int l=0; l<Nnodes; l++)
    {
        if (_tree[l]->ynchildless())
        {
            _idv.push_back(l);
            _cellnumberv[l] = m;
            m++;
        }
    }
    _Ncells = _idv.size();

    // Log the number of cells
    log->info("Construction of the tree finished.");
    log->info("  Total number of nodes: " + QString::number(Nnodes));
    log->info("  Total number of leaves: " + QString::number(_Ncells));
    vector<int> countv(maxlevel+1);
    for (int m=0; m<_Ncells; m++)
    {
        TreeNode* node = _tree[_idv[m]];
        int level = node->level();
        countv[level]++;
    }
    log->info("  Number of leaf cells of each level:");
    for (int level=0; level<=maxlevel; level++)
        log->info("    Level " + QString::number(level) + ": " + QString::number(countv[level]) + " cells");
//.........这里部分代码省略.........