class OrdinalNodeCodec(
    private val ordinalGroups: OrdinalGroupFactory
) : Codec<OrdinalNode> {
    override suspend fun WriteContext.encode(value: OrdinalNode) {
        writeEnum(value.type)
        writeInt(value.ordinalGroup.ordinal)
    }

    override suspend fun ReadContext.decode(): OrdinalNode {
        val ordinalType = readEnum<OrdinalNode.Type>()
        val ordinal = readInt()

import java.util.regex.Pattern


object RegexpPatternCodec : Codec<Pattern> {
    override suspend fun WriteContext.encode(value: Pattern) {
        writeString(value.pattern())
        writeInt(value.flags())
    }

    override suspend fun ReadContext.decode(): Pattern? {
        return Pattern.compile(readString(), readInt())
    }

        Class<?> targetClass = desc.forClass();
        writeClass(targetClass);
    }

    @Override
    protected void annotateProxyClass(Class<?> cl) throws IOException {
        writeInt(cl.getInterfaces().length);
        for (Class<?> type : cl.getInterfaces()) {
            writeClass(type);
        }
    }

    private void writeClass(Class<?> targetClass) throws IOException {

    }

    InputStream encoded(String text) {
        def stream = new ByteArrayOutputStream()
        def encoder = new KryoBackedEncoder(stream)
        encoder.writeString(text)
        encoder.writeInt(12)
        encoder.flush()
        return new ByteArrayInputStream(stream.toByteArray())
    }

            values.add(entrySerializer.read(decoder));
        }
        return values;
    }

    @Override
    public void write(Encoder encoder, C value) throws Exception {
        encoder.writeInt(value.size());
        for (T t : value) {
            entrySerializer.write(encoder, t);
        }
    }

            valueMap.put(key, value);
        }
        return valueMap;
    }

    @Override
    public void write(Encoder encoder, Map<U, V> value) throws Exception {
        encoder.writeInt(value.size());
        for (Map.Entry<U, V> entry : value.entrySet()) {
            keySerializer.write(encoder, entry.getKey());
            valueSerializer.write(encoder, entry.getValue());
        }
    }

        throw new UnsupportedOperationException();
    }

    @Override
    public void writeSmallInt(int value) throws IOException {
        writeInt(value);
    }

    @Override
    public void writeSmallLong(long value) throws IOException {
        writeLong(value);
    }

    @Override

		ix.sa.int32 = make([]int32, len(data))
		text_32(data, ix.sa.int32)
	} else {
		ix.sa.int64 = make([]int64, len(data))
		text_64(data, ix.sa.int64)
	}
	return ix
}

// writeInt writes an int x to w using buf to buffer the write.
func writeInt(w io.Writer, buf []byte, x int) error {
	binary.PutVarint(buf, int64(x))
	_, err := w.Write(buf[0:binary.MaxVarintLen64])
	return err
}

    void writeSmallLong(long value) throws IOException;

    /**
     * Writes a signed 32 bit int value. The implementation may encode the value as a variable number of bytes, not necessarily as 4 bytes.
     */
    void writeInt(int value) throws IOException;

    /**
     * Writes a signed 32 bit int value whose value is likely to be small and positive but may not be. The implementation may encode the value in a way that

        return StringValueSnapshot(value)
    }
}


object IntegerValueSnapshotCodec : Codec<IntegerValueSnapshot> {
    override suspend fun WriteContext.encode(value: IntegerValueSnapshot) {
        writeInt(value.value)
    }

    override suspend fun ReadContext.decode(): IntegerValueSnapshot {
        val value = readInt()
        return IntegerValueSnapshot(value)
    }
}