fr.vergne.translation.impl.OnDemandMetadata Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of translation-core Show documentation
Basic features to support a translation project.
The newest version!
package fr.vergne.translation.impl;

import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.Map;
import java.util.Set;

import fr.vergne.translation.TranslationMetadata;
import fr.vergne.translation.util.Reader;
import fr.vergne.translation.util.Writer;

/**
 * An {@link OnDemandMetadata} allows to retrieve the
 * {@link TranslationMetadata} values on demand, so it does not store them
 * directly. In particular, it does not try to retrieve all of them from the
 * start: they will be retrieved only if requested with
 * {@link #getStored(Field)}.

 * 

 * This implementation also provides methods to set up editable and non-editable
 * {@link Field}s, namely the configureXxx() methods. The ones
 * taking a {@link Writer} as argument allows to set up editable fields, while
 * the ones having no {@link Writer} argument set up non-editable fields.
 * 
 * @author Matthieu VERGNE 
 * 
 */
public class OnDemandMetadata implements TranslationMetadata {

	private static final Writer DEFAULT_SAVER = new Writer() {

		@Override
		public void write(OnDemandMetadata element) {
			for (Field field : element.orderedFields) {
				element.save(field);
			}
		}
	};
	private final Map, Object> changedValues = new HashMap, Object>();
	private final Map, Reader> fieldReaders = new HashMap, Reader>();
	private final Map, Writer> fieldSavers = new HashMap, Writer>();
	private final Collection listeners = new HashSet<>();
	private final Set> orderedFields = new LinkedHashSet>();
	private final Writer metadataSaver;

	/**
	 * Instantiate an {@link OnDemandMetadata} with a customized saving
	 * strategy.
	 * 
	 * @param saver
	 *            the save strategy to use when calling {@link #saveAll()}
	 */
	public OnDemandMetadata(Writer saver) {
		this.metadataSaver = saver;
	}

	/**
	 * Instantiate an {@link OnDemandMetadata} with a naive saving strategy:
	 * each modified field is saved separately. If you want to use a smarter
	 * strategy, use {@link #OnDemandMetadata(Writer)} isntead.
	 */
	public OnDemandMetadata() {
		this(DEFAULT_SAVER);
	}

	/**
	 * 
	 * @param field
	 *            the {@link Field} to configure as non-editable
	 * @param reader
	 *            the way to retrieve the stored {@link Field} value
	 */
	public  void configureField(Field field, Reader reader) {
		fieldReaders.put(field, reader);
		fieldSavers.remove(field);
		orderedFields.add(field);
	}

	/**
	 * 
	 * @param field
	 *            the {@link Field} to configure as editable
	 * @param reader
	 *            the way to retrieve the stored {@link Field} value
	 * @param writer
	 *            the way to save the {@link Field} value
	 */
	public  void configureField(Field field, Reader reader,
			Writer writer) {
		fieldReaders.put(field, reader);
		fieldSavers.put(field, writer);
		orderedFields.add(field);
	}

	@Override
	public Iterator> iterator() {
		return orderedFields.iterator();
	}

	@SuppressWarnings("unchecked")
	@Override
	public  T getStored(Field field) {
		return (T) fieldReaders.get(field).read();
	}

	@SuppressWarnings("unchecked")
	@Override
	public  T get(Field field) {
		if (changedValues.containsKey(field)) {
			return (T) changedValues.get(field);
		} else if (fieldReaders.containsKey(field)) {
			return (T) fieldReaders.get(field).read();
		} else {
			throw new IllegalArgumentException("Unmanaged field: " + field);
		}
	}

	@Override
	public  boolean isEditable(Field field) {
		return fieldSavers.containsKey(field);
	}

	@Override
	public  void set(Field field, T value)
			throws UneditableFieldException {
		if (isEditable(field)) {
			changedValues.put(field, value);
			for (FieldListener listener : listeners) {
				listener.fieldUpdated(field, value);
			}
		} else {
			throw new UneditableFieldException(field);
		}
	}

	@Override
	public void addFieldListener(FieldListener listener) {
		listeners.add(listener);
	}

	@Override
	public void removeFieldListener(FieldListener listener) {
		listeners.remove(listener);
	}

	@SuppressWarnings("unchecked")
	@Override
	public  void save(Field field) {
		if (changedValues.containsKey(field)) {
			Writer writer = (Writer) fieldSavers.get(field);
			writer.write((T) changedValues.get(field));
			for (FieldListener listener : listeners) {
				listener.fieldStored(field);
			}
		} else {
			// nothing to save
		}
	}

	@SuppressWarnings("unchecked")
	@Override
	public  void reset(Field field) {
		if (changedValues.containsKey(field)) {
			changedValues.remove(field);
			for (FieldListener listener : listeners) {
				listener.fieldUpdated(field, (T) fieldReaders.get(field).read());
			}
		} else {
			// nothing to reset
		}
	}

	@Override
	public void saveAll() {
		metadataSaver.write(this);
	}

	@Override
	public void resetAll() {
		for (Field field : orderedFields) {
			reset(field);
		}
	}

	@Override
	public String toString() {
		StringBuilder builder = new StringBuilder();
		for (Field field : orderedFields) {
			builder.append(field + ": " + get(field) + "|");
		}
		return "[" + builder.toString() + "]";
	}
}