dataUsageCacheVerV5      = 5
	dataUsageCacheVerV4      = 4
	dataUsageCacheVerV3      = 3
	dataUsageCacheVerV2      = 2
	dataUsageCacheVerV1      = 1
)

// serialize the contents of the cache.
func (d *dataUsageCache) serializeTo(dst io.Writer) error {
	// Add version and compress.
	_, err := dst.Write([]byte{dataUsageCacheVerCurrent})
	if err != nil {
		return err
	}
	enc, err := zstd.NewWriter(dst,

	if err != nil {
		t.Fatal(err)
	}
	e := want.find("abucket/dir2")
	want.replace("abucket/dir2", "", *e)
	var buf bytes.Buffer
	err = want.serializeTo(&buf)
	if err != nil {
		t.Fatal(err)
	}
	t.Log("serialized size:", buf.Len(), "bytes")
	var got dataUsageCache
	err = got.deserialize(&buf)
	if err != nil {
		t.Fatal(err)
	}
	if got.Info.LastUpdate.IsZero() {

import com.esotericsoftware.kryo.io.Output;

/**
 * A serializer class for handling object serialization and deserialization.
 * <p>
 * This class provides serialization capabilities using different serializers,
 * currently supporting Kryo and JavaBin serialization formats. The serializer
 * type is determined by the crawler data serializer configuration.
 * </p>
 * <p>

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
}

   *
   * @return the re-serialized object
   * @throws RuntimeException if the specified object was not successfully serialized or
   *     deserialized
   */
  @CanIgnoreReturnValue
  public static <T> T reserialize(T object) {
    return Platform.reserialize(object);
  }

  /**
   * Serializes and deserializes the specified object and verifies that the re-serialized object is

    }

    private static final int BYTE_ARRAY_SIZE = 8 * 1024;

    /**
     * Tests if the object can be serialized.
     *
     * @param obj the object to be serialized (must not be {@literal null})
     * @return the deserialized object
     */
    public static Object serialize(final Object obj) {
        assertArgumentNotNull("obj", obj);

        final byte[] binary = fromObjectToBinary(obj);

		if err != nil {
			return keys, err
		}
	}
	return keys, nil
}

// serialize will serialize the provided keys and values.
// The function will panic if keys/value slices aren't of equal length.
// Payload size can give an indication of expected payload size.
// If plSize is <= 0 it will be calculated.
func (x *xlMetaInlineData) serialize(plSize int, keys [][]byte, vals [][]byte) {
	if len(keys) != len(vals) {

 * serialize collections that are defined elsewhere.
 *
 * @author Jared Levy
 */
@GwtIncompatible
@J2ktIncompatible
final class Serialization {
  private Serialization() {}

  /**
   * Reads a count corresponding to a serialized map, multiset, or multimap. It returns the size of

    }

    /**
     * Serialize the inbound Model instance to a StringWriter, perform the regex replacement to resolve
     * POM expressions, then re-parse into the resolved Model instance.
     * <p>
     * <b>NOTE:</b> This will result in a different instance of Model being returned!!!
     *
     * @param model The inbound Model instance, to serialize and reference for expression resolution

 * serialize collections that are defined elsewhere.
 *
 * @author Jared Levy
 */
@GwtIncompatible
@J2ktIncompatible
final class Serialization {
  private Serialization() {}

  /**
   * Reads a count corresponding to a serialized map, multiset, or multimap. It returns the size of