reoxide 0.7.0

use super::*;
use crate::cpp::*;

#[link(name = "reoxide")]
unsafe extern "C-unwind" {
    fn StdVectorCSEHashPair_new() -> *mut StdVector<CSEHashPair>;
    fn StdVectorCSEHashPair_destroy_vec(this: *mut StdVector<CSEHashPair>);
    fn StdVectorCSEHashPair_data(this: *const StdVector<CSEHashPair>) -> *const CSEHashPair;
    fn StdVectorCSEHashPair_len(this: *const StdVector<CSEHashPair>) -> usize;
    fn StdVectorCSEHashPair_clear(this: *mut StdVector<CSEHashPair>);
    fn StdVectorCSEHashPair_push(this: *mut StdVector<CSEHashPair>, item: CSEHashPair);
    fn StdVectorCSEHashPair_extend(this: *mut StdVector<CSEHashPair>, items: *const CSEHashPair, count: usize);
}

unsafe impl StdVectorItem for CSEHashPair {
    fn new() -> ExternAlloc<StdVector<Self>> {
        unsafe {
            let v = StdVectorCSEHashPair_new();
            ExternAlloc::from_raw(v)
        }
    }

    unsafe fn destroy_vec(vec: *mut StdVector<Self>) {
        unsafe {
            StdVectorCSEHashPair_destroy_vec(vec);
        }
    }

    fn data(vec: &StdVector<Self>) -> *const Self {
        unsafe {
            StdVectorCSEHashPair_data(vec)
        }
    }

    fn len(vec: &StdVector<Self>) -> usize {
        unsafe {
            StdVectorCSEHashPair_len(vec)
        }
    }

    fn clear(vec: &mut StdVector<Self>) {
        unsafe {
            StdVectorCSEHashPair_clear(vec);
        }
    }

    fn push(vec: &mut StdVector<Self>, item: Self) {
        unsafe {
            StdVectorCSEHashPair_push(vec, item);
        }
    }

    fn extend(vec: &mut StdVector<Self>, items: &[Self]) {
        unsafe {
            StdVectorCSEHashPair_extend(vec, items.as_ptr().cast(), items.len());
        }
    }
}

#[link(name = "reoxide")]
unsafe extern "C-unwind" {
    fn StdVectorPieceNode_new() -> *mut StdVector<PieceNode>;
    fn StdVectorPieceNode_destroy_vec(this: *mut StdVector<PieceNode>);
    fn StdVectorPieceNode_data(this: *const StdVector<PieceNode>) -> *const PieceNode;
    fn StdVectorPieceNode_len(this: *const StdVector<PieceNode>) -> usize;
    fn StdVectorPieceNode_clear(this: *mut StdVector<PieceNode>);
    fn StdVectorPieceNode_push(this: *mut StdVector<PieceNode>, item: PieceNode);
    fn StdVectorPieceNode_extend(this: *mut StdVector<PieceNode>, items: *const PieceNode, count: usize);
}

unsafe impl StdVectorItem for PieceNode {
    fn new() -> ExternAlloc<StdVector<Self>> {
        unsafe {
            let v = StdVectorPieceNode_new();
            ExternAlloc::from_raw(v)
        }
    }

    unsafe fn destroy_vec(vec: *mut StdVector<Self>) {
        unsafe {
            StdVectorPieceNode_destroy_vec(vec);
        }
    }

    fn data(vec: &StdVector<Self>) -> *const Self {
        unsafe {
            StdVectorPieceNode_data(vec)
        }
    }

    fn len(vec: &StdVector<Self>) -> usize {
        unsafe {
            StdVectorPieceNode_len(vec)
        }
    }

    fn clear(vec: &mut StdVector<Self>) {
        unsafe {
            StdVectorPieceNode_clear(vec);
        }
    }

    fn push(vec: &mut StdVector<Self>, item: Self) {
        unsafe {
            StdVectorPieceNode_push(vec, item);
        }
    }

    fn extend(vec: &mut StdVector<Self>, items: &[Self]) {
        unsafe {
            StdVectorPieceNode_extend(vec, items.as_ptr().cast(), items.len());
        }
    }
}

#[link(name = "reoxide")]
unsafe extern "C-unwind" {
    fn StdVectorPtrAdditiveEdge_new<'a>() -> *mut StdVector<&'a mut AdditiveEdge>;
    fn StdVectorPtrAdditiveEdge_destroy_vec(this: *mut StdVector<&mut AdditiveEdge>);
    fn StdVectorPtrAdditiveEdge_data(this: *const StdVector<&mut AdditiveEdge>) -> *const &mut AdditiveEdge;
    fn StdVectorPtrAdditiveEdge_len(this: *const StdVector<&mut AdditiveEdge>) -> usize;
    fn StdVectorPtrAdditiveEdge_clear(this: *mut StdVector<&mut AdditiveEdge>);
    fn StdVectorPtrAdditiveEdge_push(this: *mut StdVector<&mut AdditiveEdge>, item: &mut AdditiveEdge);
    fn StdVectorPtrAdditiveEdge_extend(this: *mut StdVector<&mut AdditiveEdge>, items: *const &mut AdditiveEdge, count: usize);
}

unsafe impl StdVectorItem for &mut AdditiveEdge {
    fn new() -> ExternAlloc<StdVector<Self>> {
        unsafe {
            let v = StdVectorPtrAdditiveEdge_new();
            ExternAlloc::from_raw(v)
        }
    }

    unsafe fn destroy_vec(vec: *mut StdVector<Self>) {
        unsafe {
            StdVectorPtrAdditiveEdge_destroy_vec(vec);
        }
    }

    fn data(vec: &StdVector<Self>) -> *const Self {
        unsafe {
            StdVectorPtrAdditiveEdge_data(vec)
        }
    }

    fn len(vec: &StdVector<Self>) -> usize {
        unsafe {
            StdVectorPtrAdditiveEdge_len(vec)
        }
    }

    fn clear(vec: &mut StdVector<Self>) {
        unsafe {
            StdVectorPtrAdditiveEdge_clear(vec);
        }
    }

    fn push(vec: &mut StdVector<Self>, item: Self) {
        unsafe {
            StdVectorPtrAdditiveEdge_push(vec, item);
        }
    }

    fn extend(vec: &mut StdVector<Self>, items: &[Self]) {
        unsafe {
            StdVectorPtrAdditiveEdge_extend(vec, items.as_ptr().cast(), items.len());
        }
    }
}

#[link(name = "reoxide")]
unsafe extern "C-unwind" {
    fn StdVectorPtrPcodeOp_new<'a>() -> *mut StdVector<&'a mut PcodeOp>;
    fn StdVectorPtrPcodeOp_destroy_vec(this: *mut StdVector<&mut PcodeOp>);
    fn StdVectorPtrPcodeOp_data(this: *const StdVector<&mut PcodeOp>) -> *const &mut PcodeOp;
    fn StdVectorPtrPcodeOp_len(this: *const StdVector<&mut PcodeOp>) -> usize;
    fn StdVectorPtrPcodeOp_clear(this: *mut StdVector<&mut PcodeOp>);
    fn StdVectorPtrPcodeOp_push(this: *mut StdVector<&mut PcodeOp>, item: &mut PcodeOp);
    fn StdVectorPtrPcodeOp_extend(this: *mut StdVector<&mut PcodeOp>, items: *const &mut PcodeOp, count: usize);
}

unsafe impl StdVectorItem for &mut PcodeOp {
    fn new() -> ExternAlloc<StdVector<Self>> {
        unsafe {
            let v = StdVectorPtrPcodeOp_new();
            ExternAlloc::from_raw(v)
        }
    }

    unsafe fn destroy_vec(vec: *mut StdVector<Self>) {
        unsafe {
            StdVectorPtrPcodeOp_destroy_vec(vec);
        }
    }

    fn data(vec: &StdVector<Self>) -> *const Self {
        unsafe {
            StdVectorPtrPcodeOp_data(vec)
        }
    }

    fn len(vec: &StdVector<Self>) -> usize {
        unsafe {
            StdVectorPtrPcodeOp_len(vec)
        }
    }

    fn clear(vec: &mut StdVector<Self>) {
        unsafe {
            StdVectorPtrPcodeOp_clear(vec);
        }
    }

    fn push(vec: &mut StdVector<Self>, item: Self) {
        unsafe {
            StdVectorPtrPcodeOp_push(vec, item);
        }
    }

    fn extend(vec: &mut StdVector<Self>, items: &[Self]) {
        unsafe {
            StdVectorPtrPcodeOp_extend(vec, items.as_ptr().cast(), items.len());
        }
    }
}

#[link(name = "reoxide")]
unsafe extern "C-unwind" {
    fn StdVectorPtrVarnode_new<'a>() -> *mut StdVector<&'a mut Varnode>;
    fn StdVectorPtrVarnode_destroy_vec(this: *mut StdVector<&mut Varnode>);
    fn StdVectorPtrVarnode_data(this: *const StdVector<&mut Varnode>) -> *const &mut Varnode;
    fn StdVectorPtrVarnode_len(this: *const StdVector<&mut Varnode>) -> usize;
    fn StdVectorPtrVarnode_clear(this: *mut StdVector<&mut Varnode>);
    fn StdVectorPtrVarnode_push(this: *mut StdVector<&mut Varnode>, item: &mut Varnode);
    fn StdVectorPtrVarnode_extend(this: *mut StdVector<&mut Varnode>, items: *const &mut Varnode, count: usize);
}

unsafe impl StdVectorItem for &mut Varnode {
    fn new() -> ExternAlloc<StdVector<Self>> {
        unsafe {
            let v = StdVectorPtrVarnode_new();
            ExternAlloc::from_raw(v)
        }
    }

    unsafe fn destroy_vec(vec: *mut StdVector<Self>) {
        unsafe {
            StdVectorPtrVarnode_destroy_vec(vec);
        }
    }

    fn data(vec: &StdVector<Self>) -> *const Self {
        unsafe {
            StdVectorPtrVarnode_data(vec)
        }
    }

    fn len(vec: &StdVector<Self>) -> usize {
        unsafe {
            StdVectorPtrVarnode_len(vec)
        }
    }

    fn clear(vec: &mut StdVector<Self>) {
        unsafe {
            StdVectorPtrVarnode_clear(vec);
        }
    }

    fn push(vec: &mut StdVector<Self>, item: Self) {
        unsafe {
            StdVectorPtrVarnode_push(vec, item);
        }
    }

    fn extend(vec: &mut StdVector<Self>, items: &[Self]) {
        unsafe {
            StdVectorPtrVarnode_extend(vec, items.as_ptr().cast(), items.len());
        }
    }
}

#[link(name = "reoxide")]
unsafe extern "C-unwind" {
    fn StdVectorU32_new() -> *mut StdVector<u32>;
    fn StdVectorU32_destroy_vec(this: *mut StdVector<u32>);
    fn StdVectorU32_data(this: *const StdVector<u32>) -> *const u32;
    fn StdVectorU32_len(this: *const StdVector<u32>) -> usize;
    fn StdVectorU32_clear(this: *mut StdVector<u32>);
    fn StdVectorU32_push(this: *mut StdVector<u32>, item: u32);
    fn StdVectorU32_extend(this: *mut StdVector<u32>, items: *const u32, count: usize);
}

unsafe impl StdVectorItem for u32 {
    fn new() -> ExternAlloc<StdVector<Self>> {
        unsafe {
            let v = StdVectorU32_new();
            ExternAlloc::from_raw(v)
        }
    }

    unsafe fn destroy_vec(vec: *mut StdVector<Self>) {
        unsafe {
            StdVectorU32_destroy_vec(vec);
        }
    }

    fn data(vec: &StdVector<Self>) -> *const Self {
        unsafe {
            StdVectorU32_data(vec)
        }
    }

    fn len(vec: &StdVector<Self>) -> usize {
        unsafe {
            StdVectorU32_len(vec)
        }
    }

    fn clear(vec: &mut StdVector<Self>) {
        unsafe {
            StdVectorU32_clear(vec);
        }
    }

    fn push(vec: &mut StdVector<Self>, item: Self) {
        unsafe {
            StdVectorU32_push(vec, item);
        }
    }

    fn extend(vec: &mut StdVector<Self>, items: &[Self]) {
        unsafe {
            StdVectorU32_extend(vec, items.as_ptr().cast(), items.len());
        }
    }
}

#[link(name = "reoxide")]
unsafe extern "C-unwind" {
    fn StdVectorU64_new() -> *mut StdVector<u64>;
    fn StdVectorU64_destroy_vec(this: *mut StdVector<u64>);
    fn StdVectorU64_data(this: *const StdVector<u64>) -> *const u64;
    fn StdVectorU64_len(this: *const StdVector<u64>) -> usize;
    fn StdVectorU64_clear(this: *mut StdVector<u64>);
    fn StdVectorU64_push(this: *mut StdVector<u64>, item: u64);
    fn StdVectorU64_extend(this: *mut StdVector<u64>, items: *const u64, count: usize);
}

unsafe impl StdVectorItem for u64 {
    fn new() -> ExternAlloc<StdVector<Self>> {
        unsafe {
            let v = StdVectorU64_new();
            ExternAlloc::from_raw(v)
        }
    }

    unsafe fn destroy_vec(vec: *mut StdVector<Self>) {
        unsafe {
            StdVectorU64_destroy_vec(vec);
        }
    }

    fn data(vec: &StdVector<Self>) -> *const Self {
        unsafe {
            StdVectorU64_data(vec)
        }
    }

    fn len(vec: &StdVector<Self>) -> usize {
        unsafe {
            StdVectorU64_len(vec)
        }
    }

    fn clear(vec: &mut StdVector<Self>) {
        unsafe {
            StdVectorU64_clear(vec);
        }
    }

    fn push(vec: &mut StdVector<Self>, item: Self) {
        unsafe {
            StdVectorU64_push(vec, item);
        }
    }

    fn extend(vec: &mut StdVector<Self>, items: &[Self]) {
        unsafe {
            StdVectorU64_extend(vec, items.as_ptr().cast(), items.len());
        }
    }
}

#[link(name = "reoxide")]
unsafe extern "C-unwind" {
    fn StdVectorOpCode_new() -> *mut StdVector<OpCode>;
    fn StdVectorOpCode_destroy_vec(this: *mut StdVector<OpCode>);
    fn StdVectorOpCode_data(this: *const StdVector<OpCode>) -> *const OpCode;
    fn StdVectorOpCode_len(this: *const StdVector<OpCode>) -> usize;
    fn StdVectorOpCode_clear(this: *mut StdVector<OpCode>);
    fn StdVectorOpCode_push(this: *mut StdVector<OpCode>, item: OpCode);
    fn StdVectorOpCode_extend(this: *mut StdVector<OpCode>, items: *const OpCode, count: usize);
}

unsafe impl StdVectorItem for OpCode {
    fn new() -> ExternAlloc<StdVector<Self>> {
        unsafe {
            let v = StdVectorOpCode_new();
            ExternAlloc::from_raw(v)
        }
    }

    unsafe fn destroy_vec(vec: *mut StdVector<Self>) {
        unsafe {
            StdVectorOpCode_destroy_vec(vec);
        }
    }

    fn data(vec: &StdVector<Self>) -> *const Self {
        unsafe {
            StdVectorOpCode_data(vec)
        }
    }

    fn len(vec: &StdVector<Self>) -> usize {
        unsafe {
            StdVectorOpCode_len(vec)
        }
    }

    fn clear(vec: &mut StdVector<Self>) {
        unsafe {
            StdVectorOpCode_clear(vec);
        }
    }

    fn push(vec: &mut StdVector<Self>, item: Self) {
        unsafe {
            StdVectorOpCode_push(vec, item);
        }
    }

    fn extend(vec: &mut StdVector<Self>, items: &[Self]) {
        unsafe {
            StdVectorOpCode_extend(vec, items.as_ptr().cast(), items.len());
        }
    }
}