docs: def _compute_full_path(self, fn_parent_ref, fn_parent_seq):
          '''Based on the parent reference and sequence, computes the full path.
  
          The majority of the files in a filesystem has a very small amount of
          parent directories. By definition, a filesystem is expected to have
          much smaller amount of directories than files. As such we use a function
          with the minimal amount of arguments to find a parent, that way we can
          cache the results easily and speed up the overall code.
  
          Args:
              fn_parent_ref (int): Parent reference number
              fn_parent_seq (int): Parent sequence number
  
          Returns:
              tuple(bool, str): A tuple where the first element is a boolean that
                  is ``True`` if the the file is orphan and ``False`` if not. The
                  second element is a string with the full path without the file name
          '''
          names = []
          root_id = 5
          index, seq = fn_parent_ref, fn_parent_seq
          is_orphan = False
  
          #search until hit the root entry
          while index != root_id:
              try:
                  parent_entry = self[index]
                  #if the sequence number is wrong, something changed = orphan
                  if seq != parent_entry.header.seq_number:
                      is_orphan = True
                      break
                  else:
                      parent_fn_attr = parent_entry.get_main_filename_attr()
                      index, seq = parent_fn_attr.content.parent_ref, parent_fn_attr.content.parent_seq
                      names.append(parent_fn_attr.content.name)
              except ValueError as e:
                  #if the entry itself no longer exists = orphan
                  is_orphan = True
                  break
  
          return (is_orphan, "\\".join(reversed(names)))