apache-mime4j-0.6/src/main/java/org/apache/james/mime4j/util/StringArrayMap.java

/****************************************************************
 * Licensed to the Apache Software Foundation (ASF) under one   *
 * or more contributor license agreements.  See the NOTICE file *
 * distributed with this work for additional information        *
 * regarding copyright ownership.  The ASF licenses this file   *
 * to you 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 org.apache.james.mime4j.util;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.NoSuchElementException;

import org.apache.james.mime4j.message.Header;
import org.apache.james.mime4j.parser.ContentHandler;
import org.apache.james.mime4j.parser.Field;

/**
 * An object, which may be used to implement header, or parameter
 * maps. The maps keys are the header or parameter names. The
 * maps values are strings (single value), lists, or arrays.
 * <p>
 * Note that this class is not directly used anywhere in Mime4j.
 * Instead a user might choose to use it instead of {@link Header}
 * and {@link Field} in a custom {@link ContentHandler} implementation.
 * See also MIME4j-24.
 */
public class StringArrayMap implements Serializable {
    private static final long serialVersionUID = -5833051164281786907L;
    private final Map<String, Object> map = new HashMap<String, Object>();

    /**
     * <p>Converts the given object into a string. The object may be either of:
     * <ul>
     *   <li>a string, which is returned without conversion</li>
     *   <li>a list of strings, in which case the first element is returned</li>
     *   <li>an array of strings, in which case the first element is returned</li>
     * </ul>
     */
    public static String asString(Object pValue) {
        if (pValue == null) {
            return null;
        }
        if (pValue instanceof String) {
            return (String) pValue;
        }
        if (pValue instanceof String[]) {
            return ((String[]) pValue)[0];
        }
        if (pValue instanceof List) {
            return (String) ((List<?>) pValue).get(0);
        }
        throw new IllegalStateException("Invalid parameter class: " + pValue.getClass().getName());
    }

    /**
     * <p>Converts the given object into a string array. The object may be either of:
     * <ul>
     *   <li>a string, which is returned as an array with one element</li>
     *   <li>a list of strings, which is being converted into a string array</li>
     *   <li>an array of strings, which is returned without conversion</li>
     * </ul>
     */
    public static String[] asStringArray(Object pValue) {
        if (pValue == null) {
            return null;
        }
        if (pValue instanceof String) {
            return new String[]{(String) pValue};
        }
        if (pValue instanceof String[]) {
            return (String[]) pValue;
        }
        if (pValue instanceof List) {
            final List<?> l = (List<?>) pValue;
            return l.toArray(new String[l.size()]);
        }
        throw new IllegalStateException("Invalid parameter class: " + pValue.getClass().getName());
    }

    /**
     * <p>Converts the given object into a string enumeration. The object may be either of:
     * <ul>
     *   <li>a string, which is returned as an enumeration with one element</li>
     *   <li>a list of strings, which is being converted into a string enumeration</li>
     *   <li>an array of strings, which is being converted into a string enumeration</li>
     * </ul>
     */
    public static Enumeration<String> asStringEnum(final Object pValue) {
        if (pValue == null) {
            return null;
        }
        if (pValue instanceof String) {
            return new Enumeration<String>(){
                private Object value = pValue;
                public boolean hasMoreElements() {
                    return value != null;
                }
                public String nextElement() {
                    if (value == null) {
                        throw new NoSuchElementException();
                    }
                    final String s = (String) value;
                    value = null;
                    return s;
                }
            };
        }
        if (pValue instanceof String[]) {
            final String[] values = (String[]) pValue;
            return new Enumeration<String>() {
                private int offset;
                public boolean hasMoreElements() {
                    return offset < values.length;
                }
                public String nextElement() {
                    if (offset >= values.length) {
                        throw new NoSuchElementException();
                    }
                    return values[offset++];
                }
            };
        }
        if (pValue instanceof List) {
            @SuppressWarnings("unchecked")
            final List<String> stringList = (List<String>) pValue; 
            return Collections.enumeration(stringList);
        }
        throw new IllegalStateException("Invalid parameter class: " + pValue.getClass().getName());
    }

    /**
     * Converts the given map into a string array map: The map values
     * are string arrays.
     */
    public static Map<String, String[]> asMap(final Map<String, Object> pMap) {
        Map<String, String[]> result = new HashMap<String, String[]>(pMap.size());
        for (Map.Entry<String, Object> entry : pMap.entrySet()) {
            final String[] value = asStringArray(entry.getValue());
            result.put(entry.getKey(), value);
        }
        return Collections.unmodifiableMap(result);
    }

    /**
     * Adds a value to the given map.
     */
    protected void addMapValue(Map<String, Object> pMap, String pName, String pValue) {
        Object o = pMap.get(pName);
        if (o == null) {
            o = pValue;
        } else if (o instanceof String) {
            final List<Object> list = new ArrayList<Object>();
            list.add(o);
            list.add(pValue);
            o = list;
        } else if (o instanceof List) {
            @SuppressWarnings("unchecked")
            final List<String> stringList = (List<String>) o; 
            stringList.add(pValue);
        } else if (o instanceof String[]) {
            final List<String> list = new ArrayList<String>();
            final String[] arr = (String[]) o;
            for (String str : arr) {
                list.add(str);
            }
            list.add(pValue);
            o = list;
        } else {
            throw new IllegalStateException("Invalid object type: " + o.getClass().getName());
        }
        pMap.put(pName, o);
    }

    /**
     * Lower cases the given name.
     */
    protected String convertName(String pName) {
        return pName.toLowerCase();
    }

    /**
     * Returns the requested value.
     */
    public String getValue(String pName) {
        return asString(map.get(convertName(pName)));
    }

    /**
     * Returns the requested values as a string array.
     */
    public String[] getValues(String pName) {
        return asStringArray(map.get(convertName(pName)));
    }

    /**
     * Returns the requested values as an enumeration.
     */
    public Enumeration<String> getValueEnum(String pName) {
        return asStringEnum(map.get(convertName(pName)));
    }

    /**
     * Returns the set of registered names as an enumeration.
     * @see #getNameArray()
     */
    public Enumeration<String> getNames() {
        return Collections.enumeration(map.keySet());
    }

    /**
     * Returns an unmodifiable map of name/value pairs. The map keys
     * are the lower cased parameter/header names. The map values are
     * string arrays.
     */
    public Map<String, String[]> getMap() {
        return asMap(map);
    }

    /**
     * Adds a new name/value pair.
     */
    public void addValue(String pName, String pValue) {
        addMapValue(map, convertName(pName), pValue);
    }

    /**
     * Returns the set of registered names.
     * @see #getNames()
     */
    public String[] getNameArray() {
        final Collection<String> c = map.keySet();
        return c.toArray(new String[c.size()]);
    }
}