hicc-std 0.2.0

//! ## 使用方式
//! 
//! 注：
//! 1. `hicc-std`仅提供了`std::string`, `std::u16string`, `std::u32string`相关的构造函数.
//! 1. `v0.2.0`版本, 通过增加参数校验，消除了原接口中可能抛出的各种异常.
//!    部分接口的返回值类型发生了变化.
//! 
//! 因为都是模板类，需要使用者显示实现实例化模版类的构建函数. 参见如下代码:
//! 
//! ```text
//! use hicc::AbicClass;
//! 
//! hicc::cpp! {
//!     // c++侧需要引用hicc提供的头文件.
//!     #include <hicc/std/map.hpp>
//!     #include <hicc/std/string.hpp>
//!
//!     // 按需定义容器类型. 可以包含非缺省的Allocator等模版参数类型.
//!     typedef std::map<int, std::string> CppMap;
//! }
//! 
//! hicc::import_lib! {
//!     #![link_name = "example"]
//! 
//!     // 对应`c++`的`CppMap`
//!     class RustMap = hicc_std::map<hicc::Pod<i32>, hicc_std::string>;
//! 
//!     // 创建容器接口.
//!     #[cpp(func = "std::unique_ptr<CppMap> hicc::make_unique<CppMap>()")]
//!     fn rustmap_new() -> RustMap;
//! }
//! 
//! fn main() {
//!     let mut map = rustmap_new();
//!     let name = hicc_std::string::from(c"hello");
//!     map.insert(&0, &name);
//!     assert_eq!(map.get(&1), None);
//!     assert_eq!(map.get(&0), Some(name.as_ref()));
//! }
//! ```
//! 
//! **注意**: 
//! > 1. 模版参数类型只能是`c++`类或者可直接在`CABI`接口上传递使用的`POD`数据类型，后者只能结合`hicc::Pod<T>`使用.
//! 
//! 3. `build.rs`编译`c++`代码
//! 
//! ```text
//! fn main() {
//!     hicc_build::Build::new().rust_file("src/main.rs").compile("example");
//!     println!("cargo::rustc-link-lib=example");
//!     println!("cargo::rustc-link-lib=stdc++");
//!     println!("cargo::rerun-if-changed=src/main.rs");
//! }
//! ```
//! 
//! `hicc_build`仅支持生成静态库, 需要最终构建为可执行程序或者动态库时指定所依赖的`c++`标准库.
//! 
//! ## 迭代器接口说明
//! 
//! `c++`容器基于迭代器实现插入删除等接口违背`rust`的借用规则, `hicc-std`将迭代器做了二次封装，提供容器遍历和插入删除功能.
//! 
//! ## 测试
//! 
//! `doc test`需要开启`test feature`, 提供了测试用例用到的容器实例化类型的构建函数.
//! 
//! ```text
//! # cargo test --features "test"
//! ```
//!
mod std_string;
pub use std_string::*;

mod std_array;
pub use std_array::*;

mod std_deque;
pub use std_deque::*;

mod std_vector;
pub use std_vector::*;

mod std_stack;
pub use std_stack::*;

mod std_queue;
pub use std_queue::*;

mod std_list;
pub use std_list::*;

mod std_forward_list;
pub use std_forward_list::*;

mod std_set;
pub use std_set::*;

mod std_unordered_set;
pub use std_unordered_set::*;

mod std_map;
pub use std_map::*;

mod std_unordered_map;
pub use std_unordered_map::*;

hicc::import_lib! {
    #![link_name = "hicc_std_string"]

    hicc::cpp! {
        #include <hicc/std/string.hpp>
    }

    class string;

    #[cpp(func = "std::unique_ptr<std::string> hicc::make_unique<std::string>()")]
    fn string_new() -> string;

    #[cpp(func = "std::unique_ptr<std::string> hicc::make_unique<std::string, const char*>(const char* &&)")]
    unsafe fn string_with_cstr(s: *const i8) -> string;

    #[cpp(func = "std::unique_ptr<std::string> hicc::make_unique<std::string, const char*, size_t>(const char* &&, size_t&&)")]
    unsafe fn string_with_buf(s: *const u8, len: usize) -> string;

    #[cpp(func = "std::unique_ptr<std::u16string> hicc::make_unique<std::u16string>()")]
    fn u16string_new() -> u16string;

    #[cpp(func = "std::unique_ptr<std::u16string> hicc::make_unique<std::u16string, const char16_t*, size_t>(const char16_t* &&, size_t&&)")]
    unsafe fn u16string_with_buf(s: *const u16, len: usize) -> u16string;

    #[cpp(func = "std::unique_ptr<std::u32string> hicc::make_unique<std::u32string>()")]
    fn u32string_new() -> u32string;

    #[cpp(func = "std::unique_ptr<std::u32string> hicc::make_unique<std::u32string, const char32_t*, size_t>(const char32_t* &&, size_t&&)")]
    unsafe fn u32string_with_buf(s: *const u32, len: usize) -> u32string;
}

#[cfg(feature = "test")]
hicc::import_lib! {
    #![link_name = "hicc_std_test"]
    hicc::cpp! {
        #include <hicc/std/array.hpp>
        #include <hicc/std/deque.hpp>
        #include <hicc/std/vector.hpp>
        #include <hicc/std/stack.hpp>
        #include <hicc/std/queue.hpp>
        #include <hicc/std/list.hpp>
        #include <hicc/std/forward_list.hpp>
        #include <hicc/std/set.hpp>
        #include <hicc/std/map.hpp>
        #include <hicc/std/unordered_set.hpp>
        #include <hicc/std/unordered_map.hpp>
    }
    class string;

    /// 对应`std::array<int, N>`. 其中`N`由具体创建函数决定.
    pub class ArrayInt = array<hicc::Pod<i32>>;
    /// 对应`std::array<int, 10>`
    #[cpp(func = "std::unique_ptr<std::array<int, 10>> hicc::make_unique<std::array<int, 10>>()")]
    #[member(class = ArrayInt, method = new_10)]
    pub fn array_int_10_new() -> ArrayInt;
    /// 对应`std::array<std::string, N>`. 其中`N`由具体创建函数决定.
    pub class ArrayString = array<string>;
    /// 对应`std::array<std::string, 10>`
    #[cpp(func = "std::unique_ptr<std::array<std::string, 10>> hicc::make_unique<std::array<std::string, 10>>()")]
    #[member(class = ArrayString, method = new_10)]
    pub fn array_string_10_new() -> ArrayString;


    
    /// 对应`std::deque<int>`
    pub class DequeInt = deque<hicc::Pod<i32>>;
    #[cpp(func = "std::unique_ptr<std::deque<int>> hicc::make_unique<std::deque<int>>()")]
    #[member(class = DequeInt, method = new)]
    pub fn deque_int_new() -> DequeInt;
    /// 对应`std::deque<std::string>`
    pub class DequeString = deque<string>;
    #[cpp(func = "std::unique_ptr<std::deque<std::string>> hicc::make_unique<std::deque<std::string>>()")]
    #[member(class = DequeString, method = new)]
    pub fn deque_string_new() -> DequeString;
    
    /// 对应`std::vector<int>`
    pub class VecInt = vector<hicc::Pod<i32>>;
    #[cpp(func = "std::unique_ptr<std::vector<int>> hicc::make_unique<std::vector<int>>()")]
    #[member(class = VecInt, method = new)]
    pub fn vec_int_new() -> VecInt;

    /// 对应`std::vector<std::string>`
    pub class VecString = vector<string>;
    #[cpp(func = "std::unique_ptr<std::vector<std::string>> hicc::make_unique<std::vector<std::string>>()")]
    #[member(class = VecString, method = new)]
    pub fn vec_string_new() -> VecString;

    /// 对应`std::vector<std::vector<std::string>>`
    pub class VecVecString = vector<vector<string>>;
    #[cpp(func = "std::unique_ptr<std::vector<std::vector<std::string>>> hicc::make_unique<std::vector<std::vector<std::string>>>()")]
    #[member(class = VecVecString, method = new)]
    pub fn vec_vec_string_new() -> VecVecString;

    #[cpp(func = "std::unique_ptr<std::vector<bool>> hicc::make_unique<std::vector<bool>>()")]
    #[member(class = VecBool, method = new)]
    pub fn vec_bool_new() -> VecBool;
    
    /// 对应`std::stack<int>`
    pub class StackInt = stack<hicc::Pod<i32>>;
    #[cpp(func = "std::unique_ptr<std::stack<int>> hicc::make_unique<std::stack<int>>()")]
    #[member(class = StackInt, method = new)]
    pub fn stack_int_new() -> StackInt;
    /// 对应`std::stack<std::string>`
    pub class StackString = stack<string>;
    #[cpp(func = "std::unique_ptr<std::stack<std::string>> hicc::make_unique<std::stack<std::string>>()")]
    #[member(class = StackString, method = new)]
    pub fn stack_string_new() -> StackString;

    /// 对应`std::queue<int>`
    pub class QueueInt = queue<hicc::Pod<i32>>;
    #[cpp(func = "std::unique_ptr<std::queue<int>> hicc::make_unique<std::queue<int>>()")]
    #[member(class = QueueInt, method = new)]
    pub fn queue_int_new() -> QueueInt;

    /// 对应`std::queue<std::string>`
    pub class QueueString = queue<string>;
    #[cpp(func = "std::unique_ptr<std::queue<std::string>> hicc::make_unique<std::queue<std::string>>()")]
    #[member(class = QueueString, method = new)]
    pub fn queue_string_new() -> QueueString;

    /// 对应`std::priority_queue<int>`
    pub class PriorityQueueInt = priority_queue<hicc::Pod<i32>>;
    #[cpp(func = "std::unique_ptr<std::priority_queue<int>> hicc::make_unique<std::priority_queue<int>>()")]
    #[member(class = PriorityQueueInt, method = new)]
    pub fn priority_queue_int_new() -> PriorityQueueInt;

    /// 对应`std::list<int>`
    pub class ListInt = list<hicc::Pod<i32>>;
    #[cpp(func = "std::unique_ptr<std::list<int>> hicc::make_unique<std::list<int>>()")]
    #[member(class = ListInt, method = new)]
    pub fn list_int_new() -> ListInt;
    /// 对应`std::list<std::string>`
    pub class ListString = list<string>;
    #[cpp(func = "std::unique_ptr<std::list<std::string>> hicc::make_unique<std::list<std::string>>()")]
    #[member(class = ListString, method = new)]
    pub fn list_string_new() -> ListString;

    /// 对应`std::forward_list<int>`
    pub class ForwardListInt = forward_list<hicc::Pod<i32>>;
    #[cpp(func = "std::unique_ptr<std::forward_list<int>> hicc::make_unique<std::forward_list<int>>()")]
    #[member(class = ForwardListInt, method = new)]
    pub fn forward_list_int_new() -> ForwardListInt;

    /// 对应`std::forward_list<std::string>`
    pub class ForwardListString = forward_list<string>;
    #[cpp(func = "std::unique_ptr<std::forward_list<std::string>> hicc::make_unique<std::forward_list<std::string>>()")]
    #[member(class = ForwardListString, method = new)]
    pub fn forward_list_string_new() -> ForwardListString;

    /// 对应`std::set<int>`
    pub class SetInt = set<hicc::Pod<i32>>;
    /// 对应`std::set<std::string>`
    pub class SetString = set<string>;
    /// 对应`std::multiset<int>`
    pub class MultiSetInt = multiset<hicc::Pod<i32>>;
    /// 对应`std::multiset<std::string>`
    pub class MultiSetString = multiset<string>;

    #[cpp(func = "std::unique_ptr<std::set<int>> hicc::make_unique<std::set<int>>()")]
    #[member(class = SetInt, method = new)]
    pub fn set_int_new() -> SetInt;
    #[cpp(func = "std::unique_ptr<std::set<std::string>> hicc::make_unique<std::set<std::string>>()")]
    #[member(class = SetString, method = new)]
    pub fn set_string_new() -> SetString;

    #[cpp(func = "std::unique_ptr<std::multiset<int>> hicc::make_unique<std::multiset<int>>()")]
    #[member(class = MultiSetInt, method = new)]
    pub fn multiset_int_new() -> MultiSetInt;
    #[cpp(func = "std::unique_ptr<std::multiset<std::string>> hicc::make_unique<std::multiset<std::string>>()")]
    #[member(class = MultiSetString, method = new)]
    pub fn multiset_string_new() -> MultiSetString;

    /// 对应`std::map<std::string, std::string>`
    pub class MapStringString = map<string, string>;
    /// 对应`std::map<std::string, int>`
    pub class MapStringInt = map<string, hicc::Pod<i32>>;
    /// 对应`std::map<int, std::string>`
    pub class MapIntString = map<hicc::Pod<i32>, string>;
    /// 对应`std::map<int, int>`
    pub class MapIntInt = map<hicc::Pod<i32>, hicc::Pod<i32>>;

    #[member(class = MapStringString, method = new)]
    #[cpp(func = "std::map<std::string, std::string> hicc::make_constructor<std::map<std::string, std::string>>()")]
    pub fn map_string_string_new() -> MapStringString;
    #[member(class = MapStringInt, method = new)]
    #[cpp(func = "std::map<std::string, int> hicc::make_constructor<std::map<std::string, int>>()")]
    pub fn map_string_int_new() -> MapStringInt;
    #[member(class = MapIntString, method = new)]
    #[cpp(func = "std::map<int, std::string> hicc::make_constructor<std::map<int, std::string>>()")]
    pub fn map_int_string_new() -> MapIntString;
    #[member(class = MapIntInt, method = new)]
    #[cpp(func = "std::map<int, int> hicc::make_constructor<std::map<int, int>>()")]
    pub fn map_int_int_new() -> MapIntInt;

    /// 对应`std::multimap<std::string, std::string>`
    pub class MultiMapStringString = multimap<string, string>;
    /// 对应`std::multimap<std::string, int>`
    pub class MultiMapStringInt = multimap<string, hicc::Pod<i32>>;
    /// 对应`std::multimap<int, std::string>`
    pub class MultiMapIntString = multimap<hicc::Pod<i32>, string>;
    /// 对应`std::multimap<int, int>`
    pub class MultiMapIntInt = multimap<hicc::Pod<i32>, hicc::Pod<i32>>;

    #[member(class = MultiMapStringString, method = new)]
    #[cpp(func = "std::multimap<std::string, std::string> hicc::make_constructor<std::multimap<std::string, std::string>>()")]
    pub fn multimap_string_string_new() -> MultiMapStringString;
    #[member(class = MultiMapStringInt, method = new)]
    #[cpp(func = "std::multimap<std::string, int> hicc::make_constructor<std::multimap<std::string, int>>()")]
    pub fn multimap_string_int_new() -> MultiMapStringInt;
    #[member(class = MultiMapIntString, method = new)]
    #[cpp(func = "std::multimap<int, std::string> hicc::make_constructor<std::multimap<int, std::string>>()")]
    pub fn multimap_int_string_new() -> MultiMapIntString;
    #[member(class = MultiMapIntInt, method = new)]
    #[cpp(func = "std::multimap<int, int> hicc::make_constructor<std::multimap<int, int>>()")]
    pub fn multimap_int_int_new() -> MultiMapIntInt;
    
    /// 对应`std::unordered_set<int>`
    pub class UnorderedSetInt = unordered_set<hicc::Pod<i32>>;
    /// 对应`std::unordered_set<std::string>`
    pub class UnorderedSetString = unordered_set<string>;
    /// 对应`std::unordered_multiset<int>`
    pub class UnorderedMultiSetInt = unordered_multiset<hicc::Pod<i32>>;
    /// 对应`std::unordered_multiset<std::string>`
    pub class UnorderedMultiSetString = unordered_multiset<string>;

    #[member(class = UnorderedSetInt, method = new)]
    #[cpp(func = "std::unordered_set<int> hicc::make_constructor<std::unordered_set<int>>()")]
    pub fn unordered_set_int_new() -> UnorderedSetInt;
    #[member(class = UnorderedSetString, method = new)]
    #[cpp(func = "std::unordered_set<std::string> hicc::make_constructor<std::unordered_set<std::string>>()")]
    pub fn unordered_set_string_new() -> UnorderedSetString;

    #[member(class = UnorderedMultiSetInt, method = new)]
    #[cpp(func = "std::unordered_multiset<int> hicc::make_constructor<std::unordered_multiset<int>>()")]
    pub fn unordered_multiset_int_new() -> UnorderedMultiSetInt;
    #[member(class = UnorderedMultiSetString, method = new)]
    #[cpp(func = "std::unordered_multiset<std::string> hicc::make_constructor<std::unordered_multiset<std::string>>()")]
    pub fn unordered_multiset_string_new() -> UnorderedMultiSetString;

    /// 对应`std::unordered_map<std::string, std::string>`
    pub class UnorderedMapStringString = unordered_map<string, string>;
    /// 对应`std::unordered_map<std::string, int>`
    pub class UnorderedMapStringInt = unordered_map<string, hicc::Pod<i32>>;
    /// 对应`std::unordered_map<int, std::string>`
    pub class UnorderedMapIntString = unordered_map<hicc::Pod<i32>, string>;
    /// 对应`std::unordered_map<int, int>`
    pub class UnorderedMapIntInt = unordered_map<hicc::Pod<i32>, hicc::Pod<i32>>;

    #[member(class = UnorderedMapStringString, method = new)]
    #[cpp(func = "std::unordered_map<std::string, std::string> hicc::make_constructor<std::unordered_map<std::string, std::string>>()")]
    pub fn unordered_map_string_string_new() -> UnorderedMapStringString;
    #[member(class = UnorderedMapStringInt, method = new)]
    #[cpp(func = "std::unordered_map<std::string, int> hicc::make_constructor<std::unordered_map<std::string, int>>()")]
    pub fn unordered_map_string_int_new() -> UnorderedMapStringInt;
    #[member(class = UnorderedMapIntString, method = new)]
    #[cpp(func = "std::unordered_map<int, std::string> hicc::make_constructor<std::unordered_map<int, std::string>>()")]
    pub fn unordered_map_int_string_new() -> UnorderedMapIntString;
    #[member(class = UnorderedMapIntInt, method = new)]
    #[cpp(func = "std::unordered_map<int, int> hicc::make_constructor<std::unordered_map<int, int>>()")]
    pub fn unordered_map_int_int_new() -> UnorderedMapIntInt;

    /// 对应`std::unordered_multimap<std::string, std::string>`
    pub class UnorderedMultiMapStringString = unordered_multimap<string, string>;
    /// 对应`std::unordered_multimap<std::string, int>`
    pub class UnorderedMultiMapStringInt = unordered_multimap<string, hicc::Pod<i32>>;
    /// 对应`std::unordered_multimap<int, std::string>`
    pub class UnorderedMultiMapIntString = unordered_multimap<hicc::Pod<i32>, string>;
    /// 对应`std::unordered_multimap<int, int>`
    pub class UnorderedMultiMapIntInt = unordered_multimap<hicc::Pod<i32>, hicc::Pod<i32>>;

    #[member(class = UnorderedMultiMapStringString, method = new)]
    #[cpp(func = "std::unordered_multimap<std::string, std::string> hicc::make_constructor<std::unordered_multimap<std::string, std::string>>()")]
    pub fn unordered_multimap_string_string_new() -> UnorderedMultiMapStringString;
    #[member(class = UnorderedMultiMapStringInt, method = new)]
    #[cpp(func = "std::unordered_multimap<std::string, int> hicc::make_constructor<std::unordered_multimap<std::string, int>>()")]
    pub fn unordered_multimap_string_int_new() -> UnorderedMultiMapStringInt;
    #[member(class = UnorderedMultiMapIntString, method = new)]
    #[cpp(func = "std::unordered_multimap<int, std::string> hicc::make_constructor<std::unordered_multimap<int, std::string>>()")]
    pub fn unordered_multimap_int_string_new() -> UnorderedMultiMapIntString;
    #[member(class = UnorderedMultiMapIntInt, method = new)]
    #[cpp(func = "std::unordered_multimap<int, int> hicc::make_constructor<std::unordered_multimap<int, int>>()")]
    pub fn unordered_multimap_int_int_new() -> UnorderedMultiMapIntInt;
}