root/org.axdt.axdoc/src/org/axdt/axdoc/util/Index0r.java @ 85b4650e22de85722d0e932da31e0104e8a88327

package org.axdt.axdoc.util;

import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;

import org.axdt.axdoc.AXDocPlugin;
import org.axdt.axdoc.model.AXEntry;
import org.axdt.axdoc.model.AXIndex;
import org.axdt.axdoc.model.AXIndexNode;
import org.axdt.axdoc.model.AXLevel;
import org.axdt.axdoc.model.AXRoot;
import org.axdt.axdoc.model.AXRootType;
import org.axdt.axdoc.model.util.AXUtil;
import org.axdt.axdoc.preferences.AXDocPreferences;
import org.eclipse.core.runtime.Path;
import org.eclipse.emf.common.CommonPlugin;
import org.eclipse.emf.common.util.URI;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.resource.Resource;
import org.eclipse.emf.ecore.resource.ResourceSet;
import org.eclipse.emf.ecore.resource.impl.ResourceSetImpl;

public class Index0r {
        
        private static Index0r instance = null;
        
        public static Index0r getInstance() {
                if (instance == null) {
                        instance = new Index0r();
                        AXDocPreferences.checkAXDocPaths(instance);
                }
                return instance;
        }
        
        protected Map<String, AXRoot> roots;
        protected AXDocParser docParser;
        protected URI baseURI;
        
        public Index0r() {
                roots = new HashMap<String, AXRoot>();
                docParser = new AXDocParser();
                baseURI = createBaseUri();
        }
        protected URI createBaseUri() {
                return CommonPlugin.resolve(URI.createURI("platform:/meta/"+AXDocPlugin.PLUGIN_ID));
        }
        public AXIndexNode[] find(String qname) {
                if (qname == null || qname.length() == 0) {
                        return null;
                }
                String[] splitQname = qname.split("::");
                if (splitQname.length == 0) {
                        return null;
                }
                if (splitQname.length == 1) {
                        return findPackage(splitQname[0]);
                }
                if (splitQname.length == 2) {
                        return findMember(splitQname[0], splitQname[1]);
                }
                return null;
        }
        public AXIndexNode[] findMember(String qualifier, String name) {
                ArrayList<AXIndexNode> result = new ArrayList<AXIndexNode>();
                for (AXRoot root:roots.values()) {
                        AXIndexNode index = root.getPackageIndex(qualifier);
                        String[] qsplit = name.split("\\.");
                        if (qsplit.length > 1) {
                                for (int i = 0; index != null && i < qsplit.length-1;i++) {
                                        index = index.localEntry(qsplit[0], false);
                                }
                        }
                        if (index != null) {
                                for (AXEntry entry : index.localEntry(qsplit[qsplit.length-1])) {
                                        result.add(entry);
                                }
                        }
                }
                return result.toArray(new AXIndexNode[result.size()]);
        }
        public AXIndex[] findPackage(String name) {
                ArrayList<AXIndex> result = new ArrayList<AXIndex>();
                for (AXRoot root:roots.values()) {
                        AXIndex index = root.getPackageIndex(name);
                        if (index != null) {
                                result.add(index);
                        }
                }
                return result.toArray(new AXIndex[result.size()]);
        }
        public AXRoot addRoot(String name, String url, AXRootType type) {
                AXRoot root = roots.get(url);
                if (root == null) {
                        URI resourcePath = baseURI.appendSegment(Integer.toHexString(url.hashCode())).appendSegment("root-index.axdoc");
                        if (new Path(resourcePath.toString()).toFile().exists()) {
                                ResourceSet resset = new ResourceSetImpl();
                                Resource resource = resset.createResource(resourcePath);
                                try {
                                        resource.load(null);
                                        if (resource.getContents().size()>0) {
                                                EObject object = resource.getContents().get(0);
                                                if (object instanceof AXRoot)
                                                        return (AXRoot) object;
                                        }
                                } catch (IOException e) {
                                        AXDocPlugin.getDefault().log("error loading axdoc file",e);
                                }
                        } else {
                                root = AXUtil.createRoot(name, url, resourcePath.toString());
                                root.setRootType(type);
                        }
                        if (root != null) {
                                roots.put(root.getUrl(), root);
                        }
                }
                return root;
        }
        public AXRoot[] getRoots() {
                return roots.values().toArray(new AXRoot[roots.size()]);
        }
        public void initialize(AXRoot root, AXLevel level) {
                if (root.getRootType() == AXRootType.ASDOC) {
                        try {
                                docParser.parseDoc(root, level);
                                root.eResource().save(null);
                        } catch (Exception e) {
                                if (AXDocPlugin.getDefault() != null)
                                        AXDocPlugin.getDefault().log("error parsing asdoc at "+root.getUrl(), e);
                                else e.printStackTrace();
                        }
                } else {
                        if (AXDocPlugin.getDefault() != null)
                                AXDocPlugin.getDefault().log("only asoc index is available");
                }
        }
}