Closes the current component array.
@throws IllegalStateException if there are no open components (
{@link #writeStartComponent(String)} must be called first)
@throws IOException if there's an I/O problem
550356
public void writeEndComponent() throws IOException {
		if (stack.isEmpty()) {
			throw new IllegalStateException(Messages.INSTANCE.getExceptionMessage(2));
		}
		Info cur = stack.removeLast();

		if (!cur.wroteEndPropertiesArray) {
			generator.writeEndArray();
		}
		if (!cur.wroteStartSubComponentsArray) {
			generator.writeStartArray();
		}

		generator.writeEndArray(); //end sub-components array
		generator.writeEndArray(); //end the array of this component

		componentEnded = true;
	}
12973
public void close() throws IOException {
        if(inp != null)
            inp.close();
        if(out != null)
            out.close();
    }
301330
public void writeStartComponent(String componentName) throws IOException {
		if (generator == null) {
			init();
		}

		componentEnded = false;

		if (!stack.isEmpty()) {
			Info parent = stack.getLast();
			if (!parent.wroteEndPropertiesArray) {
				generator.writeEndArray();
				parent.wroteEndPropertiesArray = true;
			}
			if (!parent.wroteStartSubComponentsArray) {
				generator.writeStartArray();
				parent.wroteStartSubComponentsArray = true;
			}
		}

		generator.writeStartArray();
		generator.writeString(componentName);
		generator.writeStartArray(); //start properties array

		stack.add(new Info());
	}
318777
public synchronized void close() throws IOException {
		// reject modification of already closed node
		if(isOpen==false) {
			throw new IOException("Attempted to close already closed tag '" + name + "'!");
		}
		// close previously opened child node, if present
		if(lastChildNode!=null) {
			// close regular child node
			lastChildNode.close();
			// on regular nodes and comments, write closing tag into new line
			if((lastChildNode instanceof SXTextNode)==false) {
				writer.write("\n");
				indentLine();
			}
			// write closing text
			writer.write("</" + name + ">");
			lastChildNode = null;
		} else {
			// no siblings, close unique tag
			writer.write("/>");
		}
		isOpen = false;
	}
830210
protected void destroyOldEngineComponent(ComponentList component) {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
            SibTr.entry(tc, "destroyOldEngineComponent", component);
        }

        boolean removed = jmeComponents.remove(component);
        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
            SibTr.debug(tc, "destroyOldEngineComponent, component removed from jmeComponents?", removed);
        }

        JsEngineComponent engineComponent = component.getRef();

        if (_state == STATE_STARTING || _state == STATE_STARTED || _state == STATE_STOPPING || _state == STATE_STOPPING_MEMBER || _state == STATE_FAILED) {
            // Stop engine component
            engineComponent.stop(JsConstants.ME_STOP_IMMEDIATE);
        }

        if (_state != STATE_UNINITIALIZED && _state != STATE_DESTROYED) {
            // Destroy
            engineComponent.destroy();
        }

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
            SibTr.exit(tc, "destroyOldEngineComponent");
        }
    }
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();
    }
410629
public synchronized void close() throws IOException {
        if (!opened) {
            return;
        }
        //
        opened = false;
        accessor.close();
        appender.close();
        hints.clear();
        inflightWrites.clear();
        //
        if (managedWriter) {
            ((ExecutorService) writer).shutdown();
            writer = null;
        }
        if (managedDisposer) {
            disposer.shutdown();
            disposer = null;
        }
    }
49923
@Override
    public void close() throws IOException {
        if (isClosed) {
            return;
        }
        flush(sendEor);
        if (sendClose) {
            eventPipeline.fire(new Close(), channel);
        }
        isClosed = true;
    }
499100
public void close() throws IOException {
		try {
			if (!started) {
				handler.startDocument();

				if (!icalendarElementExists) {
					//don't output a <icalendar> element if the parent is a <icalendar> element
					start(ICALENDAR);
				}
			}

			if (!icalendarElementExists) {
				end(ICALENDAR);
			}
			handler.endDocument();
		} catch (SAXException e) {
			throw new IOException(e);
		}

		if (writer != null) {
			writer.close();
		}
	}
908793
public void close() throws IOException {
        value = null;
        token = null;
        stack.clear();
        stack.add(JsonScope.CLOSED);
        in.close();
    }
1091357
public void close() throws IOException {   
    if (closed) {
      checkWriteThread();
      return;
    }
    try {
      buffer.close(); 
      // writeThread should exit after this
      // and close underlying stream
      try {
        writeThread.join();
      } catch (InterruptedException e) {
        throw new IOException(e);
      }
    } finally {
      checkWriteThread();
    }
  }
744719
@Override
  public void close()
    throws IOException
  {
    if (_isClosed) {
      return;
    }
    
    _isClosed = true;
    
    flushBlock(true);
      
    _cursor.setBlob(_column.index(), this);
  }
953886
@Override
	public void close() throws IOException {
		if (this.stream != null) {
			this.stream.write(this.buffer, 0, this.pos);
		}
		
		// close file stream
		super.close();
	}
842801
@Override
	public void close() throws IOException {
		for(int i=0;i<oss.length;++i) {
			if(close[i]) {
				oss[i].close();
			}
    	}
	}
712551
@Override
  public void close() throws IOException {
    if (open.compareAndSet(true, false)) {
      onClose.run();

      Throwable thrown = null;
      do {
        for (Closeable resource : resources) {
          try {
            resource.close();
          } catch (Throwable e) {
            if (thrown == null) {
              thrown = e;
            } else {
              thrown.addSuppressed(e);
            }
          } finally {
            // ensure the resource is removed even if it doesn't remove itself when closed
            resources.remove(resource);
          }
        }

        // It's possible for a thread registering a resource to register that resource after open
        // has been set to false and even after we've looped through and closed all the resources.
        // Since registering must be incremented *before* checking the state of open, however,
        // when we reach this point in that situation either the register call is still in progress
        // (registering > 0) or the new resource has been successfully added (resources not empty).
        // In either case, we just need to repeat the loop until there are no more register calls
        // in progress (no new calls can start and no resources left to close.
      } while (registering.get() > 0 || !resources.isEmpty());
      Throwables.propagateIfPossible(thrown, IOException.class);
    }
  }
1169544
@Override
    public void close () throws IOException {
        try {
            if ( this.handle.isValid() ) {
                this.handle.close();
            }
        }
        finally {
            this.file.clearAttributeCache();
            this.tmp = null;
        }
    }
1329131
public void close() throws IOException {
        switch (state) {
            case READY:
                throw new IllegalStateException("File " + tempFile
                        + " hasn't been opened yet.");
            case CLOSED:
                throw new IllegalStateException("File " + tempFile
                        + " has been closed already.");
            default: // OPEN
                fileWriter.close();
                tempFile.renameTo(file);
                state = State.CLOSED;
        }
    }