Example usage for java.util ListIterator nextIndex

List of usage examples for java.util ListIterator nextIndex

Introduction

In this page you can find the example usage for java.util ListIterator nextIndex.

Prototype

int nextIndex();

Source Link

Document

Returns the index of the element that would be returned by a subsequent call to #next .

Usage

From source file:com.xmobileapp.rockplayer.LastFmEventImporter.java

/*********************************************
 * /* w ww. j a va2s  . c  om*/
 * insertElementInFullList
 * 
 *********************************************/
public void insertElementInFullList(ArtistEvent artistEvent) {
    /*
     * First Element
     */
    if (artistEventList.isEmpty())
        artistEventList.add(artistEvent);
    else {
        Log.i("STARTCMP", "starting");
        ArtistEvent artistEventItem;
        ListIterator<ArtistEvent> artistEventListIterator = artistEventList.listIterator();
        while (artistEventListIterator.hasNext()) {
            artistEventItem = artistEventListIterator.next();
            Log.i("CMPTIME", artistEvent.dateInMillis + "<" + artistEventItem.dateInMillis);
            if (artistEvent.dateInMillis < artistEventItem.dateInMillis) {
                artistEventList.add(artistEventListIterator.nextIndex() - 1, artistEvent);
                return;
            }
        }
        artistEventList.add(artistEventList.size(), artistEvent);
    }
}

From source file:io.bibleget.BibleGetDB.java

public boolean renewMetaData() {
    if (instance.connect()) {
        try {//from   ww  w  .j a v a  2 s  .c o  m
            DatabaseMetaData dbMeta;
            dbMeta = instance.conn.getMetaData();
            try (ResultSet rs3 = dbMeta.getTables(null, null, "METADATA", null)) {
                if (rs3.next()) {
                    //System.out.println("Table METADATA exists...");
                    try (Statement stmt = instance.conn.createStatement()) {
                        HTTPCaller myHTTPCaller = new HTTPCaller();
                        String myResponse;
                        myResponse = myHTTPCaller.getMetaData("biblebooks");
                        if (myResponse != null) {
                            JsonReader jsonReader = Json.createReader(new StringReader(myResponse));
                            JsonObject json = jsonReader.readObject();
                            JsonArray arrayJson = json.getJsonArray("results");
                            if (arrayJson != null) {
                                ListIterator pIterator = arrayJson.listIterator();
                                while (pIterator.hasNext()) {
                                    try (Statement stmt1 = instance.conn.createStatement()) {
                                        int index = pIterator.nextIndex();
                                        JsonArray currentJson = (JsonArray) pIterator.next();
                                        String biblebooks_str = currentJson.toString(); //.replaceAll("\"", "\\\\\"");
                                        //System.out.println("BibleGetDB line 267: BIBLEBOOKS"+Integer.toString(index)+"='"+biblebooks_str+"'");
                                        String stmt_str = "UPDATE METADATA SET BIBLEBOOKS"
                                                + Integer.toString(index) + "='" + biblebooks_str
                                                + "' WHERE ID=0";
                                        //System.out.println("executing update: "+stmt_str);
                                        int update = stmt1.executeUpdate(stmt_str);
                                        //System.out.println("executeUpdate resulted in: "+Integer.toString(update));
                                        stmt1.close();
                                    }
                                }
                            }

                            arrayJson = json.getJsonArray("languages");
                            if (arrayJson != null) {
                                try (Statement stmt2 = instance.conn.createStatement()) {
                                    String languages_str = arrayJson.toString(); //.replaceAll("\"", "\\\\\"");
                                    String stmt_str = "UPDATE METADATA SET LANGUAGES='" + languages_str
                                            + "' WHERE ID=0";
                                    int update = stmt2.executeUpdate(stmt_str);
                                    stmt2.close();
                                }
                            }
                        }

                        myResponse = myHTTPCaller.getMetaData("bibleversions");
                        if (myResponse != null) {
                            JsonReader jsonReader = Json.createReader(new StringReader(myResponse));
                            JsonObject json = jsonReader.readObject();
                            JsonObject objJson = json.getJsonObject("validversions_fullname");
                            if (objJson != null) {
                                String bibleversions_str = objJson.toString(); //.replaceAll("\"", "\\\\\"");
                                try (Statement stmt3 = instance.conn.createStatement()) {
                                    String stmt_str = "UPDATE METADATA SET VERSIONS='" + bibleversions_str
                                            + "' WHERE ID=0";
                                    int update = stmt3.executeUpdate(stmt_str);
                                    stmt3.close();
                                }

                                Set<String> versionsabbrev = objJson.keySet();
                                if (!versionsabbrev.isEmpty()) {
                                    String versionsabbrev_str = "";
                                    for (String s : versionsabbrev) {
                                        versionsabbrev_str += ("".equals(versionsabbrev_str) ? "" : ",") + s;
                                    }

                                    myResponse = myHTTPCaller
                                            .getMetaData("versionindex&versions=" + versionsabbrev_str);
                                    if (myResponse != null) {
                                        jsonReader = Json.createReader(new StringReader(myResponse));
                                        json = jsonReader.readObject();
                                        objJson = json.getJsonObject("indexes");
                                        if (objJson != null) {
                                            for (String name : objJson.keySet()) {
                                                JsonObjectBuilder tempBld = Json.createObjectBuilder();
                                                JsonObject book_num = objJson.getJsonObject(name);
                                                tempBld.add("book_num", book_num.getJsonArray("book_num"));
                                                tempBld.add("chapter_limit",
                                                        book_num.getJsonArray("chapter_limit"));
                                                tempBld.add("verse_limit",
                                                        book_num.getJsonArray("verse_limit"));
                                                JsonObject temp = tempBld.build();
                                                String versionindex_str = temp.toString(); //.replaceAll("\"", "\\\\\"");
                                                //add new column to METADATA table name+"IDX" VARCHAR(5000)
                                                //update METADATA table SET name+"IDX" = versionindex_str
                                                try (ResultSet rs1 = dbMeta.getColumns(null, null, "METADATA",
                                                        name + "IDX")) {
                                                    boolean updateFlag = false;
                                                    if (rs1.next()) {
                                                        //column already exists
                                                        updateFlag = true;
                                                    } else {
                                                        try (Statement stmt4 = instance.conn
                                                                .createStatement()) {
                                                            String sql = "ALTER TABLE METADATA ADD COLUMN "
                                                                    + name + "IDX VARCHAR(5000)";
                                                            boolean colAdded = stmt4.execute(sql);
                                                            if (colAdded == false) {
                                                                int count = stmt4.getUpdateCount();
                                                                if (count == -1) {
                                                                    //System.out.println("The result is a ResultSet object or there are no more results.");
                                                                } else if (count == 0) {
                                                                    //0 rows affected
                                                                    updateFlag = true;
                                                                }
                                                            }
                                                            stmt4.close();
                                                        }
                                                    }
                                                    if (updateFlag) {
                                                        try (Statement stmt5 = instance.conn
                                                                .createStatement()) {
                                                            String sql1 = "UPDATE METADATA SET " + name
                                                                    + "IDX='" + versionindex_str
                                                                    + "' WHERE ID=0";
                                                            boolean rowsUpdated = stmt5.execute(sql1);
                                                            stmt5.close();
                                                        }
                                                    }
                                                }
                                            }

                                        }
                                    }

                                }

                            }
                        }

                        stmt.close();
                    }
                }
                rs3.close();
            }
            instance.disconnect();
        } catch (SQLException ex) {
            Logger.getLogger(BibleGetDB.class.getName()).log(Level.SEVERE, null, ex);
            return false;
        }
        return true;
    }
    return false;
}

From source file:org.apache.jxtadoop.conf.Configuration.java

private void toString(ArrayList resources, StringBuffer sb) {
    ListIterator i = resources.listIterator();
    while (i.hasNext()) {
        if (i.nextIndex() != 0) {
            sb.append(", ");
        }//from w w w. jav a 2  s  .co  m
        sb.append(i.next());
    }
}

From source file:org.apache.fop.layoutmgr.AbstractBreaker.java

/**
 * Returns the average width of all the lines in the given range.
 * @param effectiveList effective block list to work on
 * @param startElementIndex index of the element starting the range
 * @param endElementIndex   index of the element ending the range
 * @return the average line length, 0 if there's no content
 *//*from w  w  w. j a  v a 2  s .  c  o m*/
private int optimizeLineLength(KnuthSequence effectiveList, int startElementIndex, int endElementIndex) {
    ListIterator<KnuthElement> effectiveListIterator;
    // optimize line length
    int boxCount = 0;
    int accumulatedLineLength = 0;
    int greatestMinimumLength = 0;
    effectiveListIterator = effectiveList.listIterator(startElementIndex);
    while (effectiveListIterator.nextIndex() <= endElementIndex) {
        KnuthElement tempEl = effectiveListIterator.next();
        if (tempEl instanceof KnuthBlockBox) {
            KnuthBlockBox blockBox = (KnuthBlockBox) tempEl;
            if (blockBox.getBPD() > 0) {
                log.debug("PSLM> nominal length of line = " + blockBox.getBPD());
                log.debug("      range = " + blockBox.getIPDRange());
                boxCount++;
                accumulatedLineLength += ((KnuthBlockBox) tempEl).getBPD();
            }
            if (blockBox.getIPDRange().getMin() > greatestMinimumLength) {
                greatestMinimumLength = blockBox.getIPDRange().getMin();
            }
        }
    }
    int averageLineLength = 0;
    if (accumulatedLineLength > 0 && boxCount > 0) {
        averageLineLength = (int) (accumulatedLineLength / boxCount);
        log.debug("Average line length = " + averageLineLength);
        if (averageLineLength < greatestMinimumLength) {
            averageLineLength = greatestMinimumLength;
            log.debug("  Correction to: " + averageLineLength);
        }
    }
    return averageLineLength;
}

From source file:com.aliyun.odps.conf.Configuration.java

@SuppressWarnings("rawtypes")
private void toString(List resources, StringBuffer sb) {
    ListIterator i = resources.listIterator();
    while (i.hasNext()) {
        if (i.nextIndex() != 0) {
            sb.append(", ");
        }//  ww  w  .  j av a 2  s.c om
        sb.append(i.next());
    }
}

From source file:org.apache.fop.layoutmgr.BlockStackingLayoutManager.java

/** {@inheritDoc} */
public int negotiateBPDAdjustment(int adj, KnuthElement lastElement) {
    assert (lastElement != null && lastElement.getPosition() != null);
    Position innerPosition = lastElement.getPosition().getPosition();

    if (innerPosition == null && lastElement.isGlue()) {
        // this adjustment applies to space-before or space-after of this block
        if (((KnuthGlue) lastElement).getAdjustmentClass() == Adjustment.SPACE_BEFORE_ADJUSTMENT) {
            // this adjustment applies to space-before
            adjustedSpaceBefore += adj;//from w  w  w  . ja v  a2 s.c om
        } else {
            // this adjustment applies to space-after
            adjustedSpaceAfter += adj;
        }
        return adj;
    } else if (innerPosition instanceof MappingPosition) {
        // this block has block-progression-unit > 0: the adjustment can concern
        // - the space-before or space-after of this block,
        // - the line number of a descendant of this block
        MappingPosition mappingPos = (MappingPosition) innerPosition;
        if (lastElement.isGlue()) {
            // lastElement is a glue
            ListIterator storedListIterator = storedList.listIterator(mappingPos.getFirstIndex());
            int newAdjustment = 0;
            while (storedListIterator.nextIndex() <= mappingPos.getLastIndex()) {
                KnuthElement storedElement = (KnuthElement) storedListIterator.next();
                if (storedElement.isGlue()) {
                    newAdjustment += ((BlockLevelLayoutManager) storedElement.getLayoutManager())
                            .negotiateBPDAdjustment(adj - newAdjustment, storedElement);
                }
            }
            newAdjustment = (newAdjustment > 0 ? bpUnit * neededUnits(newAdjustment)
                    : -bpUnit * neededUnits(-newAdjustment));
            return newAdjustment;
        } else {
            // lastElement is a penalty: this means that the paragraph
            // has been split between consecutive pages:
            // this may involve a change in the number of lines
            KnuthPenalty storedPenalty = (KnuthPenalty) storedList.get(mappingPos.getLastIndex());
            if (storedPenalty.getWidth() > 0) {
                // the original penalty has width > 0
                return ((BlockLevelLayoutManager) storedPenalty.getLayoutManager())
                        .negotiateBPDAdjustment(storedPenalty.getWidth(), storedPenalty);
            } else {
                // the original penalty has width = 0
                // the adjustment involves only the spaces before and after
                return adj;
            }
        }
    } else if (innerPosition != null && innerPosition.getLM() != this) {
        // this adjustment concerns another LM
        NonLeafPosition savedPos = (NonLeafPosition) lastElement.getPosition();
        lastElement.setPosition(innerPosition);
        int returnValue = ((BlockLevelLayoutManager) lastElement.getLayoutManager()).negotiateBPDAdjustment(adj,
                lastElement);
        lastElement.setPosition(savedPos);
        return returnValue;
    } else {
        // this should never happen
        log.error("BlockLayoutManager.negotiateBPDAdjustment(): unexpected Position");
        return 0;
    }
}

From source file:com.wolvereness.bluebutton.crash.ExceptionMessage.java

public Report(final String text) {
    final ArrayList<String> lines;
    { // _LINES_/*w  w  w.  j a v a  2  s.  c  o  m*/
        int i;
        if ((i = text.indexOf('\r')) != -1) {
            if (text.startsWith("\r\n", i)) { // StartsWith prevents OOB exception
                lines = Splitter.splitAll(text, "\r\n");
            } else {
                lines = Splitter.splitAll(text, '\r');
            }
        } else {
            lines = Splitter.splitAll(text, '\n');
        }
    } // _LINES_

    final ImmutableMap.Builder<Nodes, Node> nodes = ImmutableMap.builder();
    final ListIterator<String> it = lines.listIterator(lines.size() - 1);

    { // _DETAILS_
        int count = 0; // Number of lines with no "- " for sub-listing
        while (true) {
            String entry = it.previous();
            if (entry.startsWith(START)) {
                if (entry.startsWith(WORLD, 2)) {
                    continue; // Process this at end
                }

                final int colon = entry.indexOf(':');
                Nodes type = Nodes.valueOf(entry.substring(2, colon).toUpperCase().replace(' ', '_'));
                if (type == null) {
                    type = Nodes._NA;
                }
                final List<String> subList = lines.subList(it.nextIndex(), it.nextIndex() + count);
                final Node node = type.makeNode(entry.substring(colon + 1), subList);
                nodes.put(type, node);

                count = 0; // Reset count, as it is used for sub-listing
            } else if (entry.equals(DETAILS_START)) {
                {
                    final ArrayList<String> worlds = new ArrayList<String>();
                    while (it.hasNext()) {
                        entry = it.next();
                        if (entry.startsWith(WORLD_START)) {
                            worlds.add(entry);
                        }
                    }
                    nodes.put(Nodes.WORLD, Nodes.WORLD.makeNode(null, worlds));
                }

                while (!it.previous().equals(DETAILS_START)) {
                }
                if (!it.previous().equals("")) // NOTE_0- blank line preceding details check, see NOTE_0- below
                    throw new IllegalStateException("Expected blank line in " + lines.toString());
                while (!it.previous().startsWith(DESCRIPTION_START)) {
                }
                it.next(); // Description_start
                it.next(); // Blank line
                break; // We're done in the loop
            } else {
                count++;
            }
        }
    } // _DETAILS_

    { // _STACK_
        final LinkedList<ExceptionMessage> exceptions = new LinkedList<ExceptionMessage>();
        final List<StackTraceElement> stacks = new ArrayList<StackTraceElement>();
        final List<String> description = new ArrayList<String>();
        description.add(it.next()); // Initialize; first line is always first exception
        for (String entry = it.next(); !entry.equals(DETAILS_START); entry = it.next()) {
            // Read in all the exception information.
            // Apocalypse if the formating changes...
            if (entry.startsWith(STACK_START)) {
                // Normal stack element
                stacks.add(toStackTraceElement(entry));
            } else if (entry.startsWith(STACK_MORE_START)) {
                // "... n more" final line
                final ExceptionMessage previous = exceptions.getLast();
                final List<StackTraceElement> previousTrace = previous.getStackTrace();
                entry = entry.substring(STACK_MORE_START.length(), entry.length() - STACK_MORE_END.length());
                final int stackCount = Integer.valueOf(entry);
                stacks.addAll(previousTrace.subList(previousTrace.size() - stackCount, previousTrace.size()));
                exceptions.add(new ExceptionMessage(description, stacks));

                // Reset our counters
                description.clear();
                stacks.clear();
            } else if (entry.startsWith(CAUSED_START)) {
                // Finish old exception
                if (description.size() != 0) {
                    exceptions.add(new ExceptionMessage(description, stacks));
                    description.clear();
                    stacks.clear();
                }

                // New exception
                description.add(entry.substring(CAUSED_START.length()));
            } else {
                // Random description information
                description.add(entry);
            }
        }
        description.remove(description.size() - 1); // NOTE_0- There will be a blank line here, see NOTE_0- above
        if (description.size() != 0) {
            exceptions.add(new ExceptionMessage(description, stacks));
        }

        this.exceptions = ImmutableList.copyOf(exceptions);
    } // _STACK_

    while (!it.previous().startsWith(DESCRIPTION_START)) {
    } // This puts us on the line before the "description:"
    it.next(); // Push iterator for description_start to hit twice

    this.description = it.previous().substring(DESCRIPTION_START.length());

    { // _TIMESTAMP_
        final String timeStamp = it.previous().substring(TIME_START.length());
        Date time = null;
        try {
            time = (Date) DateFormatUtils.ISO_DATETIME_TIME_ZONE_FORMAT.parseObject(timeStamp);
        } catch (final ParseException ex) {
            try {
                time = new SimpleDateFormat().parse(timeStamp);
            } catch (final ParseException e) {
            }
        }
        this.time = time == null ? new Date(0l) : time;
    } // _TIMESTAMP_

    it.previous(); // Blank line after joke
    this.fun = it.previous();

    this.nodes = nodes.build();
}

From source file:org.canova.api.conf.Configuration.java

private void toString(List resources, StringBuilder sb) {
    ListIterator i = resources.listIterator();
    while (i.hasNext()) {
        if (i.nextIndex() != 0) {
            sb.append(", ");
        }//from  w w  w  .  ja  va  2 s. c om
        sb.append(i.next());
    }
}

From source file:org.apache.hadoop.conf.Configuration.java

private void toString(List resources, StringBuffer sb) {
    ListIterator i = resources.listIterator();
    while (i.hasNext()) {
        if (i.nextIndex() != 0) {
            sb.append(", ");
        }//from   www.j  av a 2 s. co  m
        sb.append(i.next());
    }
}

From source file:io.bibleget.BibleGetDB.java

public boolean initialize() {

    try {// w  ww  . j  ava  2 s  .c o  m
        instance.conn = DriverManager.getConnection("jdbc:derby:BIBLEGET;create=true", "bibleget", "bibleget");
        if (instance.conn == null) {
            System.out.println("Careful there! Connection not established! BibleGetDB.java line 81");
        } else {
            System.out.println("conn is not null, which means a connection was correctly established.");
        }
        DatabaseMetaData dbMeta;
        dbMeta = instance.conn.getMetaData();
        try (ResultSet rs1 = dbMeta.getTables(null, null, "OPTIONS", null)) {
            if (rs1.next()) {
                //System.out.println("Table "+rs1.getString("TABLE_NAME")+" already exists !!");
                listColNamesTypes(dbMeta, rs1);
            } else {
                //System.out.println("Table OPTIONS does not yet exist, now attempting to create...");
                try (Statement stmt = instance.conn.createStatement()) {

                    String defaultFont = "";
                    if (SystemUtils.IS_OS_WINDOWS) {
                        defaultFont = "Times New Roman";
                    } else if (SystemUtils.IS_OS_MAC_OSX) {
                        defaultFont = "Helvetica";
                    } else if (SystemUtils.IS_OS_LINUX) {
                        defaultFont = "Arial";
                    }

                    String tableCreate = "CREATE TABLE OPTIONS (" + "PARAGRAPHALIGNMENT VARCHAR(15), "
                            + "PARAGRAPHLINESPACING INT, " + "PARAGRAPHFONTFAMILY VARCHAR(50), "
                            + "PARAGRAPHLEFTINDENT INT, " + "TEXTCOLORBOOKCHAPTER VARCHAR(15), "
                            + "BGCOLORBOOKCHAPTER VARCHAR(15), " + "BOLDBOOKCHAPTER BOOLEAN, "
                            + "ITALICSBOOKCHAPTER BOOLEAN, " + "UNDERSCOREBOOKCHAPTER BOOLEAN, "
                            + "FONTSIZEBOOKCHAPTER INT, " + "VALIGNBOOKCHAPTER VARCHAR(15), "
                            + "TEXTCOLORVERSENUMBER VARCHAR(15), " + "BGCOLORVERSENUMBER VARCHAR(15), "
                            + "BOLDVERSENUMBER BOOLEAN, " + "ITALICSVERSENUMBER BOOLEAN, "
                            + "UNDERSCOREVERSENUMBER BOOLEAN, " + "FONTSIZEVERSENUMBER INT, "
                            + "VALIGNVERSENUMBER VARCHAR(15), " + "TEXTCOLORVERSETEXT VARCHAR(15), "
                            + "BGCOLORVERSETEXT VARCHAR(15), " + "BOLDVERSETEXT BOOLEAN, "
                            + "ITALICSVERSETEXT BOOLEAN, " + "UNDERSCOREVERSETEXT BOOLEAN, "
                            + "FONTSIZEVERSETEXT INT, " + "VALIGNVERSETEXT VARCHAR(15), "
                            + "PREFERREDVERSIONS VARCHAR(50), " + "NOVERSIONFORMATTING BOOLEAN" + ")";

                    String tableInsert;
                    tableInsert = "INSERT INTO OPTIONS (" + "PARAGRAPHALIGNMENT," + "PARAGRAPHLINESPACING,"
                            + "PARAGRAPHFONTFAMILY," + "PARAGRAPHLEFTINDENT," + "TEXTCOLORBOOKCHAPTER,"
                            + "BGCOLORBOOKCHAPTER," + "BOLDBOOKCHAPTER," + "ITALICSBOOKCHAPTER,"
                            + "UNDERSCOREBOOKCHAPTER," + "FONTSIZEBOOKCHAPTER," + "VALIGNBOOKCHAPTER,"
                            + "TEXTCOLORVERSENUMBER," + "BGCOLORVERSENUMBER," + "BOLDVERSENUMBER,"
                            + "ITALICSVERSENUMBER," + "UNDERSCOREVERSENUMBER," + "FONTSIZEVERSENUMBER,"
                            + "VALIGNVERSENUMBER," + "TEXTCOLORVERSETEXT," + "BGCOLORVERSETEXT,"
                            + "BOLDVERSETEXT," + "ITALICSVERSETEXT," + "UNDERSCOREVERSETEXT,"
                            + "FONTSIZEVERSETEXT," + "VALIGNVERSETEXT," + "PREFERREDVERSIONS, "
                            + "NOVERSIONFORMATTING" + ") VALUES (" + "'justify',100,'" + defaultFont + "',0,"
                            + "'#0000FF','#FFFFFF',true,false,false,14,'initial',"
                            + "'#AA0000','#FFFFFF',false,false,false,10,'super',"
                            + "'#696969','#FFFFFF',false,false,false,12,'initial'," + "'NVBSE'," + "false"
                            + ")";
                    boolean tableCreated = stmt.execute(tableCreate);
                    boolean rowsInserted;
                    int count;
                    if (tableCreated == false) {
                        //is false when it's an update count!
                        count = stmt.getUpdateCount();
                        if (count == -1) {
                            //System.out.println("The result is a ResultSet object or there are no more results.");
                        } else {
                            //this is our expected behaviour: 0 rows affected
                            //System.out.println("The Table Creation statement produced results: "+count+" rows affected.");
                            try (Statement stmt2 = instance.conn.createStatement()) {
                                rowsInserted = stmt2.execute(tableInsert);
                                if (rowsInserted == false) {
                                    count = stmt2.getUpdateCount();
                                    if (count == -1) {
                                        //System.out.println("The result is a ResultSet object or there are no more results.");
                                    } else {
                                        //this is our expected behaviour: n rows affected
                                        //System.out.println("The Row Insertion statement produced results: "+count+" rows affected.");
                                        dbMeta = instance.conn.getMetaData();
                                        try (ResultSet rs2 = dbMeta.getTables(null, null, "OPTIONS", null)) {
                                            if (rs2.next()) {
                                                listColNamesTypes(dbMeta, rs2);
                                            }
                                            rs2.close();
                                        }
                                    }
                                } else {
                                    //is true when it returns a resultset, which shouldn't be the case here
                                    try (ResultSet rx = stmt2.getResultSet()) {
                                        while (rx.next()) {
                                            //System.out.println("This isn't going to happen anyways, so...");
                                        }
                                        rx.close();
                                    }
                                }
                                stmt2.close();
                            }
                        }

                    } else {
                        //is true when it returns a resultset, which shouldn't be the case here
                        try (ResultSet rx = stmt.getResultSet()) {
                            while (rx.next()) {
                                //System.out.println("This isn't going to happen anyways, so...");
                            }
                            rx.close();
                        }
                    }
                    stmt.close();
                }
            }
            rs1.close();
        }
        //System.out.println("Finished with first ResultSet resource, now going on to next...");
        try (ResultSet rs3 = dbMeta.getTables(null, null, "METADATA", null)) {
            if (rs3.next()) {
                //System.out.println("Table "+rs3.getString("TABLE_NAME")+" already exists !!");
            } else {
                //System.out.println("Table METADATA does not exist, now attempting to create...");
                try (Statement stmt = instance.conn.createStatement()) {
                    String tableCreate = "CREATE TABLE METADATA (";
                    tableCreate += "ID INT, ";
                    for (int i = 0; i < 73; i++) {
                        tableCreate += "BIBLEBOOKS" + Integer.toString(i) + " VARCHAR(2000), ";
                    }
                    tableCreate += "LANGUAGES VARCHAR(500), ";
                    tableCreate += "VERSIONS VARCHAR(2000)";
                    tableCreate += ")";
                    boolean tableCreated = stmt.execute(tableCreate);
                    boolean rowsInserted;
                    int count;
                    if (tableCreated == false) {
                        //this is the expected result, is false when it's an update count!
                        count = stmt.getUpdateCount();
                        if (count == -1) {
                            //System.out.println("The result is a ResultSet object or there are no more results.");
                        } else {
                            //this is our expected behaviour: 0 rows affected
                            //System.out.println("The Table Creation statement produced results: "+count+" rows affected.");
                            //Insert a dummy row, because you cannot update what has not been inserted!                                
                            try (Statement stmtX = instance.conn.createStatement()) {
                                stmtX.execute("INSERT INTO METADATA (ID) VALUES (0)");
                                stmtX.close();
                            }

                            HTTPCaller myHTTPCaller = new HTTPCaller();
                            String myResponse;
                            myResponse = myHTTPCaller.getMetaData("biblebooks");
                            if (myResponse != null) {
                                JsonReader jsonReader = Json.createReader(new StringReader(myResponse));
                                JsonObject json = jsonReader.readObject();
                                JsonArray arrayJson = json.getJsonArray("results");
                                if (arrayJson != null) {

                                    ListIterator pIterator = arrayJson.listIterator();
                                    while (pIterator.hasNext()) {
                                        try (Statement stmt2 = instance.conn.createStatement()) {
                                            int index = pIterator.nextIndex();
                                            JsonArray currentJson = (JsonArray) pIterator.next();
                                            String biblebooks_str = currentJson.toString(); //.replaceAll("\"", "\\\\\"");
                                            //System.out.println("BibleGetDB line 267: BIBLEBOOKS"+Integer.toString(index)+"='"+biblebooks_str+"'");
                                            String stmt_str = "UPDATE METADATA SET BIBLEBOOKS"
                                                    + Integer.toString(index) + "='" + biblebooks_str
                                                    + "' WHERE ID=0";
                                            try {
                                                //System.out.println("executing update: "+stmt_str);
                                                int update = stmt2.executeUpdate(stmt_str);
                                                //System.out.println("executeUpdate resulted in: "+Integer.toString(update));
                                            } catch (SQLException ex) {
                                                Logger.getLogger(BibleGetDB.class.getName()).log(Level.SEVERE,
                                                        null, ex);
                                            }
                                            stmt2.close();
                                        }
                                    }
                                }

                                arrayJson = json.getJsonArray("languages");
                                if (arrayJson != null) {
                                    try (Statement stmt2 = instance.conn.createStatement()) {

                                        String languages_str = arrayJson.toString(); //.replaceAll("\"", "\\\\\"");
                                        String stmt_str = "UPDATE METADATA SET LANGUAGES='" + languages_str
                                                + "' WHERE ID=0";
                                        try {
                                            int update = stmt2.executeUpdate(stmt_str);
                                        } catch (SQLException ex) {
                                            Logger.getLogger(BibleGetDB.class.getName()).log(Level.SEVERE, null,
                                                    ex);
                                        }
                                        stmt2.close();
                                    }
                                }
                            }

                            myResponse = myHTTPCaller.getMetaData("bibleversions");
                            if (myResponse != null) {
                                JsonReader jsonReader = Json.createReader(new StringReader(myResponse));
                                JsonObject json = jsonReader.readObject();
                                JsonObject objJson = json.getJsonObject("validversions_fullname");
                                if (objJson != null) {
                                    String bibleversions_str = objJson.toString(); //.replaceAll("\"", "\\\\\"");
                                    try (Statement stmt2 = instance.conn.createStatement()) {
                                        String stmt_str = "UPDATE METADATA SET VERSIONS='" + bibleversions_str
                                                + "' WHERE ID=0";
                                        try {
                                            int update = stmt2.executeUpdate(stmt_str);
                                        } catch (SQLException ex) {
                                            Logger.getLogger(BibleGetDB.class.getName()).log(Level.SEVERE, null,
                                                    ex);
                                        }
                                        stmt2.close();
                                    }

                                    Set<String> versionsabbrev = objJson.keySet();
                                    if (!versionsabbrev.isEmpty()) {
                                        String versionsabbrev_str = "";
                                        for (String s : versionsabbrev) {
                                            versionsabbrev_str += ("".equals(versionsabbrev_str) ? "" : ",")
                                                    + s;
                                        }

                                        myResponse = myHTTPCaller
                                                .getMetaData("versionindex&versions=" + versionsabbrev_str);
                                        if (myResponse != null) {
                                            jsonReader = Json.createReader(new StringReader(myResponse));
                                            json = jsonReader.readObject();
                                            objJson = json.getJsonObject("indexes");
                                            if (objJson != null) {

                                                for (String name : objJson.keySet()) {
                                                    JsonObjectBuilder tempBld = Json.createObjectBuilder();
                                                    JsonObject book_num = objJson.getJsonObject(name);
                                                    tempBld.add("book_num", book_num.getJsonArray("book_num"));
                                                    tempBld.add("chapter_limit",
                                                            book_num.getJsonArray("chapter_limit"));
                                                    tempBld.add("verse_limit",
                                                            book_num.getJsonArray("verse_limit"));
                                                    JsonObject temp = tempBld.build();
                                                    String versionindex_str = temp.toString(); //.replaceAll("\"", "\\\\\"");
                                                    //add new column to METADATA table name+"IDX" VARCHAR(5000)
                                                    //update METADATA table SET name+"IDX" = versionindex_str
                                                    try (Statement stmt3 = instance.conn.createStatement()) {
                                                        String sql = "ALTER TABLE METADATA ADD COLUMN " + name
                                                                + "IDX VARCHAR(5000)";
                                                        boolean colAdded = stmt3.execute(sql);
                                                        if (colAdded == false) {
                                                            count = stmt3.getUpdateCount();
                                                            if (count == -1) {
                                                                //System.out.println("The result is a ResultSet object or there are no more results.");
                                                            } else if (count == 0) {
                                                                //0 rows affected
                                                                stmt3.close();

                                                                try (Statement stmt4 = instance.conn
                                                                        .createStatement()) {
                                                                    String sql1 = "UPDATE METADATA SET " + name
                                                                            + "IDX='" + versionindex_str
                                                                            + "' WHERE ID=0";
                                                                    boolean rowsUpdated = stmt4.execute(sql1);
                                                                    if (rowsUpdated == false) {
                                                                        count = stmt4.getUpdateCount();
                                                                        if (count == -1) {
                                                                            //System.out.println("The result is a ResultSet object or there are no more results.");
                                                                        } else {
                                                                            //should have affected only one row
                                                                            if (count == 1) {
                                                                                //System.out.println(sql1+" seems to have returned true");
                                                                                stmt4.close();
                                                                            }
                                                                        }
                                                                    } else {
                                                                        //returns true only when returning a resultset; should not be the case here
                                                                    }

                                                                }

                                                            }
                                                        } else {
                                                            //returns true only when returning a resultset; should not be the case here
                                                        }

                                                        stmt3.close();
                                                    }
                                                }

                                            }
                                        }

                                    }

                                }
                            }

                        }
                    } else {
                        //is true when it returns a resultset, which shouldn't be the case here
                        ResultSet rx = stmt.getResultSet();
                        while (rx.next()) {
                            //System.out.println("This isn't going to happen anyways, so...");
                        }
                    }
                    stmt.close();
                }
            }
            rs3.close();
        }
        instance.conn.close();
        return true;
    } catch (SQLException ex) {
        if (ex.getSQLState().equals("X0Y32")) {
            Logger.getLogger(BibleGetDB.class.getName()).log(Level.INFO, null,
                    "Table OPTIONS or Table METADATA already exists.  No need to recreate");
            return true;
        } else if (ex.getNextException().getErrorCode() == 45000) {
            //this means we already have a connection, so this is good too
            return true;
        } else {
            //Logger.getLogger(BibleGetDB.class.getName()).log(Level.SEVERE, null, ex.getMessage() + " : " + Arrays.toString(ex.getStackTrace()));
            Logger.getLogger(BibleGetDB.class.getName()).log(Level.SEVERE, null, ex);
            return false;
        }
    }
}