var serializerMap = sync.Map{}

// RegisterSerializer register serializer
func RegisterSerializer(name string, serializer SerializerInterface) {
	serializerMap.Store(strings.ToLower(name), serializer)
}

// GetSerializer get serializer
func GetSerializer(name string) (serializer SerializerInterface, ok bool) {
	v, ok := serializerMap.Load(strings.ToLower(name))
	if ok {
		serializer, ok = v.(SerializerInterface)
	}
	return serializer, ok
}

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.gradle.internal.serialize;

import java.io.EOFException;

public interface Serializer<T> {
    /**
     * Reads the next object from the given stream. The implementation must not perform any buffering, so that it reads only those bytes from the input stream that are

        serialize(123L, serializer) == 123L
        serialize(123, serializer) == 123
        serialize(123.4, serializer) == 123.4
    }

    def "custom serialization takes precedence over Java serialization"() {
        given:
        def customSerializer = Stub(Serializer) {
            read(_) >> { Decoder decoder ->
                return decoder.readSmallLong() + 1
            }

 */

package org.gradle.internal.serialize;

public class Serializers {
    public static <T> StatefulSerializer<T> stateful(final Serializer<T> serializer) {
        return new StatefulSerializerAdapter<T>(serializer);
    }

    private static class StatefulSerializerAdapter<T> implements StatefulSerializer<T> {
        private final Serializer<T> serializer;

        return fromBytes(bytes, serializer)
    }

    <T> T fromBytes(byte[] bytes, Serializer<T> serializer) {
        return serializer.read(getDecoder().newInstance(new ByteArrayInputStream(bytes)))
    }

    <T> byte[] toBytes(T value, Serializer<T> serializer) {
        def bytes = new ByteArrayOutputStream()
        def encoder = getEncoder().newInstance(bytes)
        serializer.write(encoder, value)
        encoder.flush()

 * limitations under the License.
 */

package org.gradle.internal.serialize;

public interface SerializerRegistry {
    /**
     * Use the given serializer for objects of the given type.
     * <p>
     * The provided serializer must be thread-safe and reusable.
     */
    <T> void register(Class<T> implementationType, Serializer<T> serializer);

    /**

        when:
        def serializer = new SetSerializer(BaseSerializerFactory.LONG_SERIALIZER)

        then:
        serialize([1L, 5L, 99L] as Set, serializer) as List == [1L, 5L, 99L]
    }

    def "serialize null entry"() {
        when:
        def serializer = new SetSerializer(stringSerializer)

        then:
        serialize(["one", null, "three"] as Set, serializer) as List == ["one", null, "three"]
    }

        result1 == "one"
        result2 == "two"
        1 * serializer.read(decoder) >> "one"
        1 * serializer.read(decoder) >> "two"
        0 * serializer._

        when:
        writer.write("one")
        writer.write("two")

        then:
        1 * serializer.write(encoder, "one")
        1 * serializer.write(encoder, "two")
        0 * serializer._
    }

    }

    def "serialize map"() {
        when:
        def serializer = new MapSerializer(BaseSerializerFactory.LONG_SERIALIZER, stringSerializer)

        then:
        serialize([1L: "one", 2L: "two", 3L: "three"], serializer) == [1L: "one", 2L: "two", 3L: "three"]
    }

    def "serialize null value"() {
        when:

        messageResult instanceof UserResponse
        messageResult.response == message.response
    }

    def "can serialize user input request event"() {
        expect:
        def event = new UserInputRequestEvent()
        def result = serialize(event, serializer)
        result instanceof UserInputRequestEvent
    }

    def "can serialize yes-no question prompt event"() {