1 files changed, 100 insertions, 0 deletions
diff --git a/sandbox/kgoodson/mappingFramework/sdo-snapshot/src/main/java/com/agfa/hap/sdo/mapper/TypeMapper.java b/sandbox/kgoodson/mappingFramework/sdo-snapshot/src/main/java/com/agfa/hap/sdo/mapper/TypeMapper.java
new file mode 100644
index 0000000000..40bc42443a
--- /dev/null
+++ b/sandbox/kgoodson/mappingFramework/sdo-snapshot/src/main/java/com/agfa/hap/sdo/mapper/TypeMapper.java
@@ -0,0 +1,100 @@
+/**
+ *
+ *  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 com.agfa.hap.sdo.mapper;
+
+import java.lang.reflect.Constructor;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+
+import com.agfa.hap.sdo.Property;
+import com.agfa.hap.sdo.Type;
+import com.agfa.hap.sdo.helper.TypeHelper;
+
+/**
+ * Maps classes onto sdo Type instances.
+ * <P/>
+ * This implementation only on classes that are registered 
+ * ({@see {@link #register(Class, String, String)}).
+ * 
+ * <P />
+ * This class is thread safe and can be concurrently accessed by multiple threads.
+ * @author AMOCZ
+ */
+public class TypeMapper {
+
+	public TypeMapper() {
+		this(new BeanPropertyAccessorBuilder());
+	}
+	
+	public TypeMapper(PropertyAccessorBuilder builder) {
+		this.propertyAccessorBuilder = builder;
+	}
+	
+    /**
+     * Locates a property accessor
+     */
+    public PropertyAccessor property(Class cls, Property property) {
+        PropertyAccessor[] properties = buildMap(cls);
+        PropertyAccessor propertyAccessor = properties[property.getIndex()];
+        if (propertyAccessor == null) {
+            throw new IllegalArgumentException("Can't access property " + property.getName() + " on " + cls.getName() + ".");
+        } 
+		return propertyAccessor;
+    }
+
+    private PropertyAccessor[] buildMap(Class cls) {
+        String clsName = cls.getName();
+        PropertyAccessor[] props = keyedByPropertyNameCache.get(clsName);
+        if (props == null) {
+        	// we don't care too much if it is computed more than once under some race conditions
+        	props = propertyAccessorBuilder.buildMap(cls, getCorrespondingType(cls));
+        	keyedByPropertyNameCache.put(clsName, props);
+        }
+        return props;
+    }
+	
+	public Type getCorrespondingType(Class clazz) {
+		String[] exc = exceptions.get(clazz);
+		if (exc != null) {
+			return TypeHelper.INSTANCE.getType(exc[0], exc[1]);					
+		}
+		return null;
+	}	
+
+	public void register(Class<?> clazz, String uri, String typeName) {
+		exceptions.put(clazz, new String[] { uri, typeName });
+		try {
+			factories.put(typeName, clazz.getConstructor((Class[]) null));
+		} catch (SecurityException e) {
+		} catch (NoSuchMethodException e) {
+		}
+	}
+	
+	public Constructor<?> getConstructor(Type type) {
+		return factories.get(type.getName());
+	}
+	
+	private final Map<String, Constructor<?>> factories = new ConcurrentHashMap<String, Constructor<?>>();
+	private final Map<Class<?>, String[]> exceptions = new ConcurrentHashMap<Class<?>, String[]>();
+    private final Map<String, PropertyAccessor[]> keyedByPropertyNameCache = 
+    	new ConcurrentHashMap<String, PropertyAccessor[]>();    
+    protected final PropertyAccessorBuilder propertyAccessorBuilder;
+
+}