root/org.axdt.axdoc.model/src/org/axdt/axdoc/model/util/AXUtil.java @ 2d81bf0e2ed8217c6cb2a26fcb22d09b8441f7a3

package org.axdt.axdoc.model.util;

import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

import org.axdt.axdoc.model.AXDocFactory;
import org.axdt.axdoc.model.AXEntry;
import org.axdt.axdoc.model.AXIndex;
import org.axdt.axdoc.model.AXMember;
import org.axdt.axdoc.model.AXRoot;
import org.axdt.axdoc.model.AXType;
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;

public class AXUtil {
        private static AXDocXMLProcessor xmlProcessor = new AXDocXMLProcessor();
        private static AXDocFactory factory = AXDocFactory.eINSTANCE;
        public static Resource createResource(String path) {
                return xmlProcessor.createResourceSet().createResource(URI.createURI(path));
        }
        public static Resource getOrCreateResource(ResourceSet set, EObject node, String path) {
                Resource resource = node.eResource();
                if (resource == null) {
                        if (set == null)
                                set = xmlProcessor.createResourceSet();
                        resource = set.createResource(URI.createURI(path));
                        resource.getContents().add(node);
                } else if (path != null) {
                        resource.setURI(URI.createURI(path));
                }
                return resource;
        }
        public static String writeToString(EObject node) throws IOException {
                ResourceSet set = (node.eResource() != null) ? node.eResource().getResourceSet() : null; 
                return writeToString(getOrCreateResource(set, node, null));
        }
        public static String writeToString(Resource resource) throws IOException {
                if (resource.getContents().isEmpty())
                        return null;
                return xmlProcessor.saveToString(resource, null);
        }
        public static Resource readFromString(String text, String path) throws IOException {
                Resource resource = createResource(path);
                ByteArrayInputStream inputStream = new ByteArrayInputStream(text.getBytes());
                resource.load(inputStream, null);
                return resource;
        }
        public static AXRoot createRoot(String url, String basePath) {
                return createRoot(null, url, basePath);
        }
        public static AXRoot createRoot(String name, String url, String resourceUrl) {
                AXRoot root = factory.createAXRoot();
                root.setName(name);
                root.setUrl(url);
                ResourceSet set = xmlProcessor.createResourceSet();
                getOrCreateResource(set, root, resourceUrl);
                return root;
        }
        public static AXIndex createPackage(AXRoot root, String name) {
                if (name == null || name.equals("")) return root;
                AXIndex current = root;
                main : for (String part : name.split("\\.")) {
                        for (AXIndex pack : current.getIndexes()) {
                                if (part.equals(pack.getName())) {
                                        current = pack;
                                        continue main;
                                }
                        }
                        AXIndex child = factory.createAXIndex();
                        child.setName(part);
                        current.getIndexes().add(child);
                        //getResource(child, child.fullName()+".axdoc.xml");
                        current = child;
                }
                return current;
        }
        public static AXMember createMember(String name) {
                AXMember member = factory.createAXMember();
                if (name.contains("()")) {
                        name = name.replace("()", "");
                        member.setFunction(true);
                }
                member.setName(name);
                return member;
        }
        public static AXType createType(String typeName) {
                AXType type = factory.createAXType();
                type.setName(typeName);
                return type;
        }
        public static List<AXEntry> getAllTypes(AXIndex index) {
                ArrayList<AXEntry> allTypes = new ArrayList<AXEntry>();
                collectAllTypes(index, allTypes);
                return allTypes;
        }
        public static void collectAllTypes(AXIndex index, List<AXEntry> allTypes) {
                for (AXEntry e:index.getEntries()) {
                        if (e.getType().isType()) allTypes.add(e);
                }
                for (AXIndex p:index.getIndexes()) {
                        collectAllTypes(p, allTypes);
                }
        }
}