Java tutorial
/* This file is part of Cyclos (www.cyclos.org). A project of the Social Trade Organisation (www.socialtrade.org). Cyclos is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. Cyclos is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with Cyclos; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ package nl.strohalm.cyclos.utils.binding; import java.util.ArrayList; import java.util.Collections; import java.util.HashMap; import java.util.Iterator; import java.util.LinkedHashMap; import java.util.List; import java.util.Map; import nl.strohalm.cyclos.utils.ClassHelper; import nl.strohalm.cyclos.utils.PropertyHelper; import org.apache.commons.collections.CollectionUtils; import org.apache.commons.collections.IteratorUtils; /** * A binder for maps * @author luis */ public class MapBinder<K, V> extends DataBinder<Map<K, V>> { private static final long serialVersionUID = -234513355349764092L; public static <K, V> MapBinder<K, V> instance(final DataBinder<K> keyBinder, final DataBinder<V> valueBinder) { return instance(keyBinder, valueBinder, null); } public static <K, V> MapBinder<K, V> instance(final DataBinder<K> keyBinder, final DataBinder<V> valueBinder, final String path) { final MapBinder<K, V> binder = new MapBinder<K, V>(keyBinder, valueBinder); binder.setPath(path); return binder; } private DataBinder<K> keyBinder; private DataBinder<V> valueBinder; public MapBinder() { final Class<Map<K, V>> clazz = ClassHelper.cast(Map.class); setType(clazz); } public MapBinder(final DataBinder<K> keyBinder, final DataBinder<V> valueBinder) { this(); setKeyBinder(keyBinder); setValueBinder(valueBinder); } public DataBinder<K> getKeyBinder() { return keyBinder; } public DataBinder<V> getValueBinder() { return valueBinder; } @Override public Map<K, V> read(final Object object) { final Map<K, V> ret = new LinkedHashMap<K, V>(); readInto(ret, object, false); return ret; } @Override public String readAsString(final Object object) { validateNestedBinders(); final StringBuilder sb = new StringBuilder(); sb.append('{'); for (final Iterator<?> it = IteratorUtils.getIterator(object); it.hasNext();) { final Object value = it.next(); sb.append(keyBinder.readAsString(value)).append('=').append(valueBinder.readAsString(value)); if (it.hasNext()) { sb.append(','); } } sb.append('}'); return sb.toString(); } @Override public Map<K, V> readFromString(final Object object) { validateNestedBinders(); final Map<K, V> ret = new LinkedHashMap<K, V>(); readInto(ret, object, true); return ret; } public void readInto(final Map<K, V> map, final Object object, final boolean asString) { validateNestedBinders(); Iterator<Object> elements = null; final Object bean = PropertyHelper.get(object, getPath()); // if (isReadFlat()) { // In this case we have separate properties, each one with a collection of values of a single property. int maxSize = 0; final List<Object> keyValues = new ArrayList<Object>(); final List<Object> valueValues = new ArrayList<Object>(); Object obj = PropertyHelper.get(bean, keyBinder.getPath()); CollectionUtils.addAll(keyValues, IteratorUtils.getIterator(obj)); obj = PropertyHelper.get(bean, valueBinder.getPath()); CollectionUtils.addAll(valueValues, IteratorUtils.getIterator(obj)); maxSize = Math.max(keyValues.size(), valueValues.size()); final List<Object> list = new ArrayList<Object>(); for (int i = 0; i < maxSize; i++) { final Map<String, Object> current = new HashMap<String, Object>(); current.put(keyBinder.getPath(), keyValues.get(i)); current.put(valueBinder.getPath(), valueValues.get(i)); list.add(current); } elements = list.iterator(); // } else { // //Here, there is a single property with a collection of values // elements = IteratorUtils.getIterator(bean); // } // Asseble the resulting collection if (elements != null) { while (elements.hasNext()) { final Object current = elements.next(); map.put(asString ? keyBinder.readFromString(current) : keyBinder.read(current), asString ? valueBinder.readFromString(current) : valueBinder.read(current)); } } } public void setKeyBinder(final DataBinder<K> keyBinder) { this.keyBinder = keyBinder; } public void setValueBinder(final DataBinder<V> valueBinder) { this.valueBinder = valueBinder; } @Override public void write(final Object object, final Map<K, V> values) { validateNestedBinders(); doWrite(object, values); } @Override public void writeAsString(final Object object, final Object value) { validateNestedBinders(); final Map<String, String> values = new HashMap<String, String>(); if (value instanceof Map<?, ?>) { for (final Map.Entry<?, ?> entry : ((Map<?, ?>) value).entrySet()) { final String keyAsString = keyBinder .readAsString(Collections.singletonMap(keyBinder.getPath(), entry.getKey())); final String valueAsString = valueBinder .readAsString(Collections.singletonMap(valueBinder.getPath(), entry.getValue())); values.put(keyAsString, valueAsString); } } else { for (final Iterator<?> it = IteratorUtils.getIterator(value); it.hasNext();) { final Object current = it.next(); values.put(keyBinder.readAsString(current), valueBinder.readAsString(current)); } } doWrite(object, values); } private void doWrite(final Object object, final Map<?, ?> map) { final List<Object> keys = new ArrayList<Object>(); final List<Object> values = new ArrayList<Object>(); for (final Map.Entry<?, ?> entry : map.entrySet()) { keys.add(entry.getKey()); values.add(entry.getValue()); } Object bean = PropertyHelper.get(object, getPath()); if (bean == null) { bean = new HashMap<String, Object>(); PropertyHelper.set(object, getPath(), bean); } PropertyHelper.set(bean, keyBinder.getPath(), keys); PropertyHelper.set(bean, valueBinder.getPath(), values); } private void validateNestedBinders() { if (this.keyBinder == null) { throw new IllegalStateException("null.key-binder"); } if (this.valueBinder == null) { throw new IllegalStateException("null.value-binder"); } } }