) {
  }

  /**
   * No further calls to this listener will be made.
   */
  open fun onClosed(eventSource: EventSource) {
  }

  /**
   * Invoked when an event source has been closed due to an error reading from or writing to the
   * network. Incoming events may have been lost. No further calls to this listener will be made.
   */
  open fun onFailure(
    eventSource: EventSource,
    t: Throwable?,

// license that can be found in the LICENSE file.

package lex

import (
	"text/scanner"

	"cmd/internal/src"
)

// A Stack is a stack of TokenReaders. As the top TokenReader hits EOF,
// it resumes reading the next one down.
type Stack struct {
	tr []TokenReader
}

// Push adds tr to the top (end) of the input stack. (Popping happens automatically.)
func (s *Stack) Push(tr TokenReader) {
	s.tr = append(s.tr, tr)
}

import okio.ByteString
import okio.ByteString.Companion.decodeHex
import okio.FileSystem
import okio.Path
import okio.Path.Companion.toOkioPath
import okio.buffer
import okio.source

/**
 * Utilities for reading HPACK tests.
 */
object HpackJsonUtil {
  @Suppress("unused")
  private val MOSHI =
    Moshi
      .Builder()
      .add(
        object : Any() {

        int bytesWritten = info.encode(buffer, 0);

        // Verify bytes written
        assertEquals(8, bytesWritten);

        // Verify encoded value
        long decodedValue = SMBUtil.readInt8(buffer, 0);
        assertEquals(endOfFile, decodedValue);
    }

    @Test
    @DisplayName("Test encode with offset")
    void testEncodeWithOffset() {
        long endOfFile = 0xFEDCBA9876543210L;

├── settings/                   # Configuration management
├── entity/                     # Domain models (SuggestItem, etc.)
├── normalizer/                 # Text normalizers
├── converter/                  # Reading converters (katakana, romaji)
├── concurrent/                 # Async patterns (Deferred/Promise)
└── util/                      # Utilities
```

### Key Design Patterns

 * governing permissions and limitations under the License.
 */
package org.codelibs.fess.suggest.converter;

import java.io.IOException;
import java.util.List;

/**
 * Interface for converting text into its reading form.
 */
public interface ReadingConverter {

    /**
     * Returns the maximum number of readings.
     *
     * @return the maximum number of readings, default is 10.
     */

    /**
     * The pipe should be opened only for writing.
     */

    int PIPE_TYPE_WRONLY = SmbConstants.O_WRONLY;

    /**
     * The pipe should be opened for both reading and writing.
     */

    int PIPE_TYPE_RDWR = SmbConstants.O_RDWR;

    /**
     * Pipe operations should behave like the <code>CallNamedPipe</code> Win32 Named Pipe function.
     */

     */
    @Override
    protected int readBytesWireFormat(final byte[] buffer, final int bufferIndex) throws SMBProtocolDecodingException {
        final int structureSize = SMBUtil.readInt2(buffer, bufferIndex);
        if (structureSize != 4) {
            throw new SMBProtocolDecodingException("Expected structureSize = 4");
        }
        return 4;
    }

     */
    @Override
    protected int readBytesWireFormat(final byte[] buffer, final int bufferIndex) throws SMBProtocolDecodingException {
        final int structureSize = SMBUtil.readInt2(buffer, bufferIndex);
        if (structureSize != 4) {
            throw new SMBProtocolDecodingException("Structure size != 4");
        }

        return 4;
    }

   */
  open fun onClosed(
    webSocket: WebSocket,
    code: Int,
    reason: String,
  ) {
  }

  /**
   * Invoked when a web socket has been closed due to an error reading from or writing to the
   * network. Both outgoing and incoming messages may have been lost. No further calls to this
   * listener will be made.
   */
  open fun onFailure(
    webSocket: WebSocket,
    t: Throwable,