fn new() -> Self {

        let term_pool: RecursiveLock<GlobalTermPool> = RecursiveLock::from_mutex(GLOBAL_TERM_POOL.share());

        let mut pool = term_pool.write().expect("Lock poisoned!");

        let (protection_sets, send_term_protection_set) = pool.register_thread_term_pool();

        let int_symbol = pool.get_int_symbol().copy();

        let empty_list_symbol = pool.get_empty_list_symbol().copy();

        let list_symbol = pool.get_list_symbol().copy();

        drop(pool);

            protection_sets,

            send_term_protection_set,

            garbage_collection_counter: Cell::new(if AGGRESSIVE_GC { 1 } else { 1000 }),

            tmp_arguments: RefCell::new(Vec::new()),

            int_symbol,

            empty_list_symbol,

            list_symbol,

            term_pool,

    }

    pub fn create_constant<'a, 'b, S: Symb<'a, 'b>>(&self, symbol: &'b S) -> ATerm {

        assert!(symbol.arity() == 0, "A constant should not have arity > 0");

        let empty_args: [ATermRef<'_>; 0] = [];

        let guard = self.term_pool.read_recursive().expect("Lock poisoned!");

        let (index, inserted) = guard.create_term_array(symbol, &empty_args);

        let result = self.protect_guard(guard, &unsafe { ATermRef::from_index(&index) });

        if inserted {

            // Intentially called after the guard is dropped.

            self.decrement_garbage_collection_counter();

        }

        result

    }

    pub fn create_term<'a, 'b, S: Symb<'a, 'b>, T: Term<'a, 'b>>(

        &self,

        symbol: &'b S,

        args: &'b [T],

    ) -> Return<ATermRef<'static>> {

        self.trigger_garbage_collection();

        let guard = self.term_pool.read_recursive().expect("Lock poisoned!");

        let mut arguments = self.tmp_arguments.borrow_mut();

        arguments.clear();

        for arg in args {

            unsafe {

                arguments.push(ATermRef::from_index(arg.shared()));

            }

        let (index, inserted) = guard.create_term_array(symbol, &arguments);

        let result = self.make_return(index, guard);

        if inserted {

            self.decrement_garbage_collection_counter();

        }

        result

    }

    pub fn create_int(&self, value: usize) -> ATerm {

        let guard = self.term_pool.read_recursive().expect("Lock poisoned!");

        let (index, inserted) = guard.create_int(value);

        let result = self.protect_guard(guard, &unsafe { ATermRef::from_index(&index) });

        if inserted {

            // Intentially called after the guard is dropped.

            self.decrement_garbage_collection_counter();

        }

        result

    }

    pub fn create_term_iter<'a, 'b, 'c, 'd, S, I, T>(&self, symbol: &'b S, args: I) -> ATerm

    where

        S: Symb<'a, 'b>,

        I: IntoIterator<Item = T>,

        T: Term<'c, 'd>,

        let guard = self.term_pool.read_recursive().expect("Lock poisoned!");

        let mut arguments = self.tmp_arguments.borrow_mut();

        arguments.clear();

        for arg in args {

            unsafe {

                arguments.push(ATermRef::from_index(arg.shared()));

            }

        let (index, inserted) = guard.create_term_array(symbol, &arguments);

        let result = self.protect_guard(guard, &unsafe { ATermRef::from_index(&index) });

        if inserted {

            // Intentially called after the guard is dropped.

            self.decrement_garbage_collection_counter();

        }

        result

    }

    pub fn try_create_term_iter<'a, 'b, 'c, 'd, S, I, T>(&self, symbol: &'b S, args: I) -> Result<ATerm, MercError>

    where

        S: Symb<'a, 'b>,

        I: IntoIterator<Item = Result<T, MercError>>,

        T: Term<'c, 'd>,

        let guard = self.term_pool.read_recursive().expect("Lock poisoned!");

        let mut arguments = self.tmp_arguments.borrow_mut();

        arguments.clear();

        for arg in args {

                arguments.push(ATermRef::from_index(arg?.shared()));

        let (index, inserted) = guard.create_term_array(symbol, &arguments);

        let result = Ok(self.protect_guard(guard, &unsafe { ATermRef::from_index(&index) }));

        if inserted {

            // Intentially called after the guard is dropped.

            self.decrement_garbage_collection_counter();

        }

        result

    }

    pub fn create_term_iter_head<'a, 'b, 'c, 'd, 'e, 'f, S, H, I, T>(

        &self,

        symbol: &'b S,

        head: &'d H,

        args: I,

    ) -> ATerm

    where

        S: Symb<'a, 'b>,

        H: Term<'c, 'd>,

        I: IntoIterator<Item = T>,

        T: Term<'e, 'f>,

        let guard = self.term_pool.read_recursive().expect("Lock poisoned!");

        let mut arguments = self.tmp_arguments.borrow_mut();

        arguments.clear();

        unsafe {

            arguments.push(ATermRef::from_index(head.shared()));

        }

        for arg in args {

            unsafe {

                arguments.push(ATermRef::from_index(arg.shared()));

            }

        let (index, inserted) = guard.create_term_array(symbol, &arguments);

        let result = self.protect_guard(guard, &unsafe { ATermRef::from_index(&index) });

        if inserted {

            // Intentially called after the guard is dropped.

            self.decrement_garbage_collection_counter();

        }

        result

    }

    pub fn create_symbol<N: Into<String> + AsRef<str>>(&self, name: N, arity: usize) -> Symbol {

        self.term_pool

            .read_recursive()

            .expect("Lock poisoned!")

            .create_symbol(name, arity, |index| unsafe {

                self.protect_symbol(&SymbolRef::from_index(&index))

            })

    }

    pub fn protect(&self, term: &ATermRef<'_>) -> ATerm {

        let root = self

            .lock_protection_set()

            .term_protection_set

            .protect(unsafe { term.shared().copy() });

        let result = ATerm::from_index(term.shared(), root);

        debug_trace!(

        result

    }

    pub fn protect_guard(&self, _guard: RecursiveLockReadGuard<'_, GlobalTermPool>, term: &ATermRef<'_>) -> ATerm {

        let root = unsafe {

            (*self.protection_sets.get())

                .term_protection_set

                .protect(term.shared().copy())

        let result = ATerm::from_index(term.shared(), root);

        debug_trace!(

        result

    }

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

        unsafe {

            self.lock_protection_set().term_protection_set.unprotect(term.root());

        }

        debug_trace!(

    }

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

        let root = self.lock_protection_set().container_protection_set.protect(container);

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

        root

    }

    pub fn drop_container(&self, root: ProtectionIndex) {

        unsafe {

            self.lock_protection_set().container_protection_set.unprotect(root);

        }

        debug_trace!("Unprotected container index {}, protection set {}", root, self.index());

    }

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

        let mut result = TermParser::parse(Rule::TermSpec, text)?;

        let root = result.next().unwrap();

        Ok(TermParser::TermSpec(root).unwrap())

    }

    pub fn protect_symbol(&self, symbol: &SymbolRef<'_>) -> Symbol {

        let mut lock = self.lock_protection_set();

        let root = lock.symbol_protection_set.protect(unsafe { symbol.shared().copy() });

        let result = unsafe { Symbol::from_index(symbol.shared(), root) };

        debug_trace!(

        result

    }

    pub fn drop_symbol(&self, symbol: &mut Symbol) {

        unsafe {

            self.lock_protection_set()

                .symbol_protection_set

                .unprotect(symbol.root());

        }

    }

    pub fn int_symbol(&self) -> &SymbolRef<'_> {

        &self.int_symbol

    }

    pub fn list_symbol(&self) -> &SymbolRef<'_> {

        &self.list_symbol

    }

    pub fn empty_list_symbol(&self) -> &SymbolRef<'_> {

        &self.empty_list_symbol

    }

    pub fn force_collect_garbage(&self) {

        let mut guard = self.term_pool.write().expect("Lock poisoned!");

        guard.collect_garbage();

    }

    pub fn collect_garbage(&self) {

        if !self.term_pool.is_locked() {

            if let Some(mut guard) = self.term_pool.try_write().expect("Lock poisoned!") {

                let value = guard.trigger_garbage_collection();

                self.garbage_collection_counter.set(value);

            }

    }

    pub(crate) unsafe fn trigger_delayed_garbage_collection(&self, guard: &mut ManuallyDrop<GlobalTermPoolGuard<'_>>) {

        debug_assert!(

            guard.read_depth() == 1,

        unsafe {

            ManuallyDrop::drop(guard);

        }

        if self.garbage_collection_counter.get() == 0 {

            self.trigger_garbage_collection();

        }

    }

    fn decrement_garbage_collection_counter(&self) {

        self.garbage_collection_counter

            .set(self.garbage_collection_counter.get().saturating_sub(1));

        self.trigger_garbage_collection();

    }

    fn trigger_garbage_collection(&self) {

        if self.garbage_collection_counter.get() == 0 && !self.term_pool.is_locked() {

            self.collect_garbage();

        }

    }

    pub fn send_term_protection_set(&self) -> &Arc<Mutex<ProtectionSet<ATermIndex>>> {

        &self.send_term_protection_set

    }

    pub(crate) fn term_pool(&self) -> &RecursiveLock<GlobalTermPool> {

        &self.term_pool

    }

    fn make_return(

        &self,

        index: ATermIndex,

        guard: RecursiveLockReadGuard<'_, GlobalTermPool>,

    ) -> Return<ATermRef<'static>> {

            Return::new(

                std::mem::transmute::<RecursiveLockReadGuard<'_, _>, RecursiveLockReadGuard<'static, _>>(guard),

                ATermRef::from_index(&index),

    }

    fn index(&self) -> usize {

        self.lock_protection_set().index

    }

    fn lock_protection_set(&self) -> ProtectionSetGuard<'_> {

        let guard = self.term_pool.read_recursive().expect("Lock poisoned!");

        let protection_set = unsafe { &mut *self.protection_sets.get() };

        ProtectionSetGuard::new(guard, protection_set)

    }

    fn drop(&mut self) {

        let mut write = self.term_pool.write().expect("Lock poisoned!");

        debug!("{}", write.metrics());

        write.deregister_thread_pool(self.index());

        debug!("{}", unsafe { &mut *self.protection_sets.get() }.metrics());

        debug!(

    }

    fn new<'a>(

        guard: RecursiveLockReadGuard<'a, GlobalTermPool>,

        object: &'a mut SharedTermProtection,

    ) -> ProtectionSetGuard<'a> {

        ProtectionSetGuard { _guard: guard, object }

    }

    fn deref(&self) -> &Self::Target {

        self.object

    }

    fn deref_mut(&mut self) -> &mut Self::Target {

        self.object

    }

    fn test_thread_local_protection() {

        merc_utilities::test_logger();

        thread::scope(|scope| {

            for _ in 0..3 {

                scope.spawn(|| {

                    let symbol = Symbol::new("test", 0);

                    let term = ATerm::constant(&symbol);

                    let protected = term.protect();

                    THREAD_TERM_POOL.with(|tp| {

                        assert!(

                            tp.lock_protection_set()

                                .term_protection_set

                                .contains_root(protected.root())

                    });

                    let root = protected.root();

                    drop(protected);

                    THREAD_TERM_POOL.with(|tp| {

                        assert!(!tp.lock_protection_set().term_protection_set.contains_root(root));

                    });

                });

        });

    }

    fn test_parsing() {

        merc_utilities::test_logger();

        let t = ATerm::from_string("f(g(a),b)").unwrap();

        assert!(t.get_head_symbol().name() == "f");

        assert!(t.arg(0).get_head_symbol().name() == "g");

        assert!(t.arg(1).get_head_symbol().name() == "b");

    }

    fn test_create_term() {

        merc_utilities::test_logger();

        let f = Symbol::new("f", 2);

        let g = Symbol::new("g", 1);

        let t = THREAD_TERM_POOL.with(|tp| {

            tp.create_term(

                &f,

                &[

                    tp.create_term(&g, &[tp.create_constant(&Symbol::new("a", 0))])

                        .protect(),

                    tp.create_constant(&Symbol::new("b", 0)),

                ],

            )

            .protect()

        });

        assert!(t.get_head_symbol().name() == "f");

        assert!(t.arg(0).get_head_symbol().name() == "g");

        assert!(t.arg(1).get_head_symbol().name() == "b");

    }