public void testWithDummyExtSubset() throws Exception {
    final String XML =
        "<!DOCTYPE root PUBLIC '//some//public//id' 'no-such-thing.dtd'>\n" + "<root />";

    SAXParserFactoryImpl spf = new SAXParserFactoryImpl();
    spf.setNamespaceAware(true);
    SAXParser sp = spf.newSAXParser();
    DefaultHandler h = new DefaultHandler();

    /* First: let's verify that we get an exception for
     * unresolved reference...
     */
    try {
      sp.parse(new InputSource(new StringReader(XML)), h);
    } catch (SAXException e) {
      verifyException(e, "No such file or directory");
    }

    // And then with dummy resolver; should work ok now
    sp = spf.newSAXParser();
    sp.getXMLReader().setEntityResolver(new MyResolver("   "));
    h = new DefaultHandler();
    try {
      sp.parse(new InputSource(new StringReader(XML)), h);
    } catch (SAXException e) {
      fail(
          "Should not have failed with entity resolver, got ("
              + e.getClass()
              + "): "
              + e.getMessage());
    }
  }
 public List<Book> getBooks(InputStream xmlStream) throws Exception {
   SAXParserFactory factory = SAXParserFactory.newInstance();
   SAXParser parser = factory.newSAXParser();
   SaxParseService handler = new SaxParseService();
   parser.parse(xmlStream, handler);
   return handler.getBooks();
 }
 @Test
 public void test1() throws Exception {
   SAXParser parser = createParser();
   parser.parse(
       Bug4991020.class.getResource("Bug4991020.xml").toExternalForm(),
       new util.DraconianErrorHandler());
 }
Example #4
0
 /**
  * Uses PackInHandler to update AD.
  *
  * @param fileName xml file to read
  * @return status message
  */
 public String importXML(String fileName, Properties ctx, String trxName) throws Exception {
   log.info("importXML:" + fileName);
   File in = new File(fileName);
   if (!in.exists()) {
     String msg = "File does not exist: " + fileName;
     log.info("importXML:" + msg);
     return msg;
   }
   try {
     log.info("starting");
     System.setProperty(
         "javax.xml.parsers.SAXParserFactory", "org.apache.xerces.jaxp.SAXParserFactoryImpl");
     PackInHandler handler = new PackInHandler();
     handler.set_TrxName(trxName);
     handler.setCtx(ctx);
     handler.setProcess(this);
     SAXParserFactory factory = SAXParserFactory.newInstance();
     SAXParser parser = factory.newSAXParser();
     String msg = "Start Parser";
     log.info(msg);
     parser.parse(in, handler);
     msg = "End Parser";
     log.info(msg);
     return "OK.";
   } catch (Exception e) {
     log.log(Level.SEVERE, "importXML:", e);
     throw e;
   }
 }
 private void processCommentLines(File file) throws SAXException, IOException {
   SAXParser parser = newSaxParser(false);
   XMLReader xmlReader = parser.getXMLReader();
   commentHandler = new CommentHandler();
   xmlReader.setProperty("http://xml.org/sax/properties/lexical-handler", commentHandler);
   parser.parse(FileUtils.openInputStream(file), commentHandler);
 }
  public static boolean compareXMLContent(final InputSource content1, final InputSource content2)
      throws ParserConfigurationException, SAXException, IOException {
    final SAXParserFactory parserFactory = SAXParserFactory.newInstance();
    parserFactory.setNamespaceAware(true);
    parserFactory.setValidating(false);

    final SAXParser parser = parserFactory.newSAXParser();

    final IdentitySAXHandler handler1 = new IdentitySAXHandler();
    parser.parse(content1, handler1);

    final IdentitySAXHandler handler2 = new IdentitySAXHandler();
    parser.parse(content2, handler2);

    return (handler1.getRootElement().equals(handler2.getRootElement()));
  }
Example #7
0
  /**
   * Does the actual parsing of a devices.xml file.
   *
   * @param deviceXml the {@link File} to load/parse. This must be an existing file.
   * @param list the list in which to write the parsed {@link LayoutDevice}.
   */
  private void parseLayoutDevices(File deviceXml, List<LayoutDevice> list) {
    // first we validate the XML
    try {
      Source source = new StreamSource(new FileReader(deviceXml));

      CaptureErrorHandler errorHandler = new CaptureErrorHandler(deviceXml.getAbsolutePath());

      Validator validator = LayoutDevicesXsd.getValidator(errorHandler);
      validator.validate(source);

      if (errorHandler.foundError() == false) {
        // do the actual parsing
        LayoutDeviceHandler handler = new LayoutDeviceHandler();

        SAXParser parser = mParserFactory.newSAXParser();
        parser.parse(new InputSource(new FileInputStream(deviceXml)), handler);

        // get the parsed devices
        list.addAll(handler.getDevices());
      }
    } catch (SAXException e) {
      AdtPlugin.log(e, "Error parsing %1$s", deviceXml.getAbsoluteFile());
    } catch (FileNotFoundException e) {
      // this shouldn't happen as we check above.
    } catch (IOException e) {
      AdtPlugin.log(e, "Error reading %1$s", deviceXml.getAbsoluteFile());
    } catch (ParserConfigurationException e) {
      AdtPlugin.log(e, "Error parsing %1$s", deviceXml.getAbsoluteFile());
    }
  }
Example #8
0
  /**
   * @param filename
   * @param docs
   */
  public void parse(String filename, Collection<WikipediaDocument> docs) {
    // System.out.println("::Parser::parse\nFilename=" + filename+ " Docs_size=" + docs.size());
    if (filename == null || filename.isEmpty()) {
      return;
    }
    try {

      InputStreamReader inReader = new InputStreamReader(new FileInputStream(filename), "UTF-8");
      BufferedReader reader = new BufferedReader(inReader);
      InputSource is = new InputSource(reader);
      is.setEncoding("UTF-8");

      SAXParserFactory spf = SAXParserFactory.newInstance();
      SAXParser saxParser = spf.newSAXParser();
      DefaultHandler handler = new XMLParser(docs);

      saxParser.parse(is, handler);

    } catch (IOException x) {
      System.err.println(x);
    } catch (ParserConfigurationException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    } catch (SAXException e) {
      // TODO Auto-generated catch block
      System.out.println("Parsing Terminated");
      e.printStackTrace();
    } finally {
    }
  }
Example #9
0
  /** Responsible for parsing the document */
  public ArrayList<String> parseDocument(URL url) {

    snippets.clear();

    // Adds a factory
    SAXParserFactory factory = SAXParserFactory.newInstance();

    try {

      // adds a new instance of parser
      SAXParser parser = factory.newSAXParser();

      // TODO SHOULD THIS BE MOVED TO MORE PROPER PLACE?
      // Sets user Agent
      System.setProperty("http.agent", "ChaosPoemSearch");

      // Stream xml to parser
      parser.parse(new InputSource(url.openStream()), this);

    } catch (SAXException se) {

    } catch (ParserConfigurationException pce) {

    } catch (ConnectException e) {

    } catch (IOException ie) {

    }

    return snippets;
  }
  private void chargerPresentation(ZipInputStream projectZip)
      throws ParserConfigurationException, SAXException, IOException, FichierException {
    ZipEntry zipEntry = projectZip.getNextEntry();

    while (zipEntry != null && !this.presentationTrouve) {
      DataInputStream data = new DataInputStream(new BufferedInputStream(projectZip));
      if (zipEntry.getName().equals("Presentation.xml")) {
        this.presentationTrouve = true;
        this.print(Application.getApplication().getTraduction("SAX_initialisation"));
        // preparation du parsing
        SAXParserFactory factory = SAXParserFactory.newInstance();
        SAXParser saxparser = factory.newSAXParser();
        this.print(Application.getApplication().getTraduction("presentation_parsing"));
        PresentationHandler handler = new PresentationHandler();
        saxparser.parse(data, handler);
        this.print(Application.getApplication().getTraduction("Presentation_charge"));
      } else {
        zipEntry = projectZip.getNextEntry();
      }
    }
    projectZip.close();
    if (!this.presentationTrouve) {
      throw new FichierException("Presentation");
    }
  }
  public static void main(String[] args)
      throws IOException, TasteException, SAXException, ParserConfigurationException {
    String docIdsTitle = "src/main/resources/docIdsTitles.xml";
    long userId = 2;
    // Integer neighbors = Integer.parseInt(args[2]);
    InputSource is = new InputSource(new FileInputStream(docIdsTitle));
    SAXParserFactory factory = SAXParserFactory.newInstance();
    factory.setValidating(false);
    SAXParser sp = factory.newSAXParser();
    WikiContentHandler handler = new WikiContentHandler();
    sp.parse(is, handler);

    MysqlConnectionPoolDataSource dataSource = new MysqlConnectionPoolDataSource();
    dataSource.setDatabaseName("se");
    dataSource.setUser("root");
    dataSource.setPassword("");
    dataSource.setCachePreparedStatements(true);
    dataSource.setCachePrepStmts(true);
    dataSource.setCacheResultSetMetadata(true);
    dataSource.setAlwaysSendSetIsolation(false);
    dataSource.setElideSetAutoCommits(true);
    // create the data model
    DataModel dataModel = new JDBCDataModelImpl(new ConnectionPoolDataSource(dataSource));
    // Create an ItemSimilarity
    ItemSimilarity itemSimilarity = new LogLikelihoodSimilarity(dataModel);
    // Create an Item Based Recommender
    ItemBasedRecommender recommender = new GenericItemBasedRecommender(dataModel, itemSimilarity);
    // Get the recommendations
    List<RecommendedItem> recommendations = recommender.recommend(userId, 5);
    // TasteUtils.printRecs(recommendations, handler.map);
    for (RecommendedItem recommendedItem : recommendations) {
      System.out.println("User:"******"Movie ID : " + recommendedItem);
    }
  }
Example #12
0
  /**
   * Contact the remote WebDAV server and do a PROPFIND lookup, returning a {@link List} of all
   * scavenged resources.
   */
  private List propfind(Location location) throws IOException {
    /* Create the new HttpClient instance associated with the location */
    final HttpClient client = new HttpClient(location);
    client.addRequestHeader("Depth", "1");
    client.setAcceptableStatus(207).connect("PROPFIND", true);

    /* Get the XML SAX Parser and parse the output of the PROPFIND */
    try {
      final SAXParserFactory factory = SAXParserFactory.newInstance();
      factory.setValidating(false);
      factory.setNamespaceAware(true);
      final SAXParser parser = factory.newSAXParser();
      final String systemId = location.toString();
      final InputSource source = new InputSource(systemId);
      final Handler handler = new Handler(location);
      source.setByteStream(client.getResponseStream());
      parser.parse(source, handler);
      return handler.list;

    } catch (ParserConfigurationException exception) {
      Exception throwable = new IOException("Error creating XML parser");
      throw (IOException) throwable.initCause(exception);
    } catch (SAXException exception) {
      Exception throwable = new IOException("Error creating XML parser");
      throw (IOException) throwable.initCause(exception);
    } finally {
      client.disconnect();
    }
  }
Example #13
0
  /* (non-Javadoc)
   * @see org.eclipse.core.internal.jobs.InternalJob#run(org.eclipse.core.runtime.IProgressMonitor)
   */
  protected IStatus run(IProgressMonitor monitor) {
    TreeNode root = new TreeNode("");

    File it = new File(proj.getLocation().addTrailingSeparator() + "goblin.xml");
    if (!it.canRead())
      return new Status(IStatus.ERROR, "ee.ut.goblin", 97, "Can't read analysis file.", null);

    DefaultHandler handler = new XMLHandler(root);
    SAXParserFactory factory = SAXParserFactory.newInstance();

    try {
      // Parse the input
      SAXParser saxParser = factory.newSAXParser();
      saxParser.parse(it, handler);
    } catch (Throwable t) {
      return new Status(IStatus.ERROR, "ee.ut.goblin", 96, t.getMessage(), t);
    }

    TreeAnalysisMap tam = new TreeAnalysisMap((TreeAnalysis) root.getChildren()[0]);

    try {
      proj.setSessionProperty(GoblinPlugin.RESULT_NAME, tam);
    } catch (CoreException e) {
      return new Status(IStatus.ERROR, "ee.ut.goblin", 95, e.getMessage(), e);
    }

    monitor.done();
    return Status.OK_STATUS;
  }
Example #14
0
  public boolean SetDoc(String strDoc) {
    try {
      SaxDoc sax = new SaxDoc();
      SAXParser sp;
      sp = SAXParserFactory.newInstance().newSAXParser();
      sp.parse(new InputSource(new StringReader(strDoc)), sax);

      headNode = sax.getRootNode();
      rootNode = new NodeModel(true);
      rootNode.SetNext(headNode);
      headNode.SetPre(rootNode);
      pointer = rootNode;

      return true;

    } catch (ParserConfigurationException e) {
      e.printStackTrace();
    } catch (SAXException e) {
      e.printStackTrace();
    } catch (IOException e) {
      e.printStackTrace();
    } catch (Exception e) {
    }

    return false;
  }
  public static void main(String argv[]) {
    if (argv.length != 3) {
      System.err.println(
          "Usage: java -server TestSAXOutput <xml file> <times to parse> <output file>");
      System.exit(-1);
    }

    String xmlFile = argv[0];
    int times = (new Integer(argv[1])).intValue();
    outFileName = argv[2];

    try {

      SAXParserFactory factory = SAXParserFactory.newInstance();
      SAXParser parser = factory.newSAXParser();
      TestSAXOutput tsp = new TestSAXOutput();
      for (int i = 0; i < times; i++) {
        parser.parse(xmlFile, tsp);
      }
    } catch (FactoryConfigurationError e) {
      System.err.print("factory configuration error:\n" + e);
    } catch (ParserConfigurationException e) {
      System.err.print("parser configuration error:\n" + e);
    } catch (SAXException e) {
      System.err.print("sax configuration error:\n" + e);
    } catch (IOException e) {
      System.err.print("io error:\n" + e);
    }
  }
  /** {@inheritDoc} */
  public ParseResult parse(RSyntaxDocument doc, String style) {

    result.clearNotices();
    Element root = doc.getDefaultRootElement();
    result.setParsedLines(0, root.getElementCount() - 1);

    if (spf == null || doc.getLength() == 0) {
      return result;
    }

    try {
      SAXParser sp = spf.newSAXParser();
      Handler handler = new Handler(doc);
      DocumentReader r = new DocumentReader(doc);
      InputSource input = new InputSource(r);
      sp.parse(input, handler);
      r.close();
    } catch (SAXParseException spe) {
      // A fatal parse error - ignore; a ParserNotice was already created.
    } catch (Exception e) {
      // e.printStackTrace(); // Will print if DTD specified and can't be found
      result.addNotice(
          new DefaultParserNotice(this, "Error parsing XML: " + e.getMessage(), 0, -1, -1));
    }

    return result;
  }
Example #17
0
  public ArrayList<IProject> getProjects() {
    final ArrayList<IProject> result = new ArrayList<IProject>();
    try {
      IProject featureProject = getFeatureProject();
      IFile featureXMLFile = featureProject.getFile("feature.xml");
      SAXParser parser = SAXParserFactory.newInstance().newSAXParser();

      DefaultHandler handler =
          new DefaultHandler() {
            @Override
            public void startElement(
                String uri, String localName, String qName, Attributes attributes)
                throws SAXException {
              if ("plugin".equals(qName)) {
                String id = attributes.getValue("id");
                IProject eachProject = ResourcesPlugin.getWorkspace().getRoot().getProject(id);
                if (!eachProject.exists()) {
                  throw new BuildException(
                      MessageFormat.format(
                          "아이디가 {0}인 프로젝틀르 찾지 못했습니다. 프로젝트 아이디와 프로젝트 명은 동일한 것으로 간주합니다.", id));
                }
                result.add(eachProject);
              }
            }
          };
      parser.parse(featureXMLFile.getContents(), handler);
    } catch (Exception e) {
      throw new BuildException(e.getMessage(), e);
    }

    return result;
  }
Example #18
0
 public void update() throws IOException, SAXException, ParserConfigurationException {
   MibewResponse response = fConnection.request("operator/update.php", "since=" + fSince);
   SAXParser sp = SAXParserFactory.newInstance().newSAXParser();
   UpdateHandler handler = new UpdateHandler();
   sp.parse(new ByteArrayInputStream(response.getResponse()), handler);
   handleResponse(response, handler);
 }
Example #19
0
 public List<Customer> readDataFromXML(String filename)
     throws ParserConfigurationException, SAXException, IOException {
   SAXParserFactory factory = SAXParserFactory.newInstance();
   SAXParser parser = factory.newSAXParser();
   parser.parse(new File(filename), this);
   return data;
 }
 public VersionInfo getNewestVersionInfo() {
   VersionInfo versionInfo = new VersionInfo();
   HttpClient hc = new DefaultHttpClient();
   HttpGet get = new HttpGet(server_address + "/VersionInfo.xml");
   try {
     HttpResponse response = hc.execute(get);
     if (response.getStatusLine().getStatusCode() == HttpStatus.SC_OK) {
       HttpEntity he = response.getEntity();
       try {
         SAXParserFactory factory = SAXParserFactory.newInstance();
         SAXParser parser = factory.newSAXParser();
         parser.parse(he.getContent(), new VersionSaxHandler(versionInfo));
       } catch (Exception e) {
         Log.e(tag, "xml解析错误");
         return null;
       }
       he.consumeContent();
     }
   } catch (ClientProtocolException e) {
     Log.e(tag, "协议错误");
     return null;
   } catch (IOException e) {
     Log.e(tag, "读写错误");
     return null;
   }
   return versionInfo;
 }
  public boolean updataFeedFromServer(final int page, final int topicId, final int size) {
    Log.d(
        TAG,
        String.format("::updataFeedFromServer(page=%s,topicID=%s,size%s)", page, topicId, size));
    try {
      List<JokeBean> jokeItems = new ArrayList<JokeBean>();
      JokeClient client = new JokeClient();
      ResponseData responseData = client.getJokes(page, size, topicId);

      if (responseData.getStatus()) {
        SAXParser parser = SAXParserFactory.newInstance().newSAXParser();
        JokeBeanHandler handler = new JokeBeanHandler();
        InputSource is = new InputSource(new StringReader(responseData.toString()));
        parser.parse(is, handler);

        jokeItems.addAll(handler.getJokeItems());

        /* Set topic id */
        for (JokeBean item : jokeItems) {
          item.setTopic(topicId);
        }

        /* Now write the joke to cache */
        return db.addAll(jokeItems);
      }
    } catch (Exception e) {
      Log.e(TAG, "" + e.getMessage());
      e.printStackTrace();
    }
    return false;
  }
  @NotNull
  private MostlySingularMultiMap<String, AnnotationData> getDataFromFile(
      @NotNull final PsiFile file) {
    Pair<MostlySingularMultiMap<String, AnnotationData>, Long> cached =
        annotationFileToDataAndModStamp.get(file);
    final long fileModificationStamp = file.getModificationStamp();
    if (cached != null && cached.getSecond() == fileModificationStamp) {
      return cached.getFirst();
    }
    DataParsingSaxHandler handler = new DataParsingSaxHandler(file);
    try {
      SAXParser saxParser = SAXParserFactory.newInstance().newSAXParser();
      saxParser.parse(new InputSource(new StringReader(escapeAttributes(file.getText()))), handler);
    } catch (IOException e) {
      LOG.error(e);
    } catch (ParserConfigurationException e) {
      LOG.error(e);
    } catch (SAXException e) {
      LOG.error(e);
    }

    Pair<MostlySingularMultiMap<String, AnnotationData>, Long> pair =
        Pair.create(handler.getResult(), file.getModificationStamp());
    annotationFileToDataAndModStamp.put(file, pair);

    return pair.first;
  }
  /** Creates new form JPanelButtons */
  public JPanelButtons(String sConfigKey, JPanelTicket panelticket) {
    initComponents();

    // Load categories default thumbnail
    tnbmacro = new ThumbNailBuilder(24, 24, "com/openbravo/images/run_script.png");

    this.panelticket = panelticket;

    props = new Properties();
    events = new HashMap<String, String>();

    String sConfigRes = panelticket.getResourceAsXML(sConfigKey);

    if (sConfigRes != null) {
      try {
        if (m_sp == null) {
          SAXParserFactory spf = SAXParserFactory.newInstance();
          m_sp = spf.newSAXParser();
        }
        m_sp.parse(new InputSource(new StringReader(sConfigRes)), new ConfigurationHandler());

      } catch (ParserConfigurationException ePC) {
        logger.log(Level.WARNING, LocalRes.getIntString("exception.parserconfig"), ePC);
      } catch (SAXException eSAX) {
        logger.log(Level.WARNING, LocalRes.getIntString("exception.xmlfile"), eSAX);
      } catch (IOException eIO) {
        logger.log(Level.WARNING, LocalRes.getIntString("exception.iofile"), eIO);
      }
    }
  }
  /**
   * 根据 xml 文件初始化配置信息,使用 AnalyzeHandler 进行 xml 解析
   *
   * <p>{@link AnalyzeHandler}
   *
   * @param context 上下文
   * @param xmlId xmlId(必须要在 res/raw 文件夹下)
   */
  void initVirtualLightningConfig(Context context, int xmlId) {
    String name = context.getResources().getResourceName(xmlId);

    if (!name.substring(name.indexOf(":") + 1, name.indexOf("/")).equals("raw")) {
      throw new VLInitException("资源文件后缀名不正确!必须为\".xml\"结尾放在\"res/raw\"的XML文件");
    }

    InputStream source = context.getResources().openRawResource(xmlId);

    try {
      SAXParser parser = SAXParserFactory.newInstance().newSAXParser();

      parser.parse(source, new AnalyzeHandler(this));

    } catch (ParserConfigurationException | SAXException | IOException e) {
      throw new VLInitException("解析 XML 文件发生错误:" + e.getMessage());
    } finally {
      try {
        source.close();
      } catch (IOException ignored) {
      }
    }

    initDatabase(context);
  }
  @Override
  public String[] parseResult(SAXParser parser, InputSource is) throws SAXException, IOException {
    ResultHandler handler = new ResultHandler();
    parser.parse(is, handler);

    return handler.getResult();
  }
  public static ParentalControlConcern parse(File file) {

    try {

      log.info("Parsing '" + file.getCanonicalPath() + "'...");
      SAXParserFactory factory = SAXParserFactory.newInstance();
      factory.setNamespaceAware(true);
      factory.setValidating(true);
      SAXParser parser = factory.newSAXParser();
      parser.setProperty(JAXP_SCHEMA_LANGUAGE, W3C_XML_SCHEMA);
      ParentalControlConcernHandler handler = new ParentalControlConcernHandler();
      parser.parse(file, handler);
      log.info("Parsed '" + file.getCanonicalPath() + "'");
      return handler.result;

    } catch (SAXParseException ex) {

      log.error(
          "Could not validate the parental control concern XML file!  Validation error follows.");
      log.error(ex.getMessage());
      ex.printStackTrace();
      return null;

    } catch (Exception ex) {

      log.error(ex);
      return null;
    }
  }
Example #27
0
  // ---- main ----
  public static void main(final String[] argv) {
    if (argv.length != 1) {
      System.err.println(
          "Usage: java "
              + GpxReader.class.getSimpleName()
              + " <file>"); //$NON-NLS-1$ //$NON-NLS-2$
      System.exit(1);
    }

    final long startMillis = System.currentTimeMillis();

    try {
      final File f = new File(argv[0]);
      System.out.println("File size: " + f.length() + " bytes"); // $NON-NLS-1$ //$NON-NLS-2$

      // Use an instance of ourselves as the SAX event handler
      final DefaultHandler handler = new GpxReader();

      // Parse the input with the default (non-validating) parser
      final SAXParser saxParser = SAXParserFactory.newInstance().newSAXParser();
      saxParser.parse(f, handler);
    } catch (final Exception t) {
      t.printStackTrace();
      System.exit(2);
    }

    final long millis = System.currentTimeMillis() - startMillis;
    System.out.println("Time consumed: " + millis + " ms"); // $NON-NLS-1$ //$NON-NLS-2$
  }
  /**
   * {@link SAXParserFactoryUtil#setXIncludeAware}のテストです。
   *
   * @throws Exception
   */
  public void testSetXIncludeAware() throws Exception {
    SAXParserFactory spf = SAXParserFactoryUtil.newInstance();
    SAXParserFactoryUtil.setXIncludeAware(spf, true);
    spf.setNamespaceAware(true);
    SAXParser parser = SAXParserFactoryUtil.newSAXParser(spf);

    InputSource is =
        new InputSource(ResourceUtil.getResourceAsStream("org/seasar/framework/util/include.xml"));
    is.setSystemId("include.xml");
    parser.parse(
        is,
        new DefaultHandler() {

          @Override
          public void startElement(
              String uri, String localName, String qName, Attributes attributes)
              throws SAXException {
            if ("bar".equals(qName)) {
              included = true;
            }
          }

          @Override
          public InputSource resolveEntity(String publicId, String systemId)
              throws IOException, SAXException {
            InputSource is =
                new InputSource(
                    ResourceUtil.getResourceAsStream("org/seasar/framework/util/included.xml"));
            is.setSystemId("included.xml");
            return is;
          }
        });
    assertTrue(included);
  }
 Parser(String uri) {
   try {
     SAXParserFactory parserFactory = SAXParserFactory.newInstance();
     SAXParser parser = parserFactory.newSAXParser();
     ConfigHandler handler = new ConfigHandler();
     parser.getXMLReader().setFeature("http://xml.org/sax/features/validation", true);
     parser.parse(new File(uri), handler);
   } catch (IOException e) {
     System.out.println("Error reading URI: " + e.getMessage());
   } catch (SAXException e) {
     System.out.println("Error in parsing: " + e.getMessage());
   } catch (ParserConfigurationException e) {
     System.out.println("Error in XML parser configuration: " + e.getMessage());
   }
   // System.out.println("Number of Persons : " + Person.numberOfPersons());
   // nameLengthStatistics();
   // System.out.println("Number of Publications with authors/editors: " +
   //                   Publication.getNumberOfPublications());
   // System.out.println("Maximum number of authors/editors in a publication: " +
   //                           Publication.getMaxNumberOfAuthors());
   // publicationCountStatistics();
   // Person.enterPublications();
   // Person.printCoauthorTable();
   // Person.printNamePartTable();
   // Person.findSimilarNames();
 }
Example #30
0
  public boolean read_config(String filename) {

    boolean valid = false;

    try {

      File file = new File(filename);
      if (file.exists()) {

        try {
          SAXParserFactory factory = SAXParserFactory.newInstance();
          SAXParser saxParser = factory.newSAXParser();
          saxParser.parse(file, get_handler());
        } catch (Exception ex) {
          ex.printStackTrace();
        }

      } else {
        System.out.println("The file " + file.getAbsolutePath() + " does not exist.");
      }

    } catch (Exception ex) {
      ex.printStackTrace();
    }

    return valid;
  }