5 files changed, 20 insertions, 22 deletions

diff --git a/src/expr/lookup.rs b/src/expr/lookup.rs
index 8e288a0..fa12197 100644
--- a/src/expr/lookup.rs
+++ b/src/expr/lookup.rs
@@ -13,7 +13,7 @@ pub struct Lookup {
 impl Lookup {
     /// Creates a new lookup entry.
     /// May return None if the set have no name.
-    pub fn new<K>(set: &Set<'_, K>) -> Option<Self> {
+    pub fn new<K>(set: &Set<K>) -> Option<Self> {
         set.get_name().map(|set_name| Lookup {
             set_name: set_name.to_owned(),
             set_id: set.get_id(),
diff --git a/src/set.rs b/src/set.rs
index d6b9514..1e20475 100644
--- a/src/set.rs
+++ b/src/set.rs
@@ -1,5 +1,5 @@
-use crate::{table::Table, MsgType, ProtoFamily};
 use crate::sys::{self, libc};
+use crate::{table::Table, MsgType, ProtoFamily};
 use std::{
     cell::Cell,
     ffi::{c_void, CStr, CString},
@@ -26,15 +26,15 @@ macro_rules! nft_set {
     }};
 }
 
-pub struct Set<'a, K> {
+pub struct Set<K> {
     pub(crate) set: *mut sys::nftnl_set,
-    pub(crate) table: &'a Table,
+    pub(crate) table: Rc<Table>,
     pub(crate) family: ProtoFamily,
     _marker: ::std::marker::PhantomData<K>,
 }
 
-impl<'a, K> Set<'a, K> {
-    pub fn new(name: &CStr, id: u32, table: &'a Table, family: ProtoFamily) -> Self
+impl<K> Set<K> {
+    pub fn new(name: &CStr, id: u32, table: Rc<Table>, family: ProtoFamily) -> Self
     where
         K: SetKey,
     {
@@ -63,7 +63,7 @@ impl<'a, K> Set<'a, K> {
         }
     }
 
-    pub unsafe fn from_raw(set: *mut sys::nftnl_set, table: &'a Table, family: ProtoFamily) -> Self
+    pub unsafe fn from_raw(set: *mut sys::nftnl_set, table: Rc<Table>, family: ProtoFamily) -> Self
     where
         K: SetKey,
     {
@@ -95,7 +95,7 @@ impl<'a, K> Set<'a, K> {
         }
     }
 
-    pub fn elems_iter(&'a self) -> SetElemsIter<'a, K> {
+    pub fn elems_iter(&self) -> SetElemsIter<K> {
         SetElemsIter::new(self)
     }
 
@@ -146,13 +146,13 @@ impl<'a, K> Set<'a, K> {
     }
 }
 
-impl<'a, K> Debug for Set<'a, K> {
+impl<K> Debug for Set<K> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         write!(f, "{:?}", self.get_str())
     }
 }
 
-unsafe impl<'a, K> crate::NlMsg for Set<'a, K> {
+unsafe impl<K> crate::NlMsg for Set<K> {
     unsafe fn write(&self, buf: *mut c_void, seq: u32, msg_type: MsgType) {
         let type_ = match msg_type {
             MsgType::Add => libc::NFT_MSG_NEWSET,
@@ -169,20 +169,20 @@ unsafe impl<'a, K> crate::NlMsg for Set<'a, K> {
     }
 }
 
-impl<'a, K> Drop for Set<'a, K> {
+impl<K> Drop for Set<K> {
     fn drop(&mut self) {
         unsafe { sys::nftnl_set_free(self.set) };
     }
 }
 
 pub struct SetElemsIter<'a, K> {
-    set: &'a Set<'a, K>,
+    set: &'a Set<K>,
     iter: *mut sys::nftnl_set_elems_iter,
     ret: Rc<Cell<i32>>,
 }
 
 impl<'a, K> SetElemsIter<'a, K> {
-    fn new(set: &'a Set<'a, K>) -> Self {
+    fn new(set: &'a Set<K>) -> Self {
         let iter = try_alloc!(unsafe {
             sys::nftnl_set_elems_iter_create(set.set as *const sys::nftnl_set)
         });
@@ -194,7 +194,7 @@ impl<'a, K> SetElemsIter<'a, K> {
     }
 }
 
-impl<'a, K: 'a> Iterator for SetElemsIter<'a, K> {
+impl<'a, K> Iterator for SetElemsIter<'a, K> {
     type Item = SetElemsMsg<'a, K>;
 
     fn next(&mut self) -> Option<Self::Item> {
@@ -219,7 +219,7 @@ impl<'a, K> Drop for SetElemsIter<'a, K> {
 }
 
 pub struct SetElemsMsg<'a, K> {
-    set: &'a Set<'a, K>,
+    set: &'a Set<K>,
     iter: *mut sys::nftnl_set_elems_iter,
     ret: Rc<Cell<i32>>,
 }
diff --git a/tests/expr.rs b/tests/expr.rs
index 9f1644c..4af18f2 100644
--- a/tests/expr.rs
+++ b/tests/expr.rs
@@ -281,7 +281,7 @@ fn lookup_expr_is_valid() {
     let set_name = &CStr::from_bytes_with_nul(b"mockset\0").unwrap();
     let mut rule = get_test_rule();
     let table = rule.get_chain().get_table();
-    let mut set = Set::new(set_name, 0, &table, ProtoFamily::Inet);
+    let mut set = Set::new(set_name, 0, table, ProtoFamily::Inet);
     let address: Ipv4Addr = [8, 8, 8, 8].into();
     set.add(&address);
     let lookup = Lookup::new(&set).unwrap();
diff --git a/tests/lib.rs b/tests/lib.rs
index c30f881..0d7132c 100644
--- a/tests/lib.rs
+++ b/tests/lib.rs
@@ -115,11 +115,11 @@ pub fn get_test_rule() -> Rule {
     Rule::new(Rc::new(get_test_chain()))
 }
 
-pub fn get_test_set<'a, T: SetKey>(table: &'a Table) -> Set<'a, T> {
+pub fn get_test_set<T: SetKey>() -> Set<T> {
     Set::new(
         CStr::from_bytes_with_nul(SET_NAME).unwrap(),
         SET_ID,
-        table,
+        Rc::new(get_test_table()),
         ProtoFamily::Ipv4,
     )
 }
diff --git a/tests/set.rs b/tests/set.rs
index a357a13..d5b2ad7 100644
--- a/tests/set.rs
+++ b/tests/set.rs
@@ -9,8 +9,7 @@ use lib::*;
 
 #[test]
 fn new_empty_set() {
-    let table = get_test_table();
-    let mut set = get_test_set::<Ipv4Addr>(&table);
+    let mut set = get_test_set::<Ipv4Addr>();
     let (nlmsghdr, _nfgenmsg, raw_expr) = get_test_nlmsg(&mut set);
     assert_eq!(
         get_operation_from_nlmsghdr_type(nlmsghdr.nlmsg_type),
@@ -39,8 +38,7 @@ fn new_empty_set() {
 
 #[test]
 fn delete_empty_set() {
-    let table = get_test_table();
-    let mut set = get_test_set::<Ipv6Addr>(&table);
+    let mut set = get_test_set::<Ipv6Addr>();
     let (nlmsghdr, _nfgenmsg, raw_expr) = get_test_nlmsg_with_msg_type(&mut set, MsgType::Del);
     assert_eq!(
         get_operation_from_nlmsghdr_type(nlmsghdr.nlmsg_type),