// Populate the sidebar
//
// This is a script, and not included directly in the page, to control the total size of the book.
// The TOC contains an entry for each page, so if each page includes a copy of the TOC,
// the total size of the page becomes O(n**2).
class MDBookSidebarScrollbox extends HTMLElement {
    constructor() {
        super();
    }
    connectedCallback() {
        this.innerHTML = '
- Rust 程序设计语言
 - 前言
 - 简介
 - 1. 入门指南
 - 1.1. 安装
 - 1.2. Hello, World!
 - 1.3. Hello, Cargo!
 
- 2. 编写一个猜数字游戏
 - 3. 常见编程概念
 - 3.1. 变量与可变性
 - 3.2. 数据类型
 - 3.3. 函数
 - 3.4. 注释
 - 3.5. 控制流
 
- 4. 认识所有权
 - 4.1. 什么是所有权?
 - 4.2. 引用与借用
 - 4.3. Slice 类型
 
- 5. 使用结构体组织相关联的数据
 - 5.1. 结构体的定义和实例化
 - 5.2. 结构体示例程序
 - 5.3. 方法语法
 
- 6. 枚举和模式匹配
 - 6.1. 枚举的定义
 - 6.2. match 控制流结构
 - 6.3. if let 和 let else 简洁控制流
 
- 7. 使用包、Crate 和模块管理不断增长的项目
 - 7.1. 包和 Crate
 - 7.2. 定义模块来控制作用域与私有性
 - 7.3. 引用模块树中项的路径
 - 7.4. 使用 use 关键字将路径引入作用域
 - 7.5. 将模块拆分成多个文件
 
- 8. 常见集合
 - 8.1. 使用 Vector 储存列表
 - 8.2. 使用字符串储存 UTF-8 编码的文本
 - 8.3. 使用 Hash Map 储存键值对
 
- 9. 错误处理
 - 9.1. 用 panic! 处理不可恢复的错误
 - 9.2. 用 Result 处理可恢复的错误
 - 9.3. 要不要 panic!
 
- 10. 泛型、Trait 和生命周期
 - 10.1. 泛型数据类型
 - 10.2. Trait:定义共同行为
 - 10.3. 生命周期确保引用有效
 
- 11. 编写自动化测试
 - 11.1. 如何编写测试
 - 11.2. 控制测试如何运行
 - 11.3. 测试的组织结构
 
- 12. 一个 I/O 项目:构建命令行程序
 - 12.1. 接受命令行参数
 - 12.2. 读取文件
 - 12.3. 重构以改进模块化与错误处理
 - 12.4. 采用测试驱动开发完善库的功能
 - 12.5. 处理环境变量
 - 12.6. 将错误信息输出到标准错误而不是标准输出
 
- 13. 函数式语言特性:迭代器与闭包
 - 13.1. 闭包:可以捕获其环境的匿名函数
 - 13.2. 使用迭代器处理元素序列
 - 13.3. 改进之前的 I/O 项目
 - 13.4. 性能比较:循环对迭代器
 
- 14. 更多关于 Cargo 和 Crates.io 的内容
 - 14.1. 采用发布配置自定义构建
 - 14.2. 将 crate 发布到 Crates.io
 - 14.3. Cargo 工作空间
 - 14.4. 使用 cargo install 安装二进制文件
 - 14.5. Cargo 自定义扩展命令
 
- 15. 智能指针
 - 15.1. 使用 Box<T> 指向堆上数据
 - 15.2. 使用 Deref Trait 将智能指针当作常规引用处理
 - 15.3. 使用 Drop Trait 运行清理代码
 - 15.4. Rc<T> 引用计数智能指针
 - 15.5. RefCell<T> 与内部可变性模式
 - 15.6. 引用循环会导致内存泄漏
 
- 16. 无畏并发
 - 16.1. 使用线程同时地运行代码
 - 16.2. 使用消息传递在线程间通信
 - 16.3. 共享状态并发
 - 16.4. 使用 Sync 与 Send Traits 的可扩展并发
 
- 17. Async 和 await
 - 17.1. Futures 和 async 语法
 - 17.2. 并发与 async
 - 17.3. 使用任意数量的 futures
 - 17.4. 流(Streams)
 - 17.5. 深入理解 async 相关的 traits
 - 17.6. future、任务和线程
 
- 18. 面向对象编程特性
 - 18.1. 面向对象语言的特征
 - 18.2. 顾及不同类型值的 trait 对象
 - 18.3. 面向对象设计模式的实现
 
- 19. 模式与模式匹配
 - 19.1. 所有可能会用到模式的位置
 - 19.2. Refutability(可反驳性): 模式是否会匹配失效
 - 19.3. 模式语法
 
- 20. 高级特性
 - 20.1. 不安全 Rust
 - 20.2. 高级 trait
 - 20.3. 高级类型
 - 20.4. 高级函数与闭包
 - 20.5. 宏
 
- 21. 最后的项目:构建多线程 web server
 - 21.1. 建立单线程 web server
 - 21.2. 将单线程 server 变为多线程 server
 - 21.3. 优雅停机与清理
 
- 22. 附录
 - 22.1. A - 关键字
 - 22.2. B - 运算符与符号
 - 22.3. C - 可派生的 trait
 - 22.4. D - 实用开发工具
 - 22.5. E - 版本
 - 22.6. F - 本书译本
 - 22.7. G - Rust 是如何开发的与 “Nightly Rust”
 
';
        // Set the current, active page, and reveal it if it's hidden
        let current_page = document.location.href.toString().split("#")[0].split("?")[0];
        if (current_page.endsWith("/")) {
            current_page += "index.html";
        }
        var links = Array.prototype.slice.call(this.querySelectorAll("a"));
        var l = links.length;
        for (var i = 0; i < l; ++i) {
            var link = links[i];
            var href = link.getAttribute("href");
            if (href && !href.startsWith("#") && !/^(?:[a-z+]+:)?\/\//.test(href)) {
                link.href = path_to_root + href;
            }
            // The "index" page is supposed to alias the first chapter in the book.
            if (link.href === current_page || (i === 0 && path_to_root === "" && current_page.endsWith("/index.html"))) {
                link.classList.add("active");
                var parent = link.parentElement;
                if (parent && parent.classList.contains("chapter-item")) {
                    parent.classList.add("expanded");
                }
                while (parent) {
                    if (parent.tagName === "LI" && parent.previousElementSibling) {
                        if (parent.previousElementSibling.classList.contains("chapter-item")) {
                            parent.previousElementSibling.classList.add("expanded");
                        }
                    }
                    parent = parent.parentElement;
                }
            }
        }
        // Track and set sidebar scroll position
        this.addEventListener('click', function(e) {
            if (e.target.tagName === 'A') {
                sessionStorage.setItem('sidebar-scroll', this.scrollTop);
            }
        }, { passive: true });
        var sidebarScrollTop = sessionStorage.getItem('sidebar-scroll');
        sessionStorage.removeItem('sidebar-scroll');
        if (sidebarScrollTop) {
            // preserve sidebar scroll position when navigating via links within sidebar
            this.scrollTop = sidebarScrollTop;
        } else {
            // scroll sidebar to current active section when navigating via "next/previous chapter" buttons
            var activeSection = document.querySelector('#sidebar .active');
            if (activeSection) {
                activeSection.scrollIntoView({ block: 'center' });
            }
        }
        // Toggle buttons
        var sidebarAnchorToggles = document.querySelectorAll('#sidebar a.toggle');
        function toggleSection(ev) {
            ev.currentTarget.parentElement.classList.toggle('expanded');
        }
        Array.from(sidebarAnchorToggles).forEach(function (el) {
            el.addEventListener('click', toggleSection);
        });
    }
}
window.customElements.define("mdbook-sidebar-scrollbox", MDBookSidebarScrollbox);