Can't understand rust lifetime conflict - rust

Question

I was doing a dummy app to get a grasp on Rust concepts.
While doing an XML structure I got the error
cannot infer an appropriate lifetime for lifetime parameter in
function call due to conflicting requirements
The definition is
impl<'a> XmlFile<'a>
and
pub fn get_node<'b>(self, node: &'b [u8]) -> &'b [u8]
From what I understand, the Rust compiler does not like that the return variable can be dropped after the function ends, if the XML file drops at a different time (since they have 'a and 'b lifetimes).
But if I put the same, I get the error
lifetime 'a is already in scope
, so I don't see a way to solve the error.
Any idea what I am missing? I think I must still be lacking some Rust concept.
Edit: Misconception from my part adding the code that causes the problem
#[allow(unused_parens)]
pub struct XmlFile<'a> {
last_open_node: &'a[u8],
last_published: String,
index_pos: u64,
content: &'a[u8],
}
impl<'a> XmlFile<'a> {
pub fn new<'b: 'a>(file: &'b [u8]) -> XmlFile<'b> {
let new_xml = XmlFile {
last_open_node: &[0: u8],
last_published: "".to_string(),
index_pos: 0,
content: file,
};
return new_xml;
}
pub fn get_node<'b: 'a>(&self, node: &'b [u8]) -> &'b [u8] {
let buf_index: u64 = 0;
let has_matched: bool = false;
self.index_pos = 0;
for c in self.content {
self.index_pos += 1;
if (c == &b'<') {
buf_index = self.index_pos;
while (c != &b' ') {
for b in node {
if b == &self.content[buf_index as usize] {
has_matched = true;
buf_index += 1
} else {
has_matched = false;
continue;
}
}
if has_matched {
while(self.content[buf_index as usize] != b'>'){
buf_index+=1;
}
let r = &self.content[self.index_pos as usize..buf_index as usize];
return r;
}
}
}
}
return &[0 : u8];
}
pub fn get_rss_version<'b:'a>(&self) -> Result<u64 , &'static str>{
let found_slice = Self::get_node(&self, "rss".as_bytes());
if(found_slice != &[0:u8]){
let version_value = Self::get_value(found_slice);
if(version_value.is_ok()){
return Ok(version_value.unwrap()) ;
}
else{
return Err("Couldn't retrieve version from tag");
}
}
else{
println!("Couldn't find tag <rss");
return Err("Couldn't find tag <rss");
}
}
}

Answer 1

Let's look at your signature for get_node:
pub fn get_node<'b: 'a>(&mut self, node: &'b [u8]) -> &'b [u8] { ... }
and what you're actually returning within this method:
let r = &self.content[self.index_pos as usize..buf_index as usize];
return r;
The signature for get_node indicates this method will be returning a sub-slice of node, but you're actually returning a sub-slice of the XmlFile's content.
One solution to the problem is to understand that the return value isn't a part of node, but instead a part of self.content. Therefore, we can change the signature to:
pub fn get_node<'b>(&mut self, node: &'b [u8]) -> &'a [u8] { ... }
In this case we can even elide the manual specification of lifetimes entirely:
pub fn get_node(&mut self, node: &[u8]) -> &[u8] { ... }
Here's a cleaned up version of your get_node method that actually compiles:
pub fn get_node(&mut self, node: &[u8]) -> &[u8] {
let mut buf_index: u64;
let mut has_matched: bool = false;
self.index_pos = 0;
for c in self.content {
self.index_pos += 1;
if c == &b'<' {
buf_index = self.index_pos;
while c != &b' ' {
for b in node {
if b == &self.content[buf_index as usize] {
has_matched = true;
buf_index += 1
} else {
has_matched = false;
continue;
}
}
if has_matched {
while self.content[buf_index as usize] != b'>' {
buf_index += 1;
}
let r = &self.content[self.index_pos as usize..buf_index as usize];
return r;
}
}
}
}
return &[0u8];
}