Summary of duplicated code

This page summarizes the code fragments that have been found to be replicated in the code. Only those fragments longer than 30 lines of code are shown.

# duplications	Total lines	Total tokens	Approx # bytes
8	513	1284	5136

You expand and collapse the code fragments using the + buttons. You can also navigate to the source code by clicking on the file names.

ID Files Lines

org.crosswire.jsword.book.sword.AbstractKeyBackend	line 215
org.crosswire.jsword.passage.AbstractKeyList	line 164

# lines : 100


        return visitor.toString();
    }

    /* (non-Javadoc)
     * @see java.lang.Object#equals(java.lang.Object)
     */
    /* @Override */
    public boolean equals(Object obj)
    {
        // Since this can not be null
        if (obj == null)
        {
            return false;
        }

        // Check that that is the same as this
        // Don't use instanceOf since that breaks inheritance
        if (!obj.getClass().equals(this.getClass()))
        {
            return false;
        }

        return compareTo(obj) == 0;
    }

    /* (non-Javadoc)
     * @see java.lang.Object#hashCode()
     */
    public int hashCode()
    {
        return getName().hashCode();
    }

    /* (non-Javadoc)
     * @see java.lang.Comparable#compareTo(java.lang.Object)
     */
    public int compareTo(Object obj)
    {
        Key that = (Key) obj;

        if (this == that)
        {
            return 0;
        }

        if (that == null)
        {
            // he is empty, we are not so he is greater
            return -1;
        }


        int ret = this.getName().compareTo(that.getName());

        if (ret != 0)
        {
            return ret;
        }

        // Compare the contents.
        Iterator thisIter = this.iterator();
        Iterator thatIter = that.iterator();

        Key thisfirst = null;
        Key thatfirst = null;

        if (thisIter.hasNext())
        {
            thisfirst = (Key) thisIter.next();
        }

        if (thatIter.hasNext())
        {
            thatfirst = (Key) thatIter.next();
        }

        if (thisfirst == null)
        {
            if (thatfirst == null)
            {
                // we are both empty, and rank the same
                return 0;
            }
            // i am empty, he is not so we are greater
            return 1;
        }

        if (thatfirst == null)
        {
            // he is empty, we are not so he is greater
            return -1;
        }

        return thisfirst.getName().compareTo(thatfirst.getName());
    }

    /* (non-Javadoc)
     * @see java.lang.Object#clone()
     */
    public Object clone()

org.crosswire.jsword.passage.DefaultLeafKeyList	line 125
org.crosswire.jsword.passage.Verse	line 836

# lines : 96


    }

    /* (non-Javadoc)
     * @see org.crosswire.jsword.passage.Key#getCardinality()
     */
    public int getCardinality()
    {
        return 1;
    }

    /* (non-Javadoc)
     * @see org.crosswire.jsword.passage.Key#isEmpty()
     */
    public boolean isEmpty()
    {
        return false;
    }

    /* (non-Javadoc)
     * @see org.crosswire.jsword.passage.Key#contains(org.crosswire.jsword.passage.Key)
     */
    public boolean contains(Key key)
    {
        return this.equals(key);
    }

    /* (non-Javadoc)
     * @see org.crosswire.jsword.passage.Key#iterator()
     */
    public Iterator iterator()
    {
        return new ItemIterator(this);
    }

    /* (non-Javadoc)
     * @see org.crosswire.jsword.passage.Key#add(org.crosswire.jsword.passage.Key)
     */
    public void addAll(Key key)
    {
        throw new UnsupportedOperationException();
    }

    /* (non-Javadoc)
     * @see org.crosswire.jsword.passage.Key#remove(org.crosswire.jsword.passage.Key)
     */
    public void removeAll(Key key)
    {
        throw new UnsupportedOperationException();
    }

    /* (non-Javadoc)
     * @see org.crosswire.jsword.passage.Key#retain(org.crosswire.jsword.passage.Key)
     */
    public void retainAll(Key key)
    {
        throw new UnsupportedOperationException();
    }

    /* (non-Javadoc)
     * @see org.crosswire.jsword.passage.Key#clear()
     */
    public void clear()
    {
    }

    /* (non-Javadoc)
     * @see org.crosswire.jsword.passage.Key#get(int)
     */
    public Key get(int index)
    {
        if (index == 0)
        {
            return this;
        }
        return null;
    }

    /* (non-Javadoc)
     * @see org.crosswire.jsword.passage.Key#indexOf(org.crosswire.jsword.passage.Key)
     */
    public int indexOf(Key that)
    {
        if (this.equals(that))
        {
            return 0;
        }
        return -1;
    }

    /* (non-Javadoc)
     * @see org.crosswire.jsword.passage.Key#blur(int)
     */
    public void blur(int by, RestrictionType restrict)
    {
        throw new UnsupportedOperationException();
    }

org.crosswire.common.swing.AltFixedSplitPane	line 306
org.crosswire.common.swing.FixedSplitPane	line 217

# lines : 72


    }

    /**
     * Whether visible borders are hinted
     *
     * @return the divider border visiblity hint
     */
    public boolean isVisibleDividerBorder()
    {
        return visibleDividerBorder;
    }

    /**
     * Set a hint whether the border should be visible or not.
     * Look and feels may ignore this.
     *
     * @param newVisibility
     */
    public void setVisibleDividerBorder(boolean newVisibility)
    {
        boolean oldVisibility = isVisibleDividerBorder();
        if (oldVisibility == newVisibility)
        {
            return;
        }
        visibleDividerBorder = newVisibility;
        firePropertyChange(PROPERTYNAME_VISIBLE_DIVIDER_BORDER, oldVisibility, newVisibility);
    }

    /* (non-Javadoc)
     * @see javax.swing.JComponent#updateUI()
     */
    /* @Override */
    public void updateUI()
    {
        super.updateUI();
        if (!visibleDividerBorder)
        {
            SplitPaneUI splitPaneUI = getUI();
            if (splitPaneUI instanceof BasicSplitPaneUI)
            {
                BasicSplitPaneUI basicUI = (BasicSplitPaneUI) splitPaneUI;
                basicUI.getDivider().setBorder(EMPTY_BORDER);
            }
        }
    }

    private static final Dimension DOT = new Dimension(0, 0);
    private boolean firstValidate = true;
    private boolean hasProportionalLocation;
    private double proportionalLocation;

    /**
     * Property for border visibility
     */
    public static final String PROPERTYNAME_VISIBLE_DIVIDER_BORDER = "visibleDividerBorder"; //$NON-NLS-1$

    /**
     * An Empty Border
     */
    private static final Border EMPTY_BORDER = new EmptyBorder(0, 0, 0, 0);

    /**
     * Hint for whether Divider border should be visible.
     */
    private boolean visibleDividerBorder;

    /**
     * Serialization ID
     */
    private static final long serialVersionUID = 3761687909593789241L;
}

org.crosswire.jsword.book.sword.SwordDictionary	line 77
org.crosswire.jsword.book.sword.SwordGenBook	line 120

# lines : 68


            List content = new ArrayList();

            String txt = backend.getRawText(key);

            List osisContent = sbmd.getFilter().toOSIS(this, key, txt);
            content.addAll(osisContent);

            return content.iterator();
        }
        catch (FilterException ex)
        {
            throw new BookException(Msg.FILTER_FAIL, ex);
        }
    }

    /* (non-Javadoc)
     * @see org.crosswire.jsword.book.Book#contains(org.crosswire.jsword.passage.Key)
     */
    public boolean contains(Key key)
    {
        return backend != null && backend.contains(key);
    }

    /* (non-Javadoc)
     * @see org.crosswire.jsword.book.Book#getRawText(org.crosswire.jsword.passage.Key)
     */
    public String getRawText(Key key) throws BookException
    {
        checkActive();

        assert key != null;
        assert backend != null;

        return backend.getRawText(key);
    }

    /* (non-Javadoc)
     * @see org.crosswire.jsword.book.Book#isWritable()
     */
    public boolean isWritable()
    {
        return backend.isWritable();
    }

    /* (non-Javadoc)
     * @see org.crosswire.jsword.book.basic.AbstractPassageBook#setRawText(org.crosswire.jsword.passage.Key, java.lang.String)
     */
    public void setRawText(Key key, String rawData) throws BookException
    {
        throw new BookException(Msg.DRIVER_READONLY);
    }

    /* (non-Javadoc)
     * @see org.crosswire.jsword.book.Book#setAliasKey(org.crosswire.jsword.passage.Key, org.crosswire.jsword.passage.Key)
     */
    public void setAliasKey(Key alias, Key source) throws BookException
    {
        throw new BookException(Msg.DRIVER_READONLY);
    }

    /* (non-Javadoc)
     * @see org.crosswire.jsword.passage.KeyFactory#getGlobalKeyList()
     */
    public Key getGlobalKeyList()
    {
        checkActive();

        return global;

org.crosswire.jsword.book.Books	line 94
org.crosswire.jsword.book.install.sword.AbstractSwordInstaller	line 161

# lines : 59


        Iterator iter = books.iterator();
        while (iter.hasNext())
        {
            Book book = (Book) iter.next();
            if (name.equals(book.getName()))
            {
                return book;
            }
        }

        // Next check for case-insensitive matches
        iter = books.iterator();
        while (iter.hasNext())
        {
            Book book = (Book) iter.next();
            if (name.equalsIgnoreCase(book.getName()))
            {
                return book;
            }
        }

        // Then check initials
        // First check for exact matches
        iter = books.iterator();
        while (iter.hasNext())
        {
            Book book = (Book) iter.next();
            BookMetaData bmd = book.getBookMetaData();
            if (name.equals(bmd.getInitials()))
            {
                return book;
            }
        }

        // Next check for case-insensitive matches
        iter = books.iterator();
        while (iter.hasNext())
        {
            Book book = (Book) iter.next();
            if (name.equalsIgnoreCase(book.getInitials()))
            {
                return book;
            }
        }
        return null;
    }

    /* (non-Javadoc)
     * @see org.crosswire.jsword.book.BookList#getBooks(org.crosswire.jsword.book.BookFilter)
     */
    public synchronized List getBooks(BookFilter filter)
    {
        List temp = CollectionUtil.createList(new BookFilterIterator(getBooks(), filter));
        return new BookSet(temp);
    }
    /* (non-Javadoc)
     * @see org.crosswire.jsword.book.install.Installer#install(org.crosswire.jsword.book.Book)
     */
    public void install(Book book)

org.crosswire.bibledesktop.book.BibleNameCellRenderer	line 56
org.crosswire.bibledesktop.book.BookListCellRenderer	line 59

# lines : 42


    public BookListCellRenderer(boolean abbreviated)
    {
        super();
        this.abbreviated = abbreviated;
        GuiUtil.applyDefaultOrientation(this);
    }

    /**
     * @return the abbreviated
     */
    public boolean isAbbreviated()
    {
        return abbreviated;
    }

    /**
     * @param newAbbreviated the abbreviated to set
     */
    public void setAbbreviated(boolean newAbbreviated)
    {
        this.abbreviated = newAbbreviated;
    }

    /* (non-Javadoc)
     * @see javax.swing.DefaultListCellRenderer#getListCellRendererComponent(javax.swing.JList, java.lang.Object, int, boolean, boolean)
     */
    public Component getListCellRendererComponent(JList list, Object value, int index, boolean selected, boolean focus)
    {
        // Do the default rendering
        Component comp = super.getListCellRendererComponent(list, value, index, selected, focus);

        // Do our rendering
        setToolTipText(null);

        if (value == null)
        {
            setText(Msg.NONE.toString());
            setEnabled(false);
        }

        // Hack to allow us to use PROTOTYPE_BOOK_NAME as a prototype value
        if (value instanceof Book)

org.crosswire.bibledesktop.book.BibleViewPane	line 343
org.crosswire.bibledesktop.book.DisplaySelectPane	line 658

# lines : 42


    }

    /**
     * Add a TitleChangedEvent listener
     */
    public synchronized void addTitleChangedListener(TitleChangedListener li)
    {
        listeners.add(TitleChangedListener.class, li);
    }

    /**
     * Remove a TitleChangedEvent listener
     */
    public synchronized void removeTitleChangedListener(TitleChangedListener li)
    {
        listeners.remove(TitleChangedListener.class, li);
    }

    /**
     * Listen for changes to the title
     * @param ev the event to throw
     */
    protected void fireTitleChanged(TitleChangedEvent ev)
    {
        // Guaranteed to return a non-null array
        Object[] contents = listeners.getListenerList();

        // Process the listeners last to first, notifying
        // those that are interested in this event
        for (int i = contents.length - 2; i >= 0; i -= 2)
        {
            if (contents[i] == TitleChangedListener.class)
            {
                ((TitleChangedListener) contents[i + 1]).titleChanged(ev);
            }
        }
    }

    /**
     * Add a DisplaySelectEvent listener
     */
    public synchronized void addCommandListener(DisplaySelectListener li)

org.crosswire.common.config.swing.AdvancedConfigEditor	line 141
org.crosswire.common.config.swing.TreeConfigEditor	line 185

# lines : 34


            deck.remove(card.getParent());
        }
    }

    /**
     * Used to update the configuration panel whenever someone
     * selects a different item form the tree on the LHS of the
     * configuration dialog.
     */
    public void selectCard()
    {
        Object obj = tree.getLastSelectedPathComponent();
        if (obj == null)
        {
            return;
        }

        title.setText(obj + " " + UserMsg.PROPERTIES); //$NON-NLS-1$

        // Get the name of the current deck
        Object[] list = tree.getSelectionPath().getPath();
        StringBuffer path = new StringBuffer();

        for (int i = 1; i < list.length; i++)
        {
            if (i > 1)
            {
                path.append('.');
            }

            path.append(list[i].toString());
        }

        String key = path.toString();