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