ComplexDataStructure.java example

Explorer
haze-master
- hazelcast-master
/*
 * Copyright (c) 2008-2017, Hazelcast, Inc. All Rights Reserved.
 *
 * 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 com.hazelcast.query.impl.extractor.specification;

import com.hazelcast.nio.serialization.Portable;
import com.hazelcast.nio.serialization.PortableFactory;
import com.hazelcast.nio.serialization.PortableReader;
import com.hazelcast.nio.serialization.PortableWriter;
import com.hazelcast.test.ObjectTestUtils;

import java.io.IOException;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

import static com.hazelcast.query.impl.extractor.AbstractExtractionSpecification.PortableAware;

/**
 * Data structure used in the tests of extraction in multi-value attributes (in collections and arrays)
 * Each multi-value attribute is present as both an array and as a collection, for example:
 * limbs_list & limbs_array, so that both extraction in arrays and in collections may be tested.
 */
public class ComplexDataStructure {

    public static class Person implements Serializable, PortableAware {
        String name;
        List<Limb> limbs_list = new ArrayList<Limb>();
        Limb[] limbs_array;
        Limb firstLimb;
        Limb secondLimb;

        transient PersonPortable portable;

        public String getName() {
            return name;
        }

        public Limb getFirstLimb() {
            return firstLimb;
        }

        @Override
        public boolean equals(Object o) {
            if (!(o instanceof Person)) {
                return false;
            }
            final Person other = (Person) o;
            return ObjectTestUtils.equals(this.name, other.name) && ObjectTestUtils.equals(this.limbs_list, other.limbs_list);
        }

        @Override
        public int hashCode() {
            return ObjectTestUtils.hash(name, limbs_list);
        }

        public PersonPortable getPortable() {
            return portable;
        }
    }

    public static class PersonPortable implements Serializable, Portable {

        static final int FACTORY_ID = 1;
        static final int ID = 10;

        String name;
        Portable[] limbs_portable;
        LimbPortable firstLimb;
        LimbPortable secondLimb;

        @Override
        public boolean equals(Object o) {
            if (!(o instanceof PersonPortable)) {
                return false;
            }
            final PersonPortable other = (PersonPortable) o;
            return ObjectTestUtils.equals(this.name, other.name);
        }

        @Override
        public int hashCode() {
            return ObjectTestUtils.hash(name);
        }

        @Override
        public int getFactoryId() {
            return FACTORY_ID;
        }

        @Override
        public int getClassId() {
            return ID;
        }

        @Override
        public void writePortable(PortableWriter writer) throws IOException {
            writer.writeUTF("name", name);
            writer.writePortableArray("limbs_portable", limbs_portable);
            writer.writePortable("firstLimb", firstLimb);
            writer.writePortable("secondLimb", secondLimb);
        }

        @Override
        public void readPortable(PortableReader reader) throws IOException {
            name = reader.readUTF("name");
            limbs_portable = reader.readPortableArray("limbs_portable");
            firstLimb = reader.readPortable("firstLimb");
            secondLimb = reader.readPortable("secondLimb");
        }
    }

    public static class Limb implements Serializable, PortableAware, Comparable<Limb> {
        String name;
        List<Finger> fingers_list = new ArrayList<Finger>();
        Finger[] fingers_array;
        List<String> tattoos_list = new ArrayList<String>();
        String[] tattoos_array;

        public String getName() {
            return name;
        }

        transient LimbPortable portable;

        @Override
        public boolean equals(Object o) {
            if (!(o instanceof Limb)) {
                return false;
            }
            final Limb other = (Limb) o;
            return ObjectTestUtils.equals(this.name, other.name) && ObjectTestUtils.equals(this.fingers_list, other.fingers_list)
                    && ObjectTestUtils.equals(this.tattoos_list, other.tattoos_list);
        }

        @Override
        public int hashCode() {
            return ObjectTestUtils.hash(name, fingers_list, tattoos_list);
        }

        public LimbPortable getPortable() {
            return portable;
        }

        @Override
        public int compareTo(Limb other) {
            return this.name.compareTo(other.name);
        }
    }

    public static class LimbPortable implements Serializable, Portable, Comparable<LimbPortable> {
        static final int FACTORY_ID = 1;
        static final int ID = 11;

        String name;
        Portable[] fingers_portable;
        String[] tattoos_portable;

        @Override
        public boolean equals(Object o) {
            if (!(o instanceof LimbPortable)) {
                return false;
            }
            final LimbPortable other = (LimbPortable) o;
            return ObjectTestUtils.equals(this.name, other.name);
        }

        @Override
        public int hashCode() {
            return ObjectTestUtils.hash(name);
        }

        @Override
        public int getFactoryId() {
            return FACTORY_ID;
        }

        @Override
        public int getClassId() {
            return ID;
        }

        @Override
        public void writePortable(PortableWriter writer) throws IOException {
            writer.writeUTF("name", name);
            writer.writePortableArray("fingers_portable", fingers_portable);
            writer.writeUTFArray("tattoos_portable", tattoos_portable);
        }

        @Override
        public void readPortable(PortableReader reader) throws IOException {
            name = reader.readUTF("name");
            fingers_portable = reader.readPortableArray("fingers_portable");
            tattoos_portable = reader.readUTFArray("tattoos_portable");
        }

        @Override
        public int compareTo(LimbPortable other) {
            return this.name.compareTo(other.name);
        }
    }

    public static class Finger implements Serializable, Comparable<Finger>, PortableAware {
        String name;
        transient FingerPortable portable;

        @Override
        public boolean equals(Object o) {
            if (!(o instanceof Finger)) {
                return false;
            }
            final Finger other = (Finger) o;
            return ObjectTestUtils.equals(this.name, other.name);
        }

        @Override
        public int hashCode() {
            return ObjectTestUtils.hashCode(name);
        }

        @Override
        public int compareTo(Finger o) {
            if (o == null || this.name == null || o.name == null) {
                return -1;
            }
            return this.name.compareTo(o.name);
        }

        public FingerPortable getPortable() {
            return portable;
        }
    }

    public static class FingerPortable implements Serializable, Comparable<FingerPortable>, Portable {
        static final int FACTORY_ID = 1;
        static final int ID = 12;

        String name;

        @Override
        public boolean equals(Object o) {
            if (!(o instanceof FingerPortable)) {
                return false;
            }
            final FingerPortable other = (FingerPortable) o;
            return ObjectTestUtils.equals(this.name, other.name);
        }

        @Override
        public int hashCode() {
            return ObjectTestUtils.hashCode(name);
        }

        @Override
        public int compareTo(FingerPortable o) {
            if (o == null || this.name == null || o.name == null) {
                return -1;
            }
            return this.name.compareTo(o.name);
        }

        @Override
        public int getFactoryId() {
            return FACTORY_ID;
        }

        @Override
        public int getClassId() {
            return ID;
        }

        @Override
        public void writePortable(PortableWriter writer) throws IOException {
            writer.writeUTF("name", name);
        }

        @Override
        public void readPortable(PortableReader reader) throws IOException {
            name = reader.readUTF("name");
        }
    }

    public static Finger finger(String name) {
        FingerPortable portable = new FingerPortable();
        portable.name = name;

        Finger finger = new Finger();
        finger.name = name;
        finger.portable = portable;
        return finger;
    }

    public static List<String> tattoos(String... tattoos) {
        return Arrays.asList(tattoos);
    }

    public static Limb limb(String name, List<String> tattoos, Finger... fingers) {
        Limb limb = new Limb();
        limb.name = name;
        if (tattoos == null) {
            limb.tattoos_list = null;
            limb.tattoos_array = null;
        } else {
            limb.tattoos_list.addAll(tattoos);
            limb.tattoos_array = new String[tattoos.size()];
            int i = 0;
            for (String tattoo : tattoos) {
                limb.tattoos_array[i++] = tattoo;
            }
        }
        if (fingers.length == 0) {
            limb.fingers_list = null;
            limb.fingers_array = null;
        } else {
            limb.fingers_list.addAll(Arrays.asList(fingers));
            limb.fingers_array = fingers;
        }

        setupLimbPortable(limb);
        return limb;
    }

    private static void setupLimbPortable(Limb limb) {
        LimbPortable portable = new LimbPortable();
        portable.name = limb.name;
        if (limb.fingers_array != null) {
            portable.fingers_portable = new Portable[limb.fingers_array.length];
            for (int i = 0; i < limb.fingers_array.length; i++) {
                portable.fingers_portable[i] = limb.fingers_array[i].getPortable();
            }
        }
        portable.tattoos_portable = limb.tattoos_array;
        limb.portable = portable;
    }

    public static Person person(String name, Limb... limbs) {
        Person person = new Person();
        person.name = name;
        if (limbs.length > 0) {
            person.limbs_list.addAll(Arrays.asList(limbs));
        } else {
            person.limbs_list = null;
        }
        if (limbs.length > 0) {
            person.firstLimb = limbs[0];
        }
        if (limbs.length > 1) {
            person.secondLimb = limbs[1];
        }
        person.limbs_array = limbs;
        setupPersonPortable(person);
        return person;
    }

    private static void setupPersonPortable(Person person) {
        PersonPortable portable = new PersonPortable();
        portable.name = person.name;
        portable.firstLimb = person.firstLimb != null ? person.firstLimb.getPortable() : null;
        portable.secondLimb = person.secondLimb != null ? person.secondLimb.getPortable() : null;

        if (person.limbs_array != null) {
            portable.limbs_portable = new Portable[person.limbs_array.length];
            for (int i = 0; i < person.limbs_array.length; i++) {
                portable.limbs_portable[i] = person.limbs_array[i].getPortable();
            }
        }

        person.portable = portable;
    }

    static class PersonPortableFactory implements PortableFactory {
        static final int ID = 1;

        @Override
        public Portable create(int classId) {
            if (PersonPortable.ID == classId) {
                return new PersonPortable();
            } else if (LimbPortable.ID == classId) {
                return new LimbPortable();
            } else if (FingerPortable.ID == classId) {
                return new FingerPortable();
            } else {
                return null;
            }
        }
    }

}