adding mostly done IDL parser with test and sample makefile

git-svn-id: svn://svn.open-ils.org/ILS/trunk@7342 dcc99617-32d9-48b4-a31d-7c20da2025e4

diff --git a/Open-ILS/src/java/Makefile b/Open-ILS/src/java/Makefile
new file mode 100644 (file)
index 0000000..2fc0387
--- /dev/null
+++ b/Open-ILS/src/java/Makefile
@@ -0,0 +1,42 @@
+JAVA_LIBDIR = .lib
+JAVAC = javac -J-Xmx256m
+JAVA = java -Xmx256m 
+OSRF_HOME = ../../../OpenSRF/src/java
+OSRF_JAVA = $(OSRF_HOME)/.lib
+EXT = $(OSRF_HOME)/ext
+JAVA_LIBS = .:$(JAVA_LIBDIR):$(OSRF_JAVA):$(EXT)/json-jdk1.5-2007-05-01.jar:$(EXT)/wstx-lgpl-3.2.1.jar:$(EXT)/stax-api-1.0.1.jar:$(EXT)/java_memcached-release_1.5.1.jar
+JAVA_SRC = \
+       org/open_ils/idl/*.java\
+       org/open_ils/test/*.java
+
+all:
+       mkdir -p $(JAVA_LIBDIR)
+       $(JAVAC) -d $(JAVA_LIBDIR) -cp $(JAVA_LIBS) $(JAVA_SRC) 2>&1 
+
+# only prints the first 30 lines of errors
+slim:
+       mkdir -p $(JAVA_LIBDIR)
+       $(JAVAC) -d $(JAVA_LIBDIR) -cp $(JAVA_LIBS) $(JAVA_SRC) 2>&1 | head -n 30
+       @echo -e "\nTruncating at 30 lines"
+
+check:
+       mkdir -p $(JAVA_LIBDIR)
+       $(JAVAC) -Xlint:unchecked -d $(JAVA_LIBDIR) -cp $(JAVA_LIBS) $(JAVA_SRC) 2>&1 | head -n 30
+       @echo -e "\nTruncating at 30 lines"
+
+run:
+       @$(JAVA) -cp $(JAVA_LIBS) $(JAVA_EXE) $(JAVA_ARGS)
+
+deps:
+       mkdir -p ext
+
+docs:
+       find . -name *.java > files;
+       javadoc -classpath $(JAVA_LIBS) -d doc @files;
+       rm files;
+
+clean:
+       rm -r $(JAVA_LIBDIR)
+       
+
+

diff --git a/Open-ILS/src/java/org/open_ils/idl/IDLField.java b/Open-ILS/src/java/org/open_ils/idl/IDLField.java
new file mode 100644 (file)
index 0000000..6955bc5
--- /dev/null
+++ b/Open-ILS/src/java/org/open_ils/idl/IDLField.java
@@ -0,0 +1,46 @@
+package org.open_ils.idl;
+
+public class IDLField {
+
+    /** Field name */
+    private String name;
+
+    /** Where this field resides in the array when serilized */
+    private int arrayPos;
+
+    /** True if this field does not belong in the database */
+    private boolean isVirtual;
+
+    public void setName(String name) {
+      this.name = name;
+    }
+    public void setArrayPos(int arrayPos) {
+      this.arrayPos = arrayPos;
+    }
+    public void setIsVirtual(boolean isVirtual) {
+      this.isVirtual = isVirtual;
+    }
+    public String getName() {
+      return this.name;
+    }
+    public int getArrayPos() {
+      return this.arrayPos;
+    }
+    public boolean getIsVirtual() {
+      return this.isVirtual;
+    }
+
+    public void toXML(StringBuffer sb) {
+        sb.append("\t\t\t<field name='");
+        sb.append(name);
+        sb.append("' ");
+        sb.append(IDLParser.OILS_NS_OBJ_PREFIX);
+        sb.append(":array_position='");
+        sb.append(arrayPos);
+        sb.append("' ");
+        sb.append(IDLParser.OILS_NS_PERSIST_PREFIX);
+        sb.append(":virtual='");
+        sb.append(isVirtual);
+        sb.append("'/>\n");
+    }
+}

diff --git a/Open-ILS/src/java/org/open_ils/idl/IDLLink.java b/Open-ILS/src/java/org/open_ils/idl/IDLLink.java
new file mode 100644 (file)
index 0000000..69a5772
--- /dev/null
+++ b/Open-ILS/src/java/org/open_ils/idl/IDLLink.java
@@ -0,0 +1,46 @@
+package org.open_ils.idl;
+
+
+public class IDLLink {
+
+   /**The field on the IDLObject this link extends from */
+   private String field;
+   private String reltype;
+   private String key;
+   private String map;
+   /**The IDL class linked to */
+   private String IDLClass;
+
+
+   public void setField(String field) {
+      this.field = field;
+   }
+   public void setReltype(String reltype) {
+      this.reltype = reltype;
+   }
+   public void setKey(String key) {
+      this.key = key;
+   }
+   public void setMap(String map) {
+      this.map = map;
+   }
+   public void setIDLClass(String IDLClass) {
+      this.IDLClass = IDLClass;
+   }
+   public String getField() {
+      return this.field;
+   }
+   public String getReltype() {
+      return this.reltype;
+   }
+   public String getKey() {
+      return this.key;
+   }
+   public String getMap() {
+      return this.map;
+   }
+   public String getIDLClass() {
+      return this.IDLClass;
+   }
+}
+

diff --git a/Open-ILS/src/java/org/open_ils/idl/IDLObject.java b/Open-ILS/src/java/org/open_ils/idl/IDLObject.java
new file mode 100644 (file)
index 0000000..aafde6e
--- /dev/null
+++ b/Open-ILS/src/java/org/open_ils/idl/IDLObject.java
@@ -0,0 +1,96 @@
+package org.open_ils.idl;
+import java.util.HashMap;
+import java.util.Iterator;
+
+
+public class IDLObject {
+
+    private String IDLClass;
+    private String fieldMapper;
+    private String controller;
+    private String rptLabel;
+    private HashMap<String, IDLField> fields;
+    private HashMap<String, IDLLink> links;
+    
+    /** true if this is a virtual object (does not live in the database) */
+    private boolean isVirtual;
+    
+    public IDLObject() {
+       fields = new HashMap<String, IDLField>();
+       links = new HashMap<String, IDLLink>();
+    }
+    
+    public String getIDLClass() {
+       return IDLClass;
+    }
+    
+    public void addLink(IDLLink link) {
+       links.put(link.getField(), link);
+    }
+    
+    public void addField(IDLField field) {
+       fields.put(field.getName(), field);
+    }
+    
+    public IDLField getField(String name) {
+        return (IDLField) fields.get(name);
+    }
+
+    public HashMap getFields() {
+        return fields;
+    }
+
+
+    /**
+     * Returns the link object found at the given field on 
+     * this IDLObject.
+     */
+    public IDLLink getLink(String fieldName) {
+        return (IDLLink) links.get(fieldName);
+    }
+    
+    public String getFieldMapper() {
+       return fieldMapper;
+    }
+    
+    public String getController() {
+       return controller;
+    }
+    
+    public String getRptLabel() {
+       return rptLabel;
+    }
+    public boolean isVirtual() {
+       return isVirtual;
+    }
+    
+    public void setIDLClass(String IDLClass) {
+       this.IDLClass = IDLClass;
+    }
+    
+    public void setFieldMapper(String fm) {
+       this.fieldMapper = fm;
+    }
+    public void setController(String controller) {
+       this.controller = controller;
+    }
+    public void setRptLabel(String label) {
+       this.rptLabel = label;
+    }
+    public void setIsVirtual(boolean isVirtual) {
+       this.isVirtual = isVirtual;
+    }
+
+
+    public void toXML(StringBuffer sb) {
+
+        sb.append("\t\t<fields>");
+        Iterator itr = fields.keySet().iterator();        
+        IDLField field;
+        while(itr.hasNext()) {
+            field = fields.get((String) itr.next()); 
+            field.toXML(sb);
+        }
+        sb.append("\t\t</fields>");
+    }
+}

diff --git a/Open-ILS/src/java/org/open_ils/idl/IDLParser.java b/Open-ILS/src/java/org/open_ils/idl/IDLParser.java
new file mode 100644 (file)
index 0000000..d6b8ed3
--- /dev/null
+++ b/Open-ILS/src/java/org/open_ils/idl/IDLParser.java
@@ -0,0 +1,178 @@
+package org.open_ils.idl;
+
+import org.opensrf.util.*;
+
+import java.util.HashMap;
+import java.util.Set;
+import java.util.Iterator;
+
+import java.io.InputStream;
+import java.io.FileInputStream;
+import java.io.IOException;
+
+import javax.xml.stream.*;
+import javax.xml.stream.events.* ;
+import javax.xml.namespace.QName;
+
+
+public class IDLParser {
+
+    public static final String OILS_NS_BASE="http://opensrf.org/spec/IDL/base/v1";
+    public static final String OILS_NS_OBJ="http://open-ils.org/spec/opensrf/IDL/objects/v1";
+    public static final String OILS_NS_OBJ_PREFIX="oils_obj";
+    public static final String OILS_NS_PERSIST="http://open-ils.org/spec/opensrf/IDL/persistance/v1";
+    public static final String OILS_NS_PERSIST_PREFIX="oils_persist";
+    public static final String OILS_NS_REPORTER="http://open-ils.org/spec/opensrf/IDL/reporter/v1";
+    public static final String OILS_NS_REPORTER_PREFIX="reporter";
+
+    /** The source for the IDL XML */
+    InputStream inStream;
+    HashMap<String, IDLObject> IDLObjects;
+    IDLObject current;
+
+    /** If true, we retain the full set of IDL objects in memory.  This is true by default. */
+    private boolean keepIDLObjects;
+
+    public IDLParser() {
+        IDLObjects = new HashMap<String, IDLObject>();
+        keepIDLObjects = true;
+    }
+
+    public IDLParser(String fileName) throws IOException {
+        this(new FileInputStream(fileName));
+    }
+
+    public IDLParser(InputStream inStream) {
+        this();
+        this.inStream = inStream;
+    }
+
+    /**
+    * Parses the IDL XML
+    */
+    public void parse() throws IOException {
+    
+        try {
+            XMLInputFactory factory = XMLInputFactory.newInstance();
+    
+            /** disable as many unused features as possible to speed up the parsing */
+            factory.setProperty(XMLInputFactory.IS_REPLACING_ENTITY_REFERENCES, Boolean.FALSE);
+            factory.setProperty(XMLInputFactory.IS_SUPPORTING_EXTERNAL_ENTITIES, Boolean.FALSE);
+            factory.setProperty(XMLInputFactory.IS_NAMESPACE_AWARE, Boolean.TRUE);
+            factory.setProperty(XMLInputFactory.IS_COALESCING, Boolean.FALSE);
+            factory.setProperty(XMLInputFactory.SUPPORT_DTD, Boolean.FALSE);
+    
+    
+        /** create the stream reader */
+            XMLStreamReader reader = factory.createXMLStreamReader(this.inStream);
+            int eventType;
+    
+            while(reader.hasNext()) {
+                /** cycle through the XML events */
+    
+                eventType = reader.next();
+    
+                switch(eventType) {
+    
+                    case XMLEvent.START_ELEMENT:
+                        handleStartElement(reader);
+                        break;
+    
+                    case XMLEvent.END_ELEMENT: 
+                        handleEndElement(reader);
+                        break;
+                }
+            }
+
+        } catch(javax.xml.stream.XMLStreamException se) {
+            /* throw local exception */
+        }
+   }
+
+   /**
+    * Returns the IDLObject with the given IDLClass 
+    */
+   public IDLObject getObject(String IDLClass) {
+      return (IDLObject) IDLObjects.get(IDLClass);
+   }
+
+    public void handleStartElement(XMLStreamReader reader) {
+
+        if(!OILS_NS_BASE.equals(reader.getNamespaceURI())) return;
+        String localpart = reader.getLocalName();
+    
+        if( "class".equals(localpart) ) {
+            current = new IDLObject();
+            current.setIDLClass(reader.getAttributeValue(null, "id"));
+            current.setController(reader.getAttributeValue(null, "controller"));
+            String persist = reader.getAttributeValue(OILS_NS_PERSIST, "virtual");
+            current.setIsVirtual("persist".equals(reader.getAttributeValue(OILS_NS_PERSIST, "virtual")));
+            return;
+        }
+    
+        if( "field".equals(localpart) ) {
+            IDLField field = new IDLField();
+            field.setName(reader.getAttributeValue(null, "name"));
+            field.setArrayPos(new Integer(reader.getAttributeValue(OILS_NS_OBJ, "array_position")));
+            field.setIsVirtual("true".equals(reader.getAttributeValue(OILS_NS_PERSIST, "virtual")));
+            current.addField(field);
+        }
+
+        if( "link".equals(localpart) ) {
+            IDLLink link = new IDLLink();
+            link.setField(reader.getAttributeValue(null, "field"));
+            link.setReltype(reader.getAttributeValue(null, "reltype"));
+            link.setKey(reader.getAttributeValue(null, "key"));
+            link.setMap(reader.getAttributeValue(null, "map"));
+            link.setIDLClass(reader.getAttributeValue(null, "class"));
+            current.addLink(link);
+        }
+    }
+
+    public void handleEndElement(XMLStreamReader reader) {
+
+        if(!OILS_NS_BASE.equals(reader.getNamespaceURI())) return;
+        String localpart = reader.getLocalName();
+
+        if("class".equals(localpart)) {
+
+            if(keepIDLObjects)
+                IDLObjects.put(current.getIDLClass(), current);
+
+            HashMap fields = current.getFields();
+            String fieldNames[] = new String[fields.size()];
+
+            for(Iterator itr = fields.keySet().iterator(); itr.hasNext(); ) {
+                String key = (String) itr.next();
+                IDLField field = (IDLField) fields.get(key);
+                fieldNames[ field.getArrayPos() ] = field.getName();
+            }
+
+            OSRFRegistry.registerObject(
+                current.getIDLClass(), OSRFRegistry.WireProtocol.ARRAY, fieldNames);
+
+            current = null;
+        }
+    }
+
+
+    public String toXML() {
+        StringBuffer sb = new StringBuffer();
+        Set keys = IDLObjects.keySet();
+        Iterator itr = IDLObjects.keySet().iterator();
+        String IDLClass;
+        IDLObject obj;
+        while(itr.hasNext()) {
+            IDLClass = (String) itr.next();
+            obj = IDLObjects.get(IDLClass);
+            obj.toXML(sb);
+        }
+        return sb.toString();
+    }
+}
+
+
+
+
+
+

diff --git a/Open-ILS/src/java/org/open_ils/test/TestIDL.java b/Open-ILS/src/java/org/open_ils/test/TestIDL.java
new file mode 100644 (file)
index 0000000..e32ba8b
--- /dev/null
+++ b/Open-ILS/src/java/org/open_ils/test/TestIDL.java
@@ -0,0 +1,11 @@
+package org.open_ils.test;
+import org.open_ils.idl.*;
+
+public class TestIDL {
+    public static void main(String args[]) throws Exception {
+        String idlFile = args[0];
+        IDLParser parser = new IDLParser(idlFile);
+        parser.parse();
+        System.out.print(parser.toXML());
+    }
+}