int TsFileIOWriter::generate_root()

in cpp/src/file/tsfile_io_writer.cc [704:809]

• 100 lines of code
• 21 McCabe index (conditional complexity)

int TsFileIOWriter::generate_root(
    SimpleList<std::shared_ptr<MetaIndexNode>> *node_queue,
    std::shared_ptr<MetaIndexNode> &root_node, MetaIndexNodeType node_type,
    FileIndexWritingMemManager &wmm) {
    int ret = E_OK;

    ASSERT(node_queue->size() > 0);
    if (node_queue->size() == 1) {
        root_node = node_queue->front();
        return ret;
    }

    const uint32_t LIST_PAGE_SIZE = 256;
    const AllocModID mid = MOD_TSFILE_WRITER_META;
    SimpleList<std::shared_ptr<MetaIndexNode>> list_x(LIST_PAGE_SIZE, mid);
    SimpleList<std::shared_ptr<MetaIndexNode>> list_y(LIST_PAGE_SIZE, mid);

    if (RET_FAIL(clone_node_list(node_queue, &list_x))) {
        return ret;
    }

    common::SimpleList<std::shared_ptr<MetaIndexNode>> *from = &list_x;
    common::SimpleList<std::shared_ptr<MetaIndexNode>> *to = &list_y;

    std::shared_ptr<MetaIndexNode> cur_index_node = nullptr;
    if (RET_FAIL(
            alloc_and_init_meta_index_node(wmm, cur_index_node, node_type))) {
    }
    while (IS_SUCC(ret)) {
        to->clear();
        SimpleList<std::shared_ptr<MetaIndexNode>>::Iterator from_iter;
        for (from_iter = from->begin();
             IS_SUCC(ret) && from_iter != from->end(); from_iter++) {
            auto iter_node = from_iter.get();
            std::shared_ptr<IMetaIndexEntry> entry = nullptr;
            auto first_child = iter_node->peek();
            if (const auto derived_entry =
                    std::dynamic_pointer_cast<DeviceMetaIndexEntry>(
                        first_child)) {
                ret = alloc_and_init_meta_index_entry(
                    wmm, entry, derived_entry->device_id_);
            } else if (const auto measurement_entry =
                           std::dynamic_pointer_cast<MeasurementMetaIndexEntry>(
                               first_child)) {
                ret = alloc_and_init_meta_index_entry(wmm, entry,
                                                      measurement_entry->name_);
            } else {
                ret = E_INVALID_DATA_POINT;
            }
            if (IS_FAIL(ret)) {
                continue;
            }

            if (cur_index_node->is_full()) {
                cur_index_node->end_offset_ = cur_file_position();
                if (RET_FAIL(to->push_back(cur_index_node))) {
                } else {
#if DEBUG_SE
                    std::cout
                        << "generate root, alloc_and_init_meta_index_node. "
                           "cur_index_node="
                        << *cur_index_node << std::endl;
#endif
                    if (RET_FAIL(alloc_and_init_meta_index_node(
                            wmm, cur_index_node, node_type))) {
                    }
                }
            }
            if (IS_SUCC(ret)) {
                if (RET_FAIL(cur_index_node->push_entry(entry))) {
                } else {
                    OFFSET_DEBUG("before writer index_node in generate_root");
                    ret = iter_node->serialize_to(write_stream_);
                    OFFSET_DEBUG("after writer index_node in generate_root");
                }
            }
        }  // end for
        if (IS_SUCC(ret)) {
            if (!cur_index_node->is_empty()) {
                cur_index_node->end_offset_ = cur_file_position();
                if (RET_FAIL(to->push_back(cur_index_node))) {
                }
#if DEBUG_SE
                std::cout << "genereate root 2, "
                             "alloc_and_init_meta_index_node. cur_index_node="
                          << *cur_index_node << std::endl;
#endif
                if (RET_FAIL(alloc_and_init_meta_index_node(wmm, cur_index_node,
                                                            node_type))) {
                }
            }
        }
        if (IS_SUCC(ret)) {
            ASSERT(from->size() > to->size());
            if (to->size() == 1) {
                root_node = to->front();
                break;
            } else {
                swap_list(from, to);
            }
        }
    }  // end while
    destroy_node_list(&list_x);
    destroy_node_list(&list_y);
    return ret;
}