Retrieves the root file entry.

    Returns:
      DataRangeFileEntry: a file entry or None if not available.
549195
def GetRootFileEntry(self):
    
    path_spec = data_range_path_spec.DataRangePathSpec(
        range_offset=self._range_offset,
        range_size=self._range_size,
        parent=self._path_spec.parent)
    return self.GetFileEntryByPathSpec(path_spec)
138380
def _GetDirectory(self):
    
    if self.entry_type != definitions.FILE_ENTRY_TYPE_DIRECTORY:
      return None
    return TARDirectory(self._file_system, self.path_spec)
540887
def root(self):
        
        sector = self.header.directory_sector_start
        position = (sector + 1) << self.header.sector_shift
        return RootEntry(self, position)
1095691
@Override
    public FatLfnDirectoryEntry getEntry(String name) {
        name = name.trim().toLowerCase(Locale.ROOT);
        
        final FatLfnDirectoryEntry entry = longNameIndex.get(name);
        
        if (entry == null) {
            if (!ShortName.canConvert(name)) return null;
            return shortNameIndex.get(ShortName.get(name));
        } else {
            return entry;
        }
    }
659388
static RegistryEntry getEntry(VirtualFile virtualFile) {
        if (virtualFile == null) {
            throw MESSAGES.nullArgument("VirutalFile");
        }
        return rootEntry.find(virtualFile);
    }
700279
public List<Data> getRange(byte[] lowerKey, byte[] upperKey)
			throws IOException {
		if (!filesAreOpened) {
			throw new IOException(
					"The files are not opened yet. Use openFiles() to open all files.");
		}
		// estimate first and last bucket
		int lowerBucket = drums.getHashFunction().getBucketId(lowerKey);
		int upperBucket = drums.getHashFunction().getBucketId(upperKey);
		if (lowerBucket > upperBucket) {
			lowerBucket = 0;
			upperBucket = drums.getHashFunction().getNumberOfBuckets() - 1;
		}

		// estimate first chunk in the first file
		long lowerChunkOffset = files[lowerBucket].getIndex()
				.getStartOffsetOfChunkByKey(lowerKey);
		// estimate last chunk in the last file
		long upperChunkOffset = files[lowerBucket].getIndex()
				.getStartOffsetOfChunkByKey(upperKey);
		long filesize, startOffset, endOffset;
		byte[] tmpB = new byte[elementSize];

		ArrayList<Data> elements = new ArrayList<Data>();
		// run over all files
		OUTER: for (int i = lowerBucket; i <= upperBucket; i++) {
			HeaderIndexFile<Data> aktFile = files[i];
			filesize = aktFile.getFilledUpFromContentStart();

			// start reading at lowerChunkOffset in first file, else start
			// reading from beginning
			startOffset = i == lowerBucket ? lowerChunkOffset : 0;
			// stop reading at upperChunkOffset in last file, else read till end
			// fo file
			endOffset = i == upperBucket ? Math.max(
					upperChunkOffset + aktFile.getChunkSize(), filesize)
					: filesize;

			while (startOffset < endOffset) {
				destBuffer.clear();
				aktFile.read(startOffset, destBuffer);
				destBuffer.flip();
				while (destBuffer.remaining() >= elementSize) {
					destBuffer.get(tmpB); // get the element
					@SuppressWarnings("unchecked")
					Data record = (Data) prototype.fromByteBuffer(ByteBuffer
							.wrap(tmpB));
					if (KeyUtils.compareKey(record.getKey(), lowerKey) >= 0
							&& KeyUtils.compareKey(record.getKey(), upperKey) <= 0) {
						elements.add(record);
					} else if (KeyUtils.compareKey(record.getKey(), upperKey) > 0) {
						// we have read all relevant elements
						break OUTER;
					}
					startOffset += elementSize;
				}
			}
		}
		return elements;
	}
968064
def GetParentFileEntry(self):
    
    location = getattr(self.path_spec, 'location', None)
    if location is None:
      return None

    parent_location = self._file_system.DirnamePath(location)
    if parent_location is None:
      return None

    if parent_location == '':
      parent_location = self._file_system.PATH_SEPARATOR

    path_spec = fake_path_spec.FakePathSpec(location=parent_location)
    return self._file_system.GetFileEntryByPathSpec(path_spec)
950987
public SortedSet<Entry> getChildEntries() throws IOException {
        if (children == null) {
            if (isFile() || rootNodeDId == -1) {
                children = NO_CHILDREN;
            }
            else {
                // Start at root node in R/B tree, and read to the left and right,
                // re-build tree, according to the docs
                children = Collections.unmodifiableSortedSet(document.getEntries(rootNodeDId, this));
            }
        }

        return children;
    }
890939
public synchronized Entry getNextEntry()
  {
    if (tc.isEntryEnabled())
      SibTr.entry(tc, "getNextEntry");
    
    checkEntryParent();
    
    Entry nextEntry = null;
    
    synchronized(parentList)
    {
      if(atTop)
      {
        //if the cursor is at the top of the list, return the first entry in the list
        nextEntry = parentList.first;
      }
      else if(!atBottom)                        
      {
        //otherwise just return the next entry in the list
        nextEntry = current.getNext();                        
      }
      //if the cursor is at the bottom of the list then we should
      //just drop through and the next entry is null
    }
    
    if (tc.isEntryEnabled())
      SibTr.exit(tc, "getNextEntry", nextEntry);
    
    return nextEntry;
  }
522808
def GetLinkedFileEntry(self):
    
    link = self._GetLink()
    if not link:
      return None

    # TODO: is there a way to determine the identifier here?
    link_identifier = None

    parent_path_spec = getattr(self.path_spec, 'parent', None)
    path_spec = apfs_path_spec.APFSPathSpec(
        location=link, parent=parent_path_spec)

    is_root = bool(
        link == self._file_system.LOCATION_ROOT or
        link_identifier == self._file_system.ROOT_DIRECTORY_IDENTIFIER)

    return APFSFileEntry(
        self._resolver_context, self._file_system, path_spec, is_root=is_root)
500933
def GetRootFileEntry(self):
    
    path_spec = sqlite_blob_path_spec.SQLiteBlobPathSpec(
        table_name=self._path_spec.table_name,
        column_name=self._path_spec.column_name,
        parent=self._path_spec.parent)
    return self.GetFileEntryByPathSpec(path_spec)
254304
def GetRootFileEntry(self):
    
    path_spec = bde_path_spec.BDEPathSpec(parent=self._path_spec.parent)
    return self.GetFileEntryByPathSpec(path_spec)
1888
def GetFileEntryByPathSpec(self, path_spec):
    
    return bde_file_entry.BDEFileEntry(
        self._resolver_context, self, path_spec, is_root=True, is_virtual=True)
960007
def GetParentFileEntry(self):
    
    store_index = vshadow.VShadowPathSpecGetStoreIndex(self.path_spec)
    if store_index is None:
      return None

    return self._file_system.GetRootFileEntry()
336238
def cache_entry(self):
        
        if self.storage_path is None:
            raise ValueError('This file is temporary and so a lal '
                             'cache entry cannot be made')

        file_url = urlparse.urlunparse(['file', 'localhost', self.storage_path, None,
                                            None, None])
        cache_entry = lal.utils.CacheEntry(self.ifo_string,
                   self.tagged_description, self.segment_list.extent(), file_url)
        cache_entry.workflow_file = self
        return cache_entry
104920
def GetRootFileEntry(self):
    
    path_spec = cpio_path_spec.CPIOPathSpec(
        location=self.LOCATION_ROOT, parent=self._path_spec.parent)
    return self.GetFileEntryByPathSpec(path_spec)
122478
def GetParentFileEntry(self):
    
    # If the file entry is a sub entry, return the SQLite blob directory.
    if self._is_virtual:
      return None

    path_spec = sqlite_blob_path_spec.SQLiteBlobPathSpec(
        table_name=self.path_spec.table_name,
        column_name=self.path_spec.column_name,
        parent=self.path_spec.parent)
    return SQLiteBlobFileEntry(
        self._resolver_context, self._file_system,
        path_spec, is_root=True, is_virtual=True)