skrueger/geotools/AttributeMetadataMap.java

package skrueger.geotools;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;

import org.apache.log4j.Logger;
import org.geotools.feature.NameImpl;
import org.opengis.feature.type.Name;

import skrueger.AttributeMetadata;
import skrueger.i8n.Translation;

/**
 * The {@link AttributeMetadataMap} is a {@link Map} holding
 * {@link AttributeMetadata} object for {@link Name} keys. It's an extension of
 * a {@link TreeMap}. It's copyable in the sense of the {@link Copyable}
 * interface.<br>
 * The {@link #get(Name)} and {@link #get(String)} methods will never return
 * <code>null</code>, but rather create a default {@link AttributeMetadata}
 * on-the-fly.
 */
public class AttributeMetadataMap extends TreeMap<Name, AttributeMetadata>
                implements Copyable<AttributeMetadataMap> {
        static private final Logger LOGGER = Logger
                        .getLogger(AttributeMetadataMap.class);

        /**
         * A list of default languages used when creating default
         * {@link AttributeMetadata} on-the-fly. If not initialized by a
         * constructor, it will be {@link Translation#getActiveLang()} only.
         **/
        private final List<String> langs;

        /**
         @Deprecated Use another constructor. AttributeMetadataMap is based on {@link Translation} and
         *             would like to know how many languages are supported, so the
         *             needed defaults can be created.
         */
        public AttributeMetadataMap() {
                langs = new ArrayList<String>();
                langs.add(Translation.getActiveLang());
        }

        /**
         * Creates an {@link AttributeMetadataMap} and sets the list of default
         * languages.
         */
        public AttributeMetadataMap(final List<String> defLanguages) {
                langs = defLanguages;
        }

        /**
         * Creates an {@link AttributeMetadataMap} and sets the list of default
         * languages.
         */
        public AttributeMetadataMap(final String[] strings) {
                langs = new ArrayList<String>(java.util.Arrays.asList(strings));
        }

        /**
         * Returns a deep-copy. @see {@link Copyable} interface
         */
        @Override
        public AttributeMetadataMap copy() {
                final AttributeMetadataMap copy = new AttributeMetadataMap(langs);
                return copyTo(copy);
        }

        /**
         * Copies all its values to another {@link AttributeMetadataMap}. @see
         * {@link Copyable} interface.
         */
        @Override
        public AttributeMetadataMap copyTo(final AttributeMetadataMap amdMap) {

                amdMap.clear();

                for (final Name key : keySet()) {
                        final AttributeMetadata attributeMetaData = get(key);
                        amdMap.put(key, attributeMetaData.copy());
                }
                return amdMap;
        }

        /**
         * Returns the {@link AttributeMetadata} for a given {@link Name}. Never
         * returns <code>null</code>, but rather creates a default
         * {@link AttributeMetadata} on the fly.
         */
        public AttributeMetadata get(final Name name) {
                final AttributeMetadata attributeMetadata = super.get(name);
                if (attributeMetadata == null && name != null
                                && !name.getLocalPart().trim().isEmpty()) {
                        put(name, new AttributeMetadata(name, langs));
                        return super.get(name);
                }
                return attributeMetadata;
        }

        /**
         * @Deprecated use get(Name name) or get(String localName)
         */
        @Override
        @Deprecated
        public AttributeMetadata get(final Object key) {
                LOGGER.warn("PLEASE DONT USE get(Object) any MORE!");
                LOGGER.warn("PLEASE DONT USE get(Object) any MORE!");
                LOGGER.warn("PLEASE DONT USE get(Object) any MORE!");
                return super.get(key);
        }

        /**
         * Returns the {@link AttributeMetadata} for a given {@link Name}. Never
         * returns <code>null</code>, but rather creates a default
         * {@link AttributeMetadata} on the fly.
         */
        public AttributeMetadata get(final String localName) {
                return this.get(new NameImpl(localName));
        }

        public List<String> getLanguages() {
                return langs;
        }

        /**
         * @return a number between 0. (bad) and 1. (good) that is calculated from
         *         the amount of translation available in the visible attributes
         */
        public double getQuality(final List<String> languages) {
                int allVisible = 0;
                double colQmSum = 0.;
                for (final AttributeMetadata oneCol : values()) {

                        if (oneCol.isVisible()) {
                                allVisible++;
                                colQmSum += oneCol.getQuality(languages);
                        }
                }

                if (allVisible > 0)
                        return colQmSum / allVisible;
                else
                        return 1.;

        }


        /**
         * @return List of {@link AttributeMetadata} objects ordered by their
         *         weight. (heavier => further down)
         */
        public List<AttributeMetadata> sortedValues() {
                final ArrayList<AttributeMetadata> list = new ArrayList<AttributeMetadata>();
                list.addAll(values());
                Collections.sort(list);
                return list;
        }

        /**
         * @return List of only the visible {@link AttributeMetadata} objects
         *         ordered by their weight. (heavier => further down)
         */
        public List<AttributeMetadata> sortedValuesVisibleOnly() {
                final ArrayList<AttributeMetadata> list = new ArrayList<AttributeMetadata>();
                for (final AttributeMetadata atm : sortedValues()) {
                        if (atm.isVisible())
                                list.add(atm);
                }
                return list;
        }
}
1	package skrueger.geotools;
2
3	import java.util.ArrayList;
4	import java.util.Collections;
5	import java.util.List;
6	import java.util.Map;
7	import java.util.TreeMap;
8
9	import org.apache.log4j.Logger;
10	import org.geotools.feature.NameImpl;
11	import org.opengis.feature.type.Name;
12
13	import skrueger.AttributeMetadata;
14	import skrueger.i8n.Translation;
15
16	/**
17	* The {@link AttributeMetadataMap} is a {@link Map} holding
18	* {@link AttributeMetadata} object for {@link Name} keys. It's an extension of
19	* a {@link TreeMap}. It's copyable in the sense of the {@link Copyable}
20	* interface.<br>
21	* The {@link #get(Name)} and {@link #get(String)} methods will never return
22	* <code>null</code>, but rather create a default {@link AttributeMetadata}
23	* on-the-fly.
24	*/
25	public class AttributeMetadataMap extends TreeMap<Name, AttributeMetadata>
26	implements Copyable<AttributeMetadataMap> {
27	static private final Logger LOGGER = Logger
28	.getLogger(AttributeMetadataMap.class);
29
30	/**
31	* A list of default languages used when creating default
32	* {@link AttributeMetadata} on-the-fly. If not initialized by a
33	* constructor, it will be {@link Translation#getActiveLang()} only.
34	**/
35	private final List<String> langs;
36
37	/**
38	@Deprecated Use another constructor. AttributeMetadataMap is based on {@link Translation} and
39	* would like to know how many languages are supported, so the
40	* needed defaults can be created.
41	*/
42	public AttributeMetadataMap() {
43	langs = new ArrayList<String>();
44	langs.add(Translation.getActiveLang());
45	}
46
47	/**
48	* Creates an {@link AttributeMetadataMap} and sets the list of default
49	* languages.
50	*/
51	public AttributeMetadataMap(final List<String> defLanguages) {
52	langs = defLanguages;
53	}
54
55	/**
56	* Creates an {@link AttributeMetadataMap} and sets the list of default
57	* languages.
58	*/
59	public AttributeMetadataMap(final String[] strings) {
60	langs = new ArrayList<String>(java.util.Arrays.asList(strings));
61	}
62
63	/**
64	* Returns a deep-copy. @see {@link Copyable} interface
65	*/
66	@Override
67	public AttributeMetadataMap copy() {
68	final AttributeMetadataMap copy = new AttributeMetadataMap(langs);
69	return copyTo(copy);
70	}
71
72	/**
73	* Copies all its values to another {@link AttributeMetadataMap}. @see
74	* {@link Copyable} interface.
75	*/
76	@Override
77	public AttributeMetadataMap copyTo(final AttributeMetadataMap amdMap) {
78
79	amdMap.clear();
80
81	for (final Name key : keySet()) {
82	final AttributeMetadata attributeMetaData = get(key);
83	amdMap.put(key, attributeMetaData.copy());
84	}
85	return amdMap;
86	}
87
88	/**
89	* Returns the {@link AttributeMetadata} for a given {@link Name}. Never
90	* returns <code>null</code>, but rather creates a default
91	* {@link AttributeMetadata} on the fly.
92	*/
93	public AttributeMetadata get(final Name name) {
94	final AttributeMetadata attributeMetadata = super.get(name);
95	if (attributeMetadata == null && name != null
96	&& !name.getLocalPart().trim().isEmpty()) {
97	put(name, new AttributeMetadata(name, langs));
98	return super.get(name);
99	}
100	return attributeMetadata;
101	}
102
103	/**
104	* @Deprecated use get(Name name) or get(String localName)
105	*/
106	@Override
107	@Deprecated
108	public AttributeMetadata get(final Object key) {
109	LOGGER.warn("PLEASE DONT USE get(Object) any MORE!");
110	LOGGER.warn("PLEASE DONT USE get(Object) any MORE!");
111	LOGGER.warn("PLEASE DONT USE get(Object) any MORE!");
112	return super.get(key);
113	}
114
115	/**
116	* Returns the {@link AttributeMetadata} for a given {@link Name}. Never
117	* returns <code>null</code>, but rather creates a default
118	* {@link AttributeMetadata} on the fly.
119	*/
120	public AttributeMetadata get(final String localName) {
121	return this.get(new NameImpl(localName));
122	}
123
124	public List<String> getLanguages() {
125	return langs;
126	}
127
128	/**
129	* @return a number between 0. (bad) and 1. (good) that is calculated from
130	* the amount of translation available in the visible attributes
131	*/
132	public double getQuality(final List<String> languages) {
133	int allVisible = 0;
134	double colQmSum = 0.;
135	for (final AttributeMetadata oneCol : values()) {
136
137	if (oneCol.isVisible()) {
138	allVisible++;
139	colQmSum += oneCol.getQuality(languages);
140	}
141	}
142
143	if (allVisible > 0)
144	return colQmSum / allVisible;
145	else
146	return 1.;
147
148	}
149
150
151	/**
152	* @return List of {@link AttributeMetadata} objects ordered by their
153	* weight. (heavier => further down)
154	*/
155	public List<AttributeMetadata> sortedValues() {
156	final ArrayList<AttributeMetadata> list = new ArrayList<AttributeMetadata>();
157	list.addAll(values());
158	Collections.sort(list);
159	return list;
160	}
161
162	/**
163	* @return List of only the visible {@link AttributeMetadata} objects
164	* ordered by their weight. (heavier => further down)
165	*/
166	public List<AttributeMetadata> sortedValuesVisibleOnly() {
167	final ArrayList<AttributeMetadata> list = new ArrayList<AttributeMetadata>();
168	for (final AttributeMetadata atm : sortedValues()) {
169	if (atm.isVisible())
170	list.add(atm);
171	}
172	return list;
173	}
174	}
Name	Value
svn:eol-style	native
svn:keywords	Id URL
svn:mime-type	text/plain