Closes the underlying {@link Reader} object.
437601
public void close() throws IOException {
		if (parser != null) {
			parser.close();
		}
		if (reader != null) {
			reader.close();
		}
	}
439709
public void close() throws InterruptedException {
        if (reader_instance != null) {
            reader_instance.closeFiles();
        }
        reader_instance = null;

        // you can only close a syncmanager, when drums was opened for READ_WRITE
        if (syncManager != null) {
            syncManager.shutdown();
            syncManager.join();
        }
    }
547931
public static void closeQuietly(final XMLStreamReader reader) {
        try {
            if (reader != null) {
                reader.close();
            }
        } catch (final Throwable t) {
            if (LOGGER.isDebugEnabled()) {
                LOGGER.debug("Ignoring exception that occurred when closing XMLStreamReader", t);
            }
        }
    }
469702
public void endRead() {
		SynchronizationPoint<NoException> sp;
		synchronized (this) {
			// if others are still reading, nothing to do
			if (--readers > 0) return;
			// if nobody is waiting to write, nothing to do
			if (writersWaiting == null) return;
			sp = writersWaiting.removeFirst();
			if (writersWaiting.isEmpty()) writersWaiting = null;
			writer = true;
		}
		sp.unblock();
	}
568578
@Override
    public void close() {
        if (!closed.compareAndSet(false, true))
            return;

        //is synchronized with itself and _next calls,
        //so no synchronization on inner reader is needed
        try {
            synchronized (inputStream) {
                inputStream.close();
            }
        } catch (IOException ex) {
            throw new RuntimeException(ex);
        }
    }
78553
@Override
    public void close() throws IOException {
        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
            Tr.debug(tc, "The input stream has been closed : " + this + " read Listener running ->" + listener);
        
        isClosed = true;
        listener = null;
        
        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
            Tr.debug(tc, "The input stream has been closed : " + this + " read Listener ->" + listener);
        
        super.close();
    }
706138
public void stop() {
		isRunning = false;
		thread.interrupt();
		try {
			closeFileReader();
		} catch (IOException ioe) {
			System.out.println(new LogEntry(Level.CRITICAL, "I/O exception while closing file reader: " + ioe.getMessage(), ioe));
		}
	}
82108
private void closeInputFile() throws IOException
	{
		myLineReader.close();
		myBufferedReader.close();
		myStreamReader.close();
		myInputStream.close();
	}
389541
@Override
public synchronized void  close(Reporter reporter) throws IOException {

	try {
			this.officeWriter.close();
		}  finally {
			if (this.currentReader!=null) {
				this.currentReader.close();
			}
		}
 }
706788
public static void close (Reader in)
    {
        if (in != null) {
            try {
                in.close();
            } catch (IOException ioe) {
                log.warning("Error closing reader", "reader", in, "cause", ioe);
            }
        }
    }
1119002
@Override
    public final void close() {
        if (this.inputReader != null) {
            try {
                this.inputReader.close();
            } catch (IOException ioe) {
                logger.error("Unable to close input reader.", ioe);
            } finally {
                this.inputReader = null;
            }
        }

        dispose();
    }
438006
@Override
    public void close() throws IOException {
        // Skip over the remaining bytes. Do not close the underlying InputStream.
        if (this.remaining > 0) {
            int toSkip = this.remaining;
            long skipped = skip(toSkip);
            if (skipped != toSkip) {
                throw new SerializationException(String.format("Read %d fewer byte(s) than expected only able to skip %d.", toSkip, skipped));
            }
        } else if (this.remaining < 0) {
            throw new SerializationException(String.format("Read more bytes than expected (%d).", -this.remaining));
        }
    }
524961
public static void close(final InputSource input) throws IOException {
        if (input != null) {
            final InputStream i = input.getByteStream();
            if (i != null) {
                i.close();
            } else {
                final Reader w = input.getCharacterStream();
                if (w != null) {
                    w.close();
                }
            }
        }
    }
815847
@Override
    public void close() throws DataSourceReadException {
        List<DataSourceReadException> exceptions =
                new ArrayList<>();
        if (this.itr != null) {
            this.itr.close();
        }
        this.processor.close();
        for (DataStreamingEventIterator<Proposition> it : this.itrs) {
            try {
                it.close();
            } catch (DataSourceReadException fe) {
                exceptions.add(fe);
            }
        }
        if (!exceptions.isEmpty()) {
            List<StackTraceElement> stes = new ArrayList<>();
            for (Exception ex : exceptions) {
                Arrays.addAll(stes, ex.getStackTrace());
            }
            
            DataSourceReadException ex = new DataSourceReadException(
                    exceptions.size() + " data source backend(s) failed");
            ex.setStackTrace(stes.toArray(new StackTraceElement[stes.size()]));
            throw ex;
        }
    }
411894
private void closeBlockReader(BlockReader reader, boolean reuseConnection) 
      throws IOException {
    if (reader.hasSentStatusCode()) {
      Socket oldSock = reader.takeSocket();
      if (dfsClient.getDataTransferProtocolVersion() < 
          DataTransferProtocol.READ_REUSE_CONNECTION_VERSION ||
          !reuseConnection) {
          // close the sock for old datanode.
        if (oldSock != null) {
          IOUtils.closeSocket(oldSock);
        }
      } else {
        socketCache.put(oldSock);
      }
    }
    reader.close();
  }
474586
public void close() throws IOException {
        if (!closed) {
            this.finish();
            this.buffer.close();
            out.close();
            closed = true;
        }
    }
544806
public static void closeEL(Reader r) {
	try {
	    if (r != null) r.close();
	}
	// catch (AlwaysThrow at) {throw at;}
	catch (Throwable e) {
	    ExceptionUtil.rethrowIfNecessary(e);
	}
    }