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