Exemplo n.º 1
0
 // This process a pretty print from an input string -
 // It does it the hard way - using the methods in this class.
 // It may not be the ideal way to pretty print a XML String
 // but it is our way and we want to be D.R.Y. here...
 // As such you may see some error messages from
 // the XMLMap class in the pretty printing.
 public static String prettyPrint(String input) {
   Map<String, Object> theMap = XMLMap.getFullMap(input);
   return XMLMap.getXML(theMap, true);
 }
Exemplo n.º 2
0
 public static List<Map<String, Object>> getList(String xmlInput, String key) {
   Map<String, Object> tmpMap = XMLMap.getFullMap(xmlInput);
   return XMLMap.getList(tmpMap, key);
 }
Exemplo n.º 3
0
  public static void runSamples() {
    System.out.println("Running XMLMap (www.mdom.org) Samples...");
    debugFlag = false;

    // Test the parsing of a Basic string Map
    Map<String, String> tm = XMLMap.getMap(simpleText);
    // System.out.println("tm="+tm);

    // Test the production of a basic map
    Map<String, String> simpleMap = new TreeMap<String, String>();
    simpleMap.put("/a/b!x", "X");
    simpleMap.put("/a/b", "B");
    simpleMap.put("/a/c/d", "D");
    System.out.println("simpleMap\n" + simpleMap);
    String simpleXml = XMLMap.getXML(simpleMap, true);
    System.out.println("simpleXml\n" + simpleXml);
    unitTest(simpleXml, false);

    // Do a select of a subMap
    Map<String, String> subMap = XMLMap.selectSubMap(tm, "/a/c");
    Map<String, Object> joinedMap = new TreeMap<String, Object>();
    System.out.println("subMap=" + subMap);
    joinedMap.put("/top/id", "1234");
    joinedMap.put("/top/fun", subMap); // Graft the map onto this node
    System.out.println("joinedMap\n" + joinedMap);
    String joinedXml = XMLMap.getXML(joinedMap, true);
    System.out.println("joinedXML\n" + joinedXml);
    unitTest(joinedXml, false);

    // Do an Array
    Map<String, Object> arrayMap = new TreeMap<String, Object>();
    String[] arrayStr = {"first", "second", "third"};
    arrayMap.put("/root/stuff", arrayStr);
    System.out.println("arrayMap\n" + arrayMap);
    String arrayXml = XMLMap.getXML(arrayMap, true);
    System.out.println("arrayXml\n" + arrayXml);
    unitTest(arrayXml, false);

    // Make a Map that is a combination of Maps, String, and Arrays
    Map<String, Object> newMap = new TreeMap<String, Object>();

    newMap.put("/Root/milton", "Root-milton");
    newMap.put("/Root/joe", "Root-joe");

    Map<String, String> m2 = new TreeMap<String, String>();
    m2.put("/fred/a", "fred-a");
    m2.put("/fred/b", "fred-b");
    newMap.put("/Root/freds", m2);

    // Add a list of maps
    // <Root>
    //   <maps>
    //     <map>
    //       <key>key-0</key>
    //       <val>val-0</val>
    //     </map>
    //     <map>
    //       <key>key-1</key>
    //       <val>val-1</val>
    //     </map>
    //   </maps>
    // </Root>

    List<Map<String, String>> lm = new ArrayList<Map<String, String>>();
    Map<String, String> m3 = null;
    m3 = new TreeMap<String, String>();
    m3.put("/key", "key-0");
    m3.put("/val", "val-0");
    lm.add(m3);

    m3 = new TreeMap<String, String>();
    m3.put("/key", "key-1");
    m3.put("/val", "val-1");
    lm.add(m3);

    newMap.put("/Root/maps/map", lm);

    // Add an array of Strings
    // <Root>
    //   <array>first</array>
    //   <array>second</array>
    //   <array>third</array>
    // </Root>

    String[] strar = {"first", "second", "third"};
    newMap.put("/Root/array", strar);

    // Add a list of Maps - this is a bit of a weird application - mostly as a
    // completeness test to insure lists of maps and arrays are equivalent.  Also
    // since the getFullMap returns maps, not Arrays of strings, this is necessary
    // to insure symmetry - i.e. we can take a map structure we produce and
    // regenerate the XML.  Most users will not use this form in construction.
    //
    // <Root>
    //     <item>item-1</item>
    //     <item>item-2</item>
    // </Root>

    List<Map<String, String>> l1 = new ArrayList<Map<String, String>>();
    Map<String, String> m4 = new TreeMap<String, String>();
    m4.put("/", "item-1");
    l1.add(m4);
    Map<String, String> m5 = new TreeMap<String, String>();
    m5.put("/", "item-2");
    l1.add(m5);
    newMap.put("/Root/item", l1);

    // Put in using the XMLMap bracket Syntax - not a particularly good
    // Way to represent multiple items - it is just here for completeness.
    newMap.put("/Root/anns/ann[0]", "Root-ann[0]");
    newMap.put("/Root/anns/ann[1]", "Root-ann[1]");
    newMap.put("/Root/bobs/bob[0]/key", "Root-bobs-bob[0]-key");
    newMap.put("/Root/bobs/bob[0]/val", "Root-bobs-bob[0]-val");
    newMap.put("/Root/bobs/bob[1]/key", "Root-bobs-bob[1]-key");
    newMap.put("/Root/bobs/bob[1]/val", "Root-bobs-bob[1]-val");

    // This is not allowed because maps cannot have duplicates
    /*
          Map<String,String> m6 = new TreeMap<String,String>();
          m5.put("/two", "two-1");
          m5.put("/two", "two-2");
          newMap.put("/Root", m6);
    */

    // Take the Map - turn it into XML and then parse the returned
    // XML into a second map - take the second map and produce more XML
    // If all goes well, the two generated blobs of XML should be the
    // same.  If anything goes wrong - we re-do it with lots of debug
    String complexXml = null;
    boolean success = false;
    debugFlag = false;
    try {
      complexXml = XMLMap.getXML(newMap, true);
      success = true;
    } catch (Exception e) {
      success = false;
    }

    // If we fail - do it again with deep levels of verbosity
    if (success) {
      unitTest(complexXml, false);
    } else {
      debugFlag = true;
      System.out.println("\n MISMATCH AND/OR SOME ERROR HAS OCCURED - REDO in VERBODE MODE");
      System.out.println("Starting out newMap=" + newMap);
      complexXml = XMLMap.getXML(newMap, true);
      unitTest(complexXml, false);
      debugFlag = false;
    }

    // A different example - iterating through nested sets - demonstrating the short form
    // of getSites() with the first parameter a string -the commented code below is the long form.

    // Map<String,Object> theMap = XMLMap.getFullMap(sitesText);
    // List<Map<String,Object>> theList = XMLMap.getList(theMap, "/sites/site");
    // for ( Map<String,Object> siteMap : theList) {

    // The short form using convenience method if you don't need the map for anything else
    System.out.println("\nParsing Sites Structure");
    for (Map<String, Object> siteMap : XMLMap.getList(sitesText, "/sites/site")) {
      System.out.println("Site=" + siteMap);
      System.out.println("Id=" + XMLMap.getString(siteMap, "/id"));
      for (Map<String, Object> toolMap : XMLMap.getList(siteMap, "/tools/tool")) {
        System.out.println("Tool=" + toolMap);
        System.out.println("ToolId=" + XMLMap.getString(toolMap, "/toolid"));
        for (Map<String, Object> property : XMLMap.getList(toolMap, "/properties/property")) {
          System.out.println("key=" + XMLMap.getString(property, "/key"));
          System.out.println("val=" + XMLMap.getString(property, "/val"));
        }
      }
    }

    // Lets parse some RSS as a final kind of easy but quite practical test
    debugFlag = false;
    System.out.println("\nParsing RSS Feed");
    // System.out.println(XMLMap.prettyPrint(rssText));
    Map<String, Object> rssFullMap = XMLMap.getFullMap(rssText);
    System.out.println("RSS Full Map\n" + rssFullMap);
    System.out.println("Rss Version=" + XMLMap.getString(rssFullMap, "/rss!version"));
    System.out.println("Chan-desc=" + XMLMap.getString(rssFullMap, "/rss/channel/description"));
    System.out.println("Chan-title=" + XMLMap.getString(rssFullMap, "/rss/channel/title"));

    Map<String, String> rssStringMap = XMLMap.flattenMap(rssFullMap);
    System.out.println("RSS Flat String Only Map\n" + rssStringMap);
    System.out.println("Rss Version=" + rssStringMap.get("/rss!version"));
    System.out.println("Chan-desc=" + rssStringMap.get("/rss/channel/description"));
    System.out.println("Chan-title=" + rssStringMap.get("/rss/channel/title"));

    for (Map<String, Object> rssItem : XMLMap.getList(rssFullMap, "/rss/channel/item")) {
      System.out.println("=== Item ===");
      System.out.println(" Item-title=" + XMLMap.getString(rssItem, "/title"));
      System.out.println(" Item-description=" + XMLMap.getString(rssItem, "/description"));
      System.out.println(" Item-link=" + XMLMap.getString(rssItem, "/link"));
    }
  }