If this file should be processed, return true.
543095
public boolean filterFile(File file)
    {
        boolean bProcessFile = super.filterFile(file);
        if (bProcessFile == false)
            return bProcessFile;
        if ((this.getProperty(ConvertCode.DEST_DIR) != null) && (!this.getProperty(ConvertCode.DEST_DIR).equalsIgnoreCase(this.getProperty(ConvertCode.SOURCE_DIR))))
            return bProcessFile;
        String s = this.getNewCalendarPath(file);
        return (s != null);   // Skip if no new path (Only if moving to the same directory)
    }
325815
private boolean hasFileChangedUnexpectedly() {
        synchronized (this) {
            if (mDiskWritesInFlight > 0) {
                // If we know we caused it, it's not unexpected.
                if (DEBUG) System.out.println( "disk write in flight, not unexpected.");
                return false;
            }
        }
        if (!mFile.canRead()) {
            return true;
        }
        synchronized (this) {
            return mStatTimestamp != mFile.lastModified() || mStatSize != mFile.length();
        }
    }
1140427
def _check(self): # TODO: fix?
        """"""
        if self._returncode:
            rarfile.check_returncode(self, '')
        if self._remain != 0:
            raise rarfile.BadRarFile("Failed the read enough data")
728055
public boolean processClassFile(String fileName) {
        Path path = Paths.get(fileName);
        try {
            ClassFile cf = ClassFile.read(path);
            processClass(cf);
            return true;
        } catch (NoSuchFileException nsfe) {
            errorNoFile(fileName);
        } catch (IOException | ConstantPoolException ex) {
            errorException(ex);
        }
        return false;
    }
1284959
void process() {

        int len = vList.size();

        for (int i = 0; i < len; i++) {
            System.out.print(".");

            String file = (String) vList.elementAt(i);

            if (!processFile(file)) {
                System.out.println("in file " + file + " !");
            }
        }

        System.out.println("");
    }
1217919
public function shouldLoadFile($file_name)
    {
        $whitelisted_files = $this->whitelisted_files;
        if ($whitelisted_files === null) return true;
        if (!(in_array($file_name, $whitelisted_files) ||
                array_key_exists($file_name, $whitelisted_files))) {
            return false;
        }
        return true;
    }
371613
public function check()
    {
        $this->isFound = file_exists($this->filename);
        $this->isReadable = is_readable($this->filename);

        $result = $this->isFound && $this->isReadable;

        return $result;
    }
372142
def is_filelike(ob):
    
    if hasattr(ob, 'read') and callable(ob.read):
        return True

    if hasattr(ob, 'write') and callable(ob.write):
        return True

    return False
1132725
def _has_file_rolled(self):
        """"""
        # if the size is smaller then before, the file has
        # probabilly been rolled
        if self._fh:
            size = self._getsize_of_current_file()
            if size < self.oldsize:
                return True

            self.oldsize = size

        return False
1199420
def _CheckIsFile(self, file_entry):
    
    if definitions.FILE_ENTRY_TYPE_FILE not in self._file_entry_types:
      return False
    return file_entry.IsFile()
264046
public function accept()
    {
        $fileinfo = $this->current();
        if (!$fileinfo->isFile()) {
            return true;
        }

        $filesize = $fileinfo->getSize();
        foreach ($this->comparators as $compare) {
            if (!$compare->test($filesize)) {
                return false;
            }
        }

        return true;
    }
1308897
def KnowsFile(self,filename):
        """"""
        if self._isMediaFile(filename) or self._isConfigFile(filename):
            return True
        return False
730790
public function process() {
        if(isset($_REQUEST['VideoFileID']) && $VideoFile = VideoFile::get()->byID($_REQUEST['VideoFileID'])){
            
            $VideoFile->process();
        }
    }
1357072
def _CheckParserCanProcessFileEntry(self, parser, file_entry):
    
    for filter_object in parser.FILTERS:
      if filter_object.Match(file_entry):
        return True

    return False
27290
def IsFileRequired(self, filename):
    """"""
    if filename not in self._file_mapping:
      return False
    mapping = self._file_mapping[filename]
    return mapping['required']
979741
def _HasOOOWrite(self, path):
    """"""
    # Check the sizes of each path before the current one.
    size = tf.io.gfile.stat(path).length
    old_size = self._finalized_sizes.get(path, None)
    if size != old_size:
      if old_size is None:
        logger.error('File %s created after file %s even though it\'s '
                         'lexicographically earlier', path, self._path)
      else:
        logger.error('File %s updated even though the current file is %s',
                         path, self._path)
      return True
    else:
      return False
1039134
def check_file?(file)
      return true if @everything
      type = mime_type_for_file(file)
      ! ignore_types.any? { |ignored| type.include?(ignored) }
    end