path: root/lib/jinterface/java_src/com/ericsson/otp/erlang/OtpErlangMap.java

/*
 * %CopyrightBegin%
 *
 * Copyright Ericsson AB 2000-2013. All Rights Reserved.
 *
 * The contents of this file are subject to the Erlang Public License,
 * Version 1.1, (the "License"); you may not use this file except in
 * compliance with the License. You should have received a copy of the
 * Erlang Public License along with this software. If not, it can be
 * retrieved online at http://www.erlang.org/.
 *
 * Software distributed under the License is distributed on an "AS IS"
 * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
 * the License for the specific language governing rights and limitations
 * under the License.
 *
 * %CopyrightEnd%
 */
package com.ericsson.otp.erlang;

import java.io.Serializable;

/**
 * Provides a Java representation of Erlang maps. Maps are created from one or
 * more arbitrary Erlang terms.
 * 
 * <p>
 * The arity of the map is the number of elements it contains. The keys and
 * values can be retrieved as arrays and the value for a key can be queried.
 * 
 */
public class OtpErlangMap extends OtpErlangObject implements Serializable,
	Cloneable {
    // don't change this!
    private static final long serialVersionUID = -6410770117696198497L;

    private static final OtpErlangObject[] NO_ELEMENTS = new OtpErlangObject[0];

    private OtpErlangObject[] keys = NO_ELEMENTS;
    private OtpErlangObject[] values = NO_ELEMENTS;

    /**
     * Create a map from an array of keys and an array of values.
     * 
     * @param keys
     *            the array of terms to create the map keys from.
     * @param values
     *            the array of terms to create the map values from.
     * 
     * @exception java.lang.IllegalArgumentException
     *                if any array is empty (null) or contains null elements.
     */
    public OtpErlangMap(final OtpErlangObject[] keys,
	    final OtpErlangObject[] values) {
	this(keys, 0, keys.length, values, 0, values.length);
    }

    /**
     * Create a map from an array of terms.
     * 
     * @param keys
     *            the array of terms to create the map from.
     * @param kstart
     *            the offset of the first key to insert.
     * @param kcount
     *            the number of keys to insert.
     * @param values
     *            the array of values to create the map from.
     * @param vstart
     *            the offset of the first value to insert.
     * @param vcount
     *            the number of values to insert.
     * 
     * @exception java.lang.IllegalArgumentException
     *                if any array is empty (null) or contains null elements.
     * @exception java.lang.IllegalArgumentException
     *                if kcount and vcount differ.
     */
    public OtpErlangMap(final OtpErlangObject[] keys, final int kstart,
	    final int kcount, final OtpErlangObject[] values, final int vstart,
	    final int vcount) {
	if (keys == null || values == null) {
	    throw new java.lang.IllegalArgumentException(
		    "Map content can't be null");
	} else if (kcount != vcount) {
	    throw new java.lang.IllegalArgumentException(
		    "Map keys and values must have same arity");
	} else if (vcount < 1) {
	    this.keys = NO_ELEMENTS;
	    this.values = NO_ELEMENTS;
	} else {
	    this.keys = new OtpErlangObject[vcount];
	    for (int i = 0; i < vcount; i++) {
		if (keys[kstart + i] != null) {
		    this.keys[i] = keys[kstart + i];
		} else {
		    throw new java.lang.IllegalArgumentException(
			    "Map key cannot be null (element" + (kstart + i)
				    + ")");
		}
	    }
	    this.values = new OtpErlangObject[vcount];
	    for (int i = 0; i < vcount; i++) {
		if (values[vstart + i] != null) {
		    this.values[i] = values[vstart + i];
		} else {
		    throw new java.lang.IllegalArgumentException(
			    "Map value cannot be null (element" + (vstart + i)
				    + ")");
		}
	    }
	}
    }

    /**
     * Create a map from a stream containing a map encoded in Erlang external
     * format.
     * 
     * @param buf
     *            the stream containing the encoded map.
     * 
     * @exception OtpErlangDecodeException
     *                if the buffer does not contain a valid external
     *                representation of an Erlang map.
     */
    public OtpErlangMap(final OtpInputStream buf)
	    throws OtpErlangDecodeException {
	final int arity = buf.read_map_head();

	if (arity > 0) {
	    keys = new OtpErlangObject[arity];
	    values = new OtpErlangObject[arity];

	    for (int i = 0; i < arity; i++) {
		keys[i] = buf.read_any();
		values[i] = buf.read_any();
	    }
	} else {
	    keys = NO_ELEMENTS;
	    values = NO_ELEMENTS;
	}
    }

    /**
     * Get the arity of the map.
     * 
     * @return the number of elements contained in the map.
     */
    public int arity() {
	return keys.length;
    }

    /**
     * Get the specified value from the map.
     * 
     * @param key
     *            the key of the requested value.
     * 
     * @return the requested value, of null if key is not a valid key.
     */
    public OtpErlangObject get(final OtpErlangObject key) {
	if (key == null) {
	    return null;
	}
	for (int i = 0; i < keys.length; i++) {
	    if (key.equals(keys[i])) {
		return values[i];
	    }
	}
	return null;
    }

    /**
     * Get all the keys from the map as an array.
     * 
     * @return an array containing all of the map's keys.
     */
    public OtpErlangObject[] keys() {
	final OtpErlangObject[] res = new OtpErlangObject[arity()];
	System.arraycopy(keys, 0, res, 0, res.length);
	return res;
    }

    /**
     * Get all the values from the map as an array.
     * 
     * @return an array containing all of the map's values.
     */
    public OtpErlangObject[] values() {
	final OtpErlangObject[] res = new OtpErlangObject[arity()];
	System.arraycopy(values, 0, res, 0, res.length);
	return res;
    }

    /**
     * Get the string representation of the map.
     * 
     * @return the string representation of the map.
     */
    @Override
    public String toString() {
	int i;
	final StringBuffer s = new StringBuffer();
	final int arity = values.length;

	s.append("#{");

	for (i = 0; i < arity; i++) {
	    if (i > 0) {
		s.append(",");
	    }
	    s.append(keys[i].toString());
	    s.append(" => ");
	    s.append(values[i].toString());
	}

	s.append("}");

	return s.toString();
    }

    /**
     * Convert this map to the equivalent Erlang external representation.
     * 
     * @param buf
     *            an output stream to which the encoded map should be written.
     */
    @Override
    public void encode(final OtpOutputStream buf) {
	final int arity = values.length;

	buf.write_map_head(arity);

	for (int i = 0; i < arity; i++) {
	    buf.write_any(keys[i]);
	    buf.write_any(values[i]);
	}
    }

    /**
     * Determine if two maps are equal. Maps are equal if they have the same
     * arity and all of the elements are equal.
     * 
     * @param o
     *            the map to compare to.
     * 
     * @return true if the maps have the same arity and all the elements are
     *         equal.
     */
    @Override
    public boolean equals(final Object o) {
	if (!(o instanceof OtpErlangMap)) {
	    return false;
	}

	final OtpErlangMap t = (OtpErlangMap) o;
	final int a = arity();

	if (a != t.arity()) {
	    return false;
	}

	for (int i = 0; i < a; i++) {
	    if (!keys[i].equals(t.keys[i])) {
		return false; // early exit
	    }
	}
	for (int i = 0; i < a; i++) {
	    if (!values[i].equals(t.values[i])) {
		return false; // early exit
	    }
	}

	return true;
    }

    @Override
    protected int doHashCode() {
	final OtpErlangObject.Hash hash = new OtpErlangObject.Hash(9);
	final int a = arity();
	hash.combine(a);
	for (int i = 0; i < a; i++) {
	    hash.combine(keys[i].hashCode());
	}
	for (int i = 0; i < a; i++) {
	    hash.combine(values[i].hashCode());
	}
	return hash.valueOf();
    }

    @Override
    public Object clone() {
	final OtpErlangMap newMap = (OtpErlangMap) super.clone();
	newMap.values = values.clone();
	return newMap;
    }
}