import org.gradle.internal.serialize.EncoderExtensions.writeLengthPrefixedShorts


object NonPrimitiveArrayCodec : Codec<Array<*>> {
    override suspend fun WriteContext.encode(value: Array<*>) {
        writeArray(value) { element ->
            write(element)
        }
    }

    override suspend fun ReadContext.decode(): Array<*> =
        readArray {
            read()
        }
}

        jsonWriter.beginArray();
        contents.write();
        endArray();
    }

    protected void beginArray(String name) throws IOException {
        jsonWriter.name(name);
        jsonWriter.beginArray();
    }

    protected void endArray() throws IOException {
        jsonWriter.endArray();
    }

    protected void writeObject(String name, Contents contents) throws IOException {

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.ide.xcode.fixtures

import com.dd.plist.NSArray
import com.dd.plist.NSDictionary
import com.dd.plist.NSObject
import com.dd.plist.NSString
import com.dd.plist.PropertyListParser
import com.google.common.base.MoreObjects

    private List<Object> readArray(JsonReader reader) {
        List<Object> values = []
        reader.beginArray()
        while (reader.peek() != JsonToken.END_ARRAY) {
            Object value = readAny(reader)
            values.add(value)
        }
        reader.endArray()
        return values
    }

    static Map<String, String> normalizeForTests(Map<String, ?> attributes) {

  public final Object[] toArray() {
    return toArray(EMPTY_ARRAY);
  }

  @CanIgnoreReturnValue
  @Override
  /*
   * This suppression is here for two reasons:
   *
   * 1. b/192354773 in our checker affects toArray declarations.
   *
   * 2. `other[size] = null` is unsound. We could "fix" this by requiring callers to pass in an

	func NewSlice3() [][][]T

	// NewSliceOfSlice is not a factory function because slices of a ...
	func NewSliceOfSlice() [][]T


TYPES
	// 
	type T struct{}

	// 
	func New() T

	// 
	func NewArray() [1]T

	// 
	func NewPointer() *T

	// 
	func NewPointerArray() [1]*T

	// 
	func NewPointerOfPointer() **T

	// 
	func NewPointerSlice() []*T

	// 

      this.upperBounds = JavaVersion.CURRENT.usedInGenericType(upperBounds);
    }

    @Override
    public Type[] getLowerBounds() {
      return toArray(lowerBounds);
    }

    @Override
    public Type[] getUpperBounds() {
      return toArray(upperBounds);
    }

    @Override
    public boolean equals(@CheckForNull Object obj) {
      if (obj instanceof WildcardType) {

    /**
     * Queries whether this object represents an array, generic or otherwise.
     *
     * @return true if this object represents an array.
     * @see #getComponentType()
     */
    public boolean isArray() {
        return type.isGenericArray()
            || (type.isClass() && rawClass().isArray());
    }

    /**
     * Returns the component type of the array type this object represents.
     *

                assert array.length == inserted;
                return new ImmutableUniqueList<T>(set, array);
            }

            private Object[] shrinkArray() {
                if (array.length == inserted) {
                    return array;
                }
                Object[] newArray = new Object[inserted];
                System.arraycopy(array, 0, newArray, 0, inserted);

                .startArray("result");

            for(String word: response.getWords()) {
                builder.value(word);
            }

            String json = builder.endArray()
                .endObject()
                .endArray()
                .endObject()
                .endObject().string();
            if(callback != null && callback.length > 0) {
                json = callback[0] + '(' + json + ')';