SchematizerImplOLD.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.felix.schematizer.impl;

//import java.lang.annotation.Annotation;
//import java.lang.reflect.Field;
//import java.lang.reflect.Method;
//import java.lang.reflect.Modifier;
//import java.lang.reflect.ParameterizedType;
//import java.lang.reflect.Type;
//import java.util.ArrayList;
//import java.util.Arrays;
//import java.util.Collection;
//import java.util.Collections;
//import java.util.Comparator;
//import java.util.HashMap;
//import java.util.HashSet;
//import java.util.LinkedHashMap;
//import java.util.List;
//import java.util.Map;
//import java.util.Map.Entry;
//import java.util.Optional;
//import java.util.Set;
//import java.util.function.Function;
//import java.util.stream.Collectors;
//
//import org.apache.felix.schematizer.Node;
//import org.apache.felix.schematizer.Node.CollectionType;
//import org.apache.felix.schematizer.Schema;
//import org.apache.felix.schematizer.Schematizer;
//import org.apache.felix.schematizer.TypeRule;
//import org.osgi.dto.DTO;
//import org.osgi.framework.Bundle;
//import org.osgi.framework.ServiceFactory;
//import org.osgi.framework.ServiceRegistration;
//import org.osgi.util.converter.StandardConverter;
//import org.osgi.util.converter.TypeReference;
//
//public class SchematizerImplOLD implements Schematizer, ServiceFactory<Schematizer> {
//
//    private final Map<String, SchemaImpl> schemas = new HashMap<>();
//    private volatile Map<String, Map<String, Object>> typeRules = new HashMap<>();
//    private final List<ClassLoader> classloaders = new ArrayList<>();
//
//    @Override
//    public Schematizer getService( Bundle bundle, ServiceRegistration<Schematizer> registration ) {
//        return this;
//    }
//
//    @Override
//    public void ungetService(Bundle bundle, ServiceRegistration<Schematizer> registration, Schematizer service) {
//        // For now, a brutish, simplistic version. If there is any change to the environment, just
//        // wipe the state and start over.
//        //
//        // TODO: something more precise, which will remove only the classes that are no longer valid (if that is possible).
//        schemas.clear();
//        typeRules.clear();
//        classloaders.clear();
//    }
//
//    @Override
//    public Optional<Schema> get(String name) {
//        if (!schemas.containsKey(name)) {
//            SchemaImpl schema = schematize(name, "");
//            schemas.put(name, schema);
//        }
//
//        return Optional.ofNullable(schemas.get(name));
//    }
//
//    @Override
//    public Optional<Schema> from(String name, Map<String, Node.DTO> map) {
//        try {
//            // TODO: some validation of the Map here would be good
//            SchemaImpl schema = new SchemaImpl(name);
//            Object rootMap = map.get("/");
//            Node.DTO rootDTO = new StandardConverter().convert(rootMap).to(Node.DTO.class);
//            Map<String, NodeImpl> allNodes = new HashMap<>();
//            NodeImpl root = new NodeImpl(rootDTO, "", new Instantiator(classloaders), allNodes);
//            associateChildNodes(root);
//            schema.add(root);
//            schema.add(allNodes);
//            return Optional.of(schema);
//        } catch (Throwable t) {
//            return Optional.empty();
//        }
//    }
//
//    @Override
//    public <T extends DTO> Schematizer rule(String name, TypeRule<T> rule) {
//        Map<String, Object> rules = rulesFor(name);
//        rules.put(rule.getPath(), rule.getType());
//        return this;
//    }
//
//    @Override
//    public <T extends DTO> Schematizer rule(String name, String path, TypeReference<T> type) {
//        Map<String, Object> rules = rulesFor(name);
//        rules.put(path, type);
//        return this;
//    }
//
//    @Override
//    public <T extends DTO> Schematizer rule(String name, TypeReference<T> type) {
//        Map<String, Object> rules = rulesFor(name);
//        rules.put("/", type);
//        return this;
//    }
//
//    @Override
//    public <T> Schematizer rule(String name, String path, Class<T> cls) {
//        Map<String, Object> rules = rulesFor(name);
//        rules.put(path, cls);
//        return this;
//    }
//
//    private Map<String, Object> rulesFor(String name) {
//        if (!typeRules.containsKey(name))
//            typeRules.put(name, new HashMap<>());
//
//        return typeRules.get(name);
//    }
//
//    @Override
//    public Schematizer usingLookup( ClassLoader classloader ) {
//        if (classloader != null)
//            classloaders.add(classloader);
//        return this;
//    }
//
//    /**
//     * Top-level entry point for schematizing a DTO. This is the starting point to set up the
//     * parsing. All other methods make recursive calls.
//     */
//    private SchemaImpl schematize(String name, String contextPath) {
//        Map<String, Object> rules = typeRules.get(name);
//        rules = ( rules != null ) ? rules : Collections.emptyMap();
//        return SchematizerImplOLD.internalSchematize(name, contextPath, rules, false, this);
//    }
//
//    @SuppressWarnings( { "unchecked", "rawtypes" } )
//    /**
//     * Schematize any node, without knowing in advance its type.
//     */
//    private static SchemaImpl internalSchematize(
//            String name,
//            String contextPath,
//            Map<String, Object> rules,
//            boolean isCollection,
//            SchematizerImplOLD schematizer)  {
//        Class<?> cls = null;
//        TypeReference<? extends DTO> ref = null;
//        if (contextPath.isEmpty() && rules.containsKey("/")) {
//            ref = (TypeReference)typeReferenceOf(rules.get("/"));
//            if (ref == null )
//                cls = rawClassOf(rules.get("/"));
//        }
//
//        if (rules.containsKey(contextPath)) {
//            ref = (TypeReference)(typeReferenceOf(rules.get(contextPath)));
//            if (ref == null )
//                cls = rawClassOf(rules.get(contextPath));
//        }
//
//        if (ref != null )
//            cls = rawClassOf(ref);
//
//        if (cls == null)
//            return handleInvalid();
//
//        if (DTO.class.isAssignableFrom(cls)) {
//            Class<? extends DTO> targetCls = (Class<DTO>)cls;
//            return schematizeDTO(name, targetCls, ref, contextPath, rules, isCollection, schematizer);
//        }
//
//        return schematizeObject( name, cls, contextPath, rules, isCollection, schematizer);
//    }
//
//    private static SchemaImpl schematizeDTO(
//            String name,
//            Class<? extends DTO> targetCls,
//            TypeReference<? extends DTO> ref,
//            String contextPath,
//            Map<String, Object> rules,
//            boolean isCollection,
//            SchematizerImplOLD schematizer) {
//
//        SchemaImpl schema = new SchemaImpl(name);
//        NodeImpl rootNode;
//        if (ref != null)
//            rootNode = new NodeImpl(contextPath, ref, false, contextPath + "/");
//        else
//            rootNode = new NodeImpl(contextPath, targetCls, false, contextPath + "/");
//        schema.add(rootNode);
//        Map<String, NodeImpl> m = createMapFromDTO(name, targetCls, ref, contextPath, rules, schematizer);
//        m.values().stream().filter(v -> v.absolutePath().equals(rootNode.absolutePath() + v.name())).forEach(v -> rootNode.add(v));
//        associateChildNodes( rootNode );
//        schema.add(m);
//        return schema;
//    }
//
//    private static SchemaImpl schematizeObject(
//            String name,
//            Class<?> targetCls,
//            String contextPath,
//            Map<String, Object> rules,
//            boolean isCollection,
//            SchematizerImplOLD schematizer) {
//
//        SchemaImpl schema = new SchemaImpl(name);
//        NodeImpl node = new NodeImpl(contextPath, targetCls, isCollection, contextPath + "/");
//        schema.add(node);
//        return schema;
//    }
//
//    private static final Comparator<Entry<String, NodeImpl>> byPath = (e1, e2) -> e1.getValue().absolutePath().compareTo(e2.getValue().absolutePath());
//    private static Map<String, NodeImpl> createMapFromDTO(
//            String name,
//            Class<?> targetCls,
//            TypeReference<? extends DTO> ref,
//            String contextPath,
//            Map<String, Object> typeRules,
//            SchematizerImplOLD schematizer) {
//        Set<String> handledFields = new HashSet<>();
//
//        Map<String, NodeImpl> result = new HashMap<>();
//        for (Field f : targetCls.getDeclaredFields()) {
//            handleField(name, f, handledFields, result, targetCls, ref, contextPath, typeRules, schematizer);
//        }
//        for (Field f : targetCls.getFields()) {
//            handleField(name, f, handledFields, result, targetCls, ref, contextPath, typeRules, schematizer);
//        }
//
//        return result.entrySet().stream().sorted(byPath).collect(Collectors.toMap(Entry::getKey, Entry::getValue, (e1, e2) -> e1, LinkedHashMap::new));
//    }
//
//    @SuppressWarnings( { "rawtypes", "unchecked" } )
//    private static void handleField(
//            String name,
//            Field field,
//            Set<String> handledFields,
//            Map<String, NodeImpl> result,
//            Class<?> targetCls,
//            TypeReference<?> ref,
//            String contextPath,
//            Map<String, Object> rules,
//            SchematizerImplOLD schematizer) {
//        if (Modifier.isStatic(field.getModifiers()))
//            return;
//
//        String fieldName = field.getName();
//        if (handledFields.contains(fieldName))
//            return; // Field with this name was already handled
//
//        try {
//            String path = contextPath + "/" + fieldName;
//            NodeImpl node;
//            if (rules.containsKey(path)) {
//                // The actual field. Since the type for this node is provided as a rule, we
//                // only need it to test whether or not it is a collection.
//                Class<?> actualFieldType = field.getType();
//                boolean isCollection = Collection.class.isAssignableFrom(actualFieldType);
//                Class<?> rawClass = rawClassOf(rules.get(path));
//                // This is the type we will persist in the Schema (as provided by the rules), NOT the "actual" field type.
//                SchemaImpl embedded = SchematizerImplOLD.internalSchematize(name, path, rules, isCollection, schematizer);
//                Class<?> fieldClass = Util.primitiveToBoxed(rawClass);
//                TypeReference fieldRef = typeReferenceOf(rules.get(path));
//                if (isCollection)
//                    node = new CollectionNode(
//                            field.getName(),
//                            fieldRef,
//                            path,
//                            (Class)actualFieldType);
//                else if (fieldRef != null )
//                    node = new NodeImpl(fieldName, fieldRef, false, path);
//                else
//                    node = new NodeImpl(fieldName, fieldClass, false, path);
//                Map<String, NodeImpl> allNodes = embedded.toMapInternal();
//                allNodes.remove(path + "/");
//                result.putAll(allNodes);
//                Map<String, NodeImpl> childNodes = extractChildren(path, allNodes);
//                node.add(childNodes);
//            } else {
//                Type fieldType = field.getType();
//                Class<?> rawClass = rawClassOf(fieldType);
//                Class<?> fieldClass = Util.primitiveToBoxed(rawClass);
//
//                if (Collection.class.isAssignableFrom(fieldClass)) {
//                    CollectionType collectionTypeAnnotation = field.getAnnotation( CollectionType.class );
//                    Class<?> collectionType;
//                    if (collectionTypeAnnotation != null)
//                        collectionType = collectionTypeAnnotation.value();
//                    else if (hasCollectionTypeAnnotation(field))
//                        collectionType = collectionTypeOf(field);
//                    else
//                        collectionType = Object.class;                        
//                    node = new CollectionNode(
//                            field.getName(),
//                            collectionType,
//                            path,
//                            (Class)fieldClass);
//
//                    if (DTO.class.isAssignableFrom(collectionType)) {
//                        SchematizerImplOLD newSchematizer = new SchematizerImplOLD();
//                        newSchematizer.typeRules.put(path, rules);
//                        if (!rules.containsKey(path))
//                            newSchematizer.rule(path, path, collectionType);
//                        SchemaImpl embedded = newSchematizer.schematize(path, path);
//                        Map<String, NodeImpl> allNodes = embedded.toMapInternal();
//                        allNodes.remove(path + "/");
//                        result.putAll(allNodes);
//                        Map<String, NodeImpl> childNodes = extractChildren(path, allNodes);
//                        node.add(childNodes);
//                    }
//                }
//                else if (DTO.class.isAssignableFrom(fieldClass)) {
//                    SchematizerImplOLD newSchematizer = new SchematizerImplOLD();
//                    newSchematizer.typeRules.put(path, rules);
//                    if (!rules.containsKey(path))
//                        newSchematizer.rule(path, path, fieldClass);
//                    SchemaImpl embedded = newSchematizer.schematize(path, path);
//                    node = new NodeImpl(
//                            field.getName(),
//                            fieldClass,
//                            false,
//                            path);
//                    Map<String, NodeImpl> allNodes = embedded.toMapInternal();
//                    allNodes.remove(path + "/");
//                    result.putAll(allNodes);
//                    Map<String, NodeImpl> childNodes = extractChildren(path, allNodes);
//                    node.add(childNodes);
//                } else {
//                    node = new NodeImpl(
//                            field.getName(),
//                            fieldClass,
//                            false,
//                            path);
//                }
//            }
//
//            result.put(node.absolutePath(), node);
//            handledFields.add(fieldName);
//        } catch (Exception e) {
//            // Ignore this field
//            // TODO print warning??
//            return;
//        }
//    }
//
//    private static Map<String, NodeImpl> extractChildren( String path, Map<String, NodeImpl> allNodes ) {
//        final Map<String, NodeImpl> children = new HashMap<>();
//        for (String key : allNodes.keySet()) {
//            String newKey = key.replace(path, "");
//            if (!newKey.substring(1).contains("/"))
//                children.put( newKey, allNodes.get(key));
//        }
//
//        return children;
//    }
//
//    private static SchemaImpl handleInvalid() {
//        // TODO
//        return null;
//    }
//
//    private static Class<?> rawClassOf(Object type) {
//        Class<?> rawClass = null;
//        if (type instanceof Class) {
//            rawClass = (Class<?>)type;
//        } else if (type instanceof ParameterizedType) {
//            ParameterizedType paramType = (ParameterizedType) type;
//            Type rawType = paramType.getRawType();
//            if (rawType instanceof Class)
//                rawClass = (Class<?>)rawType;
//        } else if (type instanceof TypeReference) {
//            return rawClassOf(((TypeReference<?>)type).getType());
//        }
//
//        return rawClass;
//    }
//
//    private static TypeReference<?> typeReferenceOf(Object type) {
//        TypeReference<?> typeRef = null;
//        if (type instanceof TypeReference)
//            typeRef = (TypeReference<?>)type;
//        return typeRef;
//    }
//
//    public static class Instantiator implements Function<String, Type> {
//        private final List<ClassLoader> classloaders = new ArrayList<>();
//
//        public Instantiator(List<ClassLoader> aClassLoadersList) {
//            classloaders.addAll( aClassLoadersList );
//        }
//
//        @Override
//        public Type apply(String className) {
//            for (ClassLoader cl : classloaders) {
//                try {
//                    return cl.loadClass(className);
//                } catch (ClassNotFoundException e) {
//                    // Try next
//                }
//            }
//
//            // Could not find the class. Try "this" ClassLoader
//            try {
//                return getClass().getClassLoader().loadClass(className);
//            } catch (ClassNotFoundException e) {
//                // Too bad
//            }
//
//            // Nothing to do. Return Object.class as the fallback
//            return Object.class;
//        }
//    }
//
//    static private void associateChildNodes(NodeImpl rootNode) {
//        for (NodeImpl child: rootNode.childrenInternal().values()) {
//            child.parent(rootNode);
//            String fieldName = child.name();
//            Class<?> parentClass = rawClassOf(rootNode.type());
//            try {
//                Field field = parentClass.getField(fieldName);
//                child.field(field);
//            } catch ( NoSuchFieldException e ) {
//                e.printStackTrace();
//            }            
//
//            associateChildNodes(child);
//        }
//    }
//
//    static private boolean hasCollectionTypeAnnotation(Field field) {
//        if (field == null)
//            return false;
//
//        Annotation[] annotations = field.getAnnotations();
//        if (annotations.length == 0)
//            return false;
//
//        return Arrays.stream(annotations)
//            .map(a -> a.annotationType().getName())
//            .anyMatch(a -> "CollectionType".equals(a.substring(a.lastIndexOf(".") + 1) ));
//    }
//
//    static private Class<?> collectionTypeOf(Field field) {
//        Annotation[] annotations = field.getAnnotations();
//
//        Annotation annotation = Arrays.stream(annotations)
//            .filter(a -> "CollectionType".equals(a.annotationType().getName().substring(a.annotationType().getName().lastIndexOf(".") + 1) ))
//            .findFirst()
//            .get();
//
//        try {
//            Method m = annotation.annotationType().getMethod("value");
//            Class<?> value = (Class<?>)m.invoke(annotation, (Object[])null);
//            return value;            
//        } catch ( Exception e ) {
//            return null;
//        }
//    }
//}