Records a fileoverview description.

@return {@code true} if the description was recorded and {@code false}
if the description was invalid or was already defined.
18285
public boolean recordFileOverview(String description) {
    if (currentInfo.documentFileOverview(description)) {
      populated = true;
      return true;
    } else {
      return false;
    }
  }
794514
protected boolean hasSerializationOverviewTags(FieldDoc field) {
        Content output = new ContentBuilder();
        TagletWriter.genTagOuput(configuration.tagletManager, field,
            configuration.tagletManager.getCustomTaglets(field),
                getTagletWriterInstance(false), output);
        return !output.isEmpty();
    }
734291
public boolean recordNoCompile() {
    if (!currentInfo.isNoCompile()) {
      currentInfo.setNoCompile(true);
      populated = true;
      return true;
    } else {
      return false;
    }
  }
635018
public boolean recordModifies(Set<String> modifies) {
    if (!hasAnySingletonSideEffectTags()
        && currentInfo.setModifies(modifies)) {
      populated = true;
      return true;
    } else {
      return false;
    }
  }
1075886
public boolean processDetail(Record parent, String strSourcePath, String strDestPath)
    {
        boolean bSubsExist = false;
        String strName;
        Script recReplication = new Script(this);
        recReplication.setKeyArea(Script.PARENT_FOLDER_ID_KEY);
        recReplication.addListener(new SubFileFilter(parent));
        try   {
            strName = parent.getField(Script.NAME).toString();
                    while (recReplication.hasNext())
            { // Read through the pictures and create an index
                recReplication.next();
                bSubsExist = true;
                strName = recReplication.getField(Script.NAME).toString();
                String strSource = recReplication.getField(Script.SOURCE_PARAM).toString();
                String strDestination = recReplication.getField(Script.DESTINATION_PARAM).toString();
                strSource = strSourcePath + strSource;
                strDestination = strDestPath + strDestination;
                this.processDetail(recReplication, strSource, strDestination);
            }
            recReplication.close();
        } catch (DBException ex)    {
            ex.printStackTrace();
        }
        if (strSourcePath.length() > 0)
            if (Character.isLetterOrDigit(strSourcePath.charAt(strSourcePath.length() - 1)))
        {
            System.out.println("From: " + strSourcePath + " To: " + strDestPath);
            File fileSource = new File(strSourcePath);
            File fileDest = new File(strDestPath);
            if (fileSource.exists())
            {
                if (fileDest.exists())
                    fileDest.delete();
                else
                    System.out.println("Target doesn't exist: " + strSourcePath);
                try   {
                    FileInputStream inStream = new FileInputStream(fileSource);
                    FileOutputStream outStream = new FileOutputStream(fileDest);
                    org.jbundle.jbackup.util.Util.copyStream(inStream, outStream);
                } catch (FileNotFoundException ex)  {
                    ex.printStackTrace();
                } catch (IOException ex)    {
                    ex.printStackTrace();
                }
            }
        }
        return bSubsExist;
    }
134672
private boolean isMoreToReadBeforeReadingRecord(
      final SequenceOffsetType recordSequenceNumber,
      final SequenceOffsetType endSequenceNumber
  )
  {
    final int compareToEnd = createSequenceNumber(recordSequenceNumber)
        .compareTo(createSequenceNumber(endSequenceNumber));

    return isEndOffsetExclusive() ? compareToEnd < 0 : compareToEnd <= 0;
  }
1047299
public static boolean checkIfFileExists(String filePath) {
        File file = new File(filePath);// getSDCardPath(), filePath);
        return (file.exists() ? true : false);
    }
397058
private boolean canWrite(File outputFile) {
		boolean fileIsValid = false;
		if (outputFile.exists()) {
			int result = JOptionPane.showConfirmDialog(
					this, "File exists, overwrite?",
					"Warning", JOptionPane.YES_NO_CANCEL_OPTION);
			switch (result) {
			case JOptionPane.YES_OPTION:
				fileIsValid = true;
				break;
			default:
				fileIsValid = false;
			}
		} else {
			fileIsValid = true;
		}
		return fileIsValid;
	}
1143272
public boolean isARecord(boolean isAFile)
    {
        Record recFileHdr = (Record)this.getRecordOwner().getRecord(FileHdr.FILE_HDR_FILE);
        if (recFileHdr == null)
        {
            recFileHdr = new FileHdr(this.getRecordOwner());
            this.addListener(new FreeOnFreeHandler(recFileHdr));
        }
        if (!recFileHdr.getField(FileHdr.FILE_NAME).equals(this.getField(ClassInfo.CLASS_NAME)))
        {
            try {
                recFileHdr.addNew();
                recFileHdr.getField(FileHdr.FILE_NAME).moveFieldToThis(this.getField(ClassInfo.CLASS_NAME));
                int oldKeyArea = recFileHdr.getDefaultOrder();
                recFileHdr.setKeyArea(FileHdr.FILE_NAME_KEY);
                recFileHdr.seek(null);
                recFileHdr.setKeyArea(oldKeyArea);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        if ((recFileHdr.getEditMode() == DBConstants.EDIT_CURRENT) && (this.getField(ClassInfo.CLASS_NAME).toString().equals(recFileHdr.getField(FileHdr.FILE_NAME).getString())))
            return true;    // This is a file
        if (isAFile)
            return false;    // Just looking for files
        if (!"Record".equalsIgnoreCase(this.getField(ClassInfo.CLASS_TYPE).toString()))
            return false;     // If this isn't a physical file, don't build it.
        if (this.getField(ClassInfo.BASE_CLASS_NAME).toString().contains("ScreenRecord"))
            return false;
        if ("Interface".equalsIgnoreCase(this.getField(ClassInfo.CLASS_TYPE).toString()))   // An interface doesn't have an interface
            return false;     // If this isn't a physical file, don't build it.
        if (RESOURCE_CLASS.equals(this.getField(ClassInfo.BASE_CLASS_NAME).toString()))
            return false;     // Resource only class
        return true;    // This is a record
    }
129041
public boolean processThisRecord(Record record)
    {
        if (record == null)
            return false;
        boolean bPhysicalName = true;
        if (DBConstants.TRUE.equalsIgnoreCase(this.getProperty(USE_DATABASE_NAME)))
            bPhysicalName = false;
        String strFilename = record.getArchiveFilename(bPhysicalName);
        if (this.getProperty(ConvertCode.DIR_PREFIX) != null)
            strFilename = Utility.addToPath(this.getProperty(ConvertCode.DIR_PREFIX), strFilename);
        
        String strMode = this.getProperty(TRANSFER_MODE);
        boolean bExport = true;
        if (strMode != null) if (strMode.equalsIgnoreCase(IMPORT))
            bExport = false;
        if (bExport)
        {
            int oldOpenMode = record.getOpenMode();
            record.setOpenMode(oldOpenMode & ~DBConstants.OPEN_DONT_CREATE);
            // Make sure the record exists
            try {
                record.open();
                if ((record.getEditMode() != DBConstants.EDIT_CURRENT) && (!record.hasNext()))  // Control file would read current
                    if (!DBConstants.TRUE.equalsIgnoreCase(this.getProperty("importEmptyFiles")))
                        return false;   // Skip empty files (default)
                record.close();
            } catch (DBException e) {
                return false; // Record doesn't exist
            }
            if (this.getProperty(LOCALE) != null)
            {
                if (!record.getTable().getDatabase().getDatabaseName(false).endsWith("_" + this.getProperty(LOCALE).toString()))
                    return false;     // If locale is set, only do locale tables
                if (DatabaseInfo.DATABASE_INFO_FILE.equalsIgnoreCase(record.getTable().getDatabase().getDatabaseName(false)))
                    return false;     // This is a special file type
            }
        }
        else
        { // Import must have file.
            if (!(new File(strFilename).exists()))
                return false;
            if (this.getProperty(LOCALE) != null)
            {
                if (!record.getTable().getDatabase().getDatabaseName(false).endsWith("_" + this.getProperty(LOCALE).toString()))
                    return false;     // If locale is set, only do locale tables
                if (DatabaseInfo.DATABASE_INFO_FILE.equalsIgnoreCase(record.getTable().getDatabase().getDatabaseName(false)))
                    return false;     // This is a special file type
            }
        }
        XmlInOut xml = new XmlInOut(this, null, null);    //0 v
        boolean bSuccess = false;
        if (bExport)
            bSuccess = xml.exportXML(record.getTable(), strFilename);
        else
            bSuccess = xml.importXML(record.getTable(), strFilename, null);
        xml.free();
        return bSuccess;
    }
757162
public boolean isDataModified() {
		if (this.deletedRecords.size() > 0) {
			return true;
		}
		for (final JKTableRecord rec : this.records) {
			if (rec.getStatus() == RecordStatus.MODIFIED) {
				return true;
			}
		}
		return false;
	}
447457
public boolean recordReturnDescription(String description) {
    if (currentInfo.documentReturn(description)) {
      populated = true;
      return true;
    } else {
      return false;
    }
  }
379098
public int putRawRecordData(Rec record)
    {
        if (this.getNodeType() == BaseMessageRecordDesc.NON_UNIQUE_NODE)
            this.getMessage().createNewNode(this.getFullKey(null));
        return super.putRawRecordData(record);
    }
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();
        }
    }
807189
public void addListener(Record record, FileListener listener)
    {
        if (this.getNextTable() != null)
            this.getNextTable().addListener(record, listener);
    }
445207
protected final boolean readLine() throws IOException {
		if (this.stream == null || this.overLimit) {
			return false;
		}

		int countInWrapBuffer = 0;

		/* position of matching positions in the delimiter byte array */
		int i = 0;

		while (true) {
			if (this.readPos >= this.limit) {
				if (!fillBuffer()) {
					if (countInWrapBuffer > 0) {
						setResult(this.wrapBuffer, 0, countInWrapBuffer);
						return true;
					} else {
						return false;
					}
				}
			}

			int startPos = this.readPos;
			int count = 0;

			while (this.readPos < this.limit && i < this.delimiter.length) {
				if ((this.readBuffer[this.readPos++]) == this.delimiter[i]) {
					i++;
				} else {
					i = 0;
				}

			}

			// check why we dropped out
			if (i == this.delimiter.length) {
				// line end
				count = this.readPos - startPos - this.delimiter.length;

				// copy to byte array
				if (countInWrapBuffer > 0) {
					// check wrap buffer size
					if (this.wrapBuffer.length < countInWrapBuffer + count) {
						final byte[] nb = new byte[countInWrapBuffer + count];
						System.arraycopy(this.wrapBuffer, 0, nb, 0, countInWrapBuffer);
						this.wrapBuffer = nb;
					}
					if (count >= 0) {
						System.arraycopy(this.readBuffer, 0, this.wrapBuffer, countInWrapBuffer, count);
					}
					setResult(this.wrapBuffer, 0, countInWrapBuffer + count);
					return true;
				} else {
					setResult(this.readBuffer, startPos, count);
					return true;
				}
			} else {
				count = this.limit - startPos;
				
				// check against the maximum record length
				if ( ((long) countInWrapBuffer) + count > this.lineLengthLimit) {
					throw new IOException("The record length exceeded the maximum record length (" + 
							this.lineLengthLimit + ").");
				}

				// buffer exhausted
				if (this.wrapBuffer.length - countInWrapBuffer < count) {
					// reallocate
					byte[] tmp = new byte[Math.max(this.wrapBuffer.length * 2, countInWrapBuffer + count)];
					System.arraycopy(this.wrapBuffer, 0, tmp, 0, countInWrapBuffer);
					this.wrapBuffer = tmp;
				}

				System.arraycopy(this.readBuffer, startPos, this.wrapBuffer, countInWrapBuffer, count);
				countInWrapBuffer += count;
			}
		}
	}
518832
protected boolean fileExists()
    {
        if (tc.isEntryEnabled())
            Tr.entry(tc, "fileExists", this);

        boolean fileAlreadyExists = true;

        File file = new File(_logDirectory, _fileName);
        fileAlreadyExists = (file.exists() && (file.length() > 0));

        if (tc.isEntryEnabled())
            Tr.exit(tc, "fileExists", new Boolean(fileAlreadyExists));
        return fileAlreadyExists;
    }