Retrieves the root file entry.

    Returns:
      FileEntry: a file entry or None.
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)
944322
private void extractEntry(File destDir, TarEntry entry) throws IOException {
        if (this.verbose) {
            if (this.progressDisplay != null) {
                this.progressDisplay.showTarProgressMessage(entry.getName());
            }
        }

        String name = entry.getName();
        name = name.replace('/', File.separatorChar);

        File destFile = new File(destDir, name);

        if (entry.isDirectory()) {
            if (!destFile.exists()) {
                if (!destFile.mkdirs()) {
                    throw new IOException("error making directory path '" + destFile.getPath() + "'");
                }
            }
        } else {
            File subDir = new File(destFile.getParent());

            if (!subDir.exists()) {
                if (!subDir.mkdirs()) {
                    throw new IOException("error making directory path '" + subDir.getPath() + "'");
                }
            }

            if (this.keepOldFiles && destFile.exists()) {
                if (this.verbose) {
                    if (this.progressDisplay != null) {
                        this.progressDisplay.showTarProgressMessage("not overwriting " + entry.getName());
                    }
                }
            } else {
                boolean asciiTrans = false;

                FileOutputStream out = new FileOutputStream(destFile);

                if (this.asciiTranslate) {
                    MimeType mime = null;
                    String contentType = null;

                    try {
                        contentType = FileTypeMap.getDefaultFileTypeMap().getContentType(destFile);

                        mime = new MimeType(contentType);

                        if (mime.getPrimaryType().equalsIgnoreCase("text")) {
                            asciiTrans = true;
                        } else if (this.transTyper != null) {
                            if (this.transTyper.isAsciiFile(entry.getName())) {
                                asciiTrans = true;
                            }
                        }
                    } catch (MimeTypeParseException ex) {
                    }

                    if (this.debug) {
                        System.err.println("EXTRACT TRANS? '" + asciiTrans + "'  ContentType='" + contentType
                            + "'  PrimaryType='" + mime.getPrimaryType() + "'");
                    }
                }

                PrintWriter outw = null;
                if (asciiTrans) {
                    outw = new PrintWriter(out);
                }

                byte[] rdbuf = new byte[32 * 1024];

                for (;;) {
                    int numRead = this.tarIn.read(rdbuf);

                    if (numRead == -1) {
                        break;
                    }

                    if (asciiTrans) {
                        for (int off = 0, b = 0; b < numRead; ++b) {
                            if (rdbuf[b] == 10) {
                                String s = new String(rdbuf, off, (b - off));

                                outw.println(s);

                                off = b + 1;
                            }
                        }
                    } else {
                        out.write(rdbuf, 0, numRead);
                    }
                }

                if (asciiTrans) {
                    outw.close();
                } else {
                    out.close();
                }
            }
        }
    }
659388
static RegistryEntry getEntry(VirtualFile virtualFile) {
        if (virtualFile == null) {
            throw MESSAGES.nullArgument("VirutalFile");
        }
        return rootEntry.find(virtualFile);
    }
67175
def GetRootKey(self):
    
    regf_key = self._regf_file.get_root_key()
    if not regf_key:
      return None

    return REGFWinRegistryKey(regf_key, key_path=self._key_path_prefix)
621952
def GetParentFileEntry(self):
    
    volume_index = lvm.LVMPathSpecGetVolumeIndex(self.path_spec)
    if volume_index is None:
      return None

    return self._file_system.GetRootFileEntry()
174978
def get_entry(journal_location, date):
    
    if not isinstance(date, datetime.date):
        return None
    try:
        with open(build_journal_path(journal_location, date), "r") as entry_file:
            return entry_file.read()
    except IOError:
        return None
1029301
def GetRootFileEntry(self):
    
    path_spec = tar_path_spec.TARPathSpec(
        location=self.LOCATION_ROOT, parent=self._path_spec.parent)
    return self.GetFileEntryByPathSpec(path_spec)
54588
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
      is_root = True
      is_virtual = True
    else:
      is_root = False
      is_virtual = False

    parent_path_spec = getattr(self.path_spec, 'parent', None)
    path_spec = cpio_path_spec.CPIOPathSpec(
        location=parent_location, parent=parent_path_spec)
    return CPIOFileEntry(
        self._resolver_context, self._file_system, path_spec,
        is_root=is_root, is_virtual=is_virtual)
90291
def GetFileEntryByPathSpec(self, path_spec):
    
    if not self.FileEntryExistsByPathSpec(path_spec):
      return None
    return os_file_entry.OSFileEntry(self._resolver_context, self, 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;
    }
730230
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 = os_path_spec.OSPathSpec(location=parent_location)
    return OSFileEntry(self._resolver_context, self._file_system, path_spec)
501872
function(entry) {
        if (entry) {
            if (successCallback) {
                // create appropriate Entry object
                var fsName = entry.filesystemName || (entry.filesystem == window.PERSISTENT ? 'persistent' : 'temporary');
                fileSystems.getFs(fsName, function(fs) {
                    var result = (entry.isDirectory) ? new DirectoryEntry(entry.name, entry.fullPath, fs, entry.nativeURL) : new FileEntry(entry.name, entry.fullPath, fs, entry.nativeURL);
                    successCallback(result);
                });
            }
        }
        else {
            // no Entry object returned
            fail(FileError.NOT_FOUND_ERR);
        }
    }
614056
def Entry(self, name, directory=None, create=1):
        
        return self._create_node(name, self.env.fs.Entry, directory, create)
889395
def GetRootFileEntry(self):
    
    path_spec = fake_path_spec.FakePathSpec(location=self.LOCATION_ROOT)
    return self.GetFileEntryByPathSpec(path_spec)
391278
protected List<Entry<V>> loadEntryFiles() {
    File[] files = getDirectory().listFiles();
    String prefix = getEntryLogPrefix();
    String suffix = getEntryLogSuffix();
    
    List<Entry<V>> entryList = new ArrayList<Entry<V>>();
    if(files == null) return entryList;
    
    for (File file : files) {
      String fileName = file.getName();
      if (fileName.startsWith(prefix) && fileName.endsWith(suffix)) {
        try {
          Entry<V> entry = _entryPool.next();
          entry.load(file);
          entryList.add(entry);
        } catch(Exception e) {
          String filePath = file.getAbsolutePath();
          _log.warn(filePath + " corrupted: length=" + file.length(), e);
          if(file.delete()) {
            _log.warn(filePath + " deleted");
          }
        }
      }
    }
    
    return entryList;
  }
402841
def _EntriesGenerator(self):
    
    # Only the virtual root file has directory entries.
    volume_index = apfs_helper.APFSContainerPathSpecGetVolumeIndex(
        self.path_spec)
    if volume_index is not None:
      return

    location = getattr(self.path_spec, 'location', None)
    if location is None or location != self._file_system.LOCATION_ROOT:
      return

    fsapfs_container = self._file_system.GetAPFSContainer()

    for volume_index in range(0, fsapfs_container.number_of_volumes):
      yield apfs_container_path_spec.APFSContainerPathSpec(
          location='/apfs{0:d}'.format(volume_index + 1),
          volume_index=volume_index, parent=self.path_spec.parent)
371179
def GetRootFileEntry(self):
    
    path_spec = vshadow_path_spec.VShadowPathSpec(
        location=self.LOCATION_ROOT, parent=self._path_spec.parent)
    return self.GetFileEntryByPathSpec(path_spec)