Hello River Folk,

This is a concept test class, for testing a Public Serialization API, for supporting alternative serialization frameworks.  Note this doesn't implement Serializable for clarity.

--
Regards,
Peter

/*
 * Copyright 2021 The Apache Software Foundation.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package tests.support;

import java.io.IOException;
import java.io.ObjectStreamField;
import java.util.Arrays;
import java.util.Objects;
import org.apache.river.api.io.AtomicSerial;
import org.apache.river.api.io.AtomicSerial.GetArg;
import org.apache.river.api.io.AtomicSerial.PutArg;

/**
 *
 * @author peter
 */
@AtomicSerial
public class SerializableTestObject {

    /**
     * Names of serial fields.  Note how these names are unrelated to field
     * names.  If we refactor field names, and rename them, the Strings
     * representing serial fields don't change and the serial form of the
     * class is not broken.
     */
    private static final String TEST_STR = "testString";
    private static final String TEST_ARRY = "testArray";
    private static final String TEST_INT = "testInt";

    /**
     * serialPersistentFields.
     *
     * This method will be used by serialization frameworks to get names
     * and types of serial fields.  These will ensure type checking occurs
     * during de-serialization, fields will be de-serialized and created prior
     * to the instantiation of the parent object.
     *
     * @return array of ObjectStreamFields
     */
    public static ObjectStreamField [] serialPersistentFields() {
        return new ObjectStreamField []{
            new ObjectStreamField(TEST_STR, String.class),
            new ObjectStreamField(TEST_ARRY, long [].class),
            new ObjectStreamField(TEST_INT, int.class)
        };
    }

    public static void serialize(PutArg args, SerializableTestObject obj) throws IOException{
        args.put(TEST_STR, obj.str);
        args.put(TEST_ARRY, obj.longs);
        args.put(TEST_INT, obj.integer);
        args.writeFields();
    }

    /**
     * Invariant validation
     * @param args
     * @return
     * @throws IOException
     * @throws ClassNotFoundException
     */
    private static GetArg check(GetArg args) throws IOException, ClassNotFoundException{
        args.get(TEST_STR, null, String.class); // check String class type.
        args.get(TEST_ARRY, null, long [].class); // check array class type.         // don't need to test int class type, but if there are other invariants
        // we check them here.
        return args;
    }

    /**
     * AtomicSerial constructor.
     * @param args
     * @throws IOException
     * @throws ClassNotFoundException
     */
    public SerializableTestObject(GetArg args) throws IOException, ClassNotFoundException{
        this(check(args).get(TEST_STR, "default", String.class),
                    args.get(TEST_ARRY, new long [0], long [].class),
                    args.get(TEST_INT, 0)
                );
    }


    private final String str;
    private final long[] longs;
    private final int integer;


    public SerializableTestObject(String str, long [] longs, int integer){
        this.str = str;
        this.longs = longs.clone();
        this.integer = integer;
    }

    @Override
    public int hashCode() {
        int hash = 5;
        hash = 67 * hash + Objects.hashCode(this.str);
        hash = 67 * hash + Arrays.hashCode(this.longs);
        hash = 67 * hash + this.integer;
        return hash;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj) {
            return true;
        }
        if (obj == null) {
            return false;
        }
        if (getClass() != obj.getClass()) {
            return false;
        }
        final SerializableTestObject other = (SerializableTestObject) obj;
        if (this.integer != other.integer) {
            return false;
        }
        if (!Objects.equals(this.str, other.str)) {
            return false;
        }
        return Arrays.equals(this.longs, other.longs);
    }


}

Reply via email to