Java API By Example, From Geeks To Geeks.

1 /* 2  * The contents of this file are subject to the terms of the Common Development 3  * and Distribution License (the License). You may not use this file except in 4  * compliance with the License. 5  * 6  * You can obtain a copy of the License at http://www.netbeans.org/cddl.html 7  * or http://www.netbeans.org/cddl.txt. 8  * 9  * When distributing Covered Code, include this CDDL Header Notice in each file 10  * and include the License file at http://www.netbeans.org/cddl.txt. 11  * If applicable, add the following below the CDDL Header, with the fields 12  * enclosed by brackets [] replaced by your own identifying information: 13  * "Portions Copyrighted [year] [name of copyright owner]" 14  * 15  * The Original Software is NetBeans. The Initial Developer of the Original 16  * Software is Sun Microsystems, Inc. Portions Copyright 1997-2006 Sun 17  * Microsystems, Inc. All Rights Reserved. 18  */ 19 20 package org.netbeans.modules.j2ee.refactoring.rename; 21 22 import java.io.IOException ; 23 import java.text.MessageFormat ; 24 import java.util.ArrayList ; 25 import java.util.Collection ; 26 import java.util.Iterator ; 27 import java.util.List ; 28 import javax.jmi.reflect.RefObject; 29 import org.netbeans.api.project.FileOwnerQuery; 30 import org.netbeans.api.project.Project; 31 import org.netbeans.jmi.javamodel.Element; 32 import org.netbeans.modules.j2ee.dd.api.ejb.AssemblyDescriptor; 33 import org.netbeans.modules.j2ee.dd.api.ejb.CmpField; 34 import org.netbeans.modules.j2ee.dd.api.ejb.CmrField; 35 import org.netbeans.modules.j2ee.dd.api.ejb.ContainerTransaction; 36 import org.netbeans.modules.j2ee.dd.api.ejb.EjbRelation; 37 import org.netbeans.modules.j2ee.dd.api.ejb.EjbRelationshipRole; 38 import org.netbeans.modules.j2ee.dd.api.ejb.ExcludeList; 39 import org.netbeans.modules.j2ee.dd.api.ejb.MethodPermission; 40 import org.netbeans.modules.j2ee.dd.api.common.VersionNotSupportedException; 41 import org.netbeans.jmi.javamodel.ClassDefinition; 42 import org.netbeans.jmi.javamodel.JavaClass; 43 import org.netbeans.jmi.javamodel.Method; 44 import org.netbeans.jmi.javamodel.Resource; 45 import org.netbeans.jmi.javamodel.UnresolvedClass; 46 import org.netbeans.modules.j2ee.dd.api.ejb.Ejb; 47 import org.netbeans.modules.j2ee.dd.api.ejb.EjbJar; 48 import org.netbeans.modules.j2ee.dd.api.ejb.EnterpriseBeans; 49 import org.netbeans.modules.j2ee.dd.api.ejb.Entity; 50 import org.netbeans.modules.j2ee.dd.api.ejb.EntityAndSession; 51 import org.netbeans.modules.j2ee.dd.api.ejb.MessageDriven; 52 import org.netbeans.modules.j2ee.dd.api.ejb.Query; 53 import org.netbeans.modules.j2ee.dd.api.ejb.QueryMethod; 54 import org.netbeans.modules.j2ee.dd.api.ejb.RelationshipRoleSource; 55 import org.netbeans.modules.j2ee.dd.api.ejb.Session; 56 import org.netbeans.modules.j2ee.refactoring.Utility; 57 import org.netbeans.modules.javacore.api.JavaModel; 58 import org.netbeans.modules.javacore.internalapi.ExternalChange; 59 import org.netbeans.modules.javacore.internalapi.JavaMetamodel; 60 import org.netbeans.modules.refactoring.api.AbstractRefactoring; 61 import org.netbeans.modules.refactoring.api.Problem; 62 import org.netbeans.modules.refactoring.api.RefactoringElement; 63 import org.netbeans.modules.refactoring.api.RefactoringSession; 64 import org.netbeans.modules.refactoring.spi.RefactoringElementImplementation; 65 import org.netbeans.modules.refactoring.api.RenameRefactoring; 66 import org.netbeans.modules.refactoring.spi.RefactoringElementsBag; 67 import org.openide.ErrorManager; 68 import org.openide.filesystems.FileObject; 69 import org.openide.util.NbBundle; 70 71 /** 72  * 73  * @author Martin Grebac 74  */ 75 public final class EjbJarRenameRefactoring { 76      77     private static final ErrorManager err = ErrorManager.getDefault().getInstance("org.netbeans.modules.j2ee.refactoring.rename"); // NOI18N 78 79     /** Whether there is an attempt to rename finder method that is defined in home and in ejb jar.xml*/ 80     private boolean isCmpHomeFinder = false; 81 82     /** Whether there is an attempt to rename finder method that is defined in local home and in ejb jar.xml*/ 83     private boolean isCmpLocalHomeFinder = false; 84 85     /** Whether there is an attempt to rename select method in implementation class */ 86     private boolean isSelectInImpl = false; 87 88     /** Whether there is an attempt to rename finder method in implementation class */ 89     private boolean isFinderInImpl = false; 90 91     /** Whether there is an attempt to rename finder method in home interface */ 92     private boolean isFinderInHome = false; 93 94     /** Whether there is an attempt to rename finder method in local home interface */ 95     private boolean isFinderInLocalHome = false; 96 97     /** Whether there is an attempt to rename create method in implementation class */ 98     private boolean isCreateInImpl = false; 99      100     /** Whether there is an attempt to rename create method in home interface */ 101     private boolean isCreateInHome = false; 102 103     /** Whether there is an attempt to rename create method in local home interface */ 104     private boolean isCreateInLocalHome = false; 105 106     /** Whether there is an attempt to rename postCreate method in implementation class */ 107     private boolean isPostCreateInImpl = false; 108 109     /** Whether there is an attempt to rename home method in implementation class */ 110     private boolean isHomeInImpl = false; 111 112     /** Whether there is an attempt to rename home method in home interface */ 113     private boolean isHomeInHome = false; 114 115     /** Whether there is an attempt to rename home method in local home interface */ 116     private boolean isHomeInLocalHome = false; 117 118     /** Whether there is an attempt to rename getter method in business interface */ 119     private boolean isGetterInBusiness = false; 120 121     /** Whether there is an attempt to rename setter method in business interface */ 122     private boolean isSetterInBusiness = false; 123 124     /** Whether there is an attempt to rename getter method in bean impl class */ 125     private boolean isGetterInImpl = false; 126 127     /** Whether there is an attempt to rename setter method in bean impl class */ 128     private boolean isSetterInImpl = false; 129 130     /** Whether there is an attempt to rename setter or getter method for cmp field */ 131     private boolean isCmpField = false; 132 133     /** Whether there is an attempt to rename setter or getter method for cmr field */ 134     private boolean isCmrField = false; 135 136     /* stores collection of interface refactorings to be invoked */ 137     ArrayList ifaceRefactors = new ArrayList (); 138      139     /* stores collection of implementation class refactorings to be invoked */ 140     ArrayList implRefactors = new ArrayList (); 141 142     /** Stores cmp entity bean class that implements business interface that is to be changed*/ 143     private JavaClass busImpltorClass = null; 144 145     /** Stores resolved class - filled in preCheck */ 146     private JavaClass javaClass = null; 147      148     /** Stores resolved entity impl class - filled in preCheck, this one doesn't change */ 149     private JavaClass entityClass = null; 150 151     /** Stores collection of potentialy affected modules by proposed change - value filled in preCheck*/ 152     private Collection emodules = null; 153      154     public EjbJarRenameRefactoring() { } 155      156     public Problem preCheck(RefObject refObject) { 157         if (ErrorManager.getDefault().isLoggable(ErrorManager.INFORMATIONAL)) err.log("> EjbJarRenameRefactoring.preCheck( " + refObject + ")"); 158         ifaceRefactors.clear(); 159         Problem problem = null; 160         if (refObject instanceof JavaClass) { 161             JavaClass jclass = (JavaClass)refObject; 162             Resource res = jclass.getResource(); 163             FileObject fo = JavaModel.getFileObject(res); 164             emodules = Utility.getRelevantEjbModules(fo); 165         } 166          167         if (refObject instanceof Method) { 168             Method method = (Method)refObject; 169             Resource res = method.getResource(); 170             FileObject fo = JavaModel.getFileObject(res); 171             emodules = Utility.getRelevantEjbModules(fo); 172             if ((emodules != null) && (emodules.size() > 0)) { // there are ejb modules that can be affected by the change 173 ClassDefinition jc = method.getDeclaringClass(); 174                 if (ErrorManager.getDefault().isLoggable(ErrorManager.INFORMATIONAL)) err.log("classdefinition jc: " + jc); 175                 if (jc instanceof JavaClass) { 176 177                     // SESSION BEAN IMPL CLASS 178 javaClass = (JavaClass)JavaModel.getDefaultExtent().getType().resolve(Utility.SESSION_BEAN); 179                     if (ErrorManager.getDefault().isLoggable(ErrorManager.INFORMATIONAL)) err.log("javaclass: " + javaClass); 180                     if (!(javaClass instanceof UnresolvedClass)) { 181                         if (jc.isSubTypeOf(javaClass)) { 182 183                             // first check if we are trying to rename a method from javax.ejb.SessionBean interface, and do not allow this 184 if (Utility.isSignatureFromSessionBeanInterface(method)) { 185                                 String msg = MessageFormat.format( 186                                                 NbBundle.getMessage(EjbJarRenameRefactoring.class, "TXT_EjbJarMethodInJavaxInterfaceProblemRename"), 187                                                 new String [] {Utility.SESSION_BEAN} 188                                              ); 189                                 Problem newProblem = new Problem(true, msg); 190                                 problem = Utility.addProblemsToEnd(problem, newProblem); 191                                 return problem; 192                             } 193 194                             String methodName = method.getName(); 195                             if (ErrorManager.getDefault().isLoggable(ErrorManager.INFORMATIONAL)) err.log("methodName: " + methodName); 196                              197                             // next check create methods 198 if (methodName.startsWith("ejbCreate")) { 199                                 // next check if we are trying to rename an ejbCreate method - this change is not allowed 200 if (methodName.equals("ejbCreate")) { //NOI18N 201 String msg = MessageFormat.format( 202                                                     NbBundle.getMessage(EjbJarRenameRefactoring.class, "TXT_EjbJarCreateMethodProblemRename"), 203                                                     new String [] {Utility.SESSION_BEAN} 204                                                  ); 205                                     Problem newProblem = new Problem(true, msg); 206                                     problem = Utility.addProblemsToEnd(problem, newProblem); 207                                     return problem; 208                                 } else { // other create methods can be renamed, too 209 Method createInHome = Utility.getHomeCreateMethodForSessionImplCreateMethod(method, fo, jc.getName(), false /*not local*/); 210                                     Method createInLocalHome = Utility.getHomeCreateMethodForSessionImplCreateMethod(method, fo, jc.getName(), true /*local*/); 211                                     if (createInHome != null) { 212                                         isCreateInImpl = true; 213                                         RenameRefactoring renameCreateInHome = new RenameRefactoring(createInHome); 214                                         Problem p = renameCreateInHome.preCheck(); 215                                         problem = Utility.addProblemsToEnd(problem, p); 216                                         String msg = MessageFormat.format( 217                                                         NbBundle.getMessage(EjbJarRenameRefactoring.class, "TXT_EjbJarIfaceMethodWarningRename"), 218                                                         new String [] {"home"} 219                                                      ); 220                                         Problem newProblem = new Problem(false, msg); 221                                         problem = Utility.addProblemsToEnd(problem, newProblem); 222                                         ifaceRefactors.add(renameCreateInHome); 223                                     } 224                                     if (createInLocalHome != null) { 225                                         isCreateInImpl = true; 226                                         RenameRefactoring renameCreateInLocalHome = new RenameRefactoring(createInLocalHome); 227                                         Problem p = renameCreateInLocalHome.preCheck(); 228                                         problem = Utility.addProblemsToEnd(problem, p); 229                                         String msg = MessageFormat.format( 230                                                         NbBundle.getMessage(EjbJarRenameRefactoring.class, "TXT_EjbJarIfaceMethodWarningRename"), 231                                                         new String [] {"local home"} 232                                                      ); 233                                         Problem newProblem = new Problem(false, msg); 234                                         problem = Utility.addProblemsToEnd(problem, newProblem); 235                                         ifaceRefactors.add(renameCreateInLocalHome); 236                                         return problem; 237                                     } 238                                 } 239                             } 240                              241                             // next check if we are trying to rename some home method - this is allowed with some restrictions and homes in home/localhome need to be renamed, too 242 Method homeInHome = Utility.getHomeHomeMethodForSessionImplHomeMethod(method, fo, jc.getName(), false /*not local*/); 243                             Method homeInLocalHome = Utility.getHomeHomeMethodForSessionImplHomeMethod(method, fo, jc.getName(), true /*local*/); 244                             if (homeInHome != null) { 245                                 isHomeInImpl = true; 246                                 RenameRefactoring renameHomeInHome = new RenameRefactoring(homeInHome); 247                                 Problem p = renameHomeInHome.preCheck(); 248                                 problem = Utility.addProblemsToEnd(problem, p); 249                                 String msg = MessageFormat.format( 250                                                 NbBundle.getMessage(EjbJarRenameRefactoring.class, "TXT_EjbJarIfaceMethodWarningRename"), 251                                                 new String [] {"home"} 252                                              ); 253                                 Problem newProblem = new Problem(false, msg); 254                                 problem = Utility.addProblemsToEnd(problem, newProblem); 255                                 ifaceRefactors.add(renameHomeInHome); 256                             } 257                             if (homeInLocalHome != null) { 258                                 isHomeInImpl = true; 259                                 RenameRefactoring renameHomeInLocalHome = new RenameRefactoring(homeInLocalHome); 260                                 Problem p = renameHomeInLocalHome.preCheck(); 261                                 problem = Utility.addProblemsToEnd(problem, p); 262                                 String msg = MessageFormat.format( 263                                                 NbBundle.getMessage(EjbJarRenameRefactoring.class, "TXT_EjbJarIfaceMethodWarningRename"), 264                                                 new String [] {"local home"} 265                                              ); 266                                 Problem newProblem = new Problem(false, msg); 267                                 problem = Utility.addProblemsToEnd(problem, newProblem); 268                                 ifaceRefactors.add(renameHomeInLocalHome); 269                                 return problem; 270                             } 271                              272                             return problem; 273                         } 274                     } 275 276                     // ENTITY BEANS IMPL CLASS 277 if (entityClass == null) { 278                         entityClass = (JavaClass)JavaModel.getDefaultExtent().getType().resolve(Utility.ENTITY_BEAN); 279                     } 280                     javaClass = entityClass; 281                     if (ErrorManager.getDefault().isLoggable(ErrorManager.INFORMATIONAL)) err.log("javaclass: " + javaClass); 282                     if (!(javaClass instanceof UnresolvedClass)) { 283                         // first check if we are trying to rename a method from javax.ejb.EntityBean interface, and do not allow this 284 if (jc.isSubTypeOf(javaClass)) { 285                              286                             // first check if we are trying to rename a method from javax.ejb.EntityBean interface, and do not allow this 287 if (Utility.isSignatureFromEntityBeanInterface(method)) { 288                                 String msg = MessageFormat.format( 289                                                 NbBundle.getMessage(EjbJarRenameRefactoring.class, "TXT_EjbJarMethodInJavaxInterfaceProblemRename"), 290                                                 new String [] {Utility.ENTITY_BEAN} 291                                              ); 292                                 Problem newProblem = new Problem(true, msg); 293                                 problem = Utility.addProblemsToEnd(problem, newProblem); 294                                 return problem; 295                             } 296 297                             // next check if we are trying to rename an ejbCreate method - this change is not allowed, too 298 String methodName = method.getName(); 299                             if (ErrorManager.getDefault().isLoggable(ErrorManager.INFORMATIONAL)) err.log("methodname: " + methodName); 300                              301                             // next check create methods 302 if (methodName.startsWith("ejbCreate")) { 303                                 // next check if we are trying to rename an ejbCreate method - this change is not allowed 304 if (methodName.equals("ejbCreate")) { //NOI18N 305 String msg = NbBundle.getMessage(EjbJarRenameRefactoring.class, "TXT_EjbJarCreateMethodProblemRename"); 306                                     Problem newProblem = new Problem(true, msg); 307                                     problem = Utility.addProblemsToEnd(problem, newProblem); 308                                     return problem; 309                                 } else { // other create methods can be renamed 310 Method createInHome = Utility.getHomeCreateMethodForEntityImplCreateMethod(method, fo, jc.getName(), false /*not local*/); 311                                     Method createInLocalHome = Utility.getHomeCreateMethodForEntityImplCreateMethod(method, fo, jc.getName(), true /*local*/); 312                                     Method postCreateInImpl = Utility.getImplPostCreateMethodForEntityImplCreateMethod(method); 313                                     isCreateInImpl = true; 314                                     if (createInHome != null) { 315                                         RenameRefactoring renameCreateInHome = new RenameRefactoring(createInHome); 316                                         Problem p = renameCreateInHome.preCheck(); 317                                         problem = Utility.addProblemsToEnd(problem, p); 318                                         String msg = MessageFormat.format( 319                                                         NbBundle.getMessage(EjbJarRenameRefactoring.class, "TXT_EjbJarIfaceMethodWarningRename"), 320                                                         new String [] {"home"} 321                                                      ); 322                                         Problem newProblem = new Problem(false, msg); 323                                         problem = Utility.addProblemsToEnd(problem, newProblem); 324                                         ifaceRefactors.add(renameCreateInHome); 325                                     } 326                                     if (createInLocalHome != null) { 327                                         RenameRefactoring renameCreateInLocalHome = new RenameRefactoring(createInLocalHome); 328                                         Problem p = renameCreateInLocalHome.preCheck(); 329                                         problem = Utility.addProblemsToEnd(problem, p); 330                                         String msg = MessageFormat.format( 331                                                         NbBundle.getMessage(EjbJarRenameRefactoring.class, "TXT_EjbJarIfaceMethodWarningRename"), 332                                                         new String [] {"local home"} 333                                                      ); 334                                         Problem newProblem = new Problem(false, msg); 335                                         problem = Utility.addProblemsToEnd(problem, newProblem); 336                                         ifaceRefactors.add(renameCreateInLocalHome); 337                                     } 338                                     if (postCreateInImpl != null) { 339                                         RenameRefactoring renamePostCreateInImpl = new RenameRefactoring(postCreateInImpl); 340                                         Problem p = renamePostCreateInImpl.preCheck(); 341                                         problem = Utility.addProblemsToEnd(problem, p); 342                                         String msg = NbBundle.getMessage(EjbJarRenameRefactoring.class, "TXT_EjbJarPostCreateMethodWarningRename"); 343                                         Problem newProblem = new Problem(false, msg); 344                                         problem = Utility.addProblemsToEnd(problem, newProblem); 345                                         implRefactors.add(renamePostCreateInImpl); 346                                         return problem; 347                                     } 348                                 } 349                             } 350 351                             // next check postCreate methods 352 if (methodName.startsWith("ejbPostCreate")) { 353                                 // next check if we are trying to rename an ejbPostCreate method - this change is not allowed 354 if (methodName.equals("ejbPostCreate")) { //NOI18N 355 String msg = NbBundle.getMessage(EjbJarRenameRefactoring.class, "TXT_EjbJarPostCreateMethodProblemRename"); 356                                     Problem newProblem = new Problem(true, msg); 357                                     problem = Utility.addProblemsToEnd(problem, newProblem); 358                                     return problem; 359                                 } else { // other postCreate methods can be renamed 360 Method createInHome = Utility.getHomeCreateMethodForEntityImplPostCreateMethod(method, fo, jc.getName(), false /*not local*/); 361                                     Method createInLocalHome = Utility.getHomeCreateMethodForEntityImplPostCreateMethod(method, fo, jc.getName(), true /*local*/); 362                                     Method createInImpl = Utility.getImplCreateMethodForEntityImplPostCreateMethod(method); 363                                     isPostCreateInImpl = true; 364                                     if (createInHome != null) { 365                                         RenameRefactoring renameCreateInHome = new RenameRefactoring(createInHome); 366                                         Problem p = renameCreateInHome.preCheck(); 367                                         problem = Utility.addProblemsToEnd(problem, p); 368                                         String msg = MessageFormat.format( 369                                                         NbBundle.getMessage(EjbJarRenameRefactoring.class, "TXT_EjbJarIfaceMethodWarningRename"), 370                                                         new String [] {"home"} 371                                                      ); 372                                         Problem newProblem = new Problem(false, msg); 373                                         problem = Utility.addProblemsToEnd(problem, newProblem); 374                                         ifaceRefactors.add(renameCreateInHome); 375                                     } 376                                     if (createInLocalHome != null) { 377                                         RenameRefactoring renameCreateInLocalHome = new RenameRefactoring(createInLocalHome); 378                                         Problem p = renameCreateInLocalHome.preCheck(); 379                                         problem = Utility.addProblemsToEnd(problem, p); 380                                         String msg = MessageFormat.format( 381                                                         NbBundle.getMessage(EjbJarRenameRefactoring.class, "TXT_EjbJarIfaceMethodWarningRename"), 382                                                         new String [] {"local home"} 383                                                      ); 384                                         Problem newProblem = new Problem(false, msg); 385                                         problem = Utility.addProblemsToEnd(problem, newProblem); 386                                         ifaceRefactors.add(renameCreateInLocalHome); 387                                     } 388                                     if (createInImpl != null) { 389                                         RenameRefactoring renamePostCreateInImpl = new RenameRefactoring(createInImpl); 390                                         Problem p = renamePostCreateInImpl.preCheck(); 391                                         problem = Utility.addProblemsToEnd(problem, p); 392                                         String msg = NbBundle.getMessage(EjbJarRenameRefactoring.class, "TXT_EjbJarCreateMethodWarningRename"); 393                                         Problem newProblem = new Problem(false, msg); 394                                         problem = Utility.addProblemsToEnd(problem, newProblem); 395                                         implRefactors.add(renamePostCreateInImpl); 396                                         return problem; 397                                     } 398                                 } 399                             } 400 401                             // next check if we are trying to rename a findByPrimaryKey method - this shouldn't be allowed 402 if (methodName.equals("findByPrimaryKey")) { //NOI18N 403 isFinderInImpl = true; 404                                 String msg = MessageFormat.format( 405                                                 NbBundle.getMessage(EjbJarRenameRefactoring.class, "TXT_EjbJarFindByPrimaryKeyMethodProblemRename"), 406                                                 new String [] {Utility.ENTITY_BEAN} 407                                              ); 408                                 Problem newProblem = new Problem(true, msg); 409                                 problem = Utility.addProblemsToEnd(problem, newProblem); 410                                 return problem; 411                             } 412 413                             if (methodName.startsWith("set") && (method.getParameters().size() == 1)) { 414                                 List typedParams = new ArrayList (); 415                                 Method getMethod = method.getDeclaringClass().getMethod("get" + methodName.substring(3), typedParams,false); 416                                 if (ErrorManager.getDefault().isLoggable(ErrorManager.INFORMATIONAL)) err.log("getMethod: " + getMethod); 417                                 if (getMethod != null) { 418                                     isSetterInImpl = true; 419                                     String fieldName = methodName.substring(3,4).toLowerCase() + methodName.substring(4); 420                                     isCmpField = Utility.isCmpField((JavaClass)jc, fieldName); 421                                     if (!isCmpField) { 422                                         isCmrField = Utility.isCmrField((JavaClass)jc, fieldName); 423                                     } 424                                     if (ErrorManager.getDefault().isLoggable(ErrorManager.INFORMATIONAL)) err.log("fieldName: " + fieldName); 425                                     RenameRefactoring renameGetterSetter = new RenameRefactoring(getMethod); 426                                     Problem p = renameGetterSetter.preCheck(); 427 // problem = Utility.addProblemsToEnd(problem, p); 428 Problem newProblem = new Problem(false, NbBundle.getMessage(EjbJarRenameRefactoring.class, "TXT_EjbJarSetterMethodWarningRename")); 429                                     problem = Utility.addProblemsToEnd(problem, newProblem); 430                                     ifaceRefactors.add(renameGetterSetter); 431                                 } 432                             } 433 434                             if (methodName.startsWith("get") || method.getParameters().size() == 0) { 435                                 List typedParams = new ArrayList (); 436                                 typedParams.add(method.getType()); 437                                 Method setMethod = method.getDeclaringClass().getMethod("set" + methodName.substring(3), typedParams,false); 438                                 if (ErrorManager.getDefault().isLoggable(ErrorManager.INFORMATIONAL)) err.log("setMethod: " + setMethod); 439                                 if (setMethod != null) { 440                                     isGetterInImpl = true; 441                                     String fieldName = methodName.substring(3,4).toLowerCase() + methodName.substring(4); 442                                     isCmpField = Utility.isCmpField((JavaClass)jc, fieldName); 443                                     if (!isCmpField) { 444                                         isCmrField = Utility.isCmrField((JavaClass)jc, fieldName); 445                                     } 446                                     if (ErrorManager.getDefault().isLoggable(ErrorManager.INFORMATIONAL)) err.log("fieldName: " + fieldName); 447                                     RenameRefactoring renameGetterSetter = new RenameRefactoring(setMethod); 448                                     Problem p = renameGetterSetter.preCheck(); 449 // problem = Utility.addProblemsToEnd(problem, p); 450 Problem newProblem = new Problem(false, NbBundle.getMessage(EjbJarRenameRefactoring.class, "TXT_EjbJarGetterMethodWarningRename")); 451                                     problem = Utility.addProblemsToEnd(problem, newProblem); 452                                     ifaceRefactors.add(renameGetterSetter); 453                                 } 454                             } 455                              456                             // next check if we are trying to rename some finder method - this is allowed with some restrictions and finders in home/localhome need to be renamed, too 457 Method finderInHome = Utility.getHomeFinderMethodForImplFinderMethod(method, fo, jc.getName(), false /*not local*/); 458                             Method finderInLocalHome = Utility.getHomeFinderMethodForImplFinderMethod(method, fo, jc.getName(), true /*local*/); 459                             if (finderInHome != null) { 460                                 isFinderInImpl = true; 461                                 RenameRefactoring renameFinderInHome = new RenameRefactoring(finderInHome); 462                                 Problem p = renameFinderInHome.preCheck(); 463                                 problem = Utility.addProblemsToEnd(problem, p); 464                                 String msg = MessageFormat.format( 465                                                 NbBundle.getMessage(EjbJarRenameRefactoring.class, "TXT_EjbJarIfaceMethodWarningRename"), 466                                                 new String [] {"home"} 467                                              ); 468                                 Problem newProblem = new Problem(false, msg); 469                                 problem = Utility.addProblemsToEnd(problem, newProblem); 470                                 ifaceRefactors.add(renameFinderInHome); 471                             } 472                             if (finderInLocalHome != null) { 473                                 isFinderInImpl = true; 474                                 RenameRefactoring renameFinderInLocalHome = new RenameRefactoring(finderInLocalHome); 475                                 Problem p = renameFinderInLocalHome.preCheck(); 476                                 problem = Utility.addProblemsToEnd(problem, p); 477                                 String msg = MessageFormat.format( 478                                                 NbBundle.getMessage(EjbJarRenameRefactoring.class, "TXT_EjbJarIfaceMethodWarningRename"), 479                                                 new String [] {"local home"} 480                                              ); 481                                 Problem newProblem = new Problem(false, msg); 482                                 problem = Utility.addProblemsToEnd(problem, newProblem); 483                                 ifaceRefactors.add(renameFinderInLocalHome); 484                                 return problem; 485                             } 486 487                             // next check if we are trying to rename some home method - this is allowed with some restrictions and homes in home/localhome need to be renamed, too 488 Method homeInHome = Utility.getHomeHomeMethodForEntityImplHomeMethod(method, fo, jc.getName(), false /*not local*/); 489                             Method homeInLocalHome = Utility.getHomeHomeMethodForEntityImplHomeMethod(method, fo, jc.getName(), true /*local*/); 490                             if (homeInHome != null) { 491                                 isHomeInImpl = true; 492                                 RenameRefactoring renameHomeInHome = new RenameRefactoring(homeInHome); 493                                 Problem p = renameHomeInHome.preCheck(); 494                                 problem = Utility.addProblemsToEnd(problem, p); 495                                 String msg = MessageFormat.format( 496                                                 NbBundle.getMessage(EjbJarRenameRefactoring.class, "TXT_EjbJarIfaceMethodWarningRename"), 497                                                 new String [] {"home"} 498                                              ); 499                                 Problem newProblem = new Problem(false, msg); 500                                 problem = Utility.addProblemsToEnd(problem, newProblem); 501                                 ifaceRefactors.add(renameHomeInHome); 502                             } 503                             if (homeInLocalHome != null) { 504                                 isHomeInImpl = true; 505                                 RenameRefactoring renameHomeInLocalHome = new RenameRefactoring(homeInLocalHome); 506                                 Problem p = renameHomeInLocalHome.preCheck(); 507                                 problem = Utility.addProblemsToEnd(problem, p); 508                                 String msg = MessageFormat.format( 509                                                 NbBundle.getMessage(EjbJarRenameRefactoring.class, "TXT_EjbJarIfaceMethodWarningRename"), 510                                                 new String [] {"local home"} 511                                              ); 512                                 Problem newProblem = new Problem(false, msg); 513                                 problem = Utility.addProblemsToEnd(problem, newProblem); 514                                 ifaceRefactors.add(renameHomeInLocalHome); 515                                 return problem; 516                             } 517                              518                             if (methodName.startsWith("ejbSelect")) { 519                                 isSelectInImpl = true; 520                             } 521                              522                             return problem; 523                         } 524                     } 525 526                     // business interface check for CMP setters/getters/field update 527 Collection implementors = ((JavaClass)jc).getImplementors(); 528                     if ((implementors != null) && (implementors.size() > 0)) { 529                          530                         boolean isBusiness = false; 531                         Iterator impltors = implementors.iterator(); 532                         while (impltors.hasNext()) { 533                             busImpltorClass = (JavaClass)impltors.next(); 534                             if (busImpltorClass.isSubTypeOf(entityClass)) { 535                                 isBusiness = true; 536                                 break; 537                             } 538                         } 539                          540                         if (isBusiness) { 541                              542                             String methodName = method.getName(); 543                             if (ErrorManager.getDefault().isLoggable(ErrorManager.INFORMATIONAL)) err.log("methodName: " + methodName); 544                             String fieldName = methodName.substring(3,4).toLowerCase() + methodName.substring(4); 545                             if (ErrorManager.getDefault().isLoggable(ErrorManager.INFORMATIONAL)) err.log("fieldName: " + fieldName); 546 547                             isCmpField = Utility.isCmpField(busImpltorClass, fieldName); 548                             if (!isCmpField) { 549                                 isCmrField = Utility.isCmrField(busImpltorClass, fieldName); 550                             } 551                             if (isCmpField || isCmrField) { 552                                 if (methodName.startsWith("set") && (method.getParameters().size() == 1)) { 553                                     List typedParams = new ArrayList (); 554                                     Method getMethod = method.getDeclaringClass().getMethod("get" + methodName.substring(3), typedParams,false); 555                                     if (ErrorManager.getDefault().isLoggable(ErrorManager.INFORMATIONAL)) err.log("getMethod: " + getMethod); 556                                     if (getMethod != null) { 557                                         isSetterInBusiness = true; 558                                         RenameRefactoring renameGetterSetter = new RenameRefactoring(getMethod); 559                                         Problem p = renameGetterSetter.preCheck(); 560     // problem = Utility.addProblemsToEnd(problem, p); 561 Problem newProblem = new Problem(false, NbBundle.getMessage(EjbJarRenameRefactoring.class, "TXT_EjbJarSetterMethodWarningRename")); 562                                         problem = Utility.addProblemsToEnd(problem, newProblem); 563                                         ifaceRefactors.add(renameGetterSetter); 564                                     } 565                                 } 566                                 if (methodName.startsWith("get") || method.getParameters().size() == 0) { 567                                     List typedParams = new ArrayList (); 568                                     typedParams.add(method.getType()); 569                                     Method setMethod = method.getDeclaringClass().getMethod("set" + methodName.substring(3), typedParams,false); 570                                     if (ErrorManager.getDefault().isLoggable(ErrorManager.INFORMATIONAL)) err.log("setMethod: " + setMethod); 571                                     if (setMethod != null) { 572                                         isGetterInBusiness = true; 573                                         if (ErrorManager.getDefault().isLoggable(ErrorManager.INFORMATIONAL)) err.log("fieldName: " + fieldName); 574                                         RenameRefactoring renameGetterSetter = new RenameRefactoring(setMethod); 575                                         Problem p = renameGetterSetter.preCheck(); 576     // problem = Utility.addProblemsToEnd(problem, p); 577 Problem newProblem = new Problem(false, NbBundle.getMessage(EjbJarRenameRefactoring.class, "TXT_EjbJarGetterMethodWarningRename")); 578                                         problem = Utility.addProblemsToEnd(problem, newProblem); 579                                         ifaceRefactors.add(renameGetterSetter); 580                                     } 581                                 } 582                             } 583                         } 584                     } 585 586                     // MESSAGE DRIVEN BEANS IMPL CLASS 587 javaClass = (JavaClass)JavaModel.getDefaultExtent().getType().resolve(Utility.MESSAGE_DRIVEN_BEAN); 588                     if (ErrorManager.getDefault().isLoggable(ErrorManager.INFORMATIONAL)) err.log("javaclass: " + javaClass); 589                     if (!(javaClass instanceof UnresolvedClass)) { 590                         if (jc.isSubTypeOf(javaClass)) { 591 592                             // first check if we are trying to rename a method from javax.ejb.MessageDrivenBean interface, and do not allow this 593 if (Utility.isSignatureFromMessageDrivenBeanInterface(method)) { 594                                 String msg = MessageFormat.format( 595                                                 NbBundle.getMessage(EjbJarRenameRefactoring.class, "TXT_EjbJarMethodInJavaxInterfaceProblemRename"), 596                                                 new String [] {Utility.MESSAGE_DRIVEN_BEAN} 597                                              ); 598                                 Problem newProblem = new Problem(true, msg); 599                                 problem = Utility.addProblemsToEnd(problem, newProblem); 600                                 return problem; 601                             } 602 603                             JavaClass listenClass = (JavaClass)JavaModel.getDefaultExtent().getType().resolve(Utility.MESSAGE_LISTENER); 604                             if (ErrorManager.getDefault().isLoggable(ErrorManager.INFORMATIONAL)) err.log("listenclass: " + listenClass); 605                             if (!(listenClass instanceof UnresolvedClass)) { 606                                 if (jc.isSubTypeOf(listenClass)) { 607                                     if (Utility.isSignatureFromMessageListenerInterface(method)) { 608                                         String msg = MessageFormat.format( 609                                                         NbBundle.getMessage(EjbJarRenameRefactoring.class, "TXT_EjbJarMethodInJavaxInterfaceProblemRename"), 610                                                         new String [] {Utility.MESSAGE_LISTENER} 611                                                      ); 612                                         Problem newProblem = new Problem(true, msg); 613                                         problem = Utility.addProblemsToEnd(problem, newProblem); 614                                         return problem; 615                                     } 616                                 } 617                             } 618 619                             // next check if we are trying to rename an ejbCreate method - this change is not allowed, too 620 String methodName = method.getName(); 621                             if (methodName.equals("ejbCreate")) { //NOI18N 622 isCreateInImpl = true; 623                                 String msg = MessageFormat.format( 624                                                 NbBundle.getMessage(EjbJarRenameRefactoring.class, "TXT_EjbJarCreateMethodProblemRename"), 625                                                 new String [] {Utility.MESSAGE_DRIVEN_BEAN} 626                                              ); 627                                 Problem newProblem = new Problem(true, msg); 628                                 problem = Utility.addProblemsToEnd(problem, newProblem); 629                                 return problem; 630                             } 631                         } 632                     } 633                      634                     // HOME INTERFACE CLASS 635 javaClass = (JavaClass)JavaModel.getDefaultExtent().getType().resolve(Utility.EJB_HOME); 636                     if (ErrorManager.getDefault().isLoggable(ErrorManager.INFORMATIONAL)) err.log("javaclass: " + javaClass); 637                     if (!(javaClass instanceof UnresolvedClass)) { 638                         if (jc.isSubTypeOf(javaClass)) { 639 640                             String methodName = method.getName(); 641 642                             // next check create methods 643 if (methodName.startsWith("create")) { 644                                 // next check if we are trying to rename an ejbCreate method - this change is not allowed 645 if (methodName.equals("create")) { //NOI18N 646 String msg = NbBundle.getMessage(EjbJarRenameRefactoring.class, "TXT_EjbJarCreateMethodProblemRename"); 647                                     Problem newProblem = new Problem(true, msg); 648                                     problem = Utility.addProblemsToEnd(problem, newProblem); 649                                     return problem; 650                                 } else { // other create methods can be renamed 651 Method createInLocalHome = Utility.getHomeCreateMethodForHomeCreateMethod(method, fo, jc.getName(), true /*local*/); 652                                     Method createInImpl = Utility.getImplCreateMethodForHomeCreateMethod(method, fo, jc.getName(), false /*not local*/); 653                                     Method postCreateInImpl = Utility.getImplPostCreateMethodForHomeCreateMethod(method, fo, jc.getName(), false /*not local*/); 654                                     isCreateInHome = true; 655                                     if (createInImpl != null) { 656                                         RenameRefactoring renameCreateInHome = new RenameRefactoring(createInImpl); 657                                         Problem p = renameCreateInHome.preCheck(); 658                                         problem = Utility.addProblemsToEnd(problem, p); 659                                         implRefactors.add(renameCreateInHome); 660                                     } 661                                     if (createInLocalHome != null) { 662                                         RenameRefactoring renameCreateInLocalHome = new RenameRefactoring(createInLocalHome); 663                                         Problem p = renameCreateInLocalHome.preCheck(); 664                                         problem = Utility.addProblemsToEnd(problem, p); 665                                         String msg = MessageFormat.format( 666                                                         NbBundle.getMessage(EjbJarRenameRefactoring.class, "TXT_EjbJarIfaceMethodWarningRename"), 667                                                         new String [] {"local home"} 668                                                      ); 669                                         Problem newProblem = new Problem(false, msg); 670                                         problem = Utility.addProblemsToEnd(problem, newProblem); 671                                         ifaceRefactors.add(renameCreateInLocalHome); 672                                     } 673                                     if (postCreateInImpl != null) { 674                                         RenameRefactoring renamePostCreateInImpl = new RenameRefactoring(postCreateInImpl); 675                                         Problem p = renamePostCreateInImpl.preCheck(); 676                                         problem = Utility.addProblemsToEnd(problem, p); 677                                         String msg = NbBundle.getMessage(EjbJarRenameRefactoring.class, "TXT_EjbJarPostCreateMethodWarningRename"); 678                                         Problem newProblem = new Problem(false, msg); 679                                         problem = Utility.addProblemsToEnd(problem, newProblem); 680                                         implRefactors.add(renamePostCreateInImpl); 681                                         return problem; 682                                     } 683                                 } 684                             } 685 686                             // next check if we are trying to rename a findByPrimaryKey method - this shouldn't be allowed 687 if (methodName.equals("findByPrimaryKey")) { //NOI18N 688 isFinderInImpl = true; 689                                 String msg = MessageFormat.format( 690                                                 NbBundle.getMessage(EjbJarRenameRefactoring.class, "TXT_EjbJarFindByPrimaryKeyMethodProblemRename"), 691                                                 new String [] {Utility.ENTITY_BEAN} 692                                              ); 693                                 Problem newProblem = new Problem(true, msg); 694                                 problem = Utility.addProblemsToEnd(problem, newProblem); 695                                 return problem; 696                             } 697                              698                             // next check if we are trying to rename some finder method - this is allowed with some restrictions and finders in implclass/localhome need to be renamed, too 699 Method finderInImpl = Utility.getImplFinderMethodForHomeFinderMethod(method, fo, jc.getName(), false /*not local*/); 700                             Method finderInLocalHome = Utility.getHomeFinderMethodForHomeFinderMethod(method, fo, jc.getName(), true /*local*/); 701                             if (methodName.startsWith("find")) { 702                                 isFinderInHome = true; 703                                 isCmpHomeFinder = true; 704                             } 705                             if (finderInImpl != null) { 706                                 RenameRefactoring renameFinderInImpl = new RenameRefactoring(finderInImpl); 707                                 Problem p = renameFinderInImpl.preCheck(); 708                                 problem = Utility.addProblemsToEnd(problem, p); 709                                 implRefactors.add(renameFinderInImpl); 710                             } 711                             if (finderInLocalHome != null) { 712                                 RenameRefactoring renameFinderInLocalHome = new RenameRefactoring(finderInLocalHome); 713                                 Problem p = renameFinderInLocalHome.preCheck(); 714                                 problem = Utility.addProblemsToEnd(problem, p); 715                                 ifaceRefactors.add(renameFinderInLocalHome); 716                             } 717 718                             // next check if we are trying to rename some home method - this is allowed with some restrictions and homes in implclass/localhome need to be renamed, too 719 Method homeInImpl = Utility.getImplHomeMethodForHomeHomeMethod(method, fo, jc.getName(), false /*not local*/); 720                             Method homeInLocalHome = Utility.getHomeHomeMethodForHomeHomeMethod(method, fo, jc.getName(), true /*local*/); 721                             if (homeInImpl != null) { 722                                 isHomeInHome = true; 723                                 RenameRefactoring renameHomeInImpl = new RenameRefactoring(homeInImpl); 724                                 Problem p = renameHomeInImpl.preCheck(); 725                                 problem = Utility.addProblemsToEnd(problem, p); 726                                 implRefactors.add(renameHomeInImpl); 727                             } 728                             if (homeInLocalHome != null) { 729                                 isHomeInHome = true; 730                                 RenameRefactoring renameHomeInLocalHome = new RenameRefactoring(homeInLocalHome); 731                                 Problem p = renameHomeInLocalHome.preCheck(); 732                                 problem = Utility.addProblemsToEnd(problem, p); 733                                 ifaceRefactors.add(renameHomeInLocalHome); 734                             } 735                         } 736                     } 737 738                     // LOCAL HOME INTERFACE CLASS 739 javaClass = (JavaClass)JavaModel.getDefaultExtent().getType().resolve(Utility.EJB_LOCAL_HOME); 740                     if (ErrorManager.getDefault().isLoggable(ErrorManager.INFORMATIONAL)) err.log("javaclass: " + javaClass); 741                     if (!(javaClass instanceof UnresolvedClass)) { 742                         if (jc.isSubTypeOf(javaClass)) { 743 744                             String methodName = method.getName(); 745                              746                             // next check create methods 747 if (methodName.startsWith("create")) { 748                                 // next check if we are trying to rename an ejbCreate method - this change is not allowed 749 if (methodName.equals("create")) { //NOI18N 750 String msg = NbBundle.getMessage(EjbJarRenameRefactoring.class, "TXT_EjbJarCreateMethodProblemRename"); 751                                     Problem newProblem = new Problem(true, msg); 752                                     problem = Utility.addProblemsToEnd(problem, newProblem); 753                                     return problem; 754                                 } else { // other create methods can be renamed 755 Method createInHome = Utility.getHomeCreateMethodForHomeCreateMethod(method, fo, jc.getName(), false /*local*/); 756                                     Method createInImpl = Utility.getImplCreateMethodForHomeCreateMethod(method, fo, jc.getName(), true /*not local*/); 757                                     Method postCreateInImpl = Utility.getImplPostCreateMethodForHomeCreateMethod(method, fo, jc.getName(), true /*not local*/); 758                                     isCreateInLocalHome = true; 759                                     if (createInImpl != null) { 760                                         RenameRefactoring renameCreateInHome = new RenameRefactoring(createInImpl); 761                                         Problem p = renameCreateInHome.preCheck(); 762                                         problem = Utility.addProblemsToEnd(problem, p); 763                                         implRefactors.add(renameCreateInHome); 764                                     } 765                                     if (createInHome != null) { 766                                         RenameRefactoring renameCreateInHome = new RenameRefactoring(createInHome); 767                                         Problem p = renameCreateInHome.preCheck(); 768                                         problem = Utility.addProblemsToEnd(problem, p); 769                                         String msg = MessageFormat.format( 770                                                         NbBundle.getMessage(EjbJarRenameRefactoring.class, "TXT_EjbJarIfaceMethodWarningRename"), 771                                                         new String [] {"home"} 772                                                      ); 773                                         Problem newProblem = new Problem(false, msg); 774                                         problem = Utility.addProblemsToEnd(problem, newProblem); 775                                         ifaceRefactors.add(renameCreateInHome); 776                                     } 777                                     if (postCreateInImpl != null) { 778                                         RenameRefactoring renamePostCreateInImpl = new RenameRefactoring(postCreateInImpl); 779                                         Problem p = renamePostCreateInImpl.preCheck(); 780                                         problem = Utility.addProblemsToEnd(problem, p); 781                                         String msg = NbBundle.getMessage(EjbJarRenameRefactoring.class, "TXT_EjbJarPostCreateMethodWarningRename"); 782                                         Problem newProblem = new Problem(false, msg); 783                                         problem = Utility.addProblemsToEnd(problem, newProblem); 784                                         implRefactors.add(renamePostCreateInImpl); 785                                         return problem; 786                                     } 787                                 } 788                             } 789 790                             // next check if we are trying to rename a findByPrimaryKey method - this shouldn't be allowed 791 if (methodName.equals("findByPrimaryKey")) { //NOI18N 792 isFinderInImpl = true; 793                                 String msg = MessageFormat.format( 794                                                 NbBundle.getMessage(EjbJarRenameRefactoring.class, "TXT_EjbJarFindByPrimaryKeyMethodProblemRename"), 795                                                 new String [] {Utility.ENTITY_BEAN} 796                                              ); 797                                 Problem newProblem = new Problem(true, msg); 798                                 problem = Utility.addProblemsToEnd(problem, newProblem); 799                                 return problem; 800                             } 801 802                             // next check if we are trying to rename some finder method - this is allowed with some restrictions and finders in implclass/home need to be renamed, too 803 Method finderInImpl = Utility.getImplFinderMethodForHomeFinderMethod(method, fo, jc.getName(), true /*local*/); 804                             Method finderInHome = Utility.getHomeFinderMethodForHomeFinderMethod(method, fo, jc.getName(), false /*not local*/); 805                             if (methodName.startsWith("find")) { 806                                 isFinderInLocalHome = true; 807                                 isCmpLocalHomeFinder = true; 808                             } 809                             if (finderInImpl != null) { 810                                 isFinderInLocalHome = true; 811                                 RenameRefactoring renameFinderInImpl = new RenameRefactoring(finderInImpl); 812                                 Problem p = renameFinderInImpl.preCheck(); 813                                 problem = Utility.addProblemsToEnd(problem, p); 814                                 implRefactors.add(renameFinderInImpl); 815                             } 816                             if (finderInHome != null) { 817                                 isFinderInLocalHome = true; 818                                 RenameRefactoring renameFinderInHome = new RenameRefactoring(finderInHome); 819                                 Problem p = renameFinderInHome.preCheck(); 820                                 problem = Utility.addProblemsToEnd(problem, p); 821                                 ifaceRefactors.add(renameFinderInHome); 822                                 return problem; 823                             } 824 825                             // next check if we are trying to rename some home method - this is allowed with some restrictions and homes in implclass/home need to be renamed, too 826 Method homeInImpl = Utility.getImplHomeMethodForHomeHomeMethod(method, fo, jc.getName(), true /*not local*/); 827                             Method homeInHome = Utility.getHomeHomeMethodForHomeHomeMethod(method, fo, jc.getName(), false /*local*/); 828                             if (homeInImpl != null) { 829                                 isHomeInLocalHome = true; 830                                 RenameRefactoring renameHomeInImpl = new RenameRefactoring(homeInImpl); 831                                 Problem p = renameHomeInImpl.preCheck(); 832                                 problem = Utility.addProblemsToEnd(problem, p); 833                                 implRefactors.add(renameHomeInImpl); 834                             } 835                             if (homeInHome != null) { 836                                 isHomeInLocalHome = true; 837                                 RenameRefactoring renameHomeInHome = new RenameRefactoring(homeInHome); 838                                 Problem p = renameHomeInHome.preCheck(); 839                                 problem = Utility.addProblemsToEnd(problem, p); 840                                 ifaceRefactors.add(renameHomeInHome); 841                                 return problem; 842                             } 843                             return problem; 844                         } 845                     } 846                 } 847             } 848         } 849         return problem; 850     } 851 852     public Problem fastCheckParameters(RefObject refObject, String newName) { 853         if (ErrorManager.getDefault().isLoggable(ErrorManager.INFORMATIONAL)) err.log("> EjbJarRenameRefactoring.fastCheckParameters( " + refObject + "," + newName + " )"); 854         Problem problem = null; 855         if (refObject instanceof Method) { 856             if (isFinderInImpl) { 857                 // rename of finder method in imlementation class was invoked 858 for (int i=0; i < ifaceRefactors.size(); i++) { 859                     RenameRefactoring rr = (RenameRefactoring)ifaceRefactors.get(i); 860                     String name = "find" + newName.substring(7); // remove 'ejbFind' from start NOI18N 861 rr.setNewName(name); 862                     Problem p = rr.fastCheckParameters(); 863                     problem = Utility.addProblemsToEnd(problem, p); 864                 } 865                 if ((javaClass != null) && !(javaClass instanceof UnresolvedClass)) { 866                     if (ErrorManager.getDefault().isLoggable(ErrorManager.INFORMATIONAL)) err.log("resolved class: " + javaClass); 867                     if (ErrorManager.getDefault().isLoggable(ErrorManager.INFORMATIONAL)) err.log("finder method in impl class"); 868                     if (!newName.startsWith("ejbFind")) { //NOI18N 869 String msg = NbBundle.getMessage(EjbJarRenameRefactoring.class, "TXT_EjbJarFinderMethodFastCheckProblemRename"); 870                         Problem newProblem = new Problem(true, msg); 871                         problem = Utility.addProblemsToEnd(problem, newProblem); 872                     } 873                 } 874             } 875             if (isSelectInImpl) { 876                 if (!newName.startsWith("ejbSelect")) { 877                     if ((javaClass != null) && !(javaClass instanceof UnresolvedClass)) { 878                         if (ErrorManager.getDefault().isLoggable(ErrorManager.INFORMATIONAL)) err.log("resolved class: " + javaClass); 879                         if (ErrorManager.getDefault().isLoggable(ErrorManager.INFORMATIONAL)) err.log("select method in impl class"); 880                         String msg = NbBundle.getMessage(EjbJarRenameRefactoring.class, "TXT_EjbJarSelectMethodFastCheckProblemRename"); 881                         Problem newProblem = new Problem(true, msg); 882                         problem = Utility.addProblemsToEnd(problem, newProblem); 883                     } 884                 } 885             } 886             if (isCreateInImpl) { 887                 if ((newName.length() >= 9) && (newName.startsWith("ejbCreate"))) { 888                     // rename of create method in imlementation class was invoked 889 for (int i=0; i < ifaceRefactors.size(); i++) { 890                         RenameRefactoring rr = (RenameRefactoring)ifaceRefactors.get(i); 891                         String name = "create" + newName.substring(9); // NOI18N remove 'ejbCreate' from start 892 rr.setNewName(name); 893                         Problem p = rr.fastCheckParameters(); 894                         problem = Utility.addProblemsToEnd(problem, p); 895                     } 896                     for (int l=0; l < implRefactors.size(); l++) { 897                         RenameRefactoring rr = (RenameRefactoring)implRefactors.get(l); 898                         String name = "ejbPostCreate" + newName.substring(9); // NOI18N remove 'ejbCreate' from start 899 rr.setNewName(name); 900                         Problem p = rr.fastCheckParameters(); 901                         problem = Utility.addProblemsToEnd(problem, p); 902                     } 903                 } else { 904                     if ((javaClass != null) && !(javaClass instanceof UnresolvedClass)) { 905                         if (ErrorManager.getDefault().isLoggable(ErrorManager.INFORMATIONAL)) err.log("resolved class: " + javaClass); 906                         if (ErrorManager.getDefault().isLoggable(ErrorManager.INFORMATIONAL)) err.log("create method in impl class"); 907                         String msg = NbBundle.getMessage(EjbJarRenameRefactoring.class, "TXT_EjbJarCreateMethodFastCheckProblemRename"); 908                         Problem newProblem = new Problem(true, msg); 909                         problem = Utility.addProblemsToEnd(problem, newProblem); 910                     } 911                 } 912             } 913             if ((isCreateInHome) || (isCreateInLocalHome)) { 914                 // rename of create method in home or local home interface was invoked 915 if ((newName.length() >= 6) && (newName.startsWith("create"))) { 916                     String name = "ejb" + newName.substring(0,1).toUpperCase() + newName.substring(1); //NOI18N 917 for (int i=0; i < ifaceRefactors.size(); i++) { 918                         RenameRefactoring rr = (RenameRefactoring)ifaceRefactors.get(i); 919                         rr.setNewName(newName); 920                         Problem p = rr.fastCheckParameters(); 921                         problem = Utility.addProblemsToEnd(problem, p); 922                     } 923                     for (int l=0; l < implRefactors.size(); l++) { 924                         RenameRefactoring rr = (RenameRefactoring)implRefactors.get(l); 925                         if (((Method)rr.getRefactoredObject()).getName().startsWith("ejbPostCreate")) { 926                             String n = "ejbPost" + newName.substring(0,1).toUpperCase() + newName.substring(1); //NOI18N 927 rr.setNewName(n); 928                         } else { 929                             rr.setNewName(name); 930                         } 931                         Problem p = rr.fastCheckParameters(); 932                         problem = Utility.addProblemsToEnd(problem, p); 933                     } 934                 } else { 935                     if ((javaClass != null) && !(javaClass instanceof UnresolvedClass)) { 936                         if (ErrorManager.getDefault().isLoggable(ErrorManager.INFORMATIONAL)) err.log("resolved class: " + javaClass); 937                         if (ErrorManager.getDefault().isLoggable(ErrorManager.INFORMATIONAL)) err.log("create method in home/localhome"); 938                         String msg = NbBundle.getMessage(EjbJarRenameRefactoring.class, "TXT_EjbJarHomeCreateMethodFastCheckProblemRename"); 939                         Problem newProblem = new Problem(true, msg); 940                         problem = Utility.addProblemsToEnd(problem, newProblem); 941                     } 942                 } 943             } 944             if (isPostCreateInImpl) { 945                 if ((newName.length() >= 13) && (newName.startsWith("ejbPostCreate"))) { 946                     // rename of postCreate method in imlementation class was invoked 947 for (int i=0; i < ifaceRefactors.size(); i++) { 948                         RenameRefactoring rr = (RenameRefactoring)ifaceRefactors.get(i); 949                         String name = "create" + newName.substring(13); // NOI18N remove 'ejbPostCreate' from start 950 rr.setNewName(name); 951                         Problem p = rr.fastCheckParameters(); 952                         problem = Utility.addProblemsToEnd(problem, p); 953                     } 954                     for (int l=0; l < implRefactors.size(); l++) { 955                         RenameRefactoring rr = (RenameRefactoring)implRefactors.get(l); 956                         String name = "ejbCreate" + newName.substring(13); // NOI18N remove 'ejbPostCreate' from start 957 rr.setNewName(name); 958                         Problem p = rr.fastCheckParameters(); 959                         problem = Utility.addProblemsToEnd(problem, p); 960                     } 961                 } else { 962                     if ((javaClass != null) && !(javaClass instanceof UnresolvedClass)) { 963                         if (ErrorManager.getDefault().isLoggable(ErrorManager.INFORMATIONAL)) err.log("resolved class: " + javaClass); 964                         if (ErrorManager.getDefault().isLoggable(ErrorManager.INFORMATIONAL)) err.log("postCreate method in impl class"); 965                         String msg = NbBundle.getMessage(EjbJarRenameRefactoring.class, "TXT_EjbJarPostCreateMethodFastCheckProblemRename"); 966                         Problem newProblem = new Problem(true, msg); 967                         problem = Utility.addProblemsToEnd(problem, newProblem); 968                     } 969                 } 970             } 971             if ((isFinderInHome) || (isFinderInLocalHome)) { 972                 // rename of finder method in home or local home interface was invoked 973 if ((newName.length() > 4) && (newName.startsWith("find"))) { 974                     String name = "ejb" + newName.substring(0,1).toUpperCase() + newName.substring(1); //NOI18N 975 for (int i=0; i < ifaceRefactors.size(); i++) { 976                         RenameRefactoring rr = (RenameRefactoring)ifaceRefactors.get(i); 977                         rr.setNewName(newName); 978                         Problem p = rr.fastCheckParameters(); 979                         problem = Utility.addProblemsToEnd(problem, p); 980                     } 981                     for (int l=0; l < implRefactors.size(); l++) { 982                         RenameRefactoring rr = (RenameRefactoring)implRefactors.get(l); 983                         rr.setNewName(name); 984                         Problem p = rr.fastCheckParameters(); 985                         problem = Utility.addProblemsToEnd(problem, p); 986                     } 987                 } else { 988                     if ((javaClass != null) && !(javaClass instanceof UnresolvedClass)) { 989                         if (ErrorManager.getDefault().isLoggable(ErrorManager.INFORMATIONAL)) err.log("resolved class: " + javaClass); 990                         if (ErrorManager.getDefault().isLoggable(ErrorManager.INFORMATIONAL)) err.log("finder method in home/localhome"); 991                         String msg = NbBundle.getMessage(EjbJarRenameRefactoring.class, "TXT_EjbJarHomeFinderMethodFastCheckProblemRename"); 992                         Problem newProblem = new Problem(true, msg); 993                         problem = Utility.addProblemsToEnd(problem, newProblem); 994                     } 995                 } 996             } 997             if ((isHomeInHome) || (isHomeInLocalHome)) { 998                 // rename of home method in home or local home interface was invoked 999 String name = "ejbHome" + newName.substring(0,1).toUpperCase() + newName.substring(1); //NOI18N 1000 for (int i=0; i < ifaceRefactors.size(); i++) { 1001                    RenameRefactoring rr = (RenameRefactoring)ifaceRefactors.get(i); 1002                    rr.setNewName(newName); 1003                    Problem p = rr.fastCheckParameters(); 1004                    problem = Utility.addProblemsToEnd(problem, p); 1005                } 1006                for (int l=0; l < implRefactors.size(); l++) { 1007                    RenameRefactoring rr = (RenameRefactoring)implRefactors.get(l); 1008                    rr.setNewName(name); 1009                    String oldName = ((Method)rr.getRefactoredObject()).getName(); 1010                    if (!(name.equals(oldName))) { 1011                        Problem p = rr.fastCheckParameters(); 1012                        problem = Utility.addProblemsToEnd(problem, p); 1013                    } 1014                } 1015            } 1016            if (isHomeInImpl) { 1017                // rename of home method in imlementation class was invoked 1018 if ((newName.length() > 7) && (newName.startsWith("ejbHome"))) { 1019                    String name = newName.substring(7,8).toLowerCase() + newName.substring(8); // remove ejbHome from the string 1020 for (int i=0; i < ifaceRefactors.size(); i++) { 1021                        RenameRefactoring rr = (RenameRefactoring)ifaceRefactors.get(i); 1022                        rr.setNewName(name); 1023                        Problem p = rr.fastCheckParameters(); 1024                        problem = Utility.addProblemsToEnd(problem, p); 1025                    } 1026                } else { 1027                    if ((javaClass != null) && !(javaClass instanceof UnresolvedClass)) { 1028                        if (ErrorManager.getDefault().isLoggable(ErrorManager.INFORMATIONAL)) err.log("resolved class: " + javaClass); 1029                        if (ErrorManager.getDefault().isLoggable(ErrorManager.INFORMATIONAL)) err.log("home method in impl class"); 1030                        String msg = NbBundle.getMessage(EjbJarRenameRefactoring.class, "TXT_EjbJarHomeMethodFastCheckProblemRename"); 1031                        Problem newProblem = new Problem(true, msg); 1032                        problem = Utility.addProblemsToEnd(problem, newProblem); 1033                    } 1034                } 1035            } 1036            if (isGetterInBusiness || isGetterInImpl) { 1037                if (newName.length() > 3) { 1038                    if (!newName.startsWith("get")) { 1039                        String msg = NbBundle.getMessage(EjbJarRenameRefactoring.class, "TXT_EjbJarGetterMethodFastCheckProblemRename"); 1040                        Problem newProblem = new Problem(true, msg); 1041                        problem = Utility.addProblemsToEnd(problem, newProblem); 1042                    } 1043                } else { 1044                    String msg = NbBundle.getMessage(EjbJarRenameRefactoring.class, "TXT_EjbJarGetterMethodFastCheckProblemRename"); 1045                    Problem newProblem = new Problem(true, msg); 1046                    problem = Utility.addProblemsToEnd(problem, newProblem); 1047                } 1048            } 1049            if (isSetterInBusiness || isSetterInImpl) { 1050                if (newName.length() > 3) { 1051                    if (!newName.startsWith("set")) { // NOI18N 1052 String msg = NbBundle.getMessage(EjbJarRenameRefactoring.class, "TXT_EjbJarSetterMethodFastCheckProblemRename"); 1053                        Problem newProblem = new Problem(true, msg); 1054                        problem = Utility.addProblemsToEnd(problem, newProblem); 1055                    } 1056                } else { 1057                    String msg = NbBundle.getMessage(EjbJarRenameRefactoring.class, "TXT_EjbJarSetterMethodFastCheckProblemRename"); 1058                    Problem newProblem = new Problem(true, msg); 1059                    problem = Utility.addProblemsToEnd(problem, newProblem); 1060                } 1061            } 1062        } 1063        return problem; 1064    } 1065 1066    public Problem checkParameters(RefObject refObject, String newName) { 1067        if (ErrorManager.getDefault().isLoggable(ErrorManager.INFORMATIONAL)) err.log("> EjbJarRenameRefactoring.checkParameters( " + refObject + "," + newName + " )"); 1068        return fastCheckParameters(refObject, newName); 1069    } 1070     1071    public Problem prepare(AbstractRefactoring refactoring, RefObject refObject, String newName, RefactoringElementsBag refactoringElements) { 1072        if (ErrorManager.getDefault().isLoggable(ErrorManager.INFORMATIONAL)) err.log("> EjbJarRenameRefactoring.prepare( " + refactoring + ", " + refObject + "," + newName + ", " + refactoringElements + " )"); 1073        RefactoringSession session = refactoringElements.getSession(); 1074        Problem problem = null; 1075                 1076        if (refObject instanceof JavaClass) { 1077             1078            JavaClass jClass = (JavaClass)refObject; 1079             1080            String name = jClass.getName(); 1081            if (ErrorManager.getDefault().isLoggable(ErrorManager.INFORMATIONAL)) err.log("name: " + name); 1082 1083            newName = name.substring(0, name.lastIndexOf('.') + 1) + newName; 1084            if (ErrorManager.getDefault().isLoggable(ErrorManager.INFORMATIONAL)) err.log("newName: " + newName); 1085             1086            Iterator emIter = null; 1087 1088            if (emodules != null) { 1089                emIter = emodules.iterator(); 1090            } 1091            if (emIter != null) { 1092                while (emIter.hasNext()) { 1093                    org.netbeans.modules.j2ee.api.ejbjar.EjbJar em = (org.netbeans.modules.j2ee.api.ejbjar.EjbJar)emIter.next(); 1094                    if (em != null) { // the class is in an ejb module 1095 FileObject ejbJarFO = em.getDeploymentDescriptor(); 1096                        EjbJar ejbJarDD = null; 1097                        try { 1098                            ejbJarDD = org.netbeans.modules.j2ee.dd.api.ejb.DDProvider.getDefault().getMergedDDRoot(em.getMetadataUnit()); 1099                        } catch (IOException ioe) { 1100                            //ignore 1101 } 1102                        if ((ejbJarDD != null) && (ejbJarDD.getStatus()!=EjbJar.STATE_INVALID_UNPARSABLE) && ejbJarFO != null) { 1103                            EnterpriseBeans eBeans = ejbJarDD.getEnterpriseBeans(); 1104 1105                            /* First check Session beans */ 1106                            Session [] sessionBeans = (eBeans == null ? null : eBeans.getSession()); 1107                            if (ErrorManager.getDefault().isLoggable(ErrorManager.INFORMATIONAL)) err.log("Session Beans: " + sessionBeans); 1108                            if ((sessionBeans != null) && (sessionBeans.length > 0)) { 1109                                for (int b=0; b < sessionBeans.length; b++) { 1110                                    Session sBean = (Session)sessionBeans[b]; 1111                                    if (ErrorManager.getDefault().isLoggable(ErrorManager.INFORMATIONAL)) err.log("Session Bean: " + sBean); 1112                                    String ejbClass = sBean.getEjbClass(); 1113                                    if (ErrorManager.getDefault().isLoggable(ErrorManager.INFORMATIONAL)) err.log("EJB Class: " + ejbClass); 1114                                    if ((ejbClass != null) && (ejbClass.equals(name))) { 1115                                        RefactoringElementImplementation elem = new EjbJarBeanClassRenameRefactoringElement(ejbJarDD, name, newName, (EntityAndSession)sBean, ejbJarFO); 1116                                        refactoringElements.add(refactoring, elem); 1117                                    } 1118                                    String ejbLocal = sBean.getLocal(); 1119                                    if (ErrorManager.getDefault().isLoggable(ErrorManager.INFORMATIONAL)) err.log("EJB Local: " + ejbLocal); 1120                                    if ((ejbLocal != null) && (ejbLocal.equals(name))) { 1121                                        RefactoringElementImplementation elem = new EjbJarLocalRenameRefactoringElement(ejbJarDD, name, newName, (EntityAndSession)sBean, ejbJarFO); 1122                                        refactoringElements.add(refactoring, elem); 1123                                    } 1124                                    String ejbLocalHome = sBean.getLocalHome(); 1125                                    if (ErrorManager.getDefault().isLoggable(ErrorManager.INFORMATIONAL)) err.log("EJB LocalHome: " + ejbLocalHome); 1126                                    if ((ejbLocalHome != null) && (ejbLocalHome.equals(name))) { 1127                                        RefactoringElementImplementation elem = new EjbJarLocalHomeRenameRefactoringElement(ejbJarDD, name, newName, (EntityAndSession)sBean, ejbJarFO); 1128                                        refactoringElements.add(refactoring, elem); 1129                                    } 1130                                    String ejbHome = sBean.getHome(); 1131                                    if (ErrorManager.getDefault().isLoggable(ErrorManager.INFORMATIONAL)) err.log("EJB Home: " + ejbHome); 1132                                    if ((ejbHome != null) && (ejbHome.equals(name))) { 1133                                        RefactoringElementImplementation elem = new EjbJarHomeRenameRefactoringElement(ejbJarDD, name, newName, (EntityAndSession)sBean, ejbJarFO); 1134                                        refactoringElements.add(refactoring, elem); 1135                                    } 1136                                    String ejbRemote = sBean.getRemote(); 1137                                    if (ErrorManager.getDefault().isLoggable(ErrorManager.INFORMATIONAL)) err.log("EJB Remote: " + ejbRemote); 1138                                    if ((ejbRemote != null) && (ejbRemote.equals(name))) { 1139                                        RefactoringElementImplementation elem = new EjbJarRemoteRenameRefactoringElement(ejbJarDD, name, newName, (EntityAndSession)sBean, ejbJarFO); 1140                                        refactoringElements.add(refactoring, elem); 1141                                    } 1142                                    // service endpoint is related to ejb based web services 1143 String serviceEndpoint = null; 1144                                    try { 1145                                        serviceEndpoint = sBean.getServiceEndpoint(); 1146                                        if (ErrorManager.getDefault().isLoggable(ErrorManager.INFORMATIONAL)) err.log("EJB Service Endpoint: " + serviceEndpoint); 1147                                        if ((serviceEndpoint != null) && (serviceEndpoint.equals(name))) { 1148                                            RefactoringElementImplementation elem = new EjbJarServiceEndpointRenameRefactoringElement(ejbJarDD, name, newName, (Session)sBean, ejbJarFO); 1149                                            refactoringElements.add(refactoring, elem); 1150                                        } 1151                                    } catch (VersionNotSupportedException versionex) { 1152                                        // No problem, just ignore 1153 if (ErrorManager.getDefault().isLoggable(ErrorManager.INFORMATIONAL)) err.log("Service endpoint not supported in this version of dd."); 1154                                    } 1155                                    // refs 1156 org.netbeans.modules.j2ee.dd.api.common.EjbRef[] refs = sBean.getEjbRef(); 1157                                    if ((refs != null) && (refs.length > 0)) { 1158                                        for (int l=0; l < refs.length; l++) { 1159                                            org.netbeans.modules.j2ee.dd.api.common.EjbRef ref = (org.netbeans.modules.j2ee.dd.api.common.EjbRef)refs[l]; 1160                                            if (ErrorManager.getDefault().isLoggable(ErrorManager.INFORMATIONAL)) err.log("EJB ref: " + ref); 1161                                            String refHome = ref.getHome(); 1162                                            if (ErrorManager.getDefault().isLoggable(ErrorManager.INFORMATIONAL)) err.log("home ref: " + refHome); 1163                                            if ((refHome != null) && (refHome.equals(name))) { 1164                                                RefactoringElementImplementation elem = 1165                                                        new EjbJarRefHomeRenameRefactoringElement(ejbJarDD, name, newName, 1166                                                            (org.netbeans.modules.j2ee.dd.api.common.EjbRef)ref, 1167                                                            ejbJarFO 1168                                                        ); 1169                                                refactoringElements.add(refactoring, elem); 1170                                            } 1171                                            String refRemote = ref.getRemote(); 1172                                            if (ErrorManager.getDefault().isLoggable(ErrorManager.INFORMATIONAL)) err.log("remote ref: " + refRemote); 1173                                            if ((refRemote != null) && (refRemote.equals(name))) { 1174                                                RefactoringElementImplementation elem = 1175                                                        new EjbJarRefRemoteRenameRefactoringElement(ejbJarDD, name, newName, 1176                                                            (org.netbeans.modules.j2ee.dd.api.common.EjbRef)ref, 1177                                                            ejbJarFO 1178                                                        ); 1179                                                refactoringElements.add(refactoring, elem); 1180                                            } 1181                                        } 1182                                    } 1183                                    // local refs 1184 org.netbeans.modules.j2ee.dd.api.common.EjbLocalRef[] localRefs = sBean.getEjbLocalRef(); 1185                                    if ((localRefs != null) && (localRefs.length > 0)) { 1186                                        for (int l=0; l < localRefs.length; l++) { 1187                                            org.netbeans.modules.j2ee.dd.api.common.EjbLocalRef localRef = (org.netbeans.modules.j2ee.dd.api.common.EjbLocalRef)localRefs[l]; 1188                                            if (ErrorManager.getDefault().isLoggable(ErrorManager.INFORMATIONAL)) err.log("EJB local ref: " + localRef); 1189                                            String refLocal = localRef.getLocal(); 1190                                            if (ErrorManager.getDefault().isLoggable(ErrorManager.INFORMATIONAL)) err.log("local ref: " + refLocal); 1191                                            if ((refLocal != null) && (refLocal.equals(name))) { 1192                                                RefactoringElementImplementation elem = 1193                                                        new EjbJarRefLocalRenameRefactoringElement(ejbJarDD, name, newName, 1194                                                            (org.netbeans.modules.j2ee.dd.api.common.EjbLocalRef)localRef, 1195                                                            ejbJarFO 1196                                                        ); 1197                                                refactoringElements.add(refactoring, elem); 1198                                            } 1199                                            String refLocalHome = localRef.getLocalHome(); 1200                                            if (ErrorManager.getDefault().isLoggable(ErrorManager.INFORMATIONAL)) err.log("localHome ref: " + refLocalHome); 1201                                            if ((refLocalHome != null) && (refLocalHome.equals(name))) { 1202                                                RefactoringElementImplementation elem = 1203                                                        new EjbJarRefLocalHomeRenameRefactoringElement(ejbJarDD, name, newName, 1204                                                            (org.netbeans.modules.j2ee.dd.api.common.EjbLocalRef)localRef, 1205                                                            ejbJarFO 1206                                                        ); 1207                                                refactoringElements.add(refactoring, elem); 1208                                            } 1209                                        } 1210                                    } 1211                                } 1212                            } 1213 1214                            /* Then entity beans */ 1215                            Entity [] entityBeans = (eBeans == null ? null : eBeans.getEntity()); 1216                            if (ErrorManager.getDefault().isLoggable(ErrorManager.INFORMATIONAL)) err.log("Entity Beans: " + entityBeans); 1217                            if ((entityBeans != null) && (entityBeans.length > 0)) { 1218                                for (int b=0; b < entityBeans.length; b++) { 1219                                    Entity entBean = (Entity)entityBeans[b]; 1220                                    if (ErrorManager.getDefault().isLoggable(ErrorManager.INFORMATIONAL)) err.log("Entity Bean: " + entBean); 1221                                    String ejbClass = entBean.getEjbClass(); 1222                                    if (ErrorManager.getDefault().isLoggable(ErrorManager.INFORMATIONAL)) err.log("EJB Class: " + ejbClass); 1223                                    if ((ejbClass != null) && (ejbClass.equals(name))) { 1224                                        RefactoringElementImplementation elem = new EjbJarBeanClassRenameRefactoringElement(ejbJarDD, name, newName, (EntityAndSession)entBean, ejbJarFO); 1225                                        refactoringElements.add(refactoring, elem); 1226                                    } 1227                                    String ejbLocal = entBean.getLocal(); 1228                                    if (ErrorManager.getDefault().isLoggable(ErrorManager.INFORMATIONAL)) err.log("EJB Local: " + ejbLocal); 1229                                    if ((ejbLocal != null) && (ejbLocal.equals(name))) { 1230                                        RefactoringElementImplementation elem = new EjbJarLocalRenameRefactoringElement(ejbJarDD, name, newName, (EntityAndSession)entBean, ejbJarFO); 1231                                        refactoringElements.add(refactoring, elem); 1232                                    } 1233                                    String ejbLocalHome = entBean.getLocalHome(); 1234                                    if (ErrorManager.getDefault().isLoggable(ErrorManager.INFORMATIONAL)) err.log("EJB LocalHome: " + ejbLocalHome); 1235                                    if ((ejbLocalHome != null) && (ejbLocalHome.equals(name))) { 1236                                        RefactoringElementImplementation elem = new EjbJarLocalHomeRenameRefactoringElement(ejbJarDD, name, newName, (EntityAndSession)entBean, ejbJarFO); 1237                                        refactoringElements.add(refactoring, elem); 1238                                    } 1239                                    String ejbHome = entBean.getHome(); 1240                                    if (ErrorManager.getDefault().isLoggable(ErrorManager.INFORMATIONAL)) err.log("EJB Home: " + ejbHome); 1241                                    if ((ejbHome != null) && (ejbHome.equals(name))) { 1242                                        RefactoringElementImplementation elem = new EjbJarHomeRenameRefactoringElement(ejbJarDD, name, newName, (EntityAndSession)entBean, ejbJarFO); 1243                                        refactoringElements.add(refactoring, elem); 1244                                    } 1245                                    String ejbRemote = entBean.getRemote(); 1246                                    if (ErrorManager.getDefault().isLoggable(ErrorManager.INFORMATIONAL)) err.log("EJB Remote: " + ejbRemote); 1247                                    if ((ejbRemote != null) && (ejbRemote.equals(name))) { 1248                                        RefactoringElementImplementation elem = new EjbJarRemoteRenameRefactoringElement(ejbJarDD, name, newName, (EntityAndSession)entBean, ejbJarFO); 1249                                        refactoringElements.add(refactoring, elem); 1250                                    } 1251                                    // refs 1252 org.netbeans.modules.j2ee.dd.api.common.EjbRef[] refs = entBean.getEjbRef(); 1253                                    if ((refs != null) && (refs.length > 0)) { 1254                                        for (int l=0; l < refs.length; l++) { 1255                                            org.netbeans.modules.j2ee.dd.api.common.EjbRef ref = (org.netbeans.modules.j2ee.dd.api.common.EjbRef)refs[l]; 1256                                            if (ErrorManager.getDefault().isLoggable(ErrorManager.INFORMATIONAL)) err.log("EJB ref: " + ref); 1257                                            String refHome = ref.getHome(); 1258                                            if (ErrorManager.getDefault().isLoggable(ErrorManager.INFORMATIONAL)) err.log("home ref: " + refHome); 1259                                            if ((refHome != null) && (refHome.equals(name))) { 1260                                                RefactoringElementImplementation elem = 1261                                                        new EjbJarRefHomeRenameRefactoringElement(ejbJarDD, name, newName, 1262                                                            (org.netbeans.modules.j2ee.dd.api.common.EjbRef)ref, 1263                                                            ejbJarFO 1264                                                        ); 1265                                                refactoringElements.add(refactoring, elem); 1266                                            } 1267                                            String refRemote = ref.getRemote(); 1268                                            if (ErrorManager.getDefault().isLoggable(ErrorManager.INFORMATIONAL)) err.log("remote ref: " + refRemote); 1269                                            if ((refRemote != null) && (refRemote.equals(name))) { 1270                                                RefactoringElementImplementation elem = 1271                                                        new EjbJarRefRemoteRenameRefactoringElement(ejbJarDD, name, newName, 1272                                                            (org.netbeans.modules.j2ee.dd.api.common.EjbRef)ref, 1273                                                            ejbJarFO 1274                                                        ); 1275                                                refactoringElements.add(refactoring, elem); 1276                                            } 1277                                        } 1278                                    } 1279                                    // local refs 1280 org.netbeans.modules.j2ee.dd.api.common.EjbLocalRef[] localRefs = entBean.getEjbLocalRef(); 1281                                    if ((localRefs != null) && (localRefs.length > 0)) { 1282                                        for (int l=0; l < localRefs.length; l++) { 1283                                            org.netbeans.modules.j2ee.dd.api.common.EjbLocalRef localRef = (org.netbeans.modules.j2ee.dd.api.common.EjbLocalRef)localRefs[l]; 1284                                            if (ErrorManager.getDefault().isLoggable(ErrorManager.INFORMATIONAL)) err.log("EJB local ref: " + localRef); 1285                                            String refLocal = localRef.getLocal(); 1286                                            if (ErrorManager.getDefault().isLoggable(ErrorManager.INFORMATIONAL)) err.log("local ref: " + refLocal); 1287                                            if ((refLocal != null) && (refLocal.equals(name))) { 1288                                                RefactoringElementImplementation elem = 1289                                                        new EjbJarRefLocalRenameRefactoringElement(ejbJarDD, name, newName, 1290                                                            (org.netbeans.modules.j2ee.dd.api.common.EjbLocalRef)localRef, 1291                                                            ejbJarFO 1292                                                        ); 1293                                                refactoringElements.add(refactoring, elem); 1294                                            } 1295                                            String refLocalHome = localRef.getLocalHome(); 1296                                            if (ErrorManager.getDefault().isLoggable(ErrorManager.INFORMATIONAL)) err.log("localHome ref: " + refLocalHome); 1297                                            if ((refLocalHome != null) && (refLocalHome.equals(name))) { 1298                                                RefactoringElementImplementation elem = 1299                                                        new EjbJarRefLocalHomeRenameRefactoringElement(ejbJarDD, name, newName, 1300                                                            (org.netbeans.modules.j2ee.dd.api.common.EjbLocalRef)localRef, 1301                                                            ejbJarFO 1302                                                        ); 1303                                                refactoringElements.add(refactoring, elem); 1304                                            } 1305                                        } 1306                                    } 1307                                } 1308                            } 1309 1310                            /* And finally message driven beans */ 1311                            MessageDriven [] messageBeans = (eBeans == null ? null : eBeans.getMessageDriven()); 1312                            if (ErrorManager.getDefault().isLoggable(ErrorManager.INFORMATIONAL)) err.log("MessageDriven Beans: " + messageBeans); 1313                            if ((messageBeans != null) && (messageBeans.length > 0)) { 1314                                for (int b=0; b < messageBeans.length; b++) { 1315                                    MessageDriven msgBean = (MessageDriven)messageBeans[b]; 1316                                    if (ErrorManager.getDefault().isLoggable(ErrorManager.INFORMATIONAL)) err.log("MessageDriven Bean: " + msgBean); 1317                                    String ejbClass = msgBean.getEjbClass(); 1318                                    if (ErrorManager.getDefault().isLoggable(ErrorManager.INFORMATIONAL)) err.log("EJB Class: " + ejbClass); 1319                                    if ((ejbClass != null) && (ejbClass.equals(name))) { 1320                                        RefactoringElementImplementation elem = new EjbJarBeanClassRenameRefactoringElement(ejbJarDD, name, newName, (Ejb)msgBean, ejbJarFO); 1321                                        refactoringElements.add(refactoring, elem); 1322                                    } 1323                                    // refs 1324 org.netbeans.modules.j2ee.dd.api.common.EjbRef[] refs = msgBean.getEjbRef(); 1325                                    if ((refs != null) && (refs.length > 0)) { 1326                                        for (int l=0; l < refs.length; l++) { 1327                                            org.netbeans.modules.j2ee.dd.api.common.EjbRef ref = (org.netbeans.modules.j2ee.dd.api.common.EjbRef)refs[l]; 1328                                            if (ErrorManager.getDefault().isLoggable(ErrorManager.INFORMATIONAL)) err.log("EJB ref: " + ref); 1329                                            String refHome = ref.getHome(); 1330                                            if (ErrorManager.getDefault().isLoggable(ErrorManager.INFORMATIONAL)) err.log("home ref: " + refHome); 1331                                            if ((refHome != null) && (refHome.equals(name))) { 1332                                                RefactoringElementImplementation elem = 1333                                                        new EjbJarRefHomeRenameRefactoringElement(ejbJarDD, name, newName, 1334                                                            (org.netbeans.modules.j2ee.dd.api.common.EjbRef)ref, 1335                                                            ejbJarFO 1336                                                        ); 1337                                                refactoringElements.add(refactoring, elem); 1338                                            } 1339                                            String refRemote = ref.getRemote(); 1340                                            if (ErrorManager.getDefault().isLoggable(ErrorManager.INFORMATIONAL)) err.log("remote ref: " + refRemote); 1341                                            if ((refRemote != null) && (refRemote.equals(name))) { 1342                                                RefactoringElementImplementation elem = 1343                                                        new EjbJarRefRemoteRenameRefactoringElement(ejbJarDD, name, newName, 1344                                                            (org.netbeans.modules.j2ee.dd.api.common.EjbRef)ref, 1345                                                            ejbJarFO 1346                                                        ); 1347                                                refactoringElements.add(refactoring, elem); 1348                                            } 1349                                        } 1350                                    } 1351                                    // local refs 1352 org.netbeans.modules.j2ee.dd.api.common.EjbLocalRef[] localRefs = msgBean.getEjbLocalRef(); 1353                                    if ((localRefs != null) && (localRefs.length > 0)) { 1354                                        for (int l=0; l < localRefs.length; l++) { 1355                                            org.netbeans.modules.j2ee.dd.api.common.EjbLocalRef localRef = (org.netbeans.modules.j2ee.dd.api.common.EjbLocalRef)localRefs[l]; 1356                                            if (ErrorManager.getDefault().isLoggable(ErrorManager.INFORMATIONAL)) err.log("EJB local ref: " + localRef); 1357                                            String refLocal = localRef.getLocal(); 1358                                            if (ErrorManager.getDefault().isLoggable(ErrorManager.INFORMATIONAL)) err.log("local ref: " + refLocal); 1359                                            if ((refLocal != null) && (refLocal.equals(name))) { 1360                                                RefactoringElementImplementation elem = 1361                                                        new EjbJarRefLocalRenameRefactoringElement(ejbJarDD, name, newName, 1362                                                            (org.netbeans.modules.j2ee.dd.api.common.EjbLocalRef)localRef, 1363                                                            ejbJarFO 1364                                                        ); 1365                                                refactoringElements.add(refactoring, elem); 1366                                            } 1367                                            String refLocalHome = localRef.getLocalHome(); 1368                                            if (ErrorManager.getDefault().isLoggable(ErrorManager.INFORMATIONAL)) err.log("localHome ref: " + refLocalHome); 1369                                            if ((refLocalHome != null) && (refLocalHome.equals(name))) { 1370                                                RefactoringElementImplementation elem = 1371                                                        new EjbJarRefLocalHomeRenameRefactoringElement(ejbJarDD, name, newName, 1372                                                            (org.netbeans.modules.j2ee.dd.api.common.EjbLocalRef)localRef, 1373                                                            ejbJarFO 1374                                                        ); 1375                                                refactoringElements.add(refactoring, elem); 1376                                            } 1377                                        } 1378                                    } 1379                                } 1380                            } 1381 1382                        } else if (ejbJarFO != null){ 1383                            Problem newProblem = new Problem(false, NbBundle.getMessage(EjbJarRenameRefactoring.class, "TXT_EjbJarRenameInvalidProblem")); 1384                            problem = Utility.addProblemsToEnd(problem, newProblem); 1385                        } 1386                    } // ejb-jar 1387 } // while 1388 } 1389             1390        } // javaclass 1391 1392        if (refObject instanceof Method) { 1393             1394            // update Assembly descriptor part 1395 Method method = (Method)refObject; 1396            String oldName = method.getName(); 1397            if (ErrorManager.getDefault().isLoggable(ErrorManager.INFORMATIONAL)) err.log("old method name: " + oldName); 1398             1399            Resource res = method.getResource(); 1400            FileObject fo = JavaModel.getFileObject(res); 1401            Collection emodules = Utility.getRelevantEjbModules(fo); 1402            if ((emodules != null) && (emodules.size() > 0)) { // there are ejb modules that can be affected by the change 1403 ClassDefinition jc = method.getDeclaringClass(); 1404                if (ErrorManager.getDefault().isLoggable(ErrorManager.INFORMATIONAL)) err.log("classdefinition jc: " + jc); 1405                if (jc instanceof JavaClass) { 1406                    Iterator emIter = emodules.iterator(); 1407                    while (emIter.hasNext()) { 1408                        org.netbeans.modules.j2ee.api.ejbjar.EjbJar em = (org.netbeans.modules.j2ee.api.ejbjar.EjbJar)emIter.next(); 1409                        if (em != null) { // the class is in an ejb module 1410 FileObject ejbJarFO = em.getDeploymentDescriptor(); 1411                            EjbJar ejbJarDD = null; 1412                            try { 1413                                ejbJarDD = org.netbeans.modules.j2ee.dd.api.ejb.DDProvider.getDefault().getMergedDDRoot(em.getMetadataUnit()); 1414                            } catch (IOException ioe) { 1415                                // ignore 1416 } 1417                            if ((ejbJarDD != null) && (ejbJarDD.getStatus()!=EjbJar.STATE_INVALID_UNPARSABLE) && ejbJarFO != null) { 1418                                AssemblyDescriptor asmDesc = ejbJarDD.getSingleAssemblyDescriptor(); 1419                                if (ErrorManager.getDefault().isLoggable(ErrorManager.INFORMATIONAL)) err.log("asm desc: " + asmDesc); 1420                                if (asmDesc != null) { 1421                                    // container transaction part under assembly descriptor 1422 ContainerTransaction[] contTx = asmDesc.getContainerTransaction(); 1423                                    if ((contTx != null) && (contTx.length > 0)) { 1424                                        for (int c=0; c<contTx.length; c++) { 1425                                            ContainerTransaction cTx = contTx[c]; 1426                                            if (ErrorManager.getDefault().isLoggable(ErrorManager.INFORMATIONAL)) err.log("ctx: " + cTx); 1427                                            if (cTx != null) { 1428                                                org.netbeans.modules.j2ee.dd.api.ejb.Method[] mtds = cTx.getMethod(); 1429                                                if ((mtds != null) && (mtds.length > 0)) { 1430                                                    for (int m=0; m < mtds.length; m++) { 1431                                                        org.netbeans.modules.j2ee.dd.api.ejb.Method mtd = mtds[m]; 1432                                                        if (ErrorManager.getDefault().isLoggable(ErrorManager.INFORMATIONAL)) err.log("mtd: " + mtd); 1433                                                        String mtdName = mtd.getMethodName(); 1434                                                        if (ErrorManager.getDefault().isLoggable(ErrorManager.INFORMATIONAL)) err.log("mtdName: " + mtdName); 1435                                                        if (mtdName.equals(method.getName())) { 1436                                                            String invokedEjbName = mtd.getEjbName(); 1437                                                            if (ErrorManager.getDefault().isLoggable(ErrorManager.INFORMATIONAL)) err.log("invokedejb: " + invokedEjbName); 1438                                                            String ejbName = Utility.getEjbNameForClass(ejbJarDD, jc); 1439                                                            if (ErrorManager.getDefault().isLoggable(ErrorManager.INFORMATIONAL)) err.log("ejbname: " + ejbName); 1440                                                            if (invokedEjbName.equals(ejbName)) { 1441                                                                RefactoringElementImplementation elem = new EjbJarContainerTxRenameRefactoringElement( 1442                                                                                                ejbJarDD, 1443                                                                                                oldName, 1444                                                                                                newName, 1445                                                                                                ejbName, 1446                                                                                                mtd, 1447                                                                                                em.getDeploymentDescriptor()); 1448                                                                refactoringElements.add(refactoring, elem); 1449                                                            } 1450                                                        } 1451 1452                                                    } 1453                                                } 1454                                            } 1455                                        } 1456                                    } 1457 1458                                    // method permissions part under assembly descriptor 1459 MethodPermission[] mtdPerms = asmDesc.getMethodPermission(); 1460                                    if ((mtdPerms != null) && (mtdPerms.length > 0)) { 1461                                        for (int c=0; c<mtdPerms.length; c++) { 1462                                            MethodPermission mtdPerm = mtdPerms[c]; 1463                                            if (ErrorManager.getDefault().isLoggable(ErrorManager.INFORMATIONAL)) err.log("mtdPerm: " + mtdPerm); 1464                                            if (mtdPerm != null) { 1465                                                org.netbeans.modules.j2ee.dd.api.ejb.Method[] mtds = mtdPerm.getMethod(); 1466                                                if ((mtds != null) && (mtds.length > 0)) { 1467                                                    for (int m=0; m < mtds.length; m++) { 1468                                                        org.netbeans.modules.j2ee.dd.api.ejb.Method mtd = mtds[m]; 1469                                                        if (ErrorManager.getDefault().isLoggable(ErrorManager.INFORMATIONAL)) err.log("mtd: " + mtd); 1470                                                        String mtdName = mtd.getMethodName(); 1471                                                        if (ErrorManager.getDefault().isLoggable(ErrorManager.INFORMATIONAL)) err.log("mtdName: " + mtdName); 1472                                                        if (mtdName.equals(method.getName())) { 1473                                                            String invokedEjbName = mtd.getEjbName(); 1474                                                            if (ErrorManager.getDefault().isLoggable(ErrorManager.INFORMATIONAL)) err.log("invokedejb: " + invokedEjbName); 1475                                                            String ejbName = Utility.getEjbNameForClass(ejbJarDD, jc); 1476                                                            if (ErrorManager.getDefault().isLoggable(ErrorManager.INFORMATIONAL)) err.log("ejbname: " + ejbName); 1477                                                            if (invokedEjbName.equals(ejbName)) { 1478                                                                RefactoringElementImplementation elem = new EjbJarMethodPermissionRenameRefactoringElement( 1479                                                                                                ejbJarDD, 1480                                                                                                oldName, 1481                                                                                                newName, 1482                                                                                                ejbName, 1483                                                                                                mtd, 1484                                                                                                em.getDeploymentDescriptor()); 1485                                                                refactoringElements.add(refactoring, elem); 1486                                                            } 1487                                                        } 1488                                                    } 1489                                                } 1490                                            } 1491                                        } 1492                                    } 1493 1494                                    // exclude list part under assembly descriptor 1495 ExcludeList excList = asmDesc.getExcludeList(); 1496                                    if (ErrorManager.getDefault().isLoggable(ErrorManager.INFORMATIONAL)) err.log("excList: " + excList); 1497                                    if (excList != null) { 1498                                        org.netbeans.modules.j2ee.dd.api.ejb.Method[] mtds = excList.getMethod(); 1499                                        if ((mtds != null) && (mtds.length > 0)) { 1500                                            for (int m=0; m < mtds.length; m++) { 1501                                                org.netbeans.modules.j2ee.dd.api.ejb.Method mtd = mtds[m]; 1502                                                if (ErrorManager.getDefault().isLoggable(ErrorManager.INFORMATIONAL)) err.log("mtd: " + mtd); 1503                                                String mtdName = mtd.getMethodName(); 1504                                                if (ErrorManager.getDefault().isLoggable(ErrorManager.INFORMATIONAL)) err.log("mtdName: " + mtdName); 1505                                                if (mtdName.equals(method.getName())) { 1506                                                    String invokedEjbName = mtd.getEjbName(); 1507                                                    if (ErrorManager.getDefault().isLoggable(ErrorManager.INFORMATIONAL)) err.log("invokedejb: " + invokedEjbName); 1508                                                    String ejbName = Utility.getEjbNameForClass(ejbJarDD, jc); 1509                                                    if (ErrorManager.getDefault().isLoggable(ErrorManager.INFORMATIONAL)) err.log("ejbname: " + ejbName); 1510                                                    if (invokedEjbName.equals(ejbName)) { 1511                                                        RefactoringElementImplementation elem = new EjbJarExcludeListRenameRefactoringElement( 1512                                                                                        ejbJarDD, 1513                                                                                        oldName, 1514                                                                                        newName, 1515                                                                                        ejbName, 1516                                                                                        mtd, 1517                                                                                        em.getDeploymentDescriptor()); 1518                                                        refactoringElements.add(refactoring, elem); 1519                                                    } 1520                                                } 1521 1522                                            } 1523                                        } 1524                                    } 1525                                } 1526                             1527                            } else { 1528                                Problem newProblem = new Problem(false, NbBundle.getMessage(EjbJarRenameRefactoring.class, "TXT_EjbJarRenameInvalidProblem")); 1529                                problem = Utility.addProblemsToEnd(problem, newProblem); 1530                            } 1531                        } 1532                    } 1533                } 1534            } 1535             1536            if ((isHomeInImpl) || (isFinderInImpl)) { 1537                for (int i=0; i < ifaceRefactors.size(); i++) { 1538                    RenameRefactoring rr = (RenameRefactoring)ifaceRefactors.get(i); 1539                    Problem p = rr.prepare(session); 1540                    problem = Utility.addProblemsToEnd(problem, p); 1541                } 1542                return problem; 1543            } 1544            if ((isCmpHomeFinder) || (isCmpLocalHomeFinder)) { 1545                if (fo != null) { 1546                    Project prj = FileOwnerQuery.getOwner(fo); 1547                    if (prj != null) { 1548                        org.netbeans.modules.j2ee.api.ejbjar.EjbJar emod = 1549                                org.netbeans.modules.j2ee.api.ejbjar.EjbJar.getEjbJar(prj.getProjectDirectory()); 1550                        ClassDefinition jc = method.getDeclaringClass(); 1551                        if (ErrorManager.getDefault().isLoggable(ErrorManager.INFORMATIONAL)) err.log("classdefinition jc: " + jc); 1552                        if (jc instanceof JavaClass) { 1553                            String className = jc.getName(); 1554                            Entity[] eBeans = Utility.getEntityBeans(emod); 1555                            EjbJar ejbJarDD = Utility.getEjbJar(emod); 1556                            if ((eBeans != null) && (ejbJarDD != null)) { 1557                                for (int e=0; e < eBeans.length; e++) { 1558                                    Entity entity = (Entity)(eBeans[e]); 1559                                    String ejbClass = isCmpHomeFinder ? entity.getHome() : entity.getLocalHome(); 1560                                    if (jc.getName().equals(ejbClass)) { 1561                                        Query[] queries = entity.getQuery(); 1562                                        for (int q=0; q<queries.length; q++) { 1563                                            Query query = (Query)(queries[q]); 1564                                            QueryMethod qm = query.getQueryMethod(); 1565                                            if (ErrorManager.getDefault().isLoggable(ErrorManager.INFORMATIONAL)) err.log("query method: " + qm); 1566                                            if (oldName.equals(qm.getMethodName())) { 1567                                                RefactoringElementImplementation elem = 1568                                                        new EjbJarFinderMethodRenameRefactoringElement(ejbJarDD, oldName, newName, entity, emod.getDeploymentDescriptor()); 1569                                                refactoringElements.add(refactoring, elem); 1570                                            } 1571                                        } 1572                                    } 1573                                } 1574                            } 1575                        } 1576                    } 1577                } 1578            } 1579            if (isSelectInImpl) { 1580                oldName = oldName.substring(9,10).toLowerCase() + oldName.substring(10); 1581                if (ErrorManager.getDefault().isLoggable(ErrorManager.INFORMATIONAL)) err.log("old method name: " + oldName); 1582                 1583                newName = newName.substring(9,10).toLowerCase() + newName.substring(10); 1584                if (ErrorManager.getDefault().isLoggable(ErrorManager.INFORMATIONAL)) err.log("new method name: " + newName); 1585                 1586                if (fo != null) { 1587                    Project prj = FileOwnerQuery.getOwner(fo); 1588                    if (prj != null) { 1589                        org.netbeans.modules.j2ee.api.ejbjar.EjbJar emod = 1590                                org.netbeans.modules.j2ee.api.ejbjar.EjbJar.getEjbJar(prj.getProjectDirectory()); 1591                        ClassDefinition jc = method.getDeclaringClass(); 1592                        if (ErrorManager.getDefault().isLoggable(ErrorManager.INFORMATIONAL)) err.log("classdefinition jc: " + jc); 1593                        if (jc instanceof JavaClass) { 1594                            String className = jc.getName(); 1595                            Entity[] eBeans = Utility.getEntityBeans(emod); 1596                            EjbJar ejbJarDD = Utility.getEjbJar(emod); 1597                            if ((eBeans != null) && (ejbJarDD != null)) { 1598                                for (int e=0; e < eBeans.length; e++) { 1599                                    Entity entity = (Entity)(eBeans[e]); 1600                                    String ejbClass = entity.getEjbClass(); 1601                                    if (jc.getName().equals(ejbClass)) { 1602                                        Query[] queries = entity.getQuery(); 1603                                        for (int q=0; q<queries.length; q++) { 1604                                            Query query = (Query)(queries[q]); 1605                                            QueryMethod qm = query.getQueryMethod(); 1606                                            if (ErrorManager.getDefault().isLoggable(ErrorManager.INFORMATIONAL)) err.log("query method: " + qm); 1607                                            if (oldName.equals(qm.getMethodName())) { 1608                                                RefactoringElementImplementation elem = 1609                                                        new EjbJarSelectMethodRenameRefactoringElement(ejbJarDD, oldName, newName, entity, emod.getDeploymentDescriptor()); 1610                                                refactoringElements.add(refactoring, elem); 1611                                            } 1612                                        } 1613                                    } 1614                                } 1615                            } 1616                        } 1617                    } 1618                } 1619            } 1620 1621            if (isSetterInBusiness || isGetterInBusiness) { 1622                if (fo != null) { 1623                    Project prj = FileOwnerQuery.getOwner(fo); 1624                    if (prj != null) { 1625                        org.netbeans.modules.j2ee.api.ejbjar.EjbJar emod = 1626                                org.netbeans.modules.j2ee.api.ejbjar.EjbJar.getEjbJar(prj.getProjectDirectory()); 1627                        if (isCmpField) { 1628                            Entity[] eBeans = Utility.getEntityBeans(emod); 1629                            EjbJar ejbJarDD = Utility.getEjbJar(emod); 1630                            if ((eBeans != null) && (ejbJarDD != null)) { 1631                                for (int e=0; e < eBeans.length; e++) { 1632                                    Entity entity = (Entity)(eBeans[e]); 1633                                    String ejbClass = entity.getEjbClass(); 1634                                    if ((busImpltorClass != null) && (busImpltorClass.getName().equals(ejbClass))) { 1635                                        String oldFieldName = method.getName().substring(3,4).toLowerCase() + method.getName().substring(4); 1636                                        String newFieldName = newName.substring(3,4).toLowerCase() + newName.substring(4); 1637                                        if (ErrorManager.getDefault().isLoggable(ErrorManager.INFORMATIONAL)) err.log("old field name: " + oldFieldName); 1638                                        CmpField[] cmpFields = entity.getCmpField(); 1639                                        for (int cm=0; cm<cmpFields.length; cm++) { 1640                                            CmpField cmpField = (CmpField)(cmpFields[cm]); 1641                                            String fieldName = cmpField.getFieldName(); 1642                                            if (ErrorManager.getDefault().isLoggable(ErrorManager.INFORMATIONAL)) err.log("field name: " + fieldName); 1643                                            // TODO: provided oldFieldName is wrong if first letter of field is upper-case, fix it and use equals() instead equalsIgnoreCase 1644 if (oldFieldName.equalsIgnoreCase(fieldName)) { 1645                                                RefactoringElementImplementation elem = 1646                                                        new EjbJarCmpFieldRenameRefactoringElement(ejbJarDD, oldFieldName, newFieldName, entity, emod.getDeploymentDescriptor()); 1647                                                refactoringElements.add(refactoring, elem); 1648                                                break; 1649                                            } 1650                                        } 1651                                        break; 1652                                    } 1653                                } 1654                            } 1655                        } 1656                        if (isCmrField) { 1657                            EjbRelation[] ejbRels = Utility.getRelationships(emod); 1658                            EjbJar ejbJarDD = Utility.getEjbJar(emod); 1659                            if ((ejbRels != null) && (ejbJarDD != null)) { 1660                                for (int e=0; e < ejbRels.length; e++) { 1661                                    EjbRelation ejbRel = (EjbRelation)(ejbRels[e]); 1662                                    String ejbName = Utility.getEntityEjbNameForClass((JavaClass)busImpltorClass); 1663                                    if (ejbName != null) { 1664                                        EjbRelationshipRole role = ejbRel.getEjbRelationshipRole(); 1665                                        if (role != null) { 1666                                            RelationshipRoleSource roleSource = role.getRelationshipRoleSource(); 1667                                            if (roleSource != null) { 1668                                                String roleEjbName = roleSource.getEjbName(); 1669                                                if (ejbName.equals(roleEjbName)) { 1670                                                    String oldFieldName = method.getName().substring(3,4).toLowerCase() + method.getName().substring(4); 1671                                                    String newFieldName = newName.substring(3,4).toLowerCase() + newName.substring(4); 1672                                                    if (ErrorManager.getDefault().isLoggable(ErrorManager.INFORMATIONAL)) err.log("old field name: " + oldFieldName); 1673                                                    CmrField cmrField = role.getCmrField(); 1674                                                    if (cmrField != null) { 1675                                                        String fieldName = cmrField.getCmrFieldName(); 1676                                                        if (ErrorManager.getDefault().isLoggable(ErrorManager.INFORMATIONAL)) err.log("field name: " + fieldName); 1677                                                        // TODO: provided oldFieldName is wrong if first letter of field is upper-case, fix it and use equals() instead equalsIgnoreCase 1678 if (oldFieldName.equalsIgnoreCase(fieldName)) { 1679                                                            RefactoringElementImplementation elem = 1680                                                                    new EjbJarCmrFieldRenameRefactoringElement(ejbJarDD, oldFieldName, newFieldName, role, emod.getDeploymentDescriptor()); 1681                                                            refactoringElements.add(refactoring, elem); 1682                                                        } 1683                                                    } 1684                                                } 1685                                            } 1686                                        } 1687                                        EjbRelationshipRole role2 = ejbRel.getEjbRelationshipRole2(); 1688                                        if (role2 != null) { 1689                                            RelationshipRoleSource roleSource = role2.getRelationshipRoleSource(); 1690                                            if (roleSource != null) { 1691                                                String roleEjbName = roleSource.getEjbName(); 1692                                                if (ejbName.equals(roleEjbName)) { 1693                                                    String oldFieldName = method.getName().substring(3,4).toLowerCase() + method.getName().substring(4); 1694                                                    String newFieldName = newName.substring(3,4).toLowerCase() + newName.substring(4); 1695                                                    if (ErrorManager.getDefault().isLoggable(ErrorManager.INFORMATIONAL)) err.log("old field name: " + oldFieldName); 1696                                                    CmrField cmrField = role2.getCmrField(); 1697                                                    if (cmrField != null) { 1698                                                        String fieldName = cmrField.getCmrFieldName(); 1699                                                        if (ErrorManager.getDefault().isLoggable(ErrorManager.INFORMATIONAL)) err.log("field name: " + fieldName); 1700                                                        // TODO: provided oldFieldName is wrong if first letter of field is upper-case, fix it and use equals() instead equalsIgnoreCase 1701 if (oldFieldName.equalsIgnoreCase(fieldName)) { 1702                                                            RefactoringElementImplementation elem = 1703                                                                    new EjbJarCmrFieldRenameRefactoringElement(ejbJarDD, oldFieldName, newFieldName, role2, emod.getDeploymentDescriptor()); 1704                                                            refactoringElements.add(refactoring, elem); 1705                                                        } 1706                                                    } 1707                                                } 1708                                            } 1709                                        } 1710                                    } 1711                                } 1712                            } 1713                        } 1714                    } 1715                } 1716            } 1717 1718            if (isSetterInImpl || isGetterInImpl) { 1719                if (fo != null) { 1720                    Project prj = FileOwnerQuery.getOwner(fo); 1721                    if (prj != null) { 1722                        org.netbeans.modules.j2ee.api.ejbjar.EjbJar emod = 1723                                org.netbeans.modules.j2ee.api.ejbjar.EjbJar.getEjbJar(prj.getProjectDirectory()); 1724                        ClassDefinition jc = method.getDeclaringClass(); 1725                        if (ErrorManager.getDefault().isLoggable(ErrorManager.INFORMATIONAL)) err.log("classdefinition jc: " + jc); 1726                        if (jc instanceof JavaClass) { 1727                            String className = jc.getName(); 1728                            if (isCmpField) { 1729                                Entity[] eBeans = Utility.getEntityBeans(emod); 1730                                EjbJar ejbJarDD = Utility.getEjbJar(emod); 1731                                if ((eBeans != null) && (ejbJarDD != null)) { 1732                                    for (int e=0; e < eBeans.length; e++) { 1733                                        Entity entity = (Entity)(eBeans[e]); 1734                                        String ejbClass = entity.getEjbClass(); 1735                                        if ((jc != null) && (className.equals(ejbClass))) { 1736                                            String oldFieldName = method.getName().substring(3,4).toLowerCase() + method.getName().substring(4); 1737                                            String newFieldName = newName.substring(3,4).toLowerCase() + newName.substring(4); 1738                                            if (ErrorManager.getDefault().isLoggable(ErrorManager.INFORMATIONAL)) err.log("old field name: " + oldFieldName); 1739                                            CmpField[] cmpFields = entity.getCmpField(); 1740                                            for (int cm=0; cm<cmpFields.length; cm++) { 1741                                                CmpField cmpField = (CmpField)(cmpFields[cm]); 1742                                                String fieldName = cmpField.getFieldName(); 1743                                                if (ErrorManager.getDefault().isLoggable(ErrorManager.INFORMATIONAL)) err.log("field name: " + fieldName); 1744                                                if (oldFieldName.equals(fieldName)) { 1745                                                    RefactoringElementImplementation elem = 1746                                                            new EjbJarCmpFieldRenameRefactoringElement(ejbJarDD, oldFieldName, newFieldName, entity, emod.getDeploymentDescriptor()); 1747                                                    refactoringElements.add(refactoring, elem); 1748                                                    break; 1749                                                } 1750                                            } 1751                                            break; 1752                                        } 1753                                    } 1754                                } 1755                            } 1756                            if (isCmrField) { 1757                                EjbRelation[] ejbRels = Utility.getRelationships(emod); 1758                                EjbJar ejbJarDD = Utility.getEjbJar(emod); 1759                                if ((ejbRels != null) && (ejbJarDD != null)) { 1760                                    for (int e=0; e < ejbRels.length; e++) { 1761                                        EjbRelation ejbRel = (EjbRelation)(ejbRels[e]); 1762                                        String ejbName = Utility.getEntityEjbNameForClass((JavaClass)jc); 1763                                        if (ejbName != null) { 1764                                            EjbRelationshipRole role = ejbRel.getEjbRelationshipRole(); 1765                                            if (role != null) { 1766                                                RelationshipRoleSource roleSource = role.getRelationshipRoleSource(); 1767                                                if (roleSource != null) { 1768                                                    String roleEjbName = roleSource.getEjbName(); 1769                                                    if (ejbName.equals(roleEjbName)) { 1770                                                        String oldFieldName = method.getName().substring(3,4).toLowerCase() + method.getName().substring(4); 1771                                                        String newFieldName = newName.substring(3,4).toLowerCase() + newName.substring(4); 1772                                                        if (ErrorManager.getDefault().isLoggable(ErrorManager.INFORMATIONAL)) err.log("old field name: " + oldFieldName); 1773                                                        CmrField cmrField = role.getCmrField(); 1774                                                        if (cmrField != null) { 1775                                                            String fieldName = cmrField.getCmrFieldName(); 1776                                                            if (ErrorManager.getDefault().isLoggable(ErrorManager.INFORMATIONAL)) err.log("field name: " + fieldName); 1777                                                            if (oldFieldName.equals(fieldName)) { 1778                                                                RefactoringElementImplementation elem = 1779                                                                        new EjbJarCmrFieldRenameRefactoringElement(ejbJarDD, oldFieldName, newFieldName, role, emod.getDeploymentDescriptor()); 1780                                                                refactoringElements.add(refactoring, elem); 1781                                                            } 1782                                                        } 1783                                                    } 1784                                                } 1785                                            } 1786                                            EjbRelationshipRole role2 = ejbRel.getEjbRelationshipRole2(); 1787                                            if (role2 != null) { 1788                                                RelationshipRoleSource roleSource = role2.getRelationshipRoleSource(); 1789                                                if (roleSource != null) { 1790                                                    String roleEjbName = roleSource.getEjbName(); 1791                                                    if (ejbName.equals(roleEjbName)) { 1792                                                        String oldFieldName = method.getName().substring(3,4).toLowerCase() + method.getName().substring(4); 1793                                                        String newFieldName = newName.substring(3,4).toLowerCase() + newName.substring(4); 1794                                                        if (ErrorManager.getDefault().isLoggable(ErrorManager.INFORMATIONAL)) err.log("old field name: " + oldFieldName); 1795                                                        CmrField cmrField = role2.getCmrField(); 1796                                                        if (cmrField != null) { 1797                                                            String fieldName = cmrField.getCmrFieldName(); 1798                                                            if (ErrorManager.getDefault().isLoggable(ErrorManager.INFORMATIONAL)) err.log("field name: " + fieldName); 1799                                                            if (oldFieldName.equals(fieldName)) { 1800                                                                RefactoringElementImplementation elem = 1801                                                                        new EjbJarCmrFieldRenameRefactoringElement(ejbJarDD, oldFieldName, newFieldName, role2, emod.getDeploymentDescriptor()); 1802                                                                refactoringElements.add(refactoring, elem); 1803                                                            } 1804                                                        } 1805                                                    } 1806                                                } 1807                                            } 1808                                        } 1809                                    } 1810                                } 1811                            } 1812                        } 1813                    } 1814                } 1815            } 1816             1817            for (int i=0; i < ifaceRefactors.size(); i++) { 1818                RenameRefactoring rr = (RenameRefactoring)ifaceRefactors.get(i); 1819                if (isGetterInBusiness || isSetterInBusiness || isSetterInImpl || isGetterInImpl) { 1820                    String newPart = newName.substring(1); 1821                    rr.setNewName(newName.startsWith("g") ? "s" + newPart : "g" + newPart); 1822                } 1823                Problem p = rr.prepare(session); 1824                problem = Utility.addProblemsToEnd(problem, p); 1825            } 1826            for (int i=0; i < implRefactors.size(); i++) { 1827                RenameRefactoring rr = (RenameRefactoring)implRefactors.get(i); 1828                String nName = rr.getNewName(); 1829                String oName = ((Method)rr.getRefactoredObject()).getName(); 1830                if (!(nName.equals(oName))) { 1831                    Problem p = rr.prepare(session); 1832                    problem = Utility.addProblemsToEnd(problem, p); 1833                } else { // this doesn't make sense = the name didn't change 1834 implRefactors.remove(rr); 1835                } 1836            } 1837        } 1838         1839        return problem; 1840    } 1841 1842    public final class EjbJarBeanClassRenameRefactoringElement extends AbstractRenameRefactoringElement implements ExternalChange { 1843 1844        protected EjbJar ejbJarDD; 1845        private Ejb ejb; 1846 1847        /** Creates a new instance of EjbJarBeanClassRenameRefactoringElement */ 1848        public EjbJarBeanClassRenameRefactoringElement(EjbJar ejbJarDD, String oldName, String newName, Ejb ejb, FileObject parentFile) { 1849            this.ejbJarDD = ejbJarDD; 1850            this.oldName = oldName; 1851            this.newName = newName; 1852            this.ejb = ejb; 1853            this.parentFile = parentFile; 1854        } 1855 1856        /** Returns text describing the refactoring formatted for display (using HTML tags). 1857         * @return Formatted text. 1858         */ 1859        public String getDisplayText() { 1860            Object [] args = new Object [] {parentFile.getNameExt(), oldName, newName}; 1861            return MessageFormat.format(NbBundle.getMessage(EjbJarRenameRefactoring.class, "TXT_EjbJarBeanClassRename"), args); 1862        } 1863 1864        /** Performs the change represented by this refactoring element. 1865         */ 1866        public void performChange() { 1867            JavaMetamodel.getManager().registerExtChange(this); 1868        } 1869 1870        public void performExternalChange() { 1871            if (ErrorManager.getDefault().isLoggable(ErrorManager.INFORMATIONAL)) err.log("> EjbJarBeanClassRenameRefactoringElement.performExternalChange: " + ejb); 1872            ejb.setEjbClass(newName); 1873            try { 1874                ejbJarDD.write(parentFile); 1875            } catch (IOException ioe) { 1876                //TODO 1877 } 1878        } 1879         1880        public void undoExternalChange() { 1881            if (ErrorManager.getDefault().isLoggable(ErrorManager.INFORMATIONAL)) err.log("> EjbJarBeanClassRenameRefactoringElement.undoExternalChange: " + ejb); 1882            ejb.setEjbClass(oldName); 1883            try { 1884                ejbJarDD.write(parentFile); 1885            } catch (IOException ioe) { 1886                //TODO 1887 } 1888        } 1889    } 1890     1891    public final class EjbJarLocalRenameRefactoringElement extends AbstractRenameRefactoringElement implements ExternalChange { 1892 1893        protected EjbJar ejbJarDD; 1894        private EntityAndSession ejb; 1895 1896        /** Creates a new instance of EjbJarLocalRenameRefactoringElement */ 1897        public EjbJarLocalRenameRefactoringElement(EjbJar ejbJarDD, String oldName, String newName, EntityAndSession ejb, FileObject parentFile) { 1898            this.ejbJarDD = ejbJarDD; 1899            this.oldName = oldName; 1900            this.newName = newName; 1901            this.ejb = ejb; 1902            this.parentFile = parentFile; 1903        } 1904 1905        /** Returns text describing the refactoring formatted for display (using HTML tags). 1906         * @return Formatted text. 1907         */ 1908        public String getDisplayText() { 1909            Object [] args = new Object [] {parentFile.getNameExt(), oldName, newName}; 1910            return MessageFormat.format(NbBundle.getMessage(EjbJarRenameRefactoring.class, "TXT_EjbJarLocalRename"), args); 1911        } 1912 1913        /** Performs the change represented by this refactoring element. 1914         */ 1915        public void performChange() { 1916            JavaMetamodel.getManager().registerExtChange(this); 1917        } 1918 1919        public void performExternalChange() { 1920            err.log("> EjbJarLocalRenameRefactoringElement.performExternalChange: " + ejb); 1921            ejb.setLocal(newName); 1922            try { 1923                ejbJarDD.write(parentFile); 1924            } catch (IOException ioe) { 1925                //TODO 1926 } 1927        } 1928         1929        public void undoExternalChange() { 1930            ejb.setLocal(oldName); 1931            try { 1932                ejbJarDD.write(parentFile); 1933            } catch (IOException ioe) { 1934                //TODO 1935 } 1936        } 1937    } 1938     1939    public final class EjbJarLocalHomeRenameRefactoringElement extends AbstractRenameRefactoringElement implements ExternalChange { 1940 1941        protected EjbJar ejbJarDD; 1942        private EntityAndSession ejb; 1943 1944        /** Creates a new instance of EjbJarLocalHomeRenameRefactoringElement */ 1945        public EjbJarLocalHomeRenameRefactoringElement(EjbJar ejbJarDD, String oldName, String newName, EntityAndSession ejb, FileObject parentFile) { 1946            this.ejbJarDD = ejbJarDD; 1947            this.oldName = oldName; 1948            this.newName = newName; 1949            this.ejb = ejb; 1950            this.parentFile = parentFile; 1951        } 1952 1953        /** Returns text describing the refactoring formatted for display (using HTML tags). 1954         * @return Formatted text. 1955         */ 1956        public String getDisplayText() { 1957            Object [] args = new Object [] {parentFile.getNameExt(), oldName, newName}; 1958            return MessageFormat.format(NbBundle.getMessage(EjbJarRenameRefactoring.class, "TXT_EjbJarLocalHomeRename"), args); 1959        } 1960 1961        /** Performs the change represented by this refactoring element. 1962         */ 1963        public void performChange() { 1964            JavaMetamodel.getManager().registerExtChange(this); 1965        } 1966 1967        public void performExternalChange() { 1968            if (ErrorManager.getDefault().isLoggable(ErrorManager.INFORMATIONAL)) err.log("> EjbJarLocalHomeRenameRefactoringElement.performExternalChange: " + ejb); 1969            ejb.setLocalHome(newName); 1970            try { 1971                ejbJarDD.write(parentFile); 1972            } catch (IOException ioe) { 1973                //TODO 1974 } 1975        } 1976         1977        public void undoExternalChange() { 1978            ejb.setLocalHome(oldName); 1979            try { 1980                ejbJarDD.write(parentFile); 1981            } catch (IOException ioe) { 1982                //TODO 1983 } 1984        } 1985    } 1986     1987    public final class EjbJarHomeRenameRefactoringElement extends AbstractRenameRefactoringElement implements ExternalChange { 1988 1989        protected EjbJar ejbJarDD; 1990        private EntityAndSession ejb; 1991 1992        /** Creates a new instance of EjbJarHomeRenameRefactoringElement */ 1993        public EjbJarHomeRenameRefactoringElement(EjbJar ejbJarDD, String oldName, String newName, EntityAndSession ejb, FileObject parentFile) { 1994            this.ejbJarDD = ejbJarDD; 1995            this.oldName = oldName; 1996            this.newName = newName; 1997            this.ejb = ejb; 1998            this.parentFile = parentFile; 1999        } 2000 2001        /** Returns text describing the refactoring formatted for display (using HTML tags). 2002         * @return Formatted text. 2003         */ 2004        public String getDisplayText() { 2005            Object [] args = new Object [] {parentFile.getNameExt(), oldName, newName}; 2006            return MessageFormat.format(NbBundle.getMessage(EjbJarRenameRefactoring.class, "TXT_EjbJarHomeRename"), args); //NOI18N 2007 } 2008 2009        /** Performs the change represented by this refactoring element. 2010         */ 2011        public void performChange() { 2012            JavaMetamodel.getManager().registerExtChange(this); 2013        } 2014 2015        public void performExternalChange() { 2016            if (ErrorManager.getDefault().isLoggable(ErrorManager.INFORMATIONAL)) err.log("> EjbJarHomeRenameRefactoringElement.performExternalChange: " + ejb); 2017            ejb.setHome(newName); 2018            try { 2019                ejbJarDD.write(parentFile); 2020            } catch (IOException ioe) { 2021                //TODO 2022 } 2023        } 2024         2025        public void undoExternalChange() { 2026            ejb.setHome(oldName); 2027            try { 2028                ejbJarDD.write(parentFile); 2029            } catch (IOException ioe) { 2030                //TODO 2031 } 2032        } 2033    } 2034     2035    public final class EjbJarRemoteRenameRefactoringElement extends AbstractRenameRefactoringElement implements ExternalChange { 2036 2037        protected EjbJar ejbJarDD; 2038        private EntityAndSession ejb; 2039 2040        /** Creates a new instance of EjbJarRemoteRenameRefactoringElement */ 2041        public EjbJarRemoteRenameRefactoringElement(EjbJar ejbJarDD, String oldName, String newName, EntityAndSession ejb, FileObject parentFile) { 2042            this.ejbJarDD = ejbJarDD; 2043            this.oldName = oldName; 2044            this.newName = newName; 2045            this.ejb = ejb; 2046            this.parentFile = parentFile; 2047        } 2048 2049        /** Returns text describing the refactoring formatted for display (using HTML tags). 2050         * @return Formatted text. 2051         */ 2052        public String getDisplayText() { 2053            Object [] args = new Object [] {parentFile.getNameExt(), oldName, newName}; 2054            return MessageFormat.format(NbBundle.getMessage(EjbJarRenameRefactoring.class, "TXT_EjbJarRemoteRename"), args); //NOI18N 2055 } 2056 2057        /** Performs the change represented by this refactoring element. 2058         */ 2059        public void performChange() { 2060            JavaMetamodel.getManager().registerExtChange(this); 2061        } 2062 2063        public void performExternalChange() { 2064            if (ErrorManager.getDefault().isLoggable(ErrorManager.INFORMATIONAL)) err.log("> EjbJarRemoteRenameRefactoringElement.performExternalChange: " + ejb); 2065            ejb.setRemote(newName); 2066            try { 2067                ejbJarDD.write(parentFile); 2068            } catch (IOException ioe) { 2069                //TODO 2070 } 2071        } 2072         2073        public void undoExternalChange() { 2074            ejb.setRemote(oldName); 2075            try { 2076                ejbJarDD.write(parentFile); 2077            } catch (IOException ioe) { 2078                //TODO 2079 } 2080        } 2081    } 2082 2083    public final class EjbJarServiceEndpointRenameRefactoringElement extends AbstractRenameRefactoringElement implements ExternalChange { 2084 2085        protected EjbJar ejbJarDD; 2086        private Session ejb; 2087 2088        /** Creates a new instance of EjbJarServiceEndpointRenameRefactoringElement */ 2089        public EjbJarServiceEndpointRenameRefactoringElement(EjbJar ejbJarDD, String oldName, String newName, Session ejb, FileObject parentFile) { 2090            this.ejbJarDD = ejbJarDD; 2091            this.oldName = oldName; 2092            this.newName = newName; 2093            this.ejb = ejb; 2094            this.parentFile = parentFile; 2095        } 2096 2097        /** Returns text describing the refactoring formatted for display (using HTML tags). 2098         * @return Formatted text. 2099         */ 2100        public String getDisplayText() { 2101            Object [] args = new Object [] {parentFile.getNameExt(), oldName, newName}; 2102            return MessageFormat.format(NbBundle.getMessage(EjbJarRenameRefactoring.class, "TXT_EjbJarServiceEndpointRename"), args); //NOI18N 2103 } 2104 2105        /** Performs the change represented by this refactoring element. 2106         */ 2107        public void performChange() { 2108            JavaMetamodel.getManager().registerExtChange(this); 2109        } 2110 2111        public void performExternalChange() { 2112            if (ErrorManager.getDefault().isLoggable(ErrorManager.INFORMATIONAL)) err.log("> EjbJarServiceEndpointRenameRefactoringElement.performExternalChange: " + ejb); 2113            try { 2114                ejb.setServiceEndpoint(newName); 2115            } catch (VersionNotSupportedException ve) { 2116                // no problem, just ignore 2117 } 2118            try { 2119                ejbJarDD.write(parentFile); 2120            } catch (IOException ioe) { 2121                //TODO 2122 } 2123        } 2124         2125        public void undoExternalChange() { 2126            try { 2127                ejb.setServiceEndpoint(oldName); 2128            } catch (VersionNotSupportedException ve) { 2129                // no problem, just ignore 2130 } 2131            try { 2132                ejbJarDD.write(parentFile); 2133            } catch (IOException ioe) { 2134                //TODO 2135 } 2136        } 2137    } 2138     2139    public final class EjbJarRefLocalRenameRefactoringElement extends AbstractRenameRefactoringElement implements ExternalChange { 2140 2141        protected EjbJar ejbJarDD; 2142        private org.netbeans.modules.j2ee.dd.api.common.EjbLocalRef localRef; 2143 2144        /** Creates a new instance of EjbJarRefLocalRenameRefactoringElement */ 2145        public EjbJarRefLocalRenameRefactoringElement(EjbJar ejbJarDD, String oldName, String newName, org.netbeans.modules.j2ee.dd.api.common.EjbLocalRef localRef, FileObject parentFile) { 2146            this.ejbJarDD = ejbJarDD; 2147            this.oldName = oldName; 2148            this.newName = newName; 2149            this.localRef = localRef; 2150            this.parentFile = parentFile; 2151        } 2152 2153        /** Returns text describing the refactoring formatted for display (using HTML tags). 2154         * @return Formatted text. 2155         */ 2156        public String getDisplayText() { 2157            Object [] args = new Object [] {parentFile.getNameExt(), oldName, newName}; 2158            return MessageFormat.format(NbBundle.getMessage(EjbJarRenameRefactoring.class, "TXT_EjbJarRefLocalRename"), args); //NOI18N 2159 } 2160 2161        /** Performs the change represented by this refactoring element. 2162         */ 2163        public void performChange() { 2164            JavaMetamodel.getManager().registerExtChange(this); 2165        } 2166 2167        public void performExternalChange() { 2168            if (ErrorManager.getDefault().isLoggable(ErrorManager.INFORMATIONAL)) err.log("> EjbJarRefLocalRenameRefactoringElement.performExternalChange: " + localRef); 2169            localRef.setLocal(newName); 2170            try { 2171                ejbJarDD.write(parentFile); 2172            } catch (IOException ioe) { 2173                //TODO 2174 } 2175        } 2176         2177        public void undoExternalChange() { 2178            localRef.setLocal(oldName); 2179            try { 2180                ejbJarDD.write(parentFile); 2181            } catch (IOException ioe) { 2182                //TODO 2183 } 2184        } 2185    } 2186     2187    public final class EjbJarRefLocalHomeRenameRefactoringElement extends AbstractRenameRefactoringElement implements ExternalChange { 2188 2189        protected EjbJar ejbJarDD; 2190        private org.netbeans.modules.j2ee.dd.api.common.EjbLocalRef localRef; 2191 2192        /** Creates a new instance of EjbJarRefLocalHomeRenameRefactoringElement */ 2193        public EjbJarRefLocalHomeRenameRefactoringElement(EjbJar ejbJarDD, String oldName, String newName, org.netbeans.modules.j2ee.dd.api.common.EjbLocalRef localRef, FileObject parentFile) { 2194            this.ejbJarDD = ejbJarDD; 2195            this.oldName = oldName; 2196            this.newName = newName; 2197            this.localRef = localRef; 2198            this.parentFile = parentFile; 2199        } 2200 2201        /** Returns text describing the refactoring formatted for display (using HTML tags). 2202         * @return Formatted text. 2203         */ 2204        public String getDisplayText() { 2205            Object [] args = new Object [] {parentFile.getNameExt(), oldName, newName}; 2206            return MessageFormat.format(NbBundle.getMessage(EjbJarRenameRefactoring.class, "TXT_EjbJarRefLocalHomeRename"), args); //NOI18N 2207 } 2208 2209        /** Performs the change represented by this refactoring element. 2210         */ 2211        public void performChange() { 2212            JavaMetamodel.getManager().registerExtChange(this); 2213        } 2214 2215        public void performExternalChange() { 2216            if (ErrorManager.getDefault().isLoggable(ErrorManager.INFORMATIONAL)) err.log("> EjbJarRefLocalHomeRenameRefactoringElement.performExternalChange: " + localRef); 2217            localRef.setLocalHome(newName); 2218            try { 2219                ejbJarDD.write(parentFile); 2220            } catch (IOException ioe) { 2221                //TODO 2222 } 2223        } 2224         2225        public void undoExternalChange() { 2226            localRef.setLocalHome(oldName); 2227            try { 2228                ejbJarDD.write(parentFile); 2229            } catch (IOException ioe) { 2230                //TODO 2231 } 2232        } 2233    } 2234 2235    public final class EjbJarRefHomeRenameRefactoringElement extends AbstractRenameRefactoringElement implements ExternalChange { 2236 2237        protected EjbJar ejbJarDD; 2238        private org.netbeans.modules.j2ee.dd.api.common.EjbRef ref; 2239 2240        /** Creates a new instance of EjbJarRefHomeRenameRefactoringElement */ 2241        public EjbJarRefHomeRenameRefactoringElement(EjbJar ejbJarDD, String oldName, String newName, org.netbeans.modules.j2ee.dd.api.common.EjbRef ref, FileObject parentFile) { 2242            this.ejbJarDD = ejbJarDD; 2243            this.oldName = oldName; 2244            this.newName = newName; 2245            this.ref = ref; 2246            this.parentFile = parentFile; 2247        } 2248 2249        /** Returns text describing the refactoring formatted for display (using HTML tags). 2250         * @return Formatted text. 2251         */ 2252        public String getDisplayText() { 2253            Object [] args = new Object [] {parentFile.getNameExt(), oldName, newName}; 2254            return MessageFormat.format(NbBundle.getMessage(EjbJarRenameRefactoring.class, "TXT_EjbJarRefHomeRename"), args); //NOI18N 2255 } 2256 2257        /** Performs the change represented by this refactoring element. 2258         */ 2259        public void performChange() { 2260            JavaMetamodel.getManager().registerExtChange(this); 2261        } 2262 2263        public void performExternalChange() { 2264            if (ErrorManager.getDefault().isLoggable(ErrorManager.INFORMATIONAL)) err.log("> EjbJarRefHomeRenameRefactoringElement.performExternalChange: " + ref); 2265            ref.setHome(newName); 2266            try { 2267                ejbJarDD.write(parentFile); 2268            } catch (IOException ioe) { 2269                //TODO 2270 } 2271        } 2272         2273        public void undoExternalChange() { 2274            ref.setHome(oldName); 2275            try { 2276                ejbJarDD.write(parentFile); 2277            } catch (IOException ioe) { 2278                //TODO 2279 } 2280        } 2281    } 2282 2283    public final class EjbJarRefRemoteRenameRefactoringElement extends AbstractRenameRefactoringElement implements ExternalChange { 2284 2285        protected EjbJar ejbJarDD; 2286        private org.netbeans.modules.j2ee.dd.api.common.EjbRef ref; 2287 2288        /** Creates a new instance of EjbJarRefRemoteRenameRefactoringElement */ 2289        public EjbJarRefRemoteRenameRefactoringElement(EjbJar ejbJarDD, String oldName, String newName, org.netbeans.modules.j2ee.dd.api.common.EjbRef ref, FileObject parentFile) { 2290            this.ejbJarDD = ejbJarDD; 2291            this.oldName = oldName; 2292            this.newName = newName; 2293            this.ref = ref; 2294            this.parentFile = parentFile; 2295        } 2296 2297        /** Returns text describing the refactoring formatted for display (using HTML tags). 2298         * @return Formatted text. 2299         */ 2300        public String getDisplayText() { 2301            Object [] args = new Object [] {parentFile.getNameExt(), oldName, newName}; 2302            return MessageFormat.format(NbBundle.getMessage(EjbJarRenameRefactoring.class, "TXT_EjbJarRefRemoteRename"), args); //NOI18N 2303 } 2304 2305        /** Performs the change represented by this refactoring element. 2306         */ 2307        public void performChange() { 2308            JavaMetamodel.getManager().registerExtChange(this); 2309        } 2310 2311        public void performExternalChange() { 2312            if (ErrorManager.getDefault().isLoggable(ErrorManager.INFORMATIONAL)) err.log("> EjbJarRefRemoteRenameRefactoringElement.performExternalChange: " + ref); 2313            ref.setRemote(newName); 2314            try { 2315                ejbJarDD.write(parentFile); 2316            } catch (IOException ioe) { 2317                //TODO 2318 } 2319        } 2320         2321        public void undoExternalChange() { 2322            ref.setRemote(oldName); 2323            try { 2324                ejbJarDD.write(parentFile); 2325            } catch (IOException ioe) { 2326                //TODO 2327 } 2328        } 2329    } 2330 2331    public final class EjbJarFinderMethodRenameRefactoringElement extends AbstractRenameRefactoringElement implements ExternalChange { 2332 2333        protected EjbJar ejbJarDD; 2334        private Entity entity; 2335 2336        /** Creates a new instance of EjbJarRefRemoteRenameRefactoringElement */ 2337        public EjbJarFinderMethodRenameRefactoringElement(EjbJar ejbJarDD, String oldName, String newName, Entity entity, FileObject parentFile) { 2338            this.ejbJarDD = ejbJarDD; 2339            this.oldName = oldName; 2340            this.newName = newName; 2341            this.entity = entity; 2342            this.parentFile = parentFile; 2343        } 2344 2345        /** Returns text describing the refactoring formatted for display (using HTML tags). 2346         * @return Formatted text. 2347         */ 2348        public String getDisplayText() { 2349            Object [] args = new Object [] {parentFile.getNameExt(), oldName, newName}; 2350            return MessageFormat.format(NbBundle.getMessage(EjbJarRenameRefactoring.class, "TXT_EjbJarFinderMethodRename"), args); //NOI18N 2351 } 2352 2353        /** Performs the change represented by this refactoring element. 2354         */ 2355        public void performChange() { 2356            JavaMetamodel.getManager().registerExtChange(this); 2357        } 2358 2359        public void performExternalChange() { 2360            if (ErrorManager.getDefault().isLoggable(ErrorManager.INFORMATIONAL)) err.log("> EjbJarFinderMethodRenameRefactoringElement.performExternalChange: " + entity); 2361            Query[] queries = entity.getQuery(); 2362            for (int q = 0; q < queries.length; q++) { 2363                Query query = queries[q]; 2364                QueryMethod qm = query.getQueryMethod(); 2365                if (oldName.equals(qm.getMethodName())) { 2366                    qm.setMethodName(newName); 2367                    try { 2368                        ejbJarDD.write(parentFile); 2369                    } catch (IOException ioe) { 2370                        //TODO 2371 } 2372                } 2373            } 2374        } 2375         2376        public void undoExternalChange() { 2377            Query[] queries = entity.getQuery(); 2378            for (int q = 0; q < queries.length; q++) { 2379                Query query = queries[q]; 2380                QueryMethod qm = query.getQueryMethod(); 2381                if (newName.equals(qm.getMethodName())) { 2382                    qm.setMethodName(oldName); 2383                    try { 2384                        ejbJarDD.write(parentFile); 2385                    } catch (IOException ioe) { 2386                        //TODO 2387 } 2388                } 2389            } 2390        } 2391    } 2392 2393    public final class EjbJarSelectMethodRenameRefactoringElement extends AbstractRenameRefactoringElement implements ExternalChange { 2394 2395        protected EjbJar ejbJarDD; 2396        private Entity entity; 2397 2398        /** Creates a new instance of EjbJarSelectMethodRenameRefactoringElement */ 2399        public EjbJarSelectMethodRenameRefactoringElement(EjbJar ejbJarDD, String oldName, String newName, Entity entity, FileObject parentFile) { 2400            this.ejbJarDD = ejbJarDD; 2401            this.oldName = oldName; 2402            this.newName = newName; 2403            this.entity = entity; 2404            this.parentFile = parentFile; 2405        } 2406 2407        /** Returns text describing the refactoring formatted for display (using HTML tags). 2408         * @return Formatted text. 2409         */ 2410        public String getDisplayText() { 2411            Object [] args = new Object [] {parentFile.getNameExt(), "ejbSelect" + oldName, "ejbSelect" + newName}; //NOI18N 2412 return MessageFormat.format(NbBundle.getMessage(EjbJarRenameRefactoring.class, "TXT_EjbJarSelectMethodRename"), args); //NOI18N 2413 } 2414 2415        /** Performs the change represented by this refactoring element. 2416         */ 2417        public void performChange() { 2418            JavaMetamodel.getManager().registerExtChange(this); 2419        } 2420 2421        public void performExternalChange() { 2422            if (ErrorManager.getDefault().isLoggable(ErrorManager.INFORMATIONAL)) err.log("> EjbJarSelectMethodRenameRefactoringElement.performExternalChange: " + entity); 2423            Query[] queries = entity.getQuery(); 2424            for (int q = 0; q < queries.length; q++) { 2425                Query query = queries[q]; 2426                QueryMethod qm = query.getQueryMethod(); 2427                if (oldName.equals(qm.getMethodName())) { 2428                    qm.setMethodName(newName); 2429                    try { 2430                        ejbJarDD.write(parentFile); 2431                    } catch (IOException ioe) { 2432                        //TODO 2433 } 2434                } 2435            } 2436        } 2437         2438        public void undoExternalChange() { 2439            Query[] queries = entity.getQuery(); 2440            for (int q = 0; q < queries.length; q++) { 2441                Query query = queries[q]; 2442                QueryMethod qm = query.getQueryMethod(); 2443                if (newName.equals(qm.getMethodName())) { 2444                    qm.setMethodName(oldName); 2445                    try { 2446                        ejbJarDD.write(parentFile); 2447                    } catch (IOException ioe) { 2448                        //TODO 2449 } 2450                } 2451            } 2452        } 2453    } 2454 2455    public final class EjbJarCmpFieldRenameRefactoringElement extends AbstractRenameRefactoringElement implements ExternalChange { 2456 2457        protected EjbJar ejbJarDD; 2458        private Entity entity; 2459 2460        /** Creates a new instance of EjbJarCmpFieldRenameRefactoringElement */ 2461        public EjbJarCmpFieldRenameRefactoringElement(EjbJar ejbJarDD, String oldName, String newName, Entity entity, FileObject parentFile) { 2462            this.ejbJarDD = ejbJarDD; 2463            this.oldName = oldName; 2464            this.newName = newName; 2465            this.entity = entity; 2466            this.parentFile = parentFile; 2467        } 2468 2469        /** Returns text describing the refactoring formatted for display (using HTML tags). 2470         * @return Formatted text. 2471         */ 2472        public String getDisplayText() { 2473            Object [] args = new Object [] {oldName, newName}; 2474            return MessageFormat.format(NbBundle.getMessage(EjbJarRenameRefactoring.class, "TXT_EjbJarCmpFieldRename"), args); //NOI18N 2475 } 2476 2477        /** Performs the change represented by this refactoring element. 2478         */ 2479        public void performChange() { 2480            JavaMetamodel.getManager().registerExtChange(this); 2481        } 2482 2483        public void performExternalChange() { 2484            if (ErrorManager.getDefault().isLoggable(ErrorManager.INFORMATIONAL)) err.log("> EjbJarCmpFieldRenameRefactoringElement.performExternalChange: " + entity); 2485            boolean dirty = false; 2486            // TODO: provided oldName is wrong if first letter of field is upper-case, fix it and use equals() instead equalsIgnoreCase 2487 if (oldName.equalsIgnoreCase(entity.getPrimkeyField())) { 2488                entity.setPrimkeyField(newName); 2489                dirty = true; 2490            } 2491            CmpField[] cmpFields = entity.getCmpField(); 2492            for (int q = 0; q < cmpFields.length; q++) { 2493                CmpField cmpField = cmpFields[q]; 2494                // TODO: provided oldName is wrong if first letter of field is upper-case, fix it and use equals() instead equalsIgnoreCase 2495 if (oldName.equalsIgnoreCase(cmpField.getFieldName())) { 2496                    cmpField.setFieldName(newName); 2497                    dirty = true; 2498                } 2499            } 2500            if (dirty) { 2501                try { 2502                    ejbJarDD.write(parentFile); 2503                } catch (IOException ioe) { 2504                    //TODO 2505 } 2506            } 2507        } 2508         2509        public void undoExternalChange() { 2510            CmpField[] cmpFields = entity.getCmpField(); 2511            for (int q = 0; q < cmpFields.length; q++) { 2512                CmpField cmpField = cmpFields[q]; 2513                // TODO: provided newName is wrong if first letter of field is upper-case, fix it and use equals() instead equalsIgnoreCase 2514 if (newName.equalsIgnoreCase(cmpField.getFieldName())) { 2515                    cmpField.setFieldName(oldName); 2516                    try { 2517                        ejbJarDD.write(parentFile); 2518                    } catch (IOException ioe) { 2519                        //TODO 2520 } 2521                } 2522            } 2523        } 2524    } 2525 2526    public final class EjbJarCmrFieldRenameRefactoringElement extends AbstractRenameRefactoringElement implements ExternalChange { 2527 2528        protected EjbJar ejbJarDD; 2529        private EjbRelationshipRole role; 2530 2531        /** Creates a new instance of EjbJarCmrFieldRenameRefactoringElement */ 2532        public EjbJarCmrFieldRenameRefactoringElement(EjbJar ejbJarDD, String oldName, String newName, EjbRelationshipRole role, FileObject parentFile) { 2533            this.ejbJarDD = ejbJarDD; 2534            this.oldName = oldName; 2535            this.newName = newName; 2536            this.role = role; 2537            this.parentFile = parentFile; 2538        } 2539 2540        /** Returns text describing the refactoring formatted for display (using HTML tags). 2541         * @return Formatted text. 2542         */ 2543        public String getDisplayText() { 2544            Object [] args = new Object [] {role.getEjbRelationshipRoleName(), oldName, newName}; 2545            return MessageFormat.format(NbBundle.getMessage(EjbJarRenameRefactoring.class, "TXT_EjbJarCmrFieldRename"), args); //NOI18N 2546 } 2547 2548        /** Performs the change represented by this refactoring element. 2549         */ 2550        public void performChange() { 2551            JavaMetamodel.getManager().registerExtChange(this); 2552        } 2553 2554        public void performExternalChange() { 2555            if (ErrorManager.getDefault().isLoggable(ErrorManager.INFORMATIONAL)) err.log("> EjbJarCmrFieldRenameRefactoringElement.performExternalChange: " + role); 2556            CmrField cmrField = role.getCmrField(); 2557            // TODO: provided oldName is wrong if first letter of field is upper-case, fix it and use equals() instead equalsIgnoreCase 2558 if (oldName.equalsIgnoreCase(cmrField.getCmrFieldName())) { 2559                cmrField.setCmrFieldName(newName); 2560                try { 2561                    ejbJarDD.write(parentFile); 2562                } catch (IOException ioe) { 2563                    //TODO 2564 } 2565            } 2566        } 2567         2568        public void undoExternalChange() { 2569            CmrField cmrField = role.getCmrField(); 2570            // TODO: provided newName is wrong if first letter of field is upper-case, fix it and use equals() instead equalsIgnoreCase 2571 if (newName.equalsIgnoreCase(cmrField.getCmrFieldName())) { 2572                cmrField.setCmrFieldName(oldName); 2573                try { 2574                    ejbJarDD.write(parentFile); 2575                } catch (IOException ioe) { 2576                    //TODO 2577 } 2578            } 2579        } 2580    } 2581     2582    public final class EjbJarExcludeListRenameRefactoringElement extends AbstractRenameRefactoringElement implements ExternalChange { 2583 2584        protected EjbJar ejbJarDD; 2585        private org.netbeans.modules.j2ee.dd.api.ejb.Method mtd; 2586        private String ejbName; 2587             2588        /** Creates a new instance of EjbJarExcludeListRenameRefactoringElement */ 2589        public EjbJarExcludeListRenameRefactoringElement( EjbJar ejbJarDD, 2590                                                            String oldMtdName, 2591                                                            String newMtdName, 2592                                                            String ejbName, 2593                                                            org.netbeans.modules.j2ee.dd.api.ejb.Method mtd, 2594                                                            FileObject parentFile) { 2595            this.ejbJarDD = ejbJarDD; 2596            this.oldName = oldMtdName; 2597            this.newName = newMtdName; 2598            this.ejbName = ejbName; 2599            this.mtd = mtd; 2600            this.parentFile = parentFile; 2601        } 2602 2603        /** Returns text describing the refactoring formatted for display (using HTML tags). 2604         * @return Formatted text. 2605         */ 2606        public String getDisplayText() { 2607            Object [] args = new Object [] {parentFile.getNameExt(), oldName, newName, ejbName}; 2608            return MessageFormat.format(NbBundle.getMessage(EjbJarRenameRefactoring.class, "TXT_EjbJarExcludeListMethodRename"), args); 2609        } 2610 2611        /** Performs the change represented by this refactoring element. 2612         */ 2613        public void performChange() { 2614            JavaMetamodel.getManager().registerExtChange(this); 2615        } 2616 2617        public void performExternalChange() { 2618            if (ErrorManager.getDefault().isLoggable(ErrorManager.INFORMATIONAL)) err.log("> EjbJarExcludeListRenameRefactoringElement.performExternalChange: " + mtd); 2619            mtd.setMethodName(newName); 2620            try { 2621                ejbJarDD.write(parentFile); 2622            } catch (IOException ioe) { 2623                //TODO 2624 } 2625        } 2626         2627        public void undoExternalChange() { 2628            mtd.setMethodName(oldName); 2629            try { 2630                ejbJarDD.write(parentFile); 2631            } catch (IOException ioe) { 2632                //TODO 2633 } 2634        } 2635    } 2636 2637    public final class EjbJarMethodPermissionRenameRefactoringElement extends AbstractRenameRefactoringElement implements ExternalChange { 2638 2639        protected EjbJar ejbJarDD; 2640        private org.netbeans.modules.j2ee.dd.api.ejb.Method mtd; 2641        private String ejbName; 2642             2643        /** Creates a new instance of EjbJarMethodPermissionRenameRefactoringElement */ 2644        public EjbJarMethodPermissionRenameRefactoringElement( EjbJar ejbJarDD, 2645                                                            String oldMtdName, 2646                                                            String newMtdName, 2647                                                            String ejbName, 2648                                                            org.netbeans.modules.j2ee.dd.api.ejb.Method mtd, 2649                                                            FileObject parentFile) { 2650            this.ejbJarDD = ejbJarDD; 2651            this.oldName = oldMtdName; 2652            this.newName = newMtdName; 2653            this.ejbName = ejbName; 2654            this.mtd = mtd; 2655            this.parentFile = parentFile; 2656        } 2657 2658        /** Returns text describing the refactoring formatted for display (using HTML tags). 2659         * @return Formatted text. 2660         */ 2661        public String getDisplayText() { 2662            Object [] args = new Object [] {parentFile.getNameExt(), oldName, newName, ejbName}; 2663            return MessageFormat.format(NbBundle.getMessage(EjbJarRenameRefactoring.class, "TXT_EjbJarMethodPermissionMethodRename"), args); 2664        } 2665 2666        /** Performs the change represented by this refactoring element. 2667         */ 2668        public void performChange() { 2669            JavaMetamodel.getManager().registerExtChange(this); 2670        } 2671 2672        public void performExternalChange() { 2673            if (ErrorManager.getDefault().isLoggable(ErrorManager.INFORMATIONAL)) err.log("> EjbJarMethodPermissionRenameRefactoringElement.performExternalChange: " + mtd); 2674            mtd.setMethodName(newName); 2675            try { 2676                ejbJarDD.write(parentFile); 2677            } catch (IOException ioe) { 2678                //TODO 2679 } 2680        } 2681         2682        public void undoExternalChange() { 2683            mtd.setMethodName(oldName); 2684            try { 2685                ejbJarDD.write(parentFile); 2686            } catch (IOException ioe) { 2687                //TODO 2688 } 2689        } 2690    } 2691 2692    public final class EjbJarContainerTxRenameRefactoringElement extends AbstractRenameRefactoringElement implements ExternalChange { 2693 2694        protected EjbJar ejbJarDD; 2695        private org.netbeans.modules.j2ee.dd.api.ejb.Method mtd; 2696        private String ejbName; 2697             2698        /** Creates a new instance of EjbJarContainerTxRenameRefactoringElement */ 2699        public EjbJarContainerTxRenameRefactoringElement( EjbJar ejbJarDD, 2700                                                            String oldMtdName, 2701                                                            String newMtdName, 2702                                                            String ejbName, 2703                                                            org.netbeans.modules.j2ee.dd.api.ejb.Method mtd, 2704                                                            FileObject parentFile) { 2705            this.ejbJarDD = ejbJarDD; 2706            this.oldName = oldMtdName; 2707            this.newName = newMtdName; 2708            this.ejbName = ejbName; 2709            this.mtd = mtd; 2710            this.parentFile = parentFile; 2711        } 2712 2713        /** Returns text describing the refactoring formatted for display (using HTML tags). 2714         * @return Formatted text. 2715         */ 2716        public String getDisplayText() { 2717            Object [] args = new Object [] {parentFile.getNameExt(), oldName, newName, ejbName}; 2718            return MessageFormat.format(NbBundle.getMessage(EjbJarRenameRefactoring.class, "TXT_EjbJarContainerTxMethodRename"), args); 2719        } 2720 2721        /** Performs the change represented by this refactoring element. 2722         */ 2723        public void performChange() { 2724            JavaMetamodel.getManager().registerExtChange(this); 2725        } 2726 2727        public void performExternalChange() { 2728            if (ErrorManager.getDefault().isLoggable(ErrorManager.INFORMATIONAL)) err.log("> EjbJarContainerTxRenameRefactoringElement.performExternalChange: " + mtd); 2729            mtd.setMethodName(newName); 2730            try { 2731                ejbJarDD.write(parentFile); 2732            } catch (IOException ioe) { 2733                //TODO 2734 } 2735        } 2736         2737        public void undoExternalChange() { 2738            mtd.setMethodName(oldName); 2739            try { 2740                ejbJarDD.write(parentFile); 2741            } catch (IOException ioe) { 2742                //TODO 2743 } 2744        } 2745    } 2746     2747} 2748

A to Z: JavaDoc & Examples Daily Java News & Articles Open Source Projects Open Source Codes Free Computer Books Remove Frame Popular Tags