* iterator} method only once, and should be tested using this class. Exceptions to this rule should
 * be clearly documented.
 *
 * <p>Note that although your APIs should be liberal in what they accept, your methods which
 * <i>return</i> iterables should make every attempt to return ones of the robust variety.
 *
 * <p>This testing utility is not thread-safe.
 *
 * @author Kevin Bourrillion
 */

        return indexOf(value) >= 0;
    }

    /**
     * 値に対するインデックスを返します。
     *
     * @param value
     *            値
     * @return 値に対するインデックス。値が含まれていない場合は{@literal -1}
     */
    public int indexOf(final Object value) {
        if (value != null) {
            for (int i = 0; i < size; i++) {
                if (value.equals(listTable[i].value)) {

    /**
     * <code>type</code>の原型が<code>clazz</code>に代入可能であれば<code>true</code>を、
     * それ以外の場合は<code>false</code>を返します。
     *
     * @param type
     *            タイプ。{@literal null}であってはいけません
     * @param clazz
     *            クラス。{@literal null}であってはいけません
     * @return <code>type</code>の原型が<code>clazz</code>に代入可能であれば<code>true</code>
     */
    public static boolean isTypeOf(final Type type, final Class<?> clazz) {

	nameAddr := p.address(operands[0])
	if !p.validSymbol("TEXT", &nameAddr, false) {
		return
	}
	name := symbolName(&nameAddr)
	next := 1

	// Next operand is the optional text flag, a literal integer.
	var flag = int64(0)
	if len(operands) == 3 {
		flag = p.evalInteger("TEXT", operands[1])
		next++
	}

	// Issue an error if we see a function defined as ABIInternal

 *   private final String city;
 *   private final String state;
 *   private final String zipcode;
 *
 *   public Address(String city, String state, String zipcode) {...}
 *
 *   {@literal @Override} public boolean equals(Object obj) {...}
 *   {@literal @Override} public int hashCode() {...}
 *   ...
 * }
 * </pre>
 *
 * <p>No cascading checks are performed against the return values of methods unless the method is a

          }
          else -> {
            // No header name.
            addLenient("", line)
          }
        }
      }

    /** Add an header line containing a field name, a literal colon, and a value. */
    fun add(line: String) =
      apply {
        val index = line.indexOf(':')
        require(index != -1) { "Unexpected header: $line" }

	// literal to evaluate the arguments at the right time.
	//    defer func() func() {
	//            _cgo0 := p
	//            return func() {
	//                    _cgoCheckPointer(_cgo0, nil)
	//                    C.f(_cgo0)
	//            }
	//    }()()
	// This works because the defer statement evaluates the first
	// function literal in order to get the function to call.

   */
  static @Nullable Object[] toArrayImpl(Collection<?> c) {
    return fillArray(c, new Object[c.size()]);
  }

  /**
   * Returns a copy of the specified subrange of the specified array that is literally an Object[],
   * and not e.g. a {@code String[]}.
   */
  static @Nullable Object[] copyAsObjectArray(@Nullable Object[] elements, int offset, int length) {

	switch e.getFunctionName() {
	case aggFnCount, aggFnAvg, aggFnMax, aggFnMin, aggFnSum:
		return e.getAggregate()
	default:
		return e.evalSQLFnNode(r, tableAlias)
	}
}

// evalNode on a literal value is independent of the node being an
// aggregation or a row function - it always returns a value.
func (e *LitValue) evalNode(_ Record) (res *Value, err error) {
	switch {
	case e.Int != nil:

		statusCode: 400,
		cause:      err,
	}
}

func errLexerInvalidOperator(err error) *s3Error {
	return &s3Error{
		code:       "LexerInvalidOperator",
		message:    "The SQL expression contains an invalid literal.",
		statusCode: 400,
		cause:      err,
	}
}

func errLexerInvalidLiteral(err error) *s3Error {
	return &s3Error{
		code:       "LexerInvalidLiteral",