213 lines
6.2 KiB
C++
213 lines
6.2 KiB
C++
// #include "syntax/decl.h"
|
|
//
|
|
// struct LineTree {
|
|
// void clear() {
|
|
// clear_node(root);
|
|
// root = nullptr;
|
|
// stack_size = 0;
|
|
// }
|
|
// void build(uint32_t x) { root = build_node(x); }
|
|
// LineData *at(uint32_t x) {
|
|
// LineNode *n = root;
|
|
// while (n) {
|
|
// uint32_t left_size = n->left ? n->left->size : 0;
|
|
// if (x < left_size) {
|
|
// n = n->left;
|
|
// } else if (x < left_size + n->data.size()) {
|
|
// return &n->data[x - left_size];
|
|
// } else {
|
|
// x -= left_size + n->data.size();
|
|
// n = n->right;
|
|
// }
|
|
// }
|
|
// return nullptr;
|
|
// }
|
|
// LineData *start_iter(uint32_t x) {
|
|
// stack_size = 0;
|
|
// LineNode *n = root;
|
|
// while (n) {
|
|
// uint32_t left_size = n->left ? n->left->size : 0;
|
|
// if (x < left_size) {
|
|
// push(n, 0);
|
|
// n = n->left;
|
|
// } else if (x < left_size + n->data.size()) {
|
|
// push(n, x - left_size + 1);
|
|
// return &n->data[x - left_size];
|
|
// } else {
|
|
// x -= left_size + n->data.size();
|
|
// push(n, UINT32_MAX);
|
|
// n = n->right;
|
|
// }
|
|
// }
|
|
// return nullptr;
|
|
// }
|
|
// void end_iter() { stack_size = 0; }
|
|
// LineData *next() {
|
|
// while (stack_size) {
|
|
// auto &f = stack[stack_size - 1];
|
|
// LineNode *n = f.node;
|
|
// if (f.index < n->data.size())
|
|
// return &n->data[f.index++];
|
|
// stack_size--;
|
|
// if (n->right) {
|
|
// n = n->right;
|
|
// while (n) {
|
|
// push(n, 0);
|
|
// if (!n->left)
|
|
// break;
|
|
// n = n->left;
|
|
// }
|
|
// return &stack[stack_size - 1].node->data[0];
|
|
// }
|
|
// }
|
|
// return nullptr;
|
|
// }
|
|
// void insert(uint32_t x, uint32_t y) { root = insert_node(root, x, y); }
|
|
// void erase(uint32_t x, uint32_t y) { root = erase_node(root, x, y); }
|
|
// uint32_t count() { return subtree_size(root); }
|
|
// ~LineTree() { clear(); }
|
|
//
|
|
// private:
|
|
// struct LineNode {
|
|
// LineNode *left = nullptr;
|
|
// LineNode *right = nullptr;
|
|
// uint8_t depth = 1;
|
|
// uint32_t size = 0;
|
|
// std::vector<LineData> data;
|
|
// };
|
|
// struct Frame {
|
|
// LineNode *node;
|
|
// uint32_t index;
|
|
// };
|
|
// void push(LineNode *n, uint32_t x) {
|
|
// stack[stack_size].node = n;
|
|
// stack[stack_size].index = x;
|
|
// stack_size++;
|
|
// }
|
|
// static void clear_node(LineNode *n) {
|
|
// if (!n)
|
|
// return;
|
|
// clear_node(n->left);
|
|
// clear_node(n->right);
|
|
// delete n;
|
|
// }
|
|
// LineNode *root = nullptr;
|
|
// Frame stack[32];
|
|
// uint8_t stack_size = 0;
|
|
// static constexpr uint32_t LEAF_TARGET = 256;
|
|
// LineTree::LineNode *erase_node(LineNode *n, uint32_t x, uint32_t y) {
|
|
// if (!n)
|
|
// return nullptr;
|
|
// if (!n->left && !n->right) {
|
|
// n->data.erase(n->data.begin() + x, n->data.begin() + x + y);
|
|
// fix(n);
|
|
// return n;
|
|
// }
|
|
// uint32_t left_size = subtree_size(n->left);
|
|
// if (x < left_size)
|
|
// n->left = erase_node(n->left, x, y);
|
|
// else
|
|
// n->right = erase_node(n->right, x - left_size - n->data.size(), y);
|
|
// if (n->left && n->right &&
|
|
// subtree_size(n->left) + subtree_size(n->right) < 256) {
|
|
// return merge(n->left, n->right);
|
|
// }
|
|
// return rebalance(n);
|
|
// }
|
|
// LineTree::LineNode *insert_node(LineNode *n, uint32_t x, uint32_t y) {
|
|
// if (!n) {
|
|
// auto *leaf = new LineNode();
|
|
// leaf->data.resize(y);
|
|
// leaf->size = y;
|
|
// return leaf;
|
|
// }
|
|
// if (!n->left && !n->right) {
|
|
// n->data.insert(n->data.begin() + x, y, LineData{});
|
|
// fix(n);
|
|
// if (n->data.size() > 512)
|
|
// return split_leaf(n);
|
|
// return n;
|
|
// }
|
|
// uint32_t left_size = subtree_size(n->left);
|
|
// if (x <= left_size)
|
|
// n->left = insert_node(n->left, x, y);
|
|
// else
|
|
// n->right = insert_node(n->right, x - left_size - n->data.size(), y);
|
|
// return rebalance(n);
|
|
// }
|
|
// LineNode *build_node(uint32_t count) {
|
|
// if (count <= LEAF_TARGET) {
|
|
// auto *n = new LineNode();
|
|
// n->data.resize(count);
|
|
// n->size = count;
|
|
// return n;
|
|
// }
|
|
// uint32_t left_count = count / 2;
|
|
// uint32_t right_count = count - left_count;
|
|
// auto *n = new LineNode();
|
|
// n->left = build_node(left_count);
|
|
// n->right = build_node(right_count);
|
|
// fix(n);
|
|
// return n;
|
|
// }
|
|
// static LineNode *split_leaf(LineNode *n) {
|
|
// auto *right = new LineNode();
|
|
// size_t mid = n->data.size() / 2;
|
|
// right->data.assign(n->data.begin() + mid, n->data.end());
|
|
// n->data.resize(mid);
|
|
// fix(n);
|
|
// fix(right);
|
|
// auto *parent = new LineNode();
|
|
// parent->left = n;
|
|
// parent->right = right;
|
|
// fix(parent);
|
|
// return parent;
|
|
// }
|
|
// static LineNode *merge(LineNode *a, LineNode *b) {
|
|
// a->data.insert(a->data.end(), b->data.begin(), b->data.end());
|
|
// delete b;
|
|
// fix(a);
|
|
// return a;
|
|
// }
|
|
// static void fix(LineNode *n) {
|
|
// n->depth = 1 + MAX(height(n->left), height(n->right));
|
|
// n->size = subtree_size(n->left) + n->data.size() +
|
|
// subtree_size(n->right);
|
|
// }
|
|
// static LineNode *rotate_right(LineNode *y) {
|
|
// LineNode *x = y->left;
|
|
// LineNode *T2 = x->right;
|
|
// x->right = y;
|
|
// y->left = T2;
|
|
// fix(y);
|
|
// fix(x);
|
|
// return x;
|
|
// }
|
|
// static LineNode *rotate_left(LineNode *x) {
|
|
// LineNode *y = x->right;
|
|
// LineNode *T2 = y->left;
|
|
// y->left = x;
|
|
// x->right = T2;
|
|
// fix(x);
|
|
// fix(y);
|
|
// return y;
|
|
// }
|
|
// static LineNode *rebalance(LineNode *n) {
|
|
// fix(n);
|
|
// int balance = int(height(n->left)) - int(height(n->right));
|
|
// if (balance > 1) {
|
|
// if (height(n->left->left) < height(n->left->right))
|
|
// n->left = rotate_left(n->left);
|
|
// return rotate_right(n);
|
|
// }
|
|
// if (balance < -1) {
|
|
// if (height(n->right->right) < height(n->right->left))
|
|
// n->right = rotate_right(n->right);
|
|
// return rotate_left(n);
|
|
// }
|
|
// return n;
|
|
// }
|
|
// static uint8_t height(LineNode *n) { return n ? n->depth : 0; }
|
|
// static uint32_t subtree_size(LineNode *n) { return n ? n->size : 0; }
|
|
// };
|