CloneSet5743


Previous CloneSetNext CloneSetBack to Main Report
Clone
Mass
Clones in
CloneSet
Parameter
Count
Clone
Similarity
Syntax Category
[Sequence Length]
63210.968interface_member_declarations[4]
Clone AbstractionParameter Bindings
Clone Instance
(Click to see clone)
Line CountSource Line
Source File
163826
plugins/org.eclipse.jdt.core/model/org/eclipse/jdt/core/IType.java
261939
plugins/org.eclipse.jdt.core/model/org/eclipse/jdt/core/IType.java
Clone Instance
1
Line Count
63
Source Line
826
Source File
plugins/org.eclipse.jdt.core/model/org/eclipse/jdt/core/IType.java

        /**
         * Creates and returns a type hierarchy for this type containing
         * this type and all of its supertypes.
         *
         * @param monitor the given progress monitor
         * @exception JavaModelException if this element does not exist or if an
         *              exception occurs while accessing its corresponding resource.
         * @return a type hierarchy for this type containing this type and all of its supertypes
         */
        ITypeHierarchy newSupertypeHierarchy(IProgressMonitor monitor)
          throws                                                              JavaModelException;
        /**
         * Creates and returns a type hierarchy for this type containing
         * this type and all of its supertypes, considering types in the given 
         * working copies. In other words, the list of working copies will take 
         * precedence over their original compilation units in the workspace.
         * <p>
         * Note that passing an empty working copy will be as if the original compilation
         * unit had been deleted.
         * </p>
         *
         * @param workingCopies the working copies that take precedence over their original compilation units
         * @param monitor the given progress monitor
         * @return a type hierarchy for this type containing this type and all of its supertypes
         * @exception JavaModelException if this element does not exist or if an
         *              exception occurs while accessing its corresponding resource.
         * @since 3.0
         */
        ITypeHierarchy newSupertypeHierarchy(ICompilationUnit[] workingCopies, IProgressMonitor monitor)
          throws       JavaModelException;

        /**
         * Creates and returns a type hierarchy for this type containing
         * this type and all of its supertypes, considering types in the given 
         * working copies. In other words, the list of working copies will take 
         * precedence over their original compilation units in the workspace.
         * <p>
         * Note that passing an empty working copy will be as if the original compilation
         * unit had been deleted.
         * </p>
         *
         * @param workingCopies the working copies that take precedence over their original compilation units
         * @param monitor the given progress monitor
         * @return a type hierarchy for this type containing this type and all of its supertypes
         * @exception JavaModelException if this element does not exist or if an
         *              exception occurs while accessing its corresponding resource.
         * @since 2.0
         * @deprecated use #newSupertypeHierarchy(ICompilationUnit[], IProgressMonitor) instead
         */
        ITypeHierarchy newSupertypeHierarchy(IWorkingCopy[] workingCopies, IProgressMonitor monitor)
          throws       JavaModelException;

        /**
         * Creates and returns a type hierarchy for this type containing
         * this type and all of its supertypes, considering types in the 
         * working copies with the given owner. 
         * In other words, the owner's working copies will take 
         * precedence over their original compilation units in the workspace.
         * <p>
         * Note that if a working copy is empty, it will be as if the original compilation
         * unit had been deleted.
         * <p>
         *
         * @param owner the owner of working copies that take precedence over their original compilation units
         * @param monitor the given progress monitor
         * @return a type hierarchy for this type containing this type and all of its supertypes
         * @exception JavaModelException if this element does not exist or if an
         *              exception occurs while accessing its corresponding resource.
         * @since 3.0
         */
        ITypeHierarchy newSupertypeHierarchy(WorkingCopyOwner owner, IProgressMonitor monitor)
          throws       JavaModelException;


Clone Instance
2
Line Count
61
Source Line
939
Source File
plugins/org.eclipse.jdt.core/model/org/eclipse/jdt/core/IType.java

        /**
         * Creates and returns a type hierarchy for this type containing
         * this type, all of its supertypes, and all its subtypes in the workspace.
         *
         * @param monitor the given progress monitor
         * @exception JavaModelException if this element does not exist or if an
         *              exception occurs while accessing its corresponding resource.
         * @return a type hierarchy for this type containing
         * this type, all of its supertypes, and all its subtypes in the workspace
         */
        ITypeHierarchy newTypeHierarchy(IProgressMonitor monitor)
          throws                                                         JavaModelException;
        /**
         * Creates and returns a type hierarchy for this type containing
         * this type, all of its supertypes, and all its subtypes in the workspace, 
         * considering types in the given working copies. In other words, the list of working 
         * copies that will take precedence over their original compilation units in the workspace.
         * <p>
         * Note that passing an empty working copy will be as if the original compilation
         * unit had been deleted.
         *
         * @param workingCopies the working copies that take precedence over their original compilation units
         * @param monitor the given progress monitor
         * @return a type hierarchy for this type containing
         * this type, all of its supertypes, and all its subtypes in the workspace
         * @exception JavaModelException if this element does not exist or if an
         *              exception occurs while accessing its corresponding resource.
         * @since 3.0
         */
        ITypeHierarchy newTypeHierarchy(ICompilationUnit[] workingCopies, IProgressMonitor monitor)
          throws                                                                                           JavaModelException;
        /**
         * Creates and returns a type hierarchy for this type containing
         * this type, all of its supertypes, and all its subtypes in the workspace, 
         * considering types in the given working copies. In other words, the list of working 
         * copies that will take precedence over their original compilation units in the workspace.
         * <p>
         * Note that passing an empty working copy will be as if the original compilation
         * unit had been deleted.
         *
         * @param workingCopies the working copies that take precedence over their original compilation units
         * @param monitor the given progress monitor
         * @return a type hierarchy for this type containing
         * this type, all of its supertypes, and all its subtypes in the workspace
         * @exception JavaModelException if this element does not exist or if an
         *              exception occurs while accessing its corresponding resource.
         * @since 2.0
         * @deprecated use #newTypeHierarchy(ICompilationUnit[], IProgressMonitor) instead
         */
        ITypeHierarchy newTypeHierarchy(IWorkingCopy[] workingCopies, IProgressMonitor monitor)
          throws                                                                                       JavaModelException;
        /**
         * Creates and returns a type hierarchy for this type containing
         * this type, all of its supertypes, and all its subtypes in the workspace, 
         * considering types in the working copies with the given owner. 
         * In other words, the owner's working copies will take 
         * precedence over their original compilation units in the workspace.
         * <p>
         * Note that if a working copy is empty, it will be as if the original compilation
         * unit had been deleted.
         * <p>
         *
         * @param owner the owner of working copies that take precedence over their original compilation units
         * @param monitor the given progress monitor
         * @return a type hierarchy for this type containing
         * this type, all of its supertypes, and all its subtypes in the workspace
         * @exception JavaModelException if this element does not exist or if an
         *              exception occurs while accessing its corresponding resource.
         * @since 3.0
         */
        ITypeHierarchy newTypeHierarchy(WorkingCopyOwner owner, IProgressMonitor monitor)
          throws                                                                                 JavaModelException;


Clone AbstractionParameter Count: 1Parameter Bindings

/**
         * Creates and returns a type hierarchy for this type containing
         * this type and all of its supertypes.
         *
         * @param monitor the given progress monitor
         * @exception JavaModelException if this element does not exist or if an
         *              exception occurs while accessing its corresponding resource.
         * @return a type hierarchy for this type containing this type and all of its supertypes
         */
/**
         * Creates and returns a type hierarchy for this type containing
         * this type, all of its supertypes, and all its subtypes in the workspace.
         *
         * @param monitor the given progress monitor
         * @exception JavaModelException if this element does not exist or if an
         *              exception occurs while accessing its corresponding resource.
         * @return a type hierarchy for this type containing
         * this type, all of its supertypes, and all its subtypes in the workspace
         */
ITypeHierarchy  [[#variable94222a40]](IProgressMonitor monitor)
  throws JavaModelException;
/**
         * Creates and returns a type hierarchy for this type containing
         * this type and all of its supertypes, considering types in the given 
         * working copies. In other words, the list of working copies will take 
         * precedence over their original compilation units in the workspace.
         * <p>
         * Note that passing an empty working copy will be as if the original compilation
         * unit had been deleted.
         * </p>
         *
         * @param workingCopies the working copies that take precedence over their original compilation units
         * @param monitor the given progress monitor
         * @return a type hierarchy for this type containing this type and all of its supertypes
         * @exception JavaModelException if this element does not exist or if an
         *              exception occurs while accessing its corresponding resource.
         * @since 3.0
         */
/**
         * Creates and returns a type hierarchy for this type containing
         * this type, all of its supertypes, and all its subtypes in the workspace, 
         * considering types in the given working copies. In other words, the list of working 
         * copies that will take precedence over their original compilation units in the workspace.
         * <p>
         * Note that passing an empty working copy will be as if the original compilation
         * unit had been deleted.
         *
         * @param workingCopies the working copies that take precedence over their original compilation units
         * @param monitor the given progress monitor
         * @return a type hierarchy for this type containing
         * this type, all of its supertypes, and all its subtypes in the workspace
         * @exception JavaModelException if this element does not exist or if an
         *              exception occurs while accessing its corresponding resource.
         * @since 3.0
         */
ITypeHierarchy  [[#variable94222a40]](ICompilationUnit[] workingCopies, IProgressMonitor monitor)
  throws JavaModelException;
/**
         * Creates and returns a type hierarchy for this type containing
         * this type and all of its supertypes, considering types in the given 
         * working copies. In other words, the list of working copies will take 
         * precedence over their original compilation units in the workspace.
         * <p>
         * Note that passing an empty working copy will be as if the original compilation
         * unit had been deleted.
         * </p>
         *
         * @param workingCopies the working copies that take precedence over their original compilation units
         * @param monitor the given progress monitor
         * @return a type hierarchy for this type containing this type and all of its supertypes
         * @exception JavaModelException if this element does not exist or if an
         *              exception occurs while accessing its corresponding resource.
         * @since 2.0
         * @deprecated use #newSupertypeHierarchy(ICompilationUnit[], IProgressMonitor) instead
         */
/**
         * Creates and returns a type hierarchy for this type containing
         * this type, all of its supertypes, and all its subtypes in the workspace, 
         * considering types in the given working copies. In other words, the list of working 
         * copies that will take precedence over their original compilation units in the workspace.
         * <p>
         * Note that passing an empty working copy will be as if the original compilation
         * unit had been deleted.
         *
         * @param workingCopies the working copies that take precedence over their original compilation units
         * @param monitor the given progress monitor
         * @return a type hierarchy for this type containing
         * this type, all of its supertypes, and all its subtypes in the workspace
         * @exception JavaModelException if this element does not exist or if an
         *              exception occurs while accessing its corresponding resource.
         * @since 2.0
         * @deprecated use #newTypeHierarchy(ICompilationUnit[], IProgressMonitor) instead
         */
ITypeHierarchy  [[#variable94222a40]](IWorkingCopy[] workingCopies, IProgressMonitor monitor)
  throws JavaModelException;
/**
         * Creates and returns a type hierarchy for this type containing
         * this type and all of its supertypes, considering types in the 
         * working copies with the given owner. 
         * In other words, the owner's working copies will take 
         * precedence over their original compilation units in the workspace.
         * <p>
         * Note that if a working copy is empty, it will be as if the original compilation
         * unit had been deleted.
         * <p>
         *
         * @param owner the owner of working copies that take precedence over their original compilation units
         * @param monitor the given progress monitor
         * @return a type hierarchy for this type containing this type and all of its supertypes
         * @exception JavaModelException if this element does not exist or if an
         *              exception occurs while accessing its corresponding resource.
         * @since 3.0
         */
/**
         * Creates and returns a type hierarchy for this type containing
         * this type, all of its supertypes, and all its subtypes in the workspace, 
         * considering types in the working copies with the given owner. 
         * In other words, the owner's working copies will take 
         * precedence over their original compilation units in the workspace.
         * <p>
         * Note that if a working copy is empty, it will be as if the original compilation
         * unit had been deleted.
         * <p>
         *
         * @param owner the owner of working copies that take precedence over their original compilation units
         * @param monitor the given progress monitor
         * @return a type hierarchy for this type containing
         * this type, all of its supertypes, and all its subtypes in the workspace
         * @exception JavaModelException if this element does not exist or if an
         *              exception occurs while accessing its corresponding resource.
         * @since 3.0
         */
ITypeHierarchy  [[#variable94222a40]](WorkingCopyOwner owner, IProgressMonitor monitor)
  throws JavaModelException;
 

CloneAbstraction
Parameter Bindings
Parameter
Index
Clone
Instance
Parameter
Name
Value
11[[#94222a40]]
newSupertypeHierarchy 
12[[#94222a40]]
newTypeHierarchy