Java Flushable类代码示例

import java.io.Flushable; //导入依赖的package包/类
private void flush(LinkedList<Request> toFlush)
    throws IOException, RequestProcessorException
{
    if (toFlush.isEmpty())
        return;

    zks.getZKDatabase().commit();
    while (!toFlush.isEmpty()) {
        Request i = toFlush.remove();
        if (nextProcessor != null) {
            nextProcessor.processRequest(i);
        }
    }
    if (nextProcessor != null && nextProcessor instanceof Flushable) {
        ((Flushable)nextProcessor).flush();
    }
}
 

import java.io.Flushable; //导入依赖的package包/类
@ApiMethod
@Comment(value = "Simply calls stream.flush() but throws RuntimeException instead of IOException")
public static void flush(Flushable stream)
{
   try
   {
      if (stream != null)
      {
         stream.flush();
      }
   }
   catch (Exception ex)
   {
      Lang.rethrow(ex);
   }
}
 

import java.io.Flushable; //导入依赖的package包/类
private void flush(GaugeWriter writer) {
	if (writer instanceof CompositeMetricWriter) {
		for (MetricWriter child : (CompositeMetricWriter) writer) {
			flush(child);
		}
	}
	try {
		if (ClassUtils.isPresent("java.io.Flushable", null)) {
			if (writer instanceof Flushable) {
				((Flushable) writer).flush();
				return;
			}
		}
		Method method = ReflectionUtils.findMethod(writer.getClass(), "flush");
		if (method != null) {
			ReflectionUtils.invokeMethod(method, writer);
		}
	}
	catch (Exception ex) {
		logger.warn("Could not flush MetricWriter: " + ex.getClass() + ": "
				+ ex.getMessage());
	}
}
 

import java.io.Flushable; //导入依赖的package包/类
/**
 * Flushes the formatter, writing any cached data to the output
 * stream.  If the underlying output stream supports the
 * {@link Flushable} interface, it is also flushed.
 *
 * @throws FormatterClosedException if the formatter is closed.
 */
public void flush()
{
  if (closed)
    throw new FormatterClosedException();
  try
    {
      if (out instanceof Flushable)
        ((Flushable) out).flush();
    }
  catch (IOException _)
    {
      // FIXME: do we ignore these or do we set ioException?
      // The docs seem to indicate that we should ignore.
    }
}
 

import java.io.Flushable; //导入依赖的package包/类
/**
  * Flushes the formatter, writing any cached data to the output
  * stream.  If the underlying output stream supports the
  * {@link Flushable} interface, it is also flushed.
  *
  * @throws FormatterClosedException if the formatter is closed.
  */
 public void flush()
 {
   if (closed)
     throw new FormatterClosedException();
   try
     {
if (out instanceof Flushable)
  ((Flushable) out).flush();
     }
   catch (IOException _)
     {
// FIXME: do we ignore these or do we set ioException?
// The docs seem to indicate that we should ignore.
     }
 }
 

import java.io.Flushable; //导入依赖的package包/类
private void flush(MetricWriter writer) {
	if (writer instanceof CompositeMetricWriter) {
		for (MetricWriter child : (CompositeMetricWriter) writer) {
			flush(child);
		}
	}
	try {
		if (ClassUtils.isPresent("java.io.Flushable", null)) {
			if (writer instanceof Flushable) {
				((Flushable) writer).flush();
				return;
			}
		}
		Method method = ReflectionUtils.findMethod(writer.getClass(), "flush");
		if (method != null) {
			ReflectionUtils.invokeMethod(method, writer);
		}
	}
	catch (Exception ex) {
		logger.warn("Could not flush MetricWriter: " + ex.getClass() + ": "
				+ ex.getMessage());
	}
}
 

import java.io.Flushable; //导入依赖的package包/类
@Override
public String readLine(String prompt, Character mask)
        throws IOException
{
    String line;
    interrupted = false;
    try {
        line = super.readLine(prompt, mask);
    }
    catch (UserInterruptException e) {
        interrupted = true;
        return null;
    }

    if (getHistory() instanceof Flushable) {
        ((Flushable) getHistory()).flush();
    }
    return line;
}
 

import java.io.Flushable; //导入依赖的package包/类
@Override
public void handleNotification(Notification notification, Object handback) {
  if(!notification.getType().equals(MemoryNotificationInfo.MEMORY_THRESHOLD_EXCEEDED)) return;
  logger.info("MemoryNotifier::activate");

  //--- copy the list of listener's  in a thread-safe way; doesn't matter if we get an update while we're notifying this way.
  final List<Flushable> toNotify = new ArrayList<>();
  synchronized (instance) {
    toNotify.addAll(listeners);
  }

  //--- spawn a thread to handle flushing; don't do multiple because threads can be heavy on the memory usage.
  Thread deferred = new Thread() {
    public void run() {
      for (final Flushable flushable : toNotify) {
        try {
          flushable.flush();
        } catch (IOException e) {
          e.printStackTrace();
        }
      }
    }
  };
  deferred.start();
}
 

import java.io.Flushable; //导入依赖的package包/类
/**
 * Test method flush
 */
@Test
public void testFlush ()
{
  // flush null stream
  assertFalse (StreamHelper.flush ((Flushable) null).isSuccess ());

  // flush stream with exception
  assertFalse (StreamHelper.flush (new MockThrowingFlushable ()).isSuccess ());

  // flush without exception
  assertTrue (StreamHelper.flush (new MockFlushable ()).isSuccess ());

  final MockCloseableWithState c = new MockCloseableWithState ();
  assertTrue (StreamHelper.flush (c).isSuccess ());
  assertFalse (c.isClosed ());
  assertTrue (c.isFlushed ());

  StreamHelper.close (new FilterOutputStream (null));
}
 

import java.io.Flushable; //导入依赖的package包/类
/**
 * @tests java.util.Formatter#flush()
 */
public void test_flush() throws IOException {
    Formatter f = null;
    f = new Formatter(notExist);
    assertTrue(f instanceof Flushable);
    f.close();
    try {
        f.flush();
        fail("should throw FormatterClosedException");
    } catch (FormatterClosedException e) {
        // expected
    }

    f = new Formatter();
    // For destination that does not implement Flushable
    // No exception should be thrown
    f.flush();
}
 

import java.io.Flushable; //导入依赖的package包/类
public static void flush(Flushable paramFlushable, boolean paramBoolean)
  throws IOException
{
  try
  {
    paramFlushable.flush();
    return;
  }
  catch (IOException localIOException)
  {
    if (paramBoolean)
    {
      logger.log(Level.WARNING, "IOException thrown while flushing Flushable.", localIOException);
      return;
    }
  }
  throw localIOException;
}
 

import java.io.Flushable; //导入依赖的package包/类
@Test
public void testAppendAndFlush() throws Exception {
  final StringBuilder progress = new StringBuilder();
  Flushable flushable =
      new Flushable() {
        @Override
        public void flush() {
          progress.append("F");
        }
      };

  CountingFlushableAppendable c = new CountingFlushableAppendable(progress, flushable);
  assertThat(c.getAppendedCountSinceLastFlush()).isEqualTo(0);
  c.append("12");
  assertThat(c.getAppendedCountSinceLastFlush()).isEqualTo(2);
  c.append("3");
  assertThat(c.getAppendedCountSinceLastFlush()).isEqualTo(3);
  c.flush();
  assertThat(c.getAppendedCountSinceLastFlush()).isEqualTo(0);
  c.append('c');
  assertThat(c.getAppendedCountSinceLastFlush()).isEqualTo(1);
  c.append("123", 1, 2);
  assertThat(progress.toString()).isEqualTo("123Fc2");
}
 

import java.io.Flushable; //导入依赖的package包/类
@Override
public synchronized void flush() {
	// thread safe flush of the writers
	if (writer != null) {
		writer.flush();
	}
	if (this.callback instanceof Flushable) {
		try {
			((Flushable) callback).flush();
		}
		catch (final IOException e) {
			LOGGER.error(
					"Cannot flush callbacks",
					e);
		}
	}
}
 

import java.io.Flushable; //导入依赖的package包/类
public AnsiConsole(Appendable target, Flushable flushable, ColorMap colorMap, boolean forceAnsi) {
    this.target = target;
    this.flushable = flushable;
    this.colorMap = colorMap;
    textArea = new TextAreaImpl(textCursor);
    statusBar = new LabelImpl(statusBarCursor);
    this.forceAnsi = forceAnsi;
}
 

import java.io.Flushable; //导入依赖的package包/类
public static void flushQuietly(Flushable flushable) {
    if (flushable == null) return;
    try {
        flushable.flush();
    } catch (Exception e) {
        OkLogger.printStackTrace(e);
    }
}