Closes the block reader. After this, this block reader should not be used anymore.
This is recommended to be called after the client finishes reading the block. It is usually
triggered when the client unlocks the block.
496308
@Override
  public void close() throws IOException {
    if (mClosed) {
      return;
    }

    try {
      // This aborts the block if the block is not fully read.
      updateBlockWriter(mBlockMeta.getBlockSize());

      if (mUnderFileSystemInputStream != null) {
        mUfsInstreamManager.release(mUnderFileSystemInputStream);
        mUnderFileSystemInputStream = null;
      }

      if (mBlockWriter != null) {
        mBlockWriter.close();
      }

      mUfsResource.close();
    } finally {
      mClosed = true;
    }
  }
1342138
@Override
  public void close()
      throws IOException {
    if (delegateReader != null) {
      logger.atWarning().log(
          "Got non-null delegateReader during close(); possible premature close() call.");
      delegateReader.close();
      delegateReader = null;
    }
  }
950791
@Override
  public void stop() {
    if (cancellable != null) {
      cancellable.cancel();
      cancellable = null;
    }
    
    if (reader != null) {
      reader.close();
    }
    
    super.stop();
  }
871789
public void close() {
    this.waitUntilInitialized();

    this.ongoingOperationsGroup.blockAndWait();

    syncLock.lock();
    try {
      if (this.networkMonitor != null) {
        this.networkMonitor.removeNetworkStateListener(this);
      }
      this.dispatcher.close();
      stop();
      this.localClient.close();
    } finally {
      syncLock.unlock();
    }
  }
595880
@Override
	public void close() {
		Iterator<Map.Entry<Path, OpenCryptoFile>> iter = openCryptoFiles.entrySet().iterator();
		while (iter.hasNext()) {
			Map.Entry<Path, OpenCryptoFile> entry = iter.next();
			iter.remove(); // remove before invoking close() to avoid concurrent modification of this iterator by #close(OpenCryptoFile)
			entry.getValue().close();
		}
	}
487247
def closed(self) -> bool:
        ''''''
        return not self.writer or not self.reader or self.reader.at_eof()
845688
public void shutdown() {
    getLogger().info(getPath() + " shutdown");
    active = false;
    try {
      if (reader != null) {
        reader.close();
        reader = null;
      }
    } catch (IOException ioe) {
      ioe.printStackTrace();
    }
  }
1073532
@Override public void close() throws IOException
   {
      long skippedLast = 0;
      if (m_remaining > 0)
      {
         skippedLast = skip(m_remaining);
         while (m_remaining > 0 && skippedLast > 0)
         {
            skippedLast = skip(m_remaining);
         }
      }
   }
1095235
@Override
    public void close() throws IOException {
        if (!closed) {
            closed = true;
            nodeCursor = null;
            _currToken = null;
        }
    }
869509
@Override
    public void close() throws IOException {
        // If not already closed, then close the input stream.
        if(!this.closed) {
            this.closed = true;
            // if the user read to the end of the virtual stream, then drain
            // the wrapped stream so the HTTP client can keep this connection
            // alive if possible.
            // This should not have too much overhead since if we've reached the
            // end of the virtual stream, there should be at most 31 bytes left
            // (2 * JceEncryptionConstants.SYMMETRIC_CIPHER_BLOCK_SIZE - 1) in the
            // stream.
            // See: S3CryptoModuleBase#getCipherBlockUpperBound
             if (this.virtualAvailable == 0) {
                 IOUtils.drainInputStream(decryptedContents);
            }
            this.decryptedContents.close();
        }
        abortIfNeeded();
    }
1136536
public void close() throws KNXMLException
	{
		if (closeReader)
			try {
				r.close();
			}
			catch (final IOException e) {
				throw new KNXMLException(e.getMessage());
			}
	}
785830
@Override
    public void close() throws IOException
    {
        if (!_closed) {
            _closed = true;
            _nodeCursor = null;
            _currToken = null;
        }
    }
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);
        }
    }
154179
public function close()
    {
        if ($this->isStreamOpened) {
            $this->closeReader();

            $sheetIterator = $this->getConcreteSheetIterator();
            if ($sheetIterator) {
                $sheetIterator->end();
            }

            $this->isStreamOpened = false;
        }
    }
463642
public void close() throws IOException {
		out.close();
		in.close();
		if (server != null) {
			server.close();
		}
		if (client != null) {
			client.close();
		}
	}
96884
def close(self):
        
        if self._file:
            if not(self._file.closed):
                self._file.close()
        self.closed = True
166711
public static void closeQuietly(XMLStreamReader reader) {
        if (reader != null) {
            try {
                reader.close();
            } catch (XMLStreamException e) {
                logger.warn("Error while closing", e);
            }
        }
    }