Java IOUtil.assertFileIsWritable方法代码示例

import htsjdk.samtools.util.IOUtil; //导入方法依赖的package包/类
protected int doWork() {
    IOUtil.assertFileIsReadable(INPUT);
    IOUtil.assertFileIsWritable(OUTPUT);

    if (INPUT.getAbsolutePath().endsWith(".sam")) {
        throw new PicardException("SAM files are not supported");
    }

    final SAMFileHeader samFileHeader = SamReaderFactory.makeDefault().referenceSequence(REFERENCE_SEQUENCE).getFileHeader(INPUT);
    for (final String comment : COMMENT) {
        if (comment.contains("\n")) {
            throw new PicardException("Comments can not contain a new line");
        }
        samFileHeader.addComment(comment);
    }

    BamFileIoUtils.reheaderBamFile(samFileHeader, INPUT, OUTPUT, CREATE_MD5_FILE, CREATE_INDEX);

    return 0;
}
 

import htsjdk.samtools.util.IOUtil; //导入方法依赖的package包/类
private File makeReadGroupFile(final SAMReadGroupRecord readGroup, final String preExtSuffix) {
    String fileName = null;
    if (RG_TAG.equalsIgnoreCase("PU")){
        fileName = readGroup.getPlatformUnit();
    } else if (RG_TAG.equalsIgnoreCase("ID")){
        fileName = readGroup.getReadGroupId();
    }
    if (fileName == null) {
        throw new PicardException("The selected RG_TAG: "+RG_TAG+" is not present in the bam header.");
    }
    fileName = IOUtil.makeFileNameSafe(fileName);
    if (preExtSuffix != null) fileName += preExtSuffix;
    fileName += COMPRESS_OUTPUTS_PER_RG ? ".fastq.gz" : ".fastq";

    final File result = (OUTPUT_DIR != null)
            ? new File(OUTPUT_DIR, fileName)
            : new File(fileName);
    IOUtil.assertFileIsWritable(result);
    return result;
}
 

import htsjdk.samtools.util.IOUtil; //导入方法依赖的package包/类
@Override
protected int doWork() {
    IOUtil.assertFileIsReadable(INPUT);
    if(OUTPUT != null) IOUtil.assertFileIsWritable(OUTPUT);

    final MetricsFile<CrosscheckMetric, ?> metricsFile = getMetricsFile();

    try {
        metricsFile.read(new FileReader(INPUT));
    } catch (FileNotFoundException e) {
        e.printStackTrace();
        return 1;
    }

    clusterMetrics(metricsFile.getMetrics()).write(OUTPUT);

    return 0;
}
 

import htsjdk.samtools.util.IOUtil; //导入方法依赖的package包/类
/**
 * Do the work after command line has been parsed.
 * RuntimeException may be thrown by this method, and are reported appropriately.
 *
 * @return program exit status.
 */
@Override
protected int doWork() {
    IOUtil.assertFileIsReadable(INPUT);
    IOUtil.assertFileIsReadable(HEADER);
    IOUtil.assertFileIsWritable(OUTPUT);

    final SAMFileHeader replacementHeader = SamReaderFactory.makeDefault().referenceSequence(REFERENCE_SEQUENCE).getFileHeader(HEADER);

    if (BamFileIoUtils.isBamFile(INPUT)) {
        blockCopyReheader(replacementHeader);
    } else {
        standardReheader(replacementHeader);
    }

    return 0;
}
 

import htsjdk.samtools.util.IOUtil; //导入方法依赖的package包/类
public static void assertOutputIsValid(final String output) {
      if (output == null) {
    	  throw new IllegalArgumentException("Cannot check validity of null output.");
      }
      if (!IOUtil.isUrl(output)) {
    	  IOUtil.assertFileIsWritable(new File(output));
      }
}
 

import htsjdk.samtools.util.IOUtil; //导入方法依赖的package包/类
@Override
protected int doWork() {
    IOUtil.assertFileIsWritable(CHART_OUTPUT);
    IOUtil.assertFileIsReadable(INPUT);

    // Initialize the SamReader, so the header is available prior to super.doWork, for getIntervalsToExamine call. */
    getSamReader();

    this.collector = new WgsMetricsWithNonZeroCoverageCollector(this, COVERAGE_CAP, getIntervalsToExamine());
    super.doWork();

    final List<SAMReadGroupRecord> readGroups = getSamFileHeader().getReadGroups();
    final String plotSubtitle = (readGroups.size() == 1) ? StringUtil.asEmptyIfNull(readGroups.get(0).getLibrary()) : "";

    if (collector.areHistogramsEmpty()) {
        log.warn("No valid bases found in input file. No plot will be produced.");
    } else {
        final int rResult = RExecutor.executeFromClasspath("picard/analysis/wgsHistogram.R",
                OUTPUT.getAbsolutePath(),
                CHART_OUTPUT.getAbsolutePath(),
                INPUT.getName(),
                plotSubtitle);
        if (rResult != 0) {
            throw new PicardException("R script wgsHistogram.R failed with return code " + rResult);
        }
    }

    return 0;
}
 

import htsjdk.samtools.util.IOUtil; //导入方法依赖的package包/类
private void assertIoFiles(final File summaryFile, final File detailsFile, final File plotsFile) {
    IOUtil.assertFileIsReadable(INPUT);
    IOUtil.assertFileIsReadable(REFERENCE_SEQUENCE);
    IOUtil.assertFileIsWritable(summaryFile);
    IOUtil.assertFileIsWritable(detailsFile);
    IOUtil.assertFileIsWritable(plotsFile);
}
 

import htsjdk.samtools.util.IOUtil; //导入方法依赖的package包/类
@Override
protected int doWork() {
    final List<File> inputs = IOUtil.unrollFiles(INPUT, BamFileIoUtils.BAM_FILE_EXTENSION, ".sam");
    for (final File f : inputs) IOUtil.assertFileIsReadable(f);
    IOUtil.assertFileIsWritable(OUTPUT);

    if (determineBlockCopyingStatus(inputs)) {
        BamFileIoUtils.gatherWithBlockCopying(inputs, OUTPUT, CREATE_INDEX, CREATE_MD5_FILE);
    } else {
        gatherNormally(inputs, OUTPUT, CREATE_INDEX, CREATE_MD5_FILE, REFERENCE_SEQUENCE);
    }

    return 0;
}
 

import htsjdk.samtools.util.IOUtil; //导入方法依赖的package包/类
@Override
protected void setup(final SAMFileHeader header, final File samFile) {
    IOUtil.assertFileIsWritable(CHART_OUTPUT);
    IOUtil.assertFileIsWritable(SUMMARY_OUTPUT);
    IOUtil.assertFileIsReadable(REFERENCE_SEQUENCE);

    //Calculate windowsByGc for the reference sequence
    final int[] windowsByGc = GcBiasUtils.calculateRefWindowsByGc(BINS, REFERENCE_SEQUENCE, SCAN_WINDOW_SIZE);

    //Delegate actual collection to GcBiasMetricCollector
    multiCollector = new GcBiasMetricsCollector(METRIC_ACCUMULATION_LEVEL, windowsByGc, header.getReadGroups(), SCAN_WINDOW_SIZE, IS_BISULFITE_SEQUENCED, ALSO_IGNORE_DUPLICATES);
}
 

import htsjdk.samtools.util.IOUtil; //导入方法依赖的package包/类
static void assertWritable(final File output, final boolean outputByReadGroup) {
    if (outputByReadGroup) {
        if (output != null) {
            IOUtil.assertDirectoryIsWritable(output);
        }
    } else {
        IOUtil.assertFileIsWritable(output);
    }
}
 

import htsjdk.samtools.util.IOUtil; //导入方法依赖的package包/类
@Override
protected int doWork() {
    IOUtil.assertFileIsReadable(INPUT);
    IOUtil.assertFileIsWritable(OUTPUT);

    final IntervalList intervalList = VCFFileReader.fromVcf(INPUT, INCLUDE_FILTERED);

    // Sort and write the output
    intervalList.uniqued().write(OUTPUT);
    return 0;
}
 

import htsjdk.samtools.util.IOUtil; //导入方法依赖的package包/类
/**
 * Writes a set of pedigrees out to disk.
 */
public void write(final File file) {
    IOUtil.assertFileIsWritable(file);
    final BufferedWriter out = IOUtil.openFileForBufferedWriting(file);

    try {
        for (final PedTrio trio : values()) {
            out.write(trio.getFamilyId());
            out.write("\t");
            out.write(trio.getIndividualId());
            out.write("\t");
            out.write(trio.getPaternalId());
            out.write("\t");
            out.write(trio.getMaternalId());
            out.write("\t");
            out.write(String.valueOf(trio.getSex().toCode()));
            out.write("\t");
            out.write(trio.getPhenotype().toString());
            out.newLine();
        }

        out.close();
    }
    catch (final IOException ioe) {
        throw new RuntimeIOException("IOException while writing to file " + file.getAbsolutePath(), ioe);
    }
}
 

import htsjdk.samtools.util.IOUtil; //导入方法依赖的package包/类
@Override protected void setup(final SAMFileHeader header, final File samFile) {
    IOUtil.assertFileIsWritable(OUTPUT);

    if (header.getSequenceDictionary().isEmpty()) {
        log.warn(INPUT.getAbsoluteFile() + " has no sequence dictionary.  If any reads " +
                "in the file are aligned, then alignment summary metrics collection will fail.");
    }

    final boolean doRefMetrics = REFERENCE_SEQUENCE != null;
    collector = new AlignmentSummaryMetricsCollector(METRIC_ACCUMULATION_LEVEL, header.getReadGroups(), doRefMetrics,
            ADAPTER_SEQUENCE, MAX_INSERT_SIZE, EXPECTED_PAIR_ORIENTATIONS, IS_BISULFITE_SEQUENCED);
}
 

import htsjdk.samtools.util.IOUtil; //导入方法依赖的package包/类
@Override
protected int doWork() {
    IOUtil.assertFileIsReadable(INTERVAL_LIST);
    IOUtil.assertFileIsReadable(REFERENCE_SEQUENCE);
    IOUtil.assertFileIsWritable(OUTPUT);

    final IntervalList intervals = IntervalList.fromFile(INTERVAL_LIST);
    final ReferenceSequenceFile ref = ReferenceSequenceFileFactory.getReferenceSequenceFile(REFERENCE_SEQUENCE);
    SequenceUtil.assertSequenceDictionariesEqual(intervals.getHeader().getSequenceDictionary(), ref.getSequenceDictionary());

    final BufferedWriter out = IOUtil.openFileForBufferedWriting(OUTPUT);

    for (final Interval interval : intervals) {
        final ReferenceSequence seq = ref.getSubsequenceAt(interval.getContig(), interval.getStart(), interval.getEnd());
        final byte[] bases = seq.getBases();
        if (interval.isNegativeStrand()) SequenceUtil.reverseComplement(bases);

        try {
            out.write(">");
            out.write(interval.getName());
            out.write("\n");

            for (int i=0; i<bases.length; ++i) {
                if (i > 0 && i % LINE_LENGTH == 0) out.write("\n");
                out.write(bases[i]);
            }

            out.write("\n");
        }
        catch (IOException ioe) {
            throw new PicardException("Error writing to file " + OUTPUT.getAbsolutePath(), ioe);

        }
    }

    CloserUtil.close(out);

    return 0;
}
 

import htsjdk.samtools.util.IOUtil; //导入方法依赖的package包/类
@Override
protected int doWork() {
    IOUtil.assertFileIsReadable(INPUT);
    IOUtil.assertFileIsReadable(SEQUENCE_DICTIONARY);
    IOUtil.assertFileIsWritable(OUTPUT);
    try {
        // create a new header that we will assign the dictionary provided by the SAMSequenceDictionaryExtractor to.
        final SAMFileHeader header = new SAMFileHeader();
        final SAMSequenceDictionary samSequenceDictionary = SAMSequenceDictionaryExtractor.extractDictionary(SEQUENCE_DICTIONARY.toPath());
        header.setSequenceDictionary(samSequenceDictionary);
        // set the sort order to be sorted by coordinate, which is actually done below
        // by getting the .uniqued() intervals list before we write out the file
        header.setSortOrder(SAMFileHeader.SortOrder.coordinate);
        final IntervalList intervalList = new IntervalList(header);

        /**
         * NB: BED is zero-based, but a BEDCodec by default (since it is returns tribble Features) has an offset of one,
         * so it returns 1-based starts.  Ugh.  Set to zero.
         */
        final FeatureReader<BEDFeature> bedReader = AbstractFeatureReader.getFeatureReader(INPUT.getAbsolutePath(), new BEDCodec(BEDCodec.StartOffset.ZERO), false);
        final CloseableTribbleIterator<BEDFeature> iterator = bedReader.iterator();
        final ProgressLogger progressLogger = new ProgressLogger(LOG, (int) 1e6);

        while (iterator.hasNext()) {
            final BEDFeature bedFeature = iterator.next();
            final String sequenceName = bedFeature.getContig();
            /**
             * NB: BED is zero-based, so we need to add one here to make it one-based.  Please observe we set the start
             * offset to zero when creating the BEDCodec.
             */
            final int start = bedFeature.getStart() + 1;
            /**
             * NB: BED is 0-based OPEN (which, for the end is equivalent to 1-based closed).
             */
            final int end = bedFeature.getEnd();
            // NB: do not use an empty name within an interval
            String name = bedFeature.getName();
            if (name.isEmpty()) name = null;

            final SAMSequenceRecord sequenceRecord = header.getSequenceDictionary().getSequence(sequenceName);

            // Do some validation
            if (null == sequenceRecord) {
                throw new PicardException(String.format("Sequence '%s' was not found in the sequence dictionary", sequenceName));
            } else if (start < 1) {
                throw new PicardException(String.format("Start on sequence '%s' was less than one: %d", sequenceName, start));
            } else if (sequenceRecord.getSequenceLength() < start) {
                throw new PicardException(String.format("Start on sequence '%s' was past the end: %d < %d", sequenceName, sequenceRecord.getSequenceLength(), start));
            } else if (end < 1) {
                throw new PicardException(String.format("End on sequence '%s' was less than one: %d", sequenceName, end));
            } else if (sequenceRecord.getSequenceLength() < end) {
                throw new PicardException(String.format("End on sequence '%s' was past the end: %d < %d", sequenceName, sequenceRecord.getSequenceLength(), end));
            } else if (end < start - 1) {
                throw new PicardException(String.format("On sequence '%s', end < start-1: %d <= %d", sequenceName, end, start));
            }

            final boolean isNegativeStrand = bedFeature.getStrand() == Strand.NEGATIVE;
            final Interval interval = new Interval(sequenceName, start, end, isNegativeStrand, name);
            intervalList.add(interval);

            progressLogger.record(sequenceName, start);
        }
        CloserUtil.close(bedReader);

        // Sort and write the output
        IntervalList out = intervalList;
        if (SORT) out = out.sorted();
        if (UNIQUE) out = out.uniqued();
        out.write(OUTPUT);

    } catch (final IOException e) {
        throw new RuntimeException(e);
    }

    return 0;
}