Class StateWriter

  • All Implemented Interfaces:
    Closeable, Flushable, Appendable, AutoCloseable

    public final class StateWriter
    extends Writer
    A class for handling state insertion. Content is written directly to "out" until an attempt to write state; at that point, it's redirected into a buffer that can be picked through in theory, this buffer should be very small, since it only needs to be enough to contain all the content after the close of the first (and, hopefully, only) form.

    Potential optimizations:

    • If we created a new FastWriter at each call to writingState(), and stored a List of them, then we'd know that state tokens could only possibly be near the start of each buffer (and might not be there at all). (There might be a close-element before the state token). Then, we'd only need to check the start of the buffer for the state token; if it's there, write out the real state, then blast the rest of the buffer out. This wouldn't even require toString(), which for large buffers is expensive. However, this optimization is only going to be especially meaningful for the multi-form case.
    • More of a FastWriter optimization than a StateWriter, but: it is far faster to create a set of small 1K buffers than constantly reallocating one big buffer.
    Version:
    $Id$
    Author:
    Adam Winer
    • Constructor Detail

      • StateWriter

        public StateWriter​(Writer initialOut,
                           int initialSize)
      • StateWriter

        public StateWriter​(Writer initialOut,
                           int initialSize,
                           FacesContext facesContext)
    • Method Detail

      • getCurrentInstance

        public static StateWriter getCurrentInstance()
      • writingState

        public void writingState()
        Mark that state is about to be written. Contrary to what you'd expect, we cannot and should not assume that this location is really going to have state; it is perfectly legit to have a ResponseWriter that filters out content, and ignores an attempt to write out state at this point. So, we have to check after the fact to see if there really are state markers.
      • isStateWritten

        public boolean isStateWritten()
      • writingStateWithoutWrapper

        public void writingStateWithoutWrapper()
      • isStateWrittenWithoutWrapper

        public boolean isStateWrittenWithoutWrapper()
      • getAndResetBuffer

        public String getAndResetBuffer()
      • release

        public void release()
      • release

        public void release​(FacesContext facesContext)