static void indexDocs(IndexWriter writer, File file)
            throws IOException {
        // do not try to index files that cannot be read
        if (file.canRead()) {
            if (file.isDirectory()) {
                String[] files = file.list();
                // an IO error could occur
                if (files != null) {
                    for (int i = 0; i < files.length; i++) {
                        indexDocs(writer, new File(file, files[i]));
                    }
                }
            } else {

                FileInputStream fis;
                try {
                    fis = new FileInputStream(file);
                } catch (FileNotFoundException fnfe) {
                    // at least on windows, some temporary files raise this exception with an "access denied" message
                    // checking if the file can be read doesn't help
                    return;
                }

                try {

                    // make a new, empty document

                    org.w3c.dom.Document XMLDoc = DocumentBuilderFactory.newInstance()
                            .newDocumentBuilder().parse(file);
                    NodeList nodeList = XMLDoc.getElementsByTagName("doc");
                    for (int i = 0; i < nodeList.getLength(); i++) {
                        Document doc = new Document();
                        NodeList childList = nodeList.item(i).getChildNodes();
                        String id = childList.item(1).getTextContent();
                        String title = childList.item(3).getTextContent();
                        String content = childList.item(5).getTextContent();
                        String level = childList.item(7).getTextContent();
                        String type = childList.item(9).getTextContent();
                        String about = childList.item(11).getTextContent();

                        Field f = new StringField("id", id, Field.Store.YES);
                        doc.add(f);
                        f = new TextField("title", title, Field.Store.YES);
                        doc.add(f);
                        f = new TextField("content", content, Field.Store.YES);
                        doc.add(f);
                        f = new StringField("level", level, Field.Store.YES);
                        doc.add(f);
                        f = new TextField("type", type, Field.Store.YES);
                        doc.add(f);
                        f = new TextField("about", about, Field.Store.YES);
                        doc.add(f);
                        if (writer.getConfig().getOpenMode() == OpenMode.CREATE) {
                            // New index, so we just add the document (no old document can be there):
                            System.out.println("adding " + file);
                            writer.addDocument(doc);
                        } else {
                            // Existing index (an old copy of this document may have been indexed) so
                            // we use updateDocument instead to replace the old one matching the exact
                            // path, if present:
                            System.out.println("updating " + file);
                            writer.updateDocument(new Term("path", file.getPath()), doc);
                        }

                    }

                    // Add the path of the file as a field named "path".  Use a
                    // field that is indexed (i.e. searchable), but don't tokenize
                    // the field into separate words and don't index term frequency
                    // or positional information:
//                    Field pathField = new StringField("path", file.getPath(), Field.Store.YES);
//                    doc.add(pathField);

                    // Add the last modified date of the file a field named "modified".
                    // Use a LongField that is indexed (i.e. efficiently filterable with
                    // NumericRangeFilter).  This indexes to milli-second resolution, which
                    // is often too fine.  You could instead create a number based on
                    // year/month/day/hour/minutes/seconds, down the resolution you require.
                    // For example the long value 2011021714 would mean
                    // February 17, 2011, 2-3 PM.
//                    doc.add(new LongField("modified", file.lastModified(), Field.Store.NO));

                    // Add the contents of the file to a field named "contents".  Specify a Reader,
                    // so that the text of the file is tokenized and indexed, but not stored.
                    // Note that FileReader expects the file to be in UTF-8 encoding.
                    // If that's not the case searching for special characters will fail.
                    //                  doc.add(new TextField("contents", new BufferedReader(new InputStreamReader(fis, StandardCharsets.UTF_8))));



                } catch (Exception e) {
                    e.printStackTrace();
                } finally {
                    fis.close();
                }
            }
        }
    }