Coverage Report - org.mule.config.i18n.CoreMessages
 
Classes in this File Line Coverage Branch Coverage Complexity
CoreMessages
0%
0/260
0%
0/10
0
 
 1  
 /*
 2  
  * Copyright (c) MuleSoft, Inc.  All rights reserved.  http://www.mulesoft.com
 3  
  * The software in this package is published under the terms of the CPAL v1.0
 4  
  * license, a copy of which has been included with this distribution in the
 5  
  * LICENSE.txt file.
 6  
  */
 7  
 package org.mule.config.i18n;
 8  
 
 9  
 import org.mule.MessageExchangePattern;
 10  
 import org.mule.api.config.ConfigurationBuilder;
 11  
 import org.mule.api.endpoint.EndpointURI;
 12  
 import org.mule.api.endpoint.ImmutableEndpoint;
 13  
 import org.mule.api.endpoint.InboundEndpoint;
 14  
 import org.mule.api.processor.MessageProcessor;
 15  
 import org.mule.api.registry.ServiceType;
 16  
 import org.mule.api.retry.RetryPolicyTemplate;
 17  
 import org.mule.api.routing.OutboundRouter;
 18  
 import org.mule.api.service.Service;
 19  
 import org.mule.api.transaction.Transaction;
 20  
 import org.mule.api.transaction.TransactionConfig;
 21  
 import org.mule.api.transformer.DataType;
 22  
 import org.mule.api.transformer.Transformer;
 23  
 import org.mule.config.MuleManifest;
 24  
 import org.mule.context.notification.ListenerSubscriptionPair;
 25  
 import org.mule.exception.AbstractExceptionListener;
 26  
 import org.mule.util.ClassUtils;
 27  
 import org.mule.util.DateUtils;
 28  
 import org.mule.util.StringMessageUtils;
 29  
 import org.mule.util.StringUtils;
 30  
 
 31  
 import java.lang.reflect.Method;
 32  
 import java.util.Date;
 33  
 import java.util.List;
 34  
 
 35  0
 public class CoreMessages extends MessageFactory
 36  
 {
 37  0
     private static final CoreMessages factory = new CoreMessages();
 38  
 
 39  0
     private static final String BUNDLE_PATH = getBundlePath("core");
 40  
 
 41  
     public static Message versionNotSet()
 42  
     {
 43  0
         return factory.createMessage(BUNDLE_PATH, 1);
 44  
     }
 45  
 
 46  
     public static Message serverStartedAt(long startDate)
 47  
     {
 48  0
         return factory.createMessage(BUNDLE_PATH, 2, new Date(startDate));
 49  
     }
 50  
 
 51  
     public static Message serverShutdownAt(Date date)
 52  
     {
 53  0
         return factory.createMessage(BUNDLE_PATH, 3, date);
 54  
     }
 55  
 
 56  
     public static Message agentsRunning()
 57  
     {
 58  0
         return factory.createMessage(BUNDLE_PATH, 4);
 59  
     }
 60  
 
 61  
     public static Message notSet()
 62  
     {
 63  0
         return factory.createMessage(BUNDLE_PATH, 5);
 64  
     }
 65  
 
 66  
     public static Message version()
 67  
     {
 68  0
         String version = StringUtils.defaultString(MuleManifest.getProductVersion(), notSet().getMessage());
 69  0
         return factory.createMessage(BUNDLE_PATH, 6, version);
 70  
     }
 71  
 
 72  
     public static Message shutdownNormally(Date date)
 73  
     {
 74  0
         return factory.createMessage(BUNDLE_PATH, 7, date);
 75  
     }
 76  
 
 77  
     public static Message serverWasUpForDuration(long duration)
 78  
     {
 79  0
         String formattedDuration = DateUtils.getFormattedDuration(duration);
 80  0
         return factory.createMessage(BUNDLE_PATH, 8, formattedDuration);
 81  
     }
 82  
 
 83  
     public static Message configNotFoundUsage()
 84  
     {
 85  0
         return factory.createMessage(BUNDLE_PATH, 9);
 86  
     }
 87  
 
 88  
     public static Message fatalErrorWhileRunning()
 89  
     {
 90  0
         return factory.createMessage(BUNDLE_PATH, 10);
 91  
     }
 92  
 
 93  
     public static Message rootStackTrace()
 94  
     {
 95  0
         return factory.createMessage(BUNDLE_PATH, 11);
 96  
     }
 97  
 
 98  
     public static Message exceptionStackIs()
 99  
     {
 100  0
         return factory.createMessage(BUNDLE_PATH, 12);
 101  
     }
 102  
 
 103  
     public static Message messageIsOfType(Class<?> type)
 104  
     {
 105  0
         return factory.createMessage(BUNDLE_PATH, 18, ClassUtils.getSimpleName(type));
 106  
     }
 107  
 
 108  
     public static Message fatalErrorInShutdown()
 109  
     {
 110  0
         return factory.createMessage(BUNDLE_PATH, 20);
 111  
     }
 112  
 
 113  
     public static Message normalShutdown()
 114  
     {
 115  0
         return factory.createMessage(BUNDLE_PATH, 21);
 116  
     }
 117  
 
 118  
     public static Message none()
 119  
     {
 120  0
         return factory.createMessage(BUNDLE_PATH, 22);
 121  
     }
 122  
 
 123  
     public static Message notClustered()
 124  
     {
 125  0
         return factory.createMessage(BUNDLE_PATH, 23);
 126  
     }
 127  
 
 128  
     public static Message failedToRouterViaEndpoint(MessageProcessor target)
 129  
     {
 130  0
         return factory.createMessage(BUNDLE_PATH, 30, target);
 131  
     }
 132  
 
 133  
     public static Message lifecycleErrorCannotUseConnector(String name, String lifecyclePhase)
 134  
     {
 135  0
         return factory.createMessage(BUNDLE_PATH, 32, name, lifecyclePhase);
 136  
     }
 137  
 
 138  
     public static Message connectorCausedError()
 139  
     {
 140  0
         return connectorCausedError(null);
 141  
     }
 142  
 
 143  
     public static Message connectorCausedError(Object connector)
 144  
     {
 145  0
         return factory.createMessage(BUNDLE_PATH, 33, connector);
 146  
     }
 147  
 
 148  
     public static Message endpointIsNullForListener()
 149  
     {
 150  0
         return factory.createMessage(BUNDLE_PATH, 34);
 151  
     }
 152  
 
 153  
     public static Message listenerAlreadyRegistered(EndpointURI endpointUri)
 154  
     {
 155  0
         return factory.createMessage(BUNDLE_PATH, 35, endpointUri);
 156  
     }
 157  
 
 158  
     public static Message objectAlreadyInitialised(String name)
 159  
     {
 160  0
         return factory.createMessage(BUNDLE_PATH, 37, name);
 161  
     }
 162  
 
 163  
     public static Message componentCausedErrorIs(Object component)
 164  
     {
 165  0
         return factory.createMessage(BUNDLE_PATH, 38, component);
 166  
     }
 167  
 
 168  
     public static Message objectFailedToInitialise(String string)
 169  
     {
 170  0
         return factory.createMessage(BUNDLE_PATH, 40, string);
 171  
     }
 172  
 
 173  
     public static Message failedToStop(String string)
 174  
     {
 175  0
         return factory.createMessage(BUNDLE_PATH, 41, string);
 176  
     }
 177  
 
 178  
     public static Message failedToStart(String string)
 179  
     {
 180  0
         return factory.createMessage(BUNDLE_PATH, 42, string);
 181  
     }
 182  
 
 183  
     public static Message proxyPoolTimedOut()
 184  
     {
 185  0
         return factory.createMessage(BUNDLE_PATH, 43);
 186  
     }
 187  
 
 188  
     public static Message failedToGetPooledObject()
 189  
     {
 190  0
         return factory.createMessage(BUNDLE_PATH, 44);
 191  
     }
 192  
 
 193  
     public static Message objectIsNull(String string)
 194  
     {
 195  0
         return factory.createMessage(BUNDLE_PATH, 45, string);
 196  
     }
 197  
 
 198  
     public static Message componentNotRegistered(String name)
 199  
     {
 200  0
         return factory.createMessage(BUNDLE_PATH, 46, name);
 201  
     }
 202  
 
 203  
     public static Message failedtoRegisterOnEndpoint(String name, Object endpointURI)
 204  
     {
 205  0
         return factory.createMessage(BUNDLE_PATH, 47, name, endpointURI);
 206  
     }
 207  
 
 208  
     public static Message failedToUnregister(String name, Object endpointURI)
 209  
     {
 210  0
         return factory.createMessage(BUNDLE_PATH, 48, name, endpointURI);
 211  
     }
 212  
 
 213  
     public static Message endpointIsMalformed(String endpoint)
 214  
     {
 215  0
         return factory.createMessage(BUNDLE_PATH, 51, endpoint);
 216  
     }
 217  
 
 218  
     public static Message transformFailedBeforeFilter()
 219  
     {
 220  0
         return factory.createMessage(BUNDLE_PATH, 52);
 221  
     }
 222  
 
 223  
     public static Message transformUnexpectedType(Class<?> class1, Class<?> returnClass)
 224  
     {
 225  0
         return factory.createMessage(BUNDLE_PATH, 53, ClassUtils.getSimpleName(class1),
 226  
             ClassUtils.getSimpleName(returnClass));
 227  
     }
 228  
 
 229  
     public static Message transformUnexpectedType(DataType<?> dt1, DataType<?> dt2)
 230  
     {
 231  0
         return factory.createMessage(BUNDLE_PATH, 53, dt1, dt2);
 232  
     }
 233  
 
 234  
     public static Message transformOnObjectUnsupportedTypeOfEndpoint(String name,
 235  
                                                                      Class<?> class1,
 236  
                                                                      ImmutableEndpoint endpoint)
 237  
     {
 238  0
         return factory.createMessage(BUNDLE_PATH, 54, name, StringMessageUtils.toString(class1),
 239  
             (endpoint != null ? endpoint.getEndpointURI() : null));
 240  
     }
 241  
 
 242  
     public static Message transformFailedFrom(Class<?> clazz)
 243  
     {
 244  0
         return factory.createMessage(BUNDLE_PATH, 55, clazz);
 245  
     }
 246  
 
 247  
     public static Message encryptionStrategyNotSet()
 248  
     {
 249  0
         return factory.createMessage(BUNDLE_PATH, 56);
 250  
     }
 251  
 
 252  
     public static Message failedToLoadTransformer(String direction, String transformer)
 253  
     {
 254  0
         return factory.createMessage(BUNDLE_PATH, 57, direction, transformer);
 255  
     }
 256  
 
 257  
     public static Message failedToLoad(String string)
 258  
     {
 259  0
         return factory.createMessage(BUNDLE_PATH, 58, string);
 260  
     }
 261  
 
 262  
     public static Message messageNotSupportedByMuleMessageFactory(Object message, Class<?> creator)
 263  
     {
 264  0
         String messageClass = (message != null ? message.getClass().getName() : "null");
 265  0
         String creatorClass = (creator != null ? creator.getName() : "null class");
 266  
         
 267  0
         return factory.createMessage(BUNDLE_PATH, 59, messageClass, creatorClass);
 268  
     }
 269  
 
 270  
     public static Message tooManyAcceptableMethodsOnObjectForTypes(Object object, Object types)
 271  
     {
 272  0
         return factory.createMessage(BUNDLE_PATH, 60, StringMessageUtils.toString(object),
 273  
             StringMessageUtils.toString(types));
 274  
     }
 275  
 
 276  
     public static Message cannotSetPropertyOnObjectWithParamType(String property,
 277  
                                                                  Class<?> class1,
 278  
                                                                  Class<?> class2)
 279  
     {
 280  0
         return factory.createMessage(BUNDLE_PATH, 61, property, StringMessageUtils.toString(class1),
 281  
             StringMessageUtils.toString(class2));
 282  
     }
 283  
 
 284  
     public static Message noComponentForEndpoint()
 285  
     {
 286  0
         return factory.createMessage(BUNDLE_PATH, 64);
 287  
     }
 288  
 
 289  
     public static Message failedToCreate(String string)
 290  
     {
 291  0
         return factory.createMessage(BUNDLE_PATH, 65, string);
 292  
     }
 293  
 
 294  
     public static Message noCorrelationId()
 295  
     {
 296  0
         return factory.createMessage(BUNDLE_PATH, 66);
 297  
     }
 298  
 
 299  
     public static Object failedToDispose(String string)
 300  
     {
 301  0
         return factory.createMessage(BUNDLE_PATH, 67, string);
 302  
     }
 303  
 
 304  
     public static Message failedToInvoke(String string)
 305  
     {
 306  0
         return factory.createMessage(BUNDLE_PATH, 68, string);
 307  
     }
 308  
 
 309  
     public static Message cannotReadPayloadAsBytes(String type)
 310  
     {
 311  0
         return factory.createMessage(BUNDLE_PATH, 69, type);
 312  
     }
 313  
 
 314  
     public static Message cannotReadPayloadAsString(String type)
 315  
     {
 316  0
         return factory.createMessage(BUNDLE_PATH, 70, type);
 317  
     }
 318  
 
 319  
     public static Message routingFailedOnEndpoint(Service service, ImmutableEndpoint endpoint)
 320  
     {
 321  0
         EndpointURI endpointURI = null;
 322  0
         if (endpoint != null)
 323  
         {
 324  0
             endpointURI = endpoint.getEndpointURI();
 325  
         }
 326  0
         return factory.createMessage(BUNDLE_PATH, 72, service.getName(), endpointURI);
 327  
     }
 328  
 
 329  
     public static Message cannotInstanciateFinder(String serviceFinder)
 330  
     {
 331  0
         return factory.createMessage(BUNDLE_PATH, 73, serviceFinder);
 332  
     }
 333  
 
 334  
     public static Message failedToCreateObjectWith(String string, Object arg)
 335  
     {
 336  0
         return factory.createMessage(BUNDLE_PATH, 74, string, arg);
 337  
     }
 338  
 
 339  
     public static Message objectNotSetInService(Object object, Object service)
 340  
     {
 341  0
         return factory.createMessage(BUNDLE_PATH, 75, object, service);
 342  
     }
 343  
 
 344  
     public static Message objectNotFound(Object object)
 345  
     {
 346  0
         return factory.createMessage(BUNDLE_PATH, 76, object);
 347  
     }
 348  
 
 349  
     public static Message objectNotFound(String type, String object)
 350  
     {
 351  0
         return factory.createMessage(BUNDLE_PATH, 76, type + ": " + object);
 352  
     }
 353  
 
 354  
     public static Message transactionMarkedForRollback()
 355  
     {
 356  0
         return factory.createMessage(BUNDLE_PATH, 77);
 357  
     }
 358  
 
 359  
     public static Message transactionCannotBindToNullKey()
 360  
     {
 361  0
         return factory.createMessage(BUNDLE_PATH, 78);
 362  
     }
 363  
 
 364  
     public static Message transactionCannotBindNullResource()
 365  
     {
 366  0
         return factory.createMessage(BUNDLE_PATH, 79);
 367  
     }
 368  
 
 369  
     public static Message transactionSingleResourceOnly()
 370  
     {
 371  0
         return factory.createMessage(BUNDLE_PATH, 80);
 372  
     }
 373  
 
 374  
     public static Message noCurrentEventForTransformer()
 375  
     {
 376  0
         return factory.createMessage(BUNDLE_PATH, 81);
 377  
     }
 378  
 
 379  
     public static Message objectNotRegistered(String type, String name)
 380  
     {
 381  0
         return factory.createMessage(BUNDLE_PATH, 82, type, name);
 382  
     }
 383  
 
 384  
     public static Message failedToSetPropertiesOn(String string)
 385  
     {
 386  0
         return factory.createMessage(BUNDLE_PATH, 83, string);
 387  
     }
 388  
 
 389  
     public static Message failedToCreateConnectorFromUri(EndpointURI uri)
 390  
     {
 391  0
         return factory.createMessage(BUNDLE_PATH, 84, uri);
 392  
     }
 393  
 
 394  
     public static Message initialisationFailure(String string)
 395  
     {
 396  0
         return factory.createMessage(BUNDLE_PATH, 85, string);
 397  
     }
 398  
 
 399  
     public static Message failedToCreateEndpointFromLocation(String string)
 400  
     {
 401  0
         return factory.createMessage(BUNDLE_PATH, 87, string);
 402  
     }
 403  
 
 404  
     public static Message managerAlreadyStarted()
 405  
     {
 406  0
         return factory.createMessage(BUNDLE_PATH, 88);
 407  
     }
 408  
 
 409  
     public static Message noEndpointsForRouter()
 410  
     {
 411  0
         return factory.createMessage(BUNDLE_PATH, 89);
 412  
     }
 413  
 
 414  
     public static Message responseTimedOutWaitingForId(int timeout, Object id)
 415  
     {
 416  0
         return factory.createMessage(BUNDLE_PATH, 90, String.valueOf(timeout), id);
 417  
     }
 418  
 
 419  
     public static Message failedToRecevieWithTimeout(Object endpoint, long timeout)
 420  
     {
 421  0
         return factory.createMessage(BUNDLE_PATH, 93, endpoint, String.valueOf(timeout));
 422  
     }
 423  
 
 424  
     public static Message failedToWriteMessageToStore(Object id, String storeName)
 425  
     {
 426  0
         return factory.createMessage(BUNDLE_PATH, 94, id, storeName);
 427  
     }
 428  
 
 429  
     public static Message failedToReadFromStore(String absolutePath)
 430  
     {
 431  0
         return factory.createMessage(BUNDLE_PATH, 95, absolutePath);
 432  
     }
 433  
 
 434  
     public static Message cannotStartTransaction(String string)
 435  
     {
 436  0
         return factory.createMessage(BUNDLE_PATH, 96, string);
 437  
     }
 438  
 
 439  
     public static Message transactionCommitFailed()
 440  
     {
 441  0
         return factory.createMessage(BUNDLE_PATH, 97);
 442  
     }
 443  
 
 444  
     public static Message transactionRollbackFailed()
 445  
     {
 446  0
         return factory.createMessage(BUNDLE_PATH, 98);
 447  
     }
 448  
 
 449  
     public static Message transactionCannotReadState()
 450  
     {
 451  0
         return factory.createMessage(BUNDLE_PATH, 99);
 452  
     }
 453  
 
 454  
     public static Message transactionResourceAlreadyListedForKey(Object key)
 455  
     {
 456  0
         return factory.createMessage(BUNDLE_PATH, 100, key);
 457  
     }
 458  
 
 459  
     public static Message noOutboundRouterSetOn(String string)
 460  
     {
 461  0
         return factory.createMessage(BUNDLE_PATH, 101, string);
 462  
     }
 463  
 
 464  
     public static Message transactionAvailableButActionIs(String string)
 465  
     {
 466  0
         return factory.createMessage(BUNDLE_PATH, 103, string);
 467  
     }
 468  
 
 469  
     public static Message transactionNotAvailableButActionIs(String string)
 470  
     {
 471  0
         return factory.createMessage(BUNDLE_PATH, 104, string);
 472  
     }
 473  
 
 474  
     public static Message noCatchAllEndpointSet()
 475  
     {
 476  0
         return factory.createMessage(BUNDLE_PATH, 105);
 477  
     }
 478  
 
 479  
     public static Message interruptedQueuingEventFor(Object object)
 480  
     {
 481  0
         return factory.createMessage(BUNDLE_PATH, 106, object);
 482  
     }
 483  
 
 484  
     public static Message transactionCannotUnbind()
 485  
     {
 486  0
         return factory.createMessage(BUNDLE_PATH, 107);
 487  
     }
 488  
 
 489  
     public static Message transactionAlreadyBound()
 490  
     {
 491  0
         return factory.createMessage(BUNDLE_PATH, 108);
 492  
     }
 493  
 
 494  
     public static Message methodWithParamsNotFoundOnObject(String method, Object class1, Class<?> class2)
 495  
     {
 496  0
         return factory.createMessage(BUNDLE_PATH, 109, method, StringMessageUtils.toString(class1),
 497  
             StringMessageUtils.toString(class2));
 498  
     }
 499  
 
 500  
     public static Message transformFailed(String from, String to)
 501  
     {
 502  0
         return factory.createMessage(BUNDLE_PATH, 110, from, to);
 503  
     }
 504  
     
 505  
     public static Message transformFailed(String from, DataType<?> to)
 506  
     {
 507  0
         return transformFailed(from, to.getClass().getName());
 508  
     }
 509  
     
 510  
     public static Message cryptoFailure()
 511  
     {
 512  0
         return factory.createMessage(BUNDLE_PATH, 112);
 513  
     }
 514  
 
 515  
     public static Message schemeNotCompatibleWithConnector(String scheme, Class<?> expectedClass)
 516  
     {
 517  0
         return factory.createMessage(BUNDLE_PATH, 115, scheme, expectedClass);
 518  
     }
 519  
 
 520  
     public static Message noEntryPointFoundWithArgs(Object object, Object args)
 521  
     {
 522  0
         return factory.createMessage(BUNDLE_PATH, 116, StringMessageUtils.toString(object),
 523  
             StringMessageUtils.toString(args));
 524  
     }
 525  
 
 526  
     public static Message authNoSecurityProvider(String providerName)
 527  
     {
 528  0
         return factory.createMessage(BUNDLE_PATH, 117, providerName);
 529  
     }
 530  
 
 531  
     public static Message transactionCanOnlyBindToResources(String string)
 532  
     {
 533  0
         return factory.createMessage(BUNDLE_PATH, 120, string);
 534  
     }
 535  
 
 536  
     public static Message cannotLoadFromClasspath(String string)
 537  
     {
 538  0
         return factory.createMessage(BUNDLE_PATH, 122, string);
 539  
     }
 540  
 
 541  
     public static Message failedToReadPayload()
 542  
     {
 543  0
         return factory.createMessage(BUNDLE_PATH, 124);
 544  
     }
 545  
 
 546  
     public static Message endpointNotFound(String endpoint)
 547  
     {
 548  0
         return factory.createMessage(BUNDLE_PATH, 126, endpoint);
 549  
     }
 550  
 
 551  
     public static Message eventProcessingFailedFor(String name)
 552  
     {
 553  0
         return factory.createMessage(BUNDLE_PATH, 127, name);
 554  
     }
 555  
 
 556  
     public static Message failedToDispatchToReplyto(ImmutableEndpoint endpoint)
 557  
     {
 558  0
         return factory.createMessage(BUNDLE_PATH, 128, endpoint);
 559  
     }
 560  
 
 561  
     public static Message authTypeNotRecognised(String string)
 562  
     {
 563  0
         return factory.createMessage(BUNDLE_PATH, 131, string);
 564  
     }
 565  
 
 566  
     public static Message authSecurityManagerNotSet()
 567  
     {
 568  0
         return factory.createMessage(BUNDLE_PATH, 132);
 569  
     }
 570  
 
 571  
     public static Message authSetButNoContext(String name)
 572  
     {
 573  0
         return factory.createMessage(BUNDLE_PATH, 133, name);
 574  
     }
 575  
 
 576  
     public static Message authDeniedOnEndpoint(EndpointURI endpointURI)
 577  
     {
 578  0
         return factory.createMessage(BUNDLE_PATH, 134, endpointURI);
 579  
     }
 580  
 
 581  
     public static Message authFailedForUser(Object user)
 582  
     {
 583  0
         return factory.createMessage(BUNDLE_PATH, 135, user);
 584  
     }
 585  
 
 586  
     public static Message authEndpointMustSendOrReceive()
 587  
     {
 588  0
         return factory.createMessage(BUNDLE_PATH, 136);
 589  
     }
 590  
 
 591  
     public static Message transactionManagerAlreadySet()
 592  
     {
 593  0
         return factory.createMessage(BUNDLE_PATH, 140);
 594  
     }
 595  
 
 596  
     public static Message failedToCreateManagerInstance(String className)
 597  
     {
 598  0
         return factory.createMessage(BUNDLE_PATH, 144, className);
 599  
     }
 600  
 
 601  
     public static Message failedToClone(String string)
 602  
     {
 603  0
         return factory.createMessage(BUNDLE_PATH, 145, string);
 604  
     }
 605  
 
 606  
     public static Message exceptionOnConnectorNoExceptionListener(String name)
 607  
     {
 608  0
         return factory.createMessage(BUNDLE_PATH, 146, name);
 609  
     }
 610  
 
 611  
     public static Message uniqueIdNotSupportedByAdapter(String name)
 612  
     {
 613  0
         return factory.createMessage(BUNDLE_PATH, 147, name);
 614  
     }
 615  
 
 616  
     public static Message serverNotificationManagerNotEnabled()
 617  
     {
 618  0
         return factory.createMessage(BUNDLE_PATH, 150);
 619  
     }
 620  
 
 621  
     public static Message failedToScheduleWork()
 622  
     {
 623  0
         return factory.createMessage(BUNDLE_PATH, 151);
 624  
     }
 625  
 
 626  
     public static Message authNoCredentials()
 627  
     {
 628  0
         return factory.createMessage(BUNDLE_PATH, 152);
 629  
     }
 630  
 
 631  
     public static Message valueIsInvalidFor(String value, String parameter)
 632  
     {
 633  0
         return factory.createMessage(BUNDLE_PATH, 154, value, parameter);
 634  
     }
 635  
 
 636  
     public static Message connectorWithProtocolNotRegistered(String scheme)
 637  
     {
 638  0
         return factory.createMessage(BUNDLE_PATH, 156, scheme);
 639  
     }
 640  
 
 641  
     public static Message propertyIsNotSupportedType(String property, Class<?> expected, Class<?> actual)
 642  
     {
 643  0
         return factory.createMessage(BUNDLE_PATH, 157, property, StringMessageUtils.toString(expected),
 644  
             StringMessageUtils.toString(actual));
 645  
     }
 646  
 
 647  
     public static Message propertyIsNotSupportedType(String property, Class<?>[] expected, Class<?> actual)
 648  
     {
 649  0
         return factory.createMessage(BUNDLE_PATH, 157, property, StringMessageUtils.toString(expected),
 650  
             StringMessageUtils.toString(actual));
 651  
     }
 652  
 
 653  
     public static Message containerAlreadyRegistered(String name)
 654  
     {
 655  0
         return factory.createMessage(BUNDLE_PATH, 155, name);
 656  
     }
 657  
 
 658  
     public static Message resourceManagerNotStarted()
 659  
     {
 660  0
         return factory.createMessage(BUNDLE_PATH, 161);
 661  
     }
 662  
 
 663  
     public static Message resourceManagerDirty()
 664  
     {
 665  0
         return factory.createMessage(BUNDLE_PATH, 162);
 666  
     }
 667  
 
 668  
     public static Message resourceManagerNotReady()
 669  
     {
 670  0
         return factory.createMessage(BUNDLE_PATH, 163);
 671  
     }
 672  
 
 673  
     public static Message reconnectStrategyFailed(Class<?> strategy, String description)
 674  
     {
 675  0
         return factory.createMessage(BUNDLE_PATH, 164, StringMessageUtils.toString(strategy), description);
 676  
     }
 677  
 
 678  
     public static Message cannotSetObjectOnceItHasBeenSet(String string)
 679  
     {
 680  0
         return factory.createMessage(BUNDLE_PATH, 165, string);
 681  
     }
 682  
 
 683  
     public static Message eventTypeNotRecognised(String string)
 684  
     {
 685  0
         return factory.createMessage(BUNDLE_PATH, 166, string);
 686  
     }
 687  
 
 688  
     public static Message isStopped(String name)
 689  
     {
 690  0
         return factory.createMessage(BUNDLE_PATH, 167, name);
 691  
     }
 692  
 
 693  
     public static Message propertyIsNotSetOnEvent(String property)
 694  
     {
 695  0
         return factory.createMessage(BUNDLE_PATH, 168, property);
 696  
     }
 697  
 
 698  
     public static Message descriptorAlreadyExists(String name)
 699  
     {
 700  0
         return factory.createMessage(BUNDLE_PATH, 171, name);
 701  
     }
 702  
 
 703  
     public static Message failedToInvokeRestService(String service)
 704  
     {
 705  0
         return factory.createMessage(BUNDLE_PATH, 172, service);
 706  
     }
 707  
 
 708  
     public static Message authNoEncryptionStrategy(String strategyName)
 709  
     {
 710  0
         return factory.createMessage(BUNDLE_PATH, 174, strategyName);
 711  
     }
 712  
 
 713  
     public static Message headerMalformedValueIs(String header, String value)
 714  
     {
 715  0
         return factory.createMessage(BUNDLE_PATH, 175, header, value);
 716  
     }
 717  
 
 718  
     public static Message transformOnObjectNotOfSpecifiedType(DataType<?> resultType, Object expectedType)
 719  
     {
 720  0
         return factory.createMessage(BUNDLE_PATH, 177, resultType.getType().getName(),
 721  
             expectedType.getClass());
 722  
     }
 723  
 
 724  
     public static Message cannotUseTxAndRemoteSync()
 725  
     {
 726  0
         return factory.createMessage(BUNDLE_PATH, 178);
 727  
     }
 728  
 
 729  
     public static Message failedToBuildMessage()
 730  
     {
 731  0
         return factory.createMessage(BUNDLE_PATH, 180);
 732  
     }
 733  
 
 734  
     public static Message propertiesNotSet(String string)
 735  
     {
 736  0
         return factory.createMessage(BUNDLE_PATH, 183, string);
 737  
     }
 738  
 
 739  
     public static Message objectNotOfCorrectType(Class<?> actualClass, Class<?>[] expectedClass)
 740  
     {
 741  0
         return factory.createMessage(BUNDLE_PATH, 185, StringMessageUtils.toString(actualClass),
 742  
             StringMessageUtils.toString(expectedClass));
 743  
     }
 744  
 
 745  
     public static Message objectNotOfCorrectType(Class<?> actualClass, Class<?> expectedClass)
 746  
     {
 747  0
         return factory.createMessage(BUNDLE_PATH, 185, StringMessageUtils.toString(actualClass),
 748  
             StringMessageUtils.toString(expectedClass));
 749  
     }
 750  
 
 751  
     public static Message failedToConvertStringUsingEncoding(String encoding)
 752  
     {
 753  0
         return factory.createMessage(BUNDLE_PATH, 188, encoding);
 754  
     }
 755  
 
 756  
     public static Message propertyHasInvalidValue(String property, Object value)
 757  
     {
 758  0
         return factory.createMessage(BUNDLE_PATH, 189, property, value);
 759  
     }
 760  
 
 761  
     public static Message schemeCannotChangeForRouter(String scheme, String scheme2)
 762  
     {
 763  0
         return factory.createMessage(BUNDLE_PATH, 192, scheme, scheme2);
 764  
     }
 765  
 
 766  
     public static Message days()
 767  
     {
 768  0
         return factory.createMessage(BUNDLE_PATH, 193);
 769  
     }
 770  
 
 771  
     public static Message hours()
 772  
     {
 773  0
         return factory.createMessage(BUNDLE_PATH, 194);
 774  
     }
 775  
 
 776  
     public static Message minutes()
 777  
     {
 778  0
         return factory.createMessage(BUNDLE_PATH, 195);
 779  
     }
 780  
 
 781  
     public static Message seconds()
 782  
     {
 783  0
         return factory.createMessage(BUNDLE_PATH, 196);
 784  
     }
 785  
 
 786  
     public static Message templateCausedMalformedEndpoint(String uri, String newUri)
 787  
     {
 788  0
         return factory.createMessage(BUNDLE_PATH, 197, uri, newUri);
 789  
     }
 790  
 
 791  
     public static Message couldNotDetermineDestinationComponentFromEndpoint(String endpoint)
 792  
     {
 793  0
         return factory.createMessage(BUNDLE_PATH, 198, endpoint);
 794  
     }
 795  
 
 796  
     public static Message sessionValueIsMalformed(String string)
 797  
     {
 798  0
         return factory.createMessage(BUNDLE_PATH, 201, string);
 799  
     }
 800  
 
 801  
     public static Message streamingFailedNoStream()
 802  
     {
 803  0
         return factory.createMessage(BUNDLE_PATH, 205);
 804  
     }
 805  
 
 806  
     public static Message connectorSchemeIncompatibleWithEndpointScheme(Object expected, Object actual)
 807  
     {
 808  0
         return factory.createMessage(BUNDLE_PATH, 206, expected, actual);
 809  
     }
 810  
 
 811  
     public static Message failedToReadAttachment(String string)
 812  
     {
 813  0
         return factory.createMessage(BUNDLE_PATH, 207, string);
 814  
     }
 815  
 
 816  
     public static Message failedToInitSecurityProvider(String providerClass)
 817  
     {
 818  0
         return factory.createMessage(BUNDLE_PATH, 208, providerClass);
 819  
     }
 820  
 
 821  
     public static Message streamingNotSupported(String protocol)
 822  
     {
 823  0
         return factory.createMessage(BUNDLE_PATH, 209, protocol);
 824  
     }
 825  
 
 826  
     public static Message streamingComponentMustHaveOneEndpoint(String name)
 827  
     {
 828  0
         return factory.createMessage(BUNDLE_PATH, 210, name);
 829  
     }
 830  
 
 831  
     public static Message streamingFailedForEndpoint(String string)
 832  
     {
 833  0
         return factory.createMessage(BUNDLE_PATH, 212, string);
 834  
     }
 835  
 
 836  
     public static Message streamingEndpointsDoNotSupportTransformers()
 837  
     {
 838  0
         return factory.createMessage(BUNDLE_PATH, 213);
 839  
     }
 840  
 
 841  
     public static Message streamingEndpointsMustBeUsedWithStreamingModel()
 842  
     {
 843  0
         return factory.createMessage(BUNDLE_PATH, 214);
 844  
     }
 845  
 
 846  
     public static Message tooManyMatchingMethodsOnObjectWhichReturn(Object object, Object returnType)
 847  
     {
 848  0
         return factory.createMessage(BUNDLE_PATH, 216, StringMessageUtils.toString(object),
 849  
             StringMessageUtils.toString(returnType));
 850  
     }
 851  
 
 852  
     public static Message failedToSetProxyOnService(Object proxy, Class<?> routerClass)
 853  
     {
 854  0
         return factory.createMessage(BUNDLE_PATH, 217, proxy, routerClass);
 855  
     }
 856  
 
 857  
     public static Message mustSetMethodNamesOnBinding()
 858  
     {
 859  0
         return factory.createMessage(BUNDLE_PATH, 218);
 860  
     }
 861  
 
 862  
     public static Message cannotFindBindingForMethod(String name)
 863  
     {
 864  0
         return factory.createMessage(BUNDLE_PATH, 219, name);
 865  
     }
 866  
 
 867  
     public static Message noMatchingMethodsOnObjectReturning(Object object, Class<?> returnType)
 868  
     {
 869  0
         return factory.createMessage(BUNDLE_PATH, 220, StringMessageUtils.toString(object),
 870  
             StringMessageUtils.toString(returnType));
 871  
     }
 872  
 
 873  
     public static Message moreThanOneConnectorWithProtocol(String protocol, String connectors)
 874  
     {
 875  0
         return factory.createMessage(BUNDLE_PATH, 221, protocol, connectors);
 876  
     }
 877  
 
 878  
     public static Message failedToGetOutputStream()
 879  
     {
 880  0
         return factory.createMessage(BUNDLE_PATH, 223);
 881  
     }
 882  
 
 883  
     public static Message noEntryPointFoundForNoArgsMethod(final Object component, final String methodName)
 884  
     {
 885  0
         return factory.createMessage(BUNDLE_PATH, 224, component, methodName);
 886  
     }
 887  
 
 888  
     public static Message noDelegateClassAndMethodProvidedForNoArgsWrapper()
 889  
     {
 890  0
         return factory.createMessage(BUNDLE_PATH, 225);
 891  
     }
 892  
 
 893  
     public static Message noDelegateClassIfDelegateInstanceSpecified()
 894  
     {
 895  0
         return factory.createMessage(BUNDLE_PATH, 226);
 896  
     }
 897  
 
 898  
     public static Message noServiceTransportDescriptor(String protocol)
 899  
     {
 900  0
         return factory.createMessage(BUNDLE_PATH, 227, protocol);
 901  
     }
 902  
 
 903  
     public static Message failedToInvokeLifecycle(String phaseName, Object object)
 904  
     {
 905  0
         return factory.createMessage(BUNDLE_PATH, 228, phaseName, object);
 906  
     }
 907  
 
 908  
     public static Message unrecognisedServiceType(ServiceType type)
 909  
     {
 910  0
         return factory.createMessage(BUNDLE_PATH, 229, type);
 911  
     }
 912  
 
 913  
     public static Message serviceFinderCantFindService(String name)
 914  
     {
 915  0
         return factory.createMessage(BUNDLE_PATH, 230, name);
 916  
     }
 917  
 
 918  
     public static Message outboundRouterMustUseOutboudEndpoints(OutboundRouter router,
 919  
                                                                 ImmutableEndpoint endpoint)
 920  
     {
 921  0
         return factory.createMessage(BUNDLE_PATH, 233, endpoint, router);
 922  
     }
 923  
 
 924  
     public static Message exceptionListenerMustUseOutboundEndpoint(AbstractExceptionListener exceptionListener,
 925  
                                                                    ImmutableEndpoint endpoint)
 926  
     {
 927  0
         return factory.createMessage(BUNDLE_PATH, 235, endpoint, exceptionListener);
 928  
     }
 929  
 
 930  
     /**
 931  
      * Returns a message that is a product informatin.
 932  
      * 
 933  
      * @return message
 934  
      */
 935  
     public static Message productInformation()
 936  
     {
 937  0
         String notset = CoreMessages.notSet().getMessage();
 938  0
         return factory.createMessage(BUNDLE_PATH, 236, StringUtils.defaultString(
 939  
             MuleManifest.getProductDescription(), notset), StringUtils.defaultString(
 940  
             MuleManifest.getProductVersion(), notset), StringUtils.defaultString(
 941  
             MuleManifest.getVendorName(), notset)
 942  
                                                        + " "
 943  
                                                        + StringUtils.defaultString(
 944  
                                                            MuleManifest.getVendorUrl(), notset));
 945  
     }
 946  
 
 947  
     public static Message noTransformerFoundForMessage(DataType<?> input, DataType<?> output)
 948  
     {
 949  0
         return factory.createMessage(BUNDLE_PATH, 237, input, output);
 950  
     }
 951  
 
 952  
     public static Message errorReadingStream()
 953  
     {
 954  0
         return factory.createMessage(BUNDLE_PATH, 238);
 955  
     }
 956  
 
 957  
     public static Message noEntryPointFoundForNoArgsMethodUsingResolver(final Object component,
 958  
                                                                         final String methodName)
 959  
     {
 960  0
         return factory.createMessage(BUNDLE_PATH, 239, methodName, component);
 961  
     }
 962  
 
 963  
     public static Message noEntryPointFoundWithArgsUsingResolver(Object object,
 964  
                                                                  Object args)
 965  
     {
 966  0
         return factory.createMessage(BUNDLE_PATH, 240, StringMessageUtils.toString(object),
 967  
             StringMessageUtils.toString(args));
 968  
     }
 969  
 
 970  
     public static Message noMatchingMethodsOnObjectReturningUsingResolver(Object object,
 971  
                                                                           Class<?> returnType)
 972  
     {
 973  0
         return factory.createMessage(BUNDLE_PATH, 241, StringMessageUtils.toString(object),
 974  
             returnType.getClass().getName());
 975  
     }
 976  
 
 977  
     public static Message tooManyAcceptableMethodsOnObjectUsingResolverForTypes(Object object,
 978  
                                                                                 Object types,
 979  
                                                                                 String methods)
 980  
     {
 981  0
         return factory.createMessage(BUNDLE_PATH, 242, StringMessageUtils.toString(object),
 982  
             StringMessageUtils.toString(types), methods);
 983  
     }
 984  
 
 985  
     public static Message tooManyMatchingMethodsOnObjectUsingResolverWhichReturn(Object object,
 986  
                                                                                  Object returnType)
 987  
     {
 988  0
         return factory.createMessage(BUNDLE_PATH, 243, StringMessageUtils.toString(returnType),
 989  
             StringMessageUtils.toString(object));
 990  
     }
 991  
 
 992  
     public static Message objectDoesNotImplementInterface(Object object, Class<?> interfaceClass)
 993  
     {
 994  0
         return factory.createMessage(BUNDLE_PATH, 244, StringMessageUtils.toString(object), interfaceClass);
 995  
     }
 996  
 
 997  
     public static Message invocationSuccessfulCantSetError()
 998  
     {
 999  0
         return factory.createMessage(BUNDLE_PATH, 245);
 1000  
     }
 1001  
 
 1002  
     public static Message noMatchingMethodsOnObjectCalledUsingResolver(Object object,
 1003  
                                                                        String methodName)
 1004  
     {
 1005  0
         return factory.createMessage(BUNDLE_PATH, 246, StringMessageUtils.toString(object), methodName);
 1006  
     }
 1007  
 
 1008  
     public static Message noJtaTransactionAvailable(final Thread callingThread)
 1009  
     {
 1010  0
         return factory.createMessage(BUNDLE_PATH, 247, StringUtils.defaultString(callingThread.toString()));
 1011  
     }
 1012  
 
 1013  
     public static Message notMuleXaTransaction(Object tx)
 1014  
     {
 1015  0
         return factory.createMessage(BUNDLE_PATH, 248, tx.getClass());
 1016  
     }
 1017  
 
 1018  
     public static Message noServiceQueueTimeoutSet(Service service)
 1019  
     {
 1020  0
         return factory.createMessage(BUNDLE_PATH, 249, service);
 1021  
     }
 1022  
 
 1023  
     public static Message failedToProcessExtractorFunction(String name)
 1024  
     {
 1025  0
         return factory.createMessage(BUNDLE_PATH, 250, name);
 1026  
     }
 1027  
 
 1028  
     public static Message expressionEvaluatorNotRegistered(String key)
 1029  
     {
 1030  0
         return factory.createMessage(BUNDLE_PATH, 251, key);
 1031  
     }
 1032  
     
 1033  
     public static Message objectAlreadyExists(String key)
 1034  
     {
 1035  0
         return factory.createMessage(BUNDLE_PATH, 252, key);
 1036  
     }
 1037  
 
 1038  
     public static Message noMuleTransactionAvailable()
 1039  
     {
 1040  0
         return factory.createMessage(BUNDLE_PATH, 253);
 1041  
     }
 1042  
 
 1043  
     public static Message objectAlreadyRegistered(String name, Object origObject, Object newObject)
 1044  
     {
 1045  0
         return factory.createMessage(BUNDLE_PATH, 254, name, origObject + "." + origObject.getClass(),
 1046  
             newObject + "." + newObject.getClass());
 1047  
     }
 1048  
 
 1049  
     public static Message transformerNotImplementDiscoverable(Transformer transformer)
 1050  
     {
 1051  0
         return factory.createMessage(BUNDLE_PATH, 255, transformer);
 1052  
     }
 1053  
 
 1054  
     public static Message transformHasMultipleMatches(Class<?> input,
 1055  
                                                       Class<?> output,
 1056  
                                                       Transformer transformer1,
 1057  
                                                       Transformer transformer2)
 1058  
     {
 1059  0
         return factory.createMessage(BUNDLE_PATH, 256, input, output,
 1060  
                 transformer1.getName() + "(" + transformer1.getClass() + ")",
 1061  
                 transformer2.getName() + "(" + transformer2.getClass() + ")");
 1062  
     }
 1063  
 
 1064  
     public static Message configurationBuilderSuccess(ConfigurationBuilder configurationBuilder,
 1065  
                                                       int numResources)
 1066  
     {
 1067  0
         return factory.createMessage(BUNDLE_PATH, 257, configurationBuilder.getClass().getName(),
 1068  
             new Integer(numResources));
 1069  
     }
 1070  
 
 1071  
     public static Message configurationBuilderSuccess(ConfigurationBuilder configurationBuilder,
 1072  
                                                       String resources)
 1073  
     {
 1074  0
         return factory.createMessage(BUNDLE_PATH, 258, configurationBuilder.getClass().getName(), resources);
 1075  
     }
 1076  
 
 1077  
     public static Message configurationBuilderNoMatching(String resource)
 1078  
     {
 1079  0
         return factory.createMessage(BUNDLE_PATH, 259, resource);
 1080  
     }
 1081  
 
 1082  
     public static Message configurationBuilderError(ConfigurationBuilder configurationBuilder)
 1083  
     {
 1084  0
         return factory.createMessage(BUNDLE_PATH, 260,
 1085  
             StringMessageUtils.toString(configurationBuilder.getClass()));
 1086  
     }
 1087  
 
 1088  
     public static Message nestedRetry()
 1089  
     {
 1090  0
         return factory.createMessage(BUNDLE_PATH, 261);
 1091  
     }
 1092  
 
 1093  
     public static Message expressionEvaluatorReturnedNull(String name, String expr)
 1094  
     {
 1095  0
         return factory.createMessage(BUNDLE_PATH, 263, name, expr);
 1096  
     }
 1097  
 
 1098  
     public static Message expressionInvalidForProperty(String property, String expr)
 1099  
     {
 1100  0
         return factory.createMessage(BUNDLE_PATH, 264, property, expr);
 1101  
     }
 1102  
 
 1103  
     public static Message expressionMalformed(String expr, String eval)
 1104  
     {
 1105  0
         return factory.createMessage(BUNDLE_PATH, 265, expr, eval);
 1106  
     }
 1107  
 
 1108  
     public static Message correlationTimedOut(Object groupId)
 1109  
     {
 1110  0
         return factory.createMessage(BUNDLE_PATH, 266, groupId);
 1111  
     }
 1112  
 
 1113  
     public static Message transformerInvalidReturnType(Class<?> clazz, String transformerName)
 1114  
     {
 1115  0
         return factory.createMessage(BUNDLE_PATH, 267, clazz, transformerName);
 1116  
     }
 1117  
 
 1118  
     public static Message transactionFactoryIsMandatory(String action)
 1119  
     {
 1120  0
         return factory.createMessage(BUNDLE_PATH, 269, action);
 1121  
     }
 1122  
 
 1123  
     public static Message failedToCreateProxyFor(Object target)
 1124  
     {
 1125  0
         return factory.createMessage(BUNDLE_PATH, 270, target);
 1126  
     }
 1127  
 
 1128  
     public static Message authorizationAttemptFailed()
 1129  
     {
 1130  0
         return factory.createMessage(BUNDLE_PATH, 271);
 1131  
     }
 1132  
 
 1133  
     public static Message retryPolicyExhausted(RetryPolicyTemplate policy)
 1134  
     {
 1135  0
         return factory.createMessage(BUNDLE_PATH, 272, policy);
 1136  
     }
 1137  
 
 1138  
     public static Message notConnectedYet(String what)
 1139  
     {
 1140  0
         return factory.createMessage(BUNDLE_PATH, 273, what);
 1141  
     }
 1142  
 
 1143  
     public static Message stopPausedSedaStageNonPeristentQueueMessageLoss(int num, String name)
 1144  
     {
 1145  0
         return factory.createMessage(BUNDLE_PATH, 274, num, name);
 1146  
     }
 1147  
 
 1148  
     public static Message splitMessageNoEndpointMatch(List<?> endpoints, Object messagePart)
 1149  
     {
 1150  0
         return factory.createMessage(BUNDLE_PATH, 275, StringMessageUtils.toString(endpoints), messagePart);
 1151  
     }
 1152  
 
 1153  
     public static Message expressionResultWasNull(String expression)
 1154  
     {
 1155  0
         return factory.createMessage(BUNDLE_PATH, 276, expression);
 1156  
     }
 1157  
 
 1158  
     public static Message propertyDoesNotExistOnObject(String property, Object object)
 1159  
     {
 1160  0
         return factory.createMessage(BUNDLE_PATH, 277, property, object);
 1161  
     }
 1162  
 
 1163  
     public static Message commitTxButNoResource(Transaction tx)
 1164  
     {
 1165  0
         return factory.createMessage(BUNDLE_PATH, 300, tx);
 1166  
     }
 1167  
 
 1168  
     public static Message rollbackTxButNoResource(Transaction tx)
 1169  
     {
 1170  0
         return factory.createMessage(BUNDLE_PATH, 301, tx);
 1171  
     }
 1172  
 
 1173  
     public static Message cannotCopyStreamPayload(String streamType)
 1174  
     {
 1175  0
         return factory.createMessage(BUNDLE_PATH, 302, streamType);
 1176  
     }
 1177  
 
 1178  
     public static Message propertiesOrNotSet(String name, String properties)
 1179  
     {
 1180  0
         return factory.createMessage(BUNDLE_PATH, 303, name, properties);
 1181  
     }
 1182  
 
 1183  
     public static Message transforemrMapBeanClassNotSet()
 1184  
     {
 1185  0
         return factory.createMessage(BUNDLE_PATH, 304);
 1186  
     }
 1187  
 
 1188  
     public static Message lifecyclePhaseNotRecognised(String phase)
 1189  
     {
 1190  0
         return factory.createMessage(BUNDLE_PATH, 305, phase);
 1191  
     }
 1192  
 
 1193  
     public static Message notificationListenerSubscriptionAlreadyRegistered(ListenerSubscriptionPair listenerPair)
 1194  
     {
 1195  0
         return factory.createMessage(BUNDLE_PATH, 306, listenerPair);
 1196  
     }
 1197  
 
 1198  
     public static Message applicationShutdownNormally(String appName, Date date)
 1199  
     {
 1200  0
         return factory.createMessage(BUNDLE_PATH, 307, appName, date);
 1201  
     }
 1202  
 
 1203  
     public static Message applicationWasUpForDuration(long duration)
 1204  
     {
 1205  0
         String formattedDuration = DateUtils.getFormattedDuration(duration);
 1206  0
         return factory.createMessage(BUNDLE_PATH, 308, formattedDuration);
 1207  
     }
 1208  
 
 1209  
     public static Message errorSchedulingMessageProcessorForAsyncInvocation(MessageProcessor processor)
 1210  
     {
 1211  0
         return factory.createMessage(BUNDLE_PATH, 309, processor);
 1212  
     }
 1213  
 
 1214  
     public static Message errorInvokingMessageProcessorAsynchronously(MessageProcessor processor)
 1215  
     {
 1216  0
         return factory.createMessage(BUNDLE_PATH, 310, processor);
 1217  
     }
 1218  
 
 1219  
     public static Message errorInvokingMessageProcessorWithinTransaction(MessageProcessor processor,
 1220  
                                                                          TransactionConfig transactionConfig)
 1221  
     {
 1222  0
         return factory.createMessage(BUNDLE_PATH, 311, processor, transactionConfig);
 1223  
     }
 1224  
 
 1225  
     private static String getEndpointDescription(InboundEndpoint endpoint)
 1226  
     {
 1227  0
         String endpointString = endpoint.getName();
 1228  0
         if (endpointString == null)
 1229  
         {
 1230  0
             endpointString = endpoint.getEndpointURI().getUri().toString();
 1231  
         }
 1232  0
         return endpointString;
 1233  
     }
 1234  
     
 1235  
     public static Message failedToStartInboundEndpoint(InboundEndpoint endpoint)
 1236  
     {
 1237  0
         return factory.createMessage(BUNDLE_PATH, 312, getEndpointDescription(endpoint));
 1238  
     }
 1239  
 
 1240  
     public static Message failedToStopInboundEndpoint(InboundEndpoint endpoint)
 1241  
     {
 1242  0
         return factory.createMessage(BUNDLE_PATH, 313, getEndpointDescription(endpoint));
 1243  
     }
 1244  
 
 1245  
     public static Message messageRejectedByFilter()
 1246  
     {
 1247  0
         return factory.createMessage(BUNDLE_PATH, 314);
 1248  
     }
 1249  
     
 1250  
     public static Message interruptedWaitingForPaused(String name)
 1251  
     {
 1252  0
         return factory.createMessage(BUNDLE_PATH, 315, name);
 1253  
     }
 1254  
 
 1255  
     public static Message objectHasMoreThanOnePostConstructAnnotation(Class<?> clazz)
 1256  
     {
 1257  0
         return factory.createMessage(BUNDLE_PATH, 316, clazz.getName());
 1258  
     }
 1259  
 
 1260  
     public static Message objectHasMoreThanOnePreDestroyAnnotation(Class<?> clazz)
 1261  
     {
 1262  0
         return factory.createMessage(BUNDLE_PATH, 317, clazz.getName());
 1263  
     }
 1264  
 
 1265  
     public static Message lifecycleMethodNotVoidOrHasParams(Method method)
 1266  
     {
 1267  0
         return factory.createMessage(BUNDLE_PATH, 318, method.getName());
 1268  
     }
 1269  
 
 1270  
     public static Message lifecycleMethodCannotBeStatic(Method method)
 1271  
     {
 1272  0
         return factory.createMessage(BUNDLE_PATH, 319, method.getName());
 1273  
     }
 1274  
 
 1275  
     public static Message lifecycleMethodCannotThrowChecked(Method method)
 1276  
     {
 1277  0
         return factory.createMessage(BUNDLE_PATH, 320, method.getName());
 1278  
     }
 1279  
 
 1280  
     public static Message cannotRenameInboundScopeProperty(String fromKey, String toKey)
 1281  
     {
 1282  0
         return factory.createMessage(BUNDLE_PATH, 321, fromKey, toKey);
 1283  
     }
 1284  
 
 1285  
     public static Message failedToFindEntrypointForComponent(String message)
 1286  
     {
 1287  0
         return factory.createMessage(BUNDLE_PATH, 322, message);
 1288  
     }
 1289  
 
 1290  
     public static Message exchangePatternForEndpointNotSupported(MessageExchangePattern mep,
 1291  
         String direction, EndpointURI endpointURI)
 1292  
     {
 1293  0
         return factory.createMessage(BUNDLE_PATH, 323, mep.name(), direction, endpointURI);
 1294  
     }
 1295  
 
 1296  
     public static Message illegalMIMEType(String badMIMIEType)
 1297  
     {
 1298  0
         return factory.createMessage(BUNDLE_PATH, 324, badMIMIEType);
 1299  
     }
 1300  
 
 1301  
     public static Message unexpectedMIMEType(String badMIMIEType, String goodMIMEType)
 1302  
     {
 1303  0
         return factory.createMessage(BUNDLE_PATH, 325, badMIMIEType, goodMIMEType);
 1304  
     }
 1305  
 
 1306  
     public static Message dynamicEndpointURIsCannotBeUsedOnInbound()
 1307  
     {
 1308  0
         return factory.createMessage(BUNDLE_PATH, 326);
 1309  
     }
 1310  
 
 1311  
     public static Message dynamicEndpointsMustSpecifyAScheme()
 1312  
     {
 1313  0
         return factory.createMessage(BUNDLE_PATH, 327);
 1314  
     }
 1315  
 
 1316  
     public static Message asyncDoesNotSupportTransactions()
 1317  
     {
 1318  0
         return factory.createMessage(BUNDLE_PATH, 328);
 1319  
     }
 1320  
     
 1321  
     public static Message methodWithNumParamsNotFoundOnObject(String method, int numArgments, Object object)
 1322  
     {
 1323  0
         return factory.createMessage(BUNDLE_PATH, 329, method, numArgments,
 1324  
             StringMessageUtils.toString(object));
 1325  
     }
 1326  
     
 1327  
     public static Message expressionEnricherNotRegistered(String key)
 1328  
     {
 1329  0
         return factory.createMessage(BUNDLE_PATH, 330, key);
 1330  
     }
 1331  
 
 1332  
     public static Message authorizationDeniedOnEndpoint(EndpointURI endpointURI)
 1333  
     {
 1334  0
         return factory.createMessage(BUNDLE_PATH, 332, endpointURI);
 1335  
     }
 1336  
 
 1337  
 }