fn protect_with(

    mut guard: BfTermPoolThreadWrite<'_, ProtectionSet<ATermPtr>>,

    gc_counter: &mut usize,

    index: usize,

    term: *const ffi::_aterm,

) -> ATerm {

    debug_assert!(!term.is_null(), "Can only protect valid terms");

    let aterm = ATermPtr::new(term);

    let root = guard.protect(aterm.clone());

    let term = ATermRef::new(term);

    trace!("Protected term {:?}, index {}, protection set {}", term, root, index,);

    let result = ATerm::new(term, root);

    // Test for garbage collection intermediately.

    *gc_counter = gc_counter.saturating_sub(1);

    if guard.unlock() && *gc_counter == 0 {

        ffi::test_garbage_collection();

        *gc_counter = TEST_GC_INTERVAL;

    }

    result

}

    pub fn new() -> ThreadTermPool {

        // Register a protection set into the global set.

        let (protection_set, container_protection_set, index) = GLOBAL_TERM_POOL.lock().register_thread_term_pool();

        ThreadTermPool {

            protection_set,

            container_protection_set,

            index,

            gc_counter: TEST_GC_INTERVAL,

            data_appl: vec![],

            _callback: ManuallyDrop::new(ffi::register_mark_callback(mark_protection_sets, protection_set_size)),

        }

    }

    pub fn protect(&mut self, term: *const ffi::_aterm) -> ATerm {

        unsafe {

            protect_with(

                self.protection_set.write_exclusive(),

                &mut self.gc_counter,

                self.index,

                term,

            )

        }

    }

    pub fn protect_container(&mut self, container: Arc<dyn Markable + Send + Sync>) -> usize {

        let root = unsafe { self.container_protection_set.write_exclusive().protect(container) };

        trace!("Protected container index {}, protection set {}", root, self.index,);

        root

    }

    pub fn drop(&mut self, term: &ATerm) {

        term.require_valid();

        unsafe {

            let mut protection_set = self.protection_set.write_exclusive();

            trace!(

            protection_set.unprotect(term.root);

        }

    }

    pub fn drop_container(&mut self, container_root: usize) {

        unsafe {

            let mut container_protection_set = self.container_protection_set.write_exclusive();

            trace!(

            container_protection_set.unprotect(container_root);

        }

    }

    pub fn is_data_application(&mut self, term: &ATermRef<'_>) -> bool {

        let symbol = term.get_head_symbol();

        while self.data_appl.len() <= symbol.arity() {

            let symbol = Symbol::take(ffi::create_function_symbol(

                String::from("DataAppl"),

                self.data_appl.len(),

            ));

            self.data_appl.push(symbol);

        }

        symbol == self.data_appl[symbol.arity()].copy()

    }

    fn drop(&mut self) {

        debug_assert!(

            self.protection_set.read().len() == 0,

        GLOBAL_TERM_POOL.lock().drop_thread_term_pool(self.index);

        #[cfg(not(target_os = "macos"))]

        unsafe {

            ManuallyDrop::drop(&mut self._callback);

        }

    }

    pub fn new() -> TermPool {

        TermPool {

            arguments: vec![],

            true_term: BoolSort::true_term(),

        }

    }

    pub fn true_term(&self) -> &DataExpression {

        &self.true_term

    }

    pub fn collect(&mut self) {

        ffi::collect_garbage();

    }

    pub fn from_string(&mut self, text: &str) -> Result<ATerm, Exception> {

        match ffi::aterm_from_string(String::from(text)) {

            Ok(term) => Ok(term.into()),

    }

    pub fn create<'a, 'b>(

        &mut self,

        symbol: &impl Borrow<SymbolRef<'a>>,

        arguments: &[impl Borrow<ATermRef<'b>>],

    ) -> ATerm {

        // Copy the arguments to make a slice.

        self.arguments.clear();

        for arg in arguments {

            unsafe {

                self.arguments.push(arg.borrow().get());

            }

        debug_assert_eq!(

            symbol.borrow().arity(),

            self.arguments.len(),

        let result = THREAD_TERM_POOL.with_borrow_mut(|tp| {

            unsafe {

                // ThreadPool is not Sync, so only one has access.

                let protection_set = tp.protection_set.write_exclusive();

                let term: *const ffi::_aterm = ffi::create_aterm(symbol.borrow().address(), &self.arguments);

                protect_with(protection_set, &mut tp.gc_counter, tp.index, term)

            }

        });

        result

    }

    pub fn create_data_application<'a, 'b>(

        &mut self,

        head: &impl Borrow<ATermRef<'a>>,

        arguments: &[impl Borrow<ATermRef<'b>>],

    ) -> ATerm {

        while self.arguments.len() < arguments.len() {

            self.arguments.push(std::ptr::null());

        }

        self.arguments.clear();

        unsafe {

            self.arguments.push(head.borrow().get());

            for arg in arguments {

                self.arguments.push(arg.borrow().get());

            }

        THREAD_TERM_POOL.with_borrow_mut(|tp| {

            while tp.data_appl.len() <= arguments.len() + 1 {

                let symbol = self.create_symbol("DataAppl", tp.data_appl.len());

                tp.data_appl.push(symbol);

            }

            let symbol = &tp.data_appl[arguments.len() + 1];

            debug_assert_eq!(

                symbol.arity(),

                self.arguments.len(),

            let result = unsafe {

                // ThreadPool is not Sync, so only one has access.

                let protection_set = tp.protection_set.write_exclusive();

                let term: *const ffi::_aterm = ffi::create_aterm(symbol.address(), &self.arguments);

                protect_with(protection_set, &mut tp.gc_counter, tp.index, term)

            };

            result

        })

    }

    pub fn create_symbol(&mut self, name: &str, arity: usize) -> Symbol {

        Symbol::take(ffi::create_function_symbol(String::from(name), arity))

    }

    pub fn create_with<F>(&mut self, create: F) -> ATerm

    where

        F: Fn() -> *const ffi::_aterm,

    {

        let result = THREAD_TERM_POOL.with_borrow_mut(|tp| {

            unsafe {

                // ThreadPool is not Sync, so only one has access.

                let protection_set = tp.protection_set.write_exclusive();

                protect_with(protection_set, &mut tp.gc_counter, tp.index, create())

            }

        });

        result

    }

    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

        // TODO: This will always print, but only depends on aterm_configuration.h

        ffi::print_metrics();

        write!(f, "{:?}", GLOBAL_TERM_POOL.lock())

    }

    fn verify_term(term: &ATermRef<'_>) {

        for subterm in term.iter() {

            assert_eq!(

                subterm.get_head_symbol().arity(),

                subterm.arguments().len(),

    }

    #[test]

        thread::scope(|s| {

            for _ in 0..2 {

                s.spawn(|| {

                    let mut tp = TermPool::new();

                    let mut rng = StdRng::seed_from_u64(seed);

                    let terms: Vec<ATerm> = (0..100)

                        .map(|_| {

                            random_term(

                                &mut tp,

                                &mut rng,

                                &[("f".to_string(), 2)],

                                &["a".to_string(), "b".to_string()],

                                10,

                            )

                        })

                        .collect();

                    tp.collect();

                    for term in &terms {

                        verify_term(term);

                    }

                });

            }

        });