<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<!-- NewPage -->
<html lang="en">
<head>
<meta http-equiv="Content-Type" content="text/html" charset="UTF-8">
<title>RB (Apache Axis2)</title>
<link rel="stylesheet" type="text/css" href="../../../../stylesheet.css" title="Style">
</head>
<body>
<script type="text/javascript"><!--
    if (location.href.indexOf('is-external=true') == -1) {
        parent.document.title="RB (Apache Axis2)";
    }
//-->
</script>
<noscript>
<div>JavaScript is disabled on your browser.</div>
</noscript>
<!-- ========= START OF TOP NAVBAR ======= -->
<div class="topNav"><a name="navbar_top">
<!--   -->
</a><a href="#skip-navbar_top" title="Skip navigation links"></a><a name="navbar_top_firstrow">
<!--   -->
</a>
<ul class="navList" title="Navigation">
<li><a href="../../../../overview-summary.html">Overview</a></li>
<li><a href="package-summary.html">Package</a></li>
<li class="navBarCell1Rev">Class</li>
<li><a href="class-use/RB.html">Use</a></li>
<li><a href="package-tree.html">Tree</a></li>
<li><a href="../../../../deprecated-list.html">Deprecated</a></li>
<li><a href="../../../../index-all.html">Index</a></li>
<li><a href="../../../../help-doc.html">Help</a></li>
</ul>
</div>
<div class="subNav">
<ul class="navList">
<li><a href="../../../../org/apache/axis2/i18n/ProjectResourceBundle.html" title="class in org.apache.axis2.i18n"><span class="strong">Prev Class</span></a></li>
<li>Next Class</li>
</ul>
<ul class="navList">
<li><a href="../../../../index.html?org/apache/axis2/i18n/RB.html" target="_top">Frames</a></li>
<li><a href="RB.html" target="_top">No Frames</a></li>
</ul>
<ul class="navList" id="allclasses_navbar_top">
<li><a href="../../../../allclasses-noframe.html">All Classes</a></li>
</ul>
<div>
<script type="text/javascript"><!--
  allClassesLink = document.getElementById("allclasses_navbar_top");
  if(window==top) {
    allClassesLink.style.display = "block";
  }
  else {
    allClassesLink.style.display = "none";
  }
  //-->
</script>
</div>
<div>
<ul class="subNavList">
<li>Summary:&nbsp;</li>
<li>Nested&nbsp;|&nbsp;</li>
<li><a href="#field_summary">Field</a>&nbsp;|&nbsp;</li>
<li><a href="#constructor_summary">Constr</a>&nbsp;|&nbsp;</li>
<li><a href="#method_summary">Method</a></li>
</ul>
<ul class="subNavList">
<li>Detail:&nbsp;</li>
<li><a href="#field_detail">Field</a>&nbsp;|&nbsp;</li>
<li><a href="#constructor_detail">Constr</a>&nbsp;|&nbsp;</li>
<li><a href="#method_detail">Method</a></li>
</ul>
</div>
<a name="skip-navbar_top">
<!--   -->
</a></div>
<!-- ========= END OF TOP NAVBAR ========= -->
<!-- ======== START OF CLASS DATA ======== -->
<div class="header">
<div class="subTitle">org.apache.axis2.i18n</div>
<h2 title="Class RB" class="title">Class RB</h2>
</div>
<div class="contentContainer">
<ul class="inheritance">
<li><a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">java.lang.Object</a></li>
<li>
<ul class="inheritance">
<li>org.apache.axis2.i18n.RB</li>
</ul>
</li>
</ul>
<div class="description">
<ul class="blockList">
<li class="blockList">
<hr>
<br>
<pre>public class <span class="strong">RB</span>
extends <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a></pre>
<div class="block">CURRENTLY NOT USED
 KEEPING FOR REFERENCE  9/19/2002
 <p/>
 <p>Wrapper class for resource bundles. Property files are used to store
 resource strings, which are the only types of resources available.
 Property files can inherit properties from other files so that
 a base property file can be used and a small number of properties
 can be over-ridden by another property file. For example you may
 create an english version of a resource file named "resource.properties".
 You then decide that the British English version of all of the properties
 except one are the same, so there is no need to redefine all of the
 properties in "resource_en_GB", just the one that is different.</p>
 <p>The property file lookup searches for classes with various suffixes
 on the basis if the desired local and the current default local
 (as returned by Local.getDefault()). As property files are found the
 property values are merged so that inheritance is preserved.</p>
 <p>The order of searching is:</p>
 <dir>
 basename + "_" + langage + "_" + country + "_" + variant
 basename + "_" + langage + "_" + country
 basename + "_" + langage
 basename + "_" + defaultLanguage + "_" + defaultCountry + "_" + defaultVariant
 basename + "_" + defaultLanguage + "_" + defaultCountry
 basename + "_" + defaultLanguage
 basename
 </dir>
 <p>The basename is the name of the property file without the ".properties"
 extension.</p>
 <p>Properties will be cached for performance.<p>
 <p>Property values stored in the property files can also contain dynamic
 variables. Any dynamic variable defined in PropertiesUtil.getVariableValue()
 can be used (such as {date}), as well as arguments in the form {0}, {1}, etc.
 Argument values are specified in the various overloaded getString() methods.</p></div>
</li>
</ul>
</div>
<div class="summary">
<ul class="blockList">
<li class="blockList">
<!-- =========== FIELD SUMMARY =========== -->
<ul class="blockList">
<li class="blockList"><a name="field_summary">
<!--   -->
</a>
<h3>Field Summary</h3>
<table class="overviewSummary" border="0" cellpadding="3" cellspacing="0" summary="Field Summary table, listing fields, and an explanation">
<caption><span>Fields</span><span class="tabEnd">&nbsp;</span></caption>
<tr>
<th class="colFirst" scope="col">Modifier and Type</th>
<th class="colLast" scope="col">Field and Description</th>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/apache/axis2/i18n/RB.html#BASE_NAME">BASE_NAME</a></strong></code>&nbsp;</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>protected <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/apache/axis2/i18n/RB.html#basePropertyFileName">basePropertyFileName</a></strong></code>&nbsp;</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/apache/axis2/i18n/RB.html#PROPERTY_EXT">PROPERTY_EXT</a></strong></code>&nbsp;</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>protected <a href="https://docs.oracle.com/javase/7/docs/api/java/util/Properties.html?is-external=true" title="class or interface in java.util">Properties</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/apache/axis2/i18n/RB.html#resourceProperties">resourceProperties</a></strong></code>&nbsp;</td>
</tr>
</table>
</li>
</ul>
<!-- ======== CONSTRUCTOR SUMMARY ======== -->
<ul class="blockList">
<li class="blockList"><a name="constructor_summary">
<!--   -->
</a>
<h3>Constructor Summary</h3>
<table class="overviewSummary" border="0" cellpadding="3" cellspacing="0" summary="Constructor Summary table, listing constructors, and an explanation">
<caption><span>Constructors</span><span class="tabEnd">&nbsp;</span></caption>
<tr>
<th class="colOne" scope="col">Constructor and Description</th>
</tr>
<tr class="altColor">
<td class="colOne"><code><strong><a href="../../../../org/apache/axis2/i18n/RB.html#RB(java.lang.Object, java.lang.String)">RB</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;caller,
  <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;name)</code>
<div class="block">Construct a new RB</div>
</td>
</tr>
<tr class="rowColor">
<td class="colOne"><code><strong><a href="../../../../org/apache/axis2/i18n/RB.html#RB(java.lang.Object, java.lang.String, java.util.Locale)">RB</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;caller,
  <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;name,
  <a href="https://docs.oracle.com/javase/7/docs/api/java/util/Locale.html?is-external=true" title="class or interface in java.util">Locale</a>&nbsp;locale)</code>
<div class="block">Construct a new RB</div>
</td>
</tr>
<tr class="altColor">
<td class="colOne"><code><strong><a href="../../../../org/apache/axis2/i18n/RB.html#RB(java.lang.String)">RB</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;name)</code>
<div class="block">Construct a new RB</div>
</td>
</tr>
</table>
</li>
</ul>
<!-- ========== METHOD SUMMARY =========== -->
<ul class="blockList">
<li class="blockList"><a name="method_summary">
<!--   -->
</a>
<h3>Method Summary</h3>
<table class="overviewSummary" border="0" cellpadding="3" cellspacing="0" summary="Method Summary table, listing methods, and an explanation">
<caption><span>Methods</span><span class="tabEnd">&nbsp;</span></caption>
<tr>
<th class="colFirst" scope="col">Modifier and Type</th>
<th class="colLast" scope="col">Method and Description</th>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static void</code></td>
<td class="colLast"><code><strong><a href="../../../../org/apache/axis2/i18n/RB.html#clearCache()">clearCache</a></strong>()</code>
<div class="block">Clears the internal cache.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/apache/axis2/i18n/RB.html#getMessage(java.lang.Object, java.lang.String, java.util.Locale, java.lang.String, java.lang.Object[])">getMessage</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;caller,
          <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;basename,
          <a href="https://docs.oracle.com/javase/7/docs/api/java/util/Locale.html?is-external=true" title="class or interface in java.util">Locale</a>&nbsp;locale,
          <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;key,
          <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>[]&nbsp;args)</code>&nbsp;</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code><a href="https://docs.oracle.com/javase/7/docs/api/java/util/Properties.html?is-external=true" title="class or interface in java.util">Properties</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/apache/axis2/i18n/RB.html#getProperties()">getProperties</a></strong>()</code>
<div class="block">Get the underlying properties</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/apache/axis2/i18n/RB.html#getString(java.lang.Object, java.util.Locale, java.lang.String)">getString</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;caller,
         <a href="https://docs.oracle.com/javase/7/docs/api/java/util/Locale.html?is-external=true" title="class or interface in java.util">Locale</a>&nbsp;locale,
         <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;key)</code>
<div class="block">Get a message from resource.properties from the package of the given object.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/apache/axis2/i18n/RB.html#getString(java.lang.Object, java.util.Locale, java.lang.String, java.lang.Object)">getString</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;caller,
         <a href="https://docs.oracle.com/javase/7/docs/api/java/util/Locale.html?is-external=true" title="class or interface in java.util">Locale</a>&nbsp;locale,
         <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;key,
         <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;arg0)</code>
<div class="block">Get a message from resource.properties from the package of the given object.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/apache/axis2/i18n/RB.html#getString(java.lang.Object, java.util.Locale, java.lang.String, java.lang.Object[])">getString</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;caller,
         <a href="https://docs.oracle.com/javase/7/docs/api/java/util/Locale.html?is-external=true" title="class or interface in java.util">Locale</a>&nbsp;locale,
         <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;key,
         <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>[]&nbsp;args)</code>
<div class="block">Get a message from resource.properties from the package of the given object.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/apache/axis2/i18n/RB.html#getString(java.lang.Object, java.util.Locale, java.lang.String, java.lang.Object, java.lang.Object)">getString</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;caller,
         <a href="https://docs.oracle.com/javase/7/docs/api/java/util/Locale.html?is-external=true" title="class or interface in java.util">Locale</a>&nbsp;locale,
         <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;key,
         <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;arg0,
         <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;arg1)</code>
<div class="block">Get a message from resource.properties from the package of the given object.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/apache/axis2/i18n/RB.html#getString(java.lang.Object, java.util.Locale, java.lang.String, java.lang.Object, java.lang.Object, java.lang.Object)">getString</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;caller,
         <a href="https://docs.oracle.com/javase/7/docs/api/java/util/Locale.html?is-external=true" title="class or interface in java.util">Locale</a>&nbsp;locale,
         <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;key,
         <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;arg0,
         <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;arg1,
         <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;arg2)</code>
<div class="block">Get a message from resource.properties from the package of the given object.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/apache/axis2/i18n/RB.html#getString(java.lang.Object, java.util.Locale, java.lang.String, java.lang.Object, java.lang.Object, java.lang.Object, java.lang.Object)">getString</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;caller,
         <a href="https://docs.oracle.com/javase/7/docs/api/java/util/Locale.html?is-external=true" title="class or interface in java.util">Locale</a>&nbsp;locale,
         <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;key,
         <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;arg0,
         <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;arg1,
         <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;arg2,
         <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;arg3)</code>
<div class="block">Get a message from resource.properties from the package of the given object.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/apache/axis2/i18n/RB.html#getString(java.lang.Object, java.util.Locale, java.lang.String, java.lang.Object, java.lang.Object, java.lang.Object, java.lang.Object, java.lang.Object)">getString</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;caller,
         <a href="https://docs.oracle.com/javase/7/docs/api/java/util/Locale.html?is-external=true" title="class or interface in java.util">Locale</a>&nbsp;locale,
         <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;key,
         <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;arg0,
         <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;arg1,
         <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;arg2,
         <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;arg3,
         <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;arg4)</code>
<div class="block">Get a message from resource.properties from the package of the given object.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/apache/axis2/i18n/RB.html#getString(java.lang.Object, java.lang.String)">getString</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;caller,
         <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;key)</code>
<div class="block">Get a message from resource.properties from the package of the given object.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/apache/axis2/i18n/RB.html#getString(java.lang.Object, java.lang.String, java.lang.Object)">getString</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;caller,
         <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;key,
         <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;arg0)</code>
<div class="block">Get a message from resource.properties from the package of the given object.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/apache/axis2/i18n/RB.html#getString(java.lang.Object, java.lang.String, java.lang.Object[])">getString</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;caller,
         <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;key,
         <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>[]&nbsp;args)</code>
<div class="block">Get a message from resource.properties from the package of the given object.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/apache/axis2/i18n/RB.html#getString(java.lang.Object, java.lang.String, java.lang.Object, java.lang.Object)">getString</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;caller,
         <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;key,
         <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;arg0,
         <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;arg1)</code>
<div class="block">Get a message from resource.properties from the package of the given object.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/apache/axis2/i18n/RB.html#getString(java.lang.Object, java.lang.String, java.lang.Object, java.lang.Object, java.lang.Object)">getString</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;caller,
         <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;key,
         <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;arg0,
         <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;arg1,
         <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;arg2)</code>
<div class="block">Get a message from resource.properties from the package of the given object.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/apache/axis2/i18n/RB.html#getString(java.lang.Object, java.lang.String, java.lang.Object, java.lang.Object, java.lang.Object, java.lang.Object)">getString</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;caller,
         <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;key,
         <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;arg0,
         <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;arg1,
         <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;arg2,
         <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;arg3)</code>
<div class="block">Get a message from resource.properties from the package of the given object.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/apache/axis2/i18n/RB.html#getString(java.lang.Object, java.lang.String, java.lang.Object, java.lang.Object, java.lang.Object, java.lang.Object, java.lang.Object)">getString</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;caller,
         <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;key,
         <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;arg0,
         <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;arg1,
         <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;arg2,
         <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;arg3,
         <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;arg4)</code>
<div class="block">Get a message from resource.properties from the package of the given object.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code><a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/apache/axis2/i18n/RB.html#getString(java.lang.String)">getString</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;key)</code>
<div class="block">Gets a string message from the resource bundle for the given key</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code><a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/apache/axis2/i18n/RB.html#getString(java.lang.String, java.lang.Object)">getString</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;key,
         <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;arg0)</code>
<div class="block">Gets a string message from the resource bundle for the given key.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code><a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/apache/axis2/i18n/RB.html#getString(java.lang.String, java.lang.Object[])">getString</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;key,
         <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>[]&nbsp;array)</code>
<div class="block">Gets a string message from the resource bundle for the given key.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code><a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/apache/axis2/i18n/RB.html#getString(java.lang.String, java.lang.Object, java.lang.Object)">getString</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;key,
         <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;arg0,
         <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;arg1)</code>
<div class="block">Gets a string message from the resource bundle for the given key.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code><a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/apache/axis2/i18n/RB.html#getString(java.lang.String, java.lang.Object, java.lang.Object, java.lang.Object)">getString</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;key,
         <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;arg0,
         <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;arg1,
         <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;arg2)</code>
<div class="block">Gets a string message from the resource bundle for the given key.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>protected <a href="https://docs.oracle.com/javase/7/docs/api/java/util/Properties.html?is-external=true" title="class or interface in java.util">Properties</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/apache/axis2/i18n/RB.html#loadProperties(java.lang.String, java.lang.ClassLoader)">loadProperties</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;resname,
              <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/ClassLoader.html?is-external=true" title="class or interface in java.lang">ClassLoader</a>&nbsp;loader)</code>&nbsp;</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>protected void</code></td>
<td class="colLast"><code><strong><a href="../../../../org/apache/axis2/i18n/RB.html#loadProperties(java.lang.String, java.lang.ClassLoader, java.util.Locale, java.util.Locale)">loadProperties</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;basename,
              <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/ClassLoader.html?is-external=true" title="class or interface in java.lang">ClassLoader</a>&nbsp;loader,
              <a href="https://docs.oracle.com/javase/7/docs/api/java/util/Locale.html?is-external=true" title="class or interface in java.util">Locale</a>&nbsp;locale,
              <a href="https://docs.oracle.com/javase/7/docs/api/java/util/Locale.html?is-external=true" title="class or interface in java.util">Locale</a>&nbsp;defaultLocale)</code>&nbsp;</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>protected <a href="https://docs.oracle.com/javase/7/docs/api/java/util/Properties.html?is-external=true" title="class or interface in java.util">Properties</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/apache/axis2/i18n/RB.html#loadProperties(java.lang.String, java.lang.ClassLoader, java.util.Locale, java.util.Properties)">loadProperties</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;basename,
              <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/ClassLoader.html?is-external=true" title="class or interface in java.lang">ClassLoader</a>&nbsp;loader,
              <a href="https://docs.oracle.com/javase/7/docs/api/java/util/Locale.html?is-external=true" title="class or interface in java.util">Locale</a>&nbsp;locale,
              <a href="https://docs.oracle.com/javase/7/docs/api/java/util/Properties.html?is-external=true" title="class or interface in java.util">Properties</a>&nbsp;props)</code>&nbsp;</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>protected <a href="https://docs.oracle.com/javase/7/docs/api/java/util/Properties.html?is-external=true" title="class or interface in java.util">Properties</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/apache/axis2/i18n/RB.html#merge(java.util.Properties, java.util.Properties)">merge</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/util/Properties.html?is-external=true" title="class or interface in java.util">Properties</a>&nbsp;p1,
     <a href="https://docs.oracle.com/javase/7/docs/api/java/util/Properties.html?is-external=true" title="class or interface in java.util">Properties</a>&nbsp;p2)</code>
<div class="block">Merge two Properties objects</div>
</td>
</tr>
</table>
<ul class="blockList">
<li class="blockList"><a name="methods_inherited_from_class_java.lang.Object">
<!--   -->
</a>
<h3>Methods inherited from class&nbsp;java.lang.<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a></h3>
<code><a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true#clone()" title="class or interface in java.lang">clone</a>, <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true#equals(java.lang.Object)" title="class or interface in java.lang">equals</a>, <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true#finalize()" title="class or interface in java.lang">finalize</a>, <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true#getClass()" title="class or interface in java.lang">getClass</a>, <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true#hashCode()" title="class or interface in java.lang">hashCode</a>, <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true#notify()" title="class or interface in java.lang">notify</a>, <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true#notifyAll()" title="class or interface in java.lang">notifyAll</a>, <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true#toString()" title="class or interface in java.lang">toString</a>, <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true#wait()" title="class or interface in java.lang">wait</a>, <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true#wait(long)" title="class or interface in java.lang">wait</a>, <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true#wait(long, int)" title="class or interface in java.lang">wait</a></code></li>
</ul>
</li>
</ul>
</li>
</ul>
</div>
<div class="details">
<ul class="blockList">
<li class="blockList">
<!-- ============ FIELD DETAIL =========== -->
<ul class="blockList">
<li class="blockList"><a name="field_detail">
<!--   -->
</a>
<h3>Field Detail</h3>
<a name="BASE_NAME">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>BASE_NAME</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> BASE_NAME</pre>
<dl><dt><span class="strong">See Also:</span></dt><dd><a href="../../../../constant-values.html#org.apache.axis2.i18n.RB.BASE_NAME">Constant Field Values</a></dd></dl>
</li>
</ul>
<a name="PROPERTY_EXT">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>PROPERTY_EXT</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> PROPERTY_EXT</pre>
<dl><dt><span class="strong">See Also:</span></dt><dd><a href="../../../../constant-values.html#org.apache.axis2.i18n.RB.PROPERTY_EXT">Constant Field Values</a></dd></dl>
</li>
</ul>
<a name="basePropertyFileName">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>basePropertyFileName</h4>
<pre>protected&nbsp;<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> basePropertyFileName</pre>
</li>
</ul>
<a name="resourceProperties">
<!--   -->
</a>
<ul class="blockListLast">
<li class="blockList">
<h4>resourceProperties</h4>
<pre>protected&nbsp;<a href="https://docs.oracle.com/javase/7/docs/api/java/util/Properties.html?is-external=true" title="class or interface in java.util">Properties</a> resourceProperties</pre>
</li>
</ul>
</li>
</ul>
<!-- ========= CONSTRUCTOR DETAIL ======== -->
<ul class="blockList">
<li class="blockList"><a name="constructor_detail">
<!--   -->
</a>
<h3>Constructor Detail</h3>
<a name="RB(java.lang.String)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>RB</h4>
<pre>public&nbsp;RB(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;name)
   throws <a href="https://docs.oracle.com/javase/7/docs/api/java/util/MissingResourceException.html?is-external=true" title="class or interface in java.util">MissingResourceException</a></pre>
<div class="block">Construct a new RB</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>name</code> - The name of the property file without the ".properties" extension</dd>
<dt><span class="strong">Throws:</span></dt>
<dd><code><a href="https://docs.oracle.com/javase/7/docs/api/java/util/MissingResourceException.html?is-external=true" title="class or interface in java.util">MissingResourceException</a></code></dd></dl>
</li>
</ul>
<a name="RB(java.lang.Object, java.lang.String)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>RB</h4>
<pre>public&nbsp;RB(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;caller,
  <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;name)
   throws <a href="https://docs.oracle.com/javase/7/docs/api/java/util/MissingResourceException.html?is-external=true" title="class or interface in java.util">MissingResourceException</a></pre>
<div class="block">Construct a new RB</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>caller</code> - The calling object. This is used to get the package name
               to further construct the basename as well as to get the proper ClassLoader</dd><dd><code>name</code> - The name of the property file without the ".properties" extension</dd>
<dt><span class="strong">Throws:</span></dt>
<dd><code><a href="https://docs.oracle.com/javase/7/docs/api/java/util/MissingResourceException.html?is-external=true" title="class or interface in java.util">MissingResourceException</a></code></dd></dl>
</li>
</ul>
<a name="RB(java.lang.Object, java.lang.String, java.util.Locale)">
<!--   -->
</a>
<ul class="blockListLast">
<li class="blockList">
<h4>RB</h4>
<pre>public&nbsp;RB(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;caller,
  <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;name,
  <a href="https://docs.oracle.com/javase/7/docs/api/java/util/Locale.html?is-external=true" title="class or interface in java.util">Locale</a>&nbsp;locale)
   throws <a href="https://docs.oracle.com/javase/7/docs/api/java/util/MissingResourceException.html?is-external=true" title="class or interface in java.util">MissingResourceException</a></pre>
<div class="block">Construct a new RB</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>caller</code> - The calling object. This is used to get the package name
               to further construct the basename as well as to get the proper ClassLoader</dd><dd><code>name</code> - The name of the property file without the ".properties" extension</dd><dd><code>locale</code> - The locale</dd>
<dt><span class="strong">Throws:</span></dt>
<dd><code><a href="https://docs.oracle.com/javase/7/docs/api/java/util/MissingResourceException.html?is-external=true" title="class or interface in java.util">MissingResourceException</a></code></dd></dl>
</li>
</ul>
</li>
</ul>
<!-- ============ METHOD DETAIL ========== -->
<ul class="blockList">
<li class="blockList"><a name="method_detail">
<!--   -->
</a>
<h3>Method Detail</h3>
<a name="getString(java.lang.String)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getString</h4>
<pre>public&nbsp;<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;getString(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;key)
                 throws <a href="https://docs.oracle.com/javase/7/docs/api/java/util/MissingResourceException.html?is-external=true" title="class or interface in java.util">MissingResourceException</a></pre>
<div class="block">Gets a string message from the resource bundle for the given key</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>key</code> - The resource key</dd>
<dt><span class="strong">Returns:</span></dt><dd>The message</dd>
<dt><span class="strong">Throws:</span></dt>
<dd><code><a href="https://docs.oracle.com/javase/7/docs/api/java/util/MissingResourceException.html?is-external=true" title="class or interface in java.util">MissingResourceException</a></code></dd></dl>
</li>
</ul>
<a name="getString(java.lang.String, java.lang.Object)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getString</h4>
<pre>public&nbsp;<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;getString(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;key,
               <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;arg0)
                 throws <a href="https://docs.oracle.com/javase/7/docs/api/java/util/MissingResourceException.html?is-external=true" title="class or interface in java.util">MissingResourceException</a></pre>
<div class="block"><p>Gets a string message from the resource bundle for the given key. The
 message may contain variables that will be substituted with the given
 arguments. Variables have the format:</p>
 <dir>
 This message has two variables: {0} and {1}
 </dir></div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>key</code> - The resource key</dd><dd><code>arg0</code> - The argument to place in variable {0}</dd>
<dt><span class="strong">Returns:</span></dt><dd>The message</dd>
<dt><span class="strong">Throws:</span></dt>
<dd><code><a href="https://docs.oracle.com/javase/7/docs/api/java/util/MissingResourceException.html?is-external=true" title="class or interface in java.util">MissingResourceException</a></code></dd></dl>
</li>
</ul>
<a name="getString(java.lang.String, java.lang.Object, java.lang.Object)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getString</h4>
<pre>public&nbsp;<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;getString(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;key,
               <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;arg0,
               <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;arg1)
                 throws <a href="https://docs.oracle.com/javase/7/docs/api/java/util/MissingResourceException.html?is-external=true" title="class or interface in java.util">MissingResourceException</a></pre>
<div class="block"><p>Gets a string message from the resource bundle for the given key. The
 message may contain variables that will be substituted with the given
 arguments. Variables have the format:</p>
 <dir>
 This message has two variables: {0} and {1}
 </dir></div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>key</code> - The resource key</dd><dd><code>arg0</code> - The argument to place in variable {0}</dd><dd><code>arg1</code> - The argument to place in variable {1}</dd>
<dt><span class="strong">Returns:</span></dt><dd>The message</dd>
<dt><span class="strong">Throws:</span></dt>
<dd><code><a href="https://docs.oracle.com/javase/7/docs/api/java/util/MissingResourceException.html?is-external=true" title="class or interface in java.util">MissingResourceException</a></code></dd></dl>
</li>
</ul>
<a name="getString(java.lang.String, java.lang.Object, java.lang.Object, java.lang.Object)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getString</h4>
<pre>public&nbsp;<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;getString(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;key,
               <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;arg0,
               <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;arg1,
               <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;arg2)
                 throws <a href="https://docs.oracle.com/javase/7/docs/api/java/util/MissingResourceException.html?is-external=true" title="class or interface in java.util">MissingResourceException</a></pre>
<div class="block"><p>Gets a string message from the resource bundle for the given key. The
 message may contain variables that will be substituted with the given
 arguments. Variables have the format:</p>
 <dir>
 This message has two variables: {0} and {1}
 </dir></div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>key</code> - The resource key</dd><dd><code>arg0</code> - The argument to place in variable {0}</dd><dd><code>arg1</code> - The argument to place in variable {1}</dd><dd><code>arg2</code> - The argument to place in variable {1}</dd>
<dt><span class="strong">Returns:</span></dt><dd>The message</dd>
<dt><span class="strong">Throws:</span></dt>
<dd><code><a href="https://docs.oracle.com/javase/7/docs/api/java/util/MissingResourceException.html?is-external=true" title="class or interface in java.util">MissingResourceException</a></code></dd></dl>
</li>
</ul>
<a name="getString(java.lang.String, java.lang.Object[])">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getString</h4>
<pre>public&nbsp;<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;getString(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;key,
               <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>[]&nbsp;array)
                 throws <a href="https://docs.oracle.com/javase/7/docs/api/java/util/MissingResourceException.html?is-external=true" title="class or interface in java.util">MissingResourceException</a></pre>
<div class="block"><p>Gets a string message from the resource bundle for the given key. The
 message may contain variables that will be substituted with the given
 arguments. Variables have the format:</p>
 <dir>
 This message has two variables: {0} and {1}
 </dir></div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>key</code> - The resource key</dd><dd><code>array</code> - An array of objects to place in corresponding variables</dd>
<dt><span class="strong">Returns:</span></dt><dd>The message</dd>
<dt><span class="strong">Throws:</span></dt>
<dd><code><a href="https://docs.oracle.com/javase/7/docs/api/java/util/MissingResourceException.html?is-external=true" title="class or interface in java.util">MissingResourceException</a></code></dd></dl>
</li>
</ul>
<a name="loadProperties(java.lang.String, java.lang.ClassLoader, java.util.Locale, java.util.Locale)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>loadProperties</h4>
<pre>protected&nbsp;void&nbsp;loadProperties(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;basename,
                  <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/ClassLoader.html?is-external=true" title="class or interface in java.lang">ClassLoader</a>&nbsp;loader,
                  <a href="https://docs.oracle.com/javase/7/docs/api/java/util/Locale.html?is-external=true" title="class or interface in java.util">Locale</a>&nbsp;locale,
                  <a href="https://docs.oracle.com/javase/7/docs/api/java/util/Locale.html?is-external=true" title="class or interface in java.util">Locale</a>&nbsp;defaultLocale)
                       throws <a href="https://docs.oracle.com/javase/7/docs/api/java/util/MissingResourceException.html?is-external=true" title="class or interface in java.util">MissingResourceException</a></pre>
<dl><dt><span class="strong">Throws:</span></dt>
<dd><code><a href="https://docs.oracle.com/javase/7/docs/api/java/util/MissingResourceException.html?is-external=true" title="class or interface in java.util">MissingResourceException</a></code></dd></dl>
</li>
</ul>
<a name="loadProperties(java.lang.String, java.lang.ClassLoader, java.util.Locale, java.util.Properties)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>loadProperties</h4>
<pre>protected&nbsp;<a href="https://docs.oracle.com/javase/7/docs/api/java/util/Properties.html?is-external=true" title="class or interface in java.util">Properties</a>&nbsp;loadProperties(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;basename,
                        <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/ClassLoader.html?is-external=true" title="class or interface in java.lang">ClassLoader</a>&nbsp;loader,
                        <a href="https://docs.oracle.com/javase/7/docs/api/java/util/Locale.html?is-external=true" title="class or interface in java.util">Locale</a>&nbsp;locale,
                        <a href="https://docs.oracle.com/javase/7/docs/api/java/util/Properties.html?is-external=true" title="class or interface in java.util">Properties</a>&nbsp;props)</pre>
</li>
</ul>
<a name="loadProperties(java.lang.String, java.lang.ClassLoader)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>loadProperties</h4>
<pre>protected&nbsp;<a href="https://docs.oracle.com/javase/7/docs/api/java/util/Properties.html?is-external=true" title="class or interface in java.util">Properties</a>&nbsp;loadProperties(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;resname,
                        <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/ClassLoader.html?is-external=true" title="class or interface in java.lang">ClassLoader</a>&nbsp;loader)</pre>
</li>
</ul>
<a name="merge(java.util.Properties, java.util.Properties)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>merge</h4>
<pre>protected&nbsp;<a href="https://docs.oracle.com/javase/7/docs/api/java/util/Properties.html?is-external=true" title="class or interface in java.util">Properties</a>&nbsp;merge(<a href="https://docs.oracle.com/javase/7/docs/api/java/util/Properties.html?is-external=true" title="class or interface in java.util">Properties</a>&nbsp;p1,
               <a href="https://docs.oracle.com/javase/7/docs/api/java/util/Properties.html?is-external=true" title="class or interface in java.util">Properties</a>&nbsp;p2)</pre>
<div class="block">Merge two Properties objects</div>
</li>
</ul>
<a name="getProperties()">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getProperties</h4>
<pre>public&nbsp;<a href="https://docs.oracle.com/javase/7/docs/api/java/util/Properties.html?is-external=true" title="class or interface in java.util">Properties</a>&nbsp;getProperties()</pre>
<div class="block">Get the underlying properties</div>
</li>
</ul>
<a name="getString(java.lang.Object, java.lang.String)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getString</h4>
<pre>public static&nbsp;<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;getString(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;caller,
               <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;key)
                        throws <a href="https://docs.oracle.com/javase/7/docs/api/java/util/MissingResourceException.html?is-external=true" title="class or interface in java.util">MissingResourceException</a></pre>
<div class="block">Get a message from resource.properties from the package of the given object.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>caller</code> - The calling object, used to get the package name and class loader</dd><dd><code>key</code> - The resource key</dd>
<dt><span class="strong">Returns:</span></dt><dd>The formatted message</dd>
<dt><span class="strong">Throws:</span></dt>
<dd><code><a href="https://docs.oracle.com/javase/7/docs/api/java/util/MissingResourceException.html?is-external=true" title="class or interface in java.util">MissingResourceException</a></code></dd></dl>
</li>
</ul>
<a name="getString(java.lang.Object, java.lang.String, java.lang.Object)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getString</h4>
<pre>public static&nbsp;<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;getString(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;caller,
               <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;key,
               <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;arg0)
                        throws <a href="https://docs.oracle.com/javase/7/docs/api/java/util/MissingResourceException.html?is-external=true" title="class or interface in java.util">MissingResourceException</a></pre>
<div class="block">Get a message from resource.properties from the package of the given object.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>caller</code> - The calling object, used to get the package name and class loader</dd><dd><code>key</code> - The resource key</dd><dd><code>arg0</code> - The argument to place in variable {0}</dd>
<dt><span class="strong">Returns:</span></dt><dd>The formatted message</dd>
<dt><span class="strong">Throws:</span></dt>
<dd><code><a href="https://docs.oracle.com/javase/7/docs/api/java/util/MissingResourceException.html?is-external=true" title="class or interface in java.util">MissingResourceException</a></code></dd></dl>
</li>
</ul>
<a name="getString(java.lang.Object, java.lang.String, java.lang.Object, java.lang.Object)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getString</h4>
<pre>public static&nbsp;<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;getString(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;caller,
               <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;key,
               <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;arg0,
               <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;arg1)
                        throws <a href="https://docs.oracle.com/javase/7/docs/api/java/util/MissingResourceException.html?is-external=true" title="class or interface in java.util">MissingResourceException</a></pre>
<div class="block">Get a message from resource.properties from the package of the given object.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>caller</code> - The calling object, used to get the package name and class loader</dd><dd><code>key</code> - The resource key</dd><dd><code>arg0</code> - The argument to place in variable {0}</dd><dd><code>arg1</code> - The argument to place in variable {1}</dd>
<dt><span class="strong">Returns:</span></dt><dd>The formatted message</dd>
<dt><span class="strong">Throws:</span></dt>
<dd><code><a href="https://docs.oracle.com/javase/7/docs/api/java/util/MissingResourceException.html?is-external=true" title="class or interface in java.util">MissingResourceException</a></code></dd></dl>
</li>
</ul>
<a name="getString(java.lang.Object, java.lang.String, java.lang.Object, java.lang.Object, java.lang.Object)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getString</h4>
<pre>public static&nbsp;<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;getString(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;caller,
               <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;key,
               <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;arg0,
               <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;arg1,
               <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;arg2)
                        throws <a href="https://docs.oracle.com/javase/7/docs/api/java/util/MissingResourceException.html?is-external=true" title="class or interface in java.util">MissingResourceException</a></pre>
<div class="block">Get a message from resource.properties from the package of the given object.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>caller</code> - The calling object, used to get the package name and class loader</dd><dd><code>key</code> - The resource key</dd><dd><code>arg0</code> - The argument to place in variable {0}</dd><dd><code>arg1</code> - The argument to place in variable {1}</dd><dd><code>arg2</code> - The argument to place in variable {2}</dd>
<dt><span class="strong">Returns:</span></dt><dd>The formatted message</dd>
<dt><span class="strong">Throws:</span></dt>
<dd><code><a href="https://docs.oracle.com/javase/7/docs/api/java/util/MissingResourceException.html?is-external=true" title="class or interface in java.util">MissingResourceException</a></code></dd></dl>
</li>
</ul>
<a name="getString(java.lang.Object, java.lang.String, java.lang.Object, java.lang.Object, java.lang.Object, java.lang.Object)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getString</h4>
<pre>public static&nbsp;<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;getString(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;caller,
               <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;key,
               <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;arg0,
               <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;arg1,
               <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;arg2,
               <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;arg3)
                        throws <a href="https://docs.oracle.com/javase/7/docs/api/java/util/MissingResourceException.html?is-external=true" title="class or interface in java.util">MissingResourceException</a></pre>
<div class="block">Get a message from resource.properties from the package of the given object.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>caller</code> - The calling object, used to get the package name and class loader</dd><dd><code>key</code> - The resource key</dd><dd><code>arg0</code> - The argument to place in variable {0}</dd><dd><code>arg1</code> - The argument to place in variable {1}</dd><dd><code>arg2</code> - The argument to place in variable {2}</dd><dd><code>arg3</code> - The argument to place in variable {3}</dd>
<dt><span class="strong">Returns:</span></dt><dd>The formatted message</dd>
<dt><span class="strong">Throws:</span></dt>
<dd><code><a href="https://docs.oracle.com/javase/7/docs/api/java/util/MissingResourceException.html?is-external=true" title="class or interface in java.util">MissingResourceException</a></code></dd></dl>
</li>
</ul>
<a name="getString(java.lang.Object, java.lang.String, java.lang.Object, java.lang.Object, java.lang.Object, java.lang.Object, java.lang.Object)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getString</h4>
<pre>public static&nbsp;<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;getString(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;caller,
               <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;key,
               <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;arg0,
               <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;arg1,
               <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;arg2,
               <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;arg3,
               <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;arg4)
                        throws <a href="https://docs.oracle.com/javase/7/docs/api/java/util/MissingResourceException.html?is-external=true" title="class or interface in java.util">MissingResourceException</a></pre>
<div class="block">Get a message from resource.properties from the package of the given object.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>caller</code> - The calling object, used to get the package name and class loader</dd><dd><code>key</code> - The resource key</dd><dd><code>arg0</code> - The argument to place in variable {0}</dd><dd><code>arg1</code> - The argument to place in variable {1}</dd><dd><code>arg2</code> - The argument to place in variable {2}</dd><dd><code>arg3</code> - The argument to place in variable {3}</dd><dd><code>arg4</code> - The argument to place in variable {4}</dd>
<dt><span class="strong">Returns:</span></dt><dd>Returns the formatted message.</dd>
<dt><span class="strong">Throws:</span></dt>
<dd><code><a href="https://docs.oracle.com/javase/7/docs/api/java/util/MissingResourceException.html?is-external=true" title="class or interface in java.util">MissingResourceException</a></code></dd></dl>
</li>
</ul>
<a name="getString(java.lang.Object, java.lang.String, java.lang.Object[])">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getString</h4>
<pre>public static&nbsp;<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;getString(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;caller,
               <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;key,
               <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>[]&nbsp;args)
                        throws <a href="https://docs.oracle.com/javase/7/docs/api/java/util/MissingResourceException.html?is-external=true" title="class or interface in java.util">MissingResourceException</a></pre>
<div class="block">Get a message from resource.properties from the package of the given object.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>caller</code> - The calling object, used to get the package name and class loader</dd><dd><code>key</code> - The resource key</dd><dd><code>args</code> - An array of objects to place in corresponding variables</dd>
<dt><span class="strong">Returns:</span></dt><dd>Returns the formatted message.</dd>
<dt><span class="strong">Throws:</span></dt>
<dd><code><a href="https://docs.oracle.com/javase/7/docs/api/java/util/MissingResourceException.html?is-external=true" title="class or interface in java.util">MissingResourceException</a></code></dd></dl>
</li>
</ul>
<a name="getString(java.lang.Object, java.util.Locale, java.lang.String)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getString</h4>
<pre>public static&nbsp;<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;getString(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;caller,
               <a href="https://docs.oracle.com/javase/7/docs/api/java/util/Locale.html?is-external=true" title="class or interface in java.util">Locale</a>&nbsp;locale,
               <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;key)
                        throws <a href="https://docs.oracle.com/javase/7/docs/api/java/util/MissingResourceException.html?is-external=true" title="class or interface in java.util">MissingResourceException</a></pre>
<div class="block">Get a message from resource.properties from the package of the given object.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>caller</code> - The calling object, used to get the package name and class loader</dd><dd><code>locale</code> - The locale</dd><dd><code>key</code> - The resource key</dd>
<dt><span class="strong">Returns:</span></dt><dd>The formatted message</dd>
<dt><span class="strong">Throws:</span></dt>
<dd><code><a href="https://docs.oracle.com/javase/7/docs/api/java/util/MissingResourceException.html?is-external=true" title="class or interface in java.util">MissingResourceException</a></code></dd></dl>
</li>
</ul>
<a name="getString(java.lang.Object, java.util.Locale, java.lang.String, java.lang.Object)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getString</h4>
<pre>public static&nbsp;<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;getString(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;caller,
               <a href="https://docs.oracle.com/javase/7/docs/api/java/util/Locale.html?is-external=true" title="class or interface in java.util">Locale</a>&nbsp;locale,
               <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;key,
               <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;arg0)
                        throws <a href="https://docs.oracle.com/javase/7/docs/api/java/util/MissingResourceException.html?is-external=true" title="class or interface in java.util">MissingResourceException</a></pre>
<div class="block">Get a message from resource.properties from the package of the given object.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>caller</code> - The calling object, used to get the package name and class loader</dd><dd><code>locale</code> - The locale</dd><dd><code>key</code> - The resource key</dd><dd><code>arg0</code> - The argument to place in variable {0}</dd>
<dt><span class="strong">Returns:</span></dt><dd>The formatted message</dd>
<dt><span class="strong">Throws:</span></dt>
<dd><code><a href="https://docs.oracle.com/javase/7/docs/api/java/util/MissingResourceException.html?is-external=true" title="class or interface in java.util">MissingResourceException</a></code></dd></dl>
</li>
</ul>
<a name="getString(java.lang.Object, java.util.Locale, java.lang.String, java.lang.Object, java.lang.Object)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getString</h4>
<pre>public static&nbsp;<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;getString(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;caller,
               <a href="https://docs.oracle.com/javase/7/docs/api/java/util/Locale.html?is-external=true" title="class or interface in java.util">Locale</a>&nbsp;locale,
               <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;key,
               <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;arg0,
               <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;arg1)
                        throws <a href="https://docs.oracle.com/javase/7/docs/api/java/util/MissingResourceException.html?is-external=true" title="class or interface in java.util">MissingResourceException</a></pre>
<div class="block">Get a message from resource.properties from the package of the given object.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>caller</code> - The calling object, used to get the package name and class loader</dd><dd><code>locale</code> - The locale</dd><dd><code>key</code> - The resource key</dd><dd><code>arg0</code> - The argument to place in variable {0}</dd><dd><code>arg1</code> - The argument to place in variable {1}</dd>
<dt><span class="strong">Returns:</span></dt><dd>The formatted message</dd>
<dt><span class="strong">Throws:</span></dt>
<dd><code><a href="https://docs.oracle.com/javase/7/docs/api/java/util/MissingResourceException.html?is-external=true" title="class or interface in java.util">MissingResourceException</a></code></dd></dl>
</li>
</ul>
<a name="getString(java.lang.Object, java.util.Locale, java.lang.String, java.lang.Object, java.lang.Object, java.lang.Object)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getString</h4>
<pre>public static&nbsp;<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;getString(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;caller,
               <a href="https://docs.oracle.com/javase/7/docs/api/java/util/Locale.html?is-external=true" title="class or interface in java.util">Locale</a>&nbsp;locale,
               <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;key,
               <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;arg0,
               <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;arg1,
               <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;arg2)
                        throws <a href="https://docs.oracle.com/javase/7/docs/api/java/util/MissingResourceException.html?is-external=true" title="class or interface in java.util">MissingResourceException</a></pre>
<div class="block">Get a message from resource.properties from the package of the given object.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>caller</code> - The calling object, used to get the package name and class loader</dd><dd><code>locale</code> - The locale</dd><dd><code>key</code> - The resource key</dd><dd><code>arg0</code> - The argument to place in variable {0}</dd><dd><code>arg1</code> - The argument to place in variable {1}</dd><dd><code>arg2</code> - The argument to place in variable {2}</dd>
<dt><span class="strong">Returns:</span></dt><dd>The formatted message</dd>
<dt><span class="strong">Throws:</span></dt>
<dd><code><a href="https://docs.oracle.com/javase/7/docs/api/java/util/MissingResourceException.html?is-external=true" title="class or interface in java.util">MissingResourceException</a></code></dd></dl>
</li>
</ul>
<a name="getString(java.lang.Object, java.util.Locale, java.lang.String, java.lang.Object, java.lang.Object, java.lang.Object, java.lang.Object)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getString</h4>
<pre>public static&nbsp;<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;getString(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;caller,
               <a href="https://docs.oracle.com/javase/7/docs/api/java/util/Locale.html?is-external=true" title="class or interface in java.util">Locale</a>&nbsp;locale,
               <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;key,
               <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;arg0,
               <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;arg1,
               <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;arg2,
               <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;arg3)
                        throws <a href="https://docs.oracle.com/javase/7/docs/api/java/util/MissingResourceException.html?is-external=true" title="class or interface in java.util">MissingResourceException</a></pre>
<div class="block">Get a message from resource.properties from the package of the given object.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>caller</code> - The calling object, used to get the package name and class loader</dd><dd><code>locale</code> - The locale</dd><dd><code>key</code> - The resource key</dd><dd><code>arg0</code> - The argument to place in variable {0}</dd><dd><code>arg1</code> - The argument to place in variable {1}</dd><dd><code>arg2</code> - The argument to place in variable {2}</dd><dd><code>arg3</code> - The argument to place in variable {3}</dd>
<dt><span class="strong">Returns:</span></dt><dd>The formatted message</dd>
<dt><span class="strong">Throws:</span></dt>
<dd><code><a href="https://docs.oracle.com/javase/7/docs/api/java/util/MissingResourceException.html?is-external=true" title="class or interface in java.util">MissingResourceException</a></code></dd></dl>
</li>
</ul>
<a name="getString(java.lang.Object, java.util.Locale, java.lang.String, java.lang.Object, java.lang.Object, java.lang.Object, java.lang.Object, java.lang.Object)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getString</h4>
<pre>public static&nbsp;<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;getString(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;caller,
               <a href="https://docs.oracle.com/javase/7/docs/api/java/util/Locale.html?is-external=true" title="class or interface in java.util">Locale</a>&nbsp;locale,
               <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;key,
               <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;arg0,
               <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;arg1,
               <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;arg2,
               <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;arg3,
               <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;arg4)
                        throws <a href="https://docs.oracle.com/javase/7/docs/api/java/util/MissingResourceException.html?is-external=true" title="class or interface in java.util">MissingResourceException</a></pre>
<div class="block">Get a message from resource.properties from the package of the given object.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>caller</code> - The calling object, used to get the package name and class loader</dd><dd><code>locale</code> - The locale</dd><dd><code>key</code> - The resource key</dd><dd><code>arg0</code> - The argument to place in variable {0}</dd><dd><code>arg1</code> - The argument to place in variable {1}</dd><dd><code>arg2</code> - The argument to place in variable {2}</dd><dd><code>arg3</code> - The argument to place in variable {3}</dd>
<dt><span class="strong">Returns:</span></dt><dd>Returns the formatted message.</dd>
<dt><span class="strong">Throws:</span></dt>
<dd><code><a href="https://docs.oracle.com/javase/7/docs/api/java/util/MissingResourceException.html?is-external=true" title="class or interface in java.util">MissingResourceException</a></code></dd></dl>
</li>
</ul>
<a name="getString(java.lang.Object, java.util.Locale, java.lang.String, java.lang.Object[])">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getString</h4>
<pre>public static&nbsp;<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;getString(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;caller,
               <a href="https://docs.oracle.com/javase/7/docs/api/java/util/Locale.html?is-external=true" title="class or interface in java.util">Locale</a>&nbsp;locale,
               <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;key,
               <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>[]&nbsp;args)
                        throws <a href="https://docs.oracle.com/javase/7/docs/api/java/util/MissingResourceException.html?is-external=true" title="class or interface in java.util">MissingResourceException</a></pre>
<div class="block">Get a message from resource.properties from the package of the given object.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>caller</code> - The calling object, used to get the package name and class loader</dd><dd><code>locale</code> - The locale</dd><dd><code>key</code> - The resource key</dd><dd><code>args</code> - An array of objects to place in corresponding variables</dd>
<dt><span class="strong">Returns:</span></dt><dd>Returns the formatted message.</dd>
<dt><span class="strong">Throws:</span></dt>
<dd><code><a href="https://docs.oracle.com/javase/7/docs/api/java/util/MissingResourceException.html?is-external=true" title="class or interface in java.util">MissingResourceException</a></code></dd></dl>
</li>
</ul>
<a name="getMessage(java.lang.Object, java.lang.String, java.util.Locale, java.lang.String, java.lang.Object[])">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getMessage</h4>
<pre>public static&nbsp;<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;getMessage(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;caller,
                <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;basename,
                <a href="https://docs.oracle.com/javase/7/docs/api/java/util/Locale.html?is-external=true" title="class or interface in java.util">Locale</a>&nbsp;locale,
                <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;key,
                <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>[]&nbsp;args)
                         throws <a href="https://docs.oracle.com/javase/7/docs/api/java/util/MissingResourceException.html?is-external=true" title="class or interface in java.util">MissingResourceException</a></pre>
<dl><dt><span class="strong">Throws:</span></dt>
<dd><code><a href="https://docs.oracle.com/javase/7/docs/api/java/util/MissingResourceException.html?is-external=true" title="class or interface in java.util">MissingResourceException</a></code></dd></dl>
</li>
</ul>
<a name="clearCache()">
<!--   -->
</a>
<ul class="blockListLast">
<li class="blockList">
<h4>clearCache</h4>
<pre>public static&nbsp;void&nbsp;clearCache()</pre>
<div class="block">Clears the internal cache.</div>
</li>
</ul>
</li>
</ul>
</li>
</ul>
</div>
</div>
<!-- ========= END OF CLASS DATA ========= -->
<!-- ======= START OF BOTTOM NAVBAR ====== -->
<div class="bottomNav"><a name="navbar_bottom">
<!--   -->
</a><a href="#skip-navbar_bottom" title="Skip navigation links"></a><a name="navbar_bottom_firstrow">
<!--   -->
</a>
<ul class="navList" title="Navigation">
<li><a href="../../../../overview-summary.html">Overview</a></li>
<li><a href="package-summary.html">Package</a></li>
<li class="navBarCell1Rev">Class</li>
<li><a href="class-use/RB.html">Use</a></li>
<li><a href="package-tree.html">Tree</a></li>
<li><a href="../../../../deprecated-list.html">Deprecated</a></li>
<li><a href="../../../../index-all.html">Index</a></li>
<li><a href="../../../../help-doc.html">Help</a></li>
</ul>
</div>
<div class="subNav">
<ul class="navList">
<li><a href="../../../../org/apache/axis2/i18n/ProjectResourceBundle.html" title="class in org.apache.axis2.i18n"><span class="strong">Prev Class</span></a></li>
<li>Next Class</li>
</ul>
<ul class="navList">
<li><a href="../../../../index.html?org/apache/axis2/i18n/RB.html" target="_top">Frames</a></li>
<li><a href="RB.html" target="_top">No Frames</a></li>
</ul>
<ul class="navList" id="allclasses_navbar_bottom">
<li><a href="../../../../allclasses-noframe.html">All Classes</a></li>
</ul>
<div>
<script type="text/javascript"><!--
  allClassesLink = document.getElementById("allclasses_navbar_bottom");
  if(window==top) {
    allClassesLink.style.display = "block";
  }
  else {
    allClassesLink.style.display = "none";
  }
  //-->
</script>
</div>
<div>
<ul class="subNavList">
<li>Summary:&nbsp;</li>
<li>Nested&nbsp;|&nbsp;</li>
<li><a href="#field_summary">Field</a>&nbsp;|&nbsp;</li>
<li><a href="#constructor_summary">Constr</a>&nbsp;|&nbsp;</li>
<li><a href="#method_summary">Method</a></li>
</ul>
<ul class="subNavList">
<li>Detail:&nbsp;</li>
<li><a href="#field_detail">Field</a>&nbsp;|&nbsp;</li>
<li><a href="#constructor_detail">Constr</a>&nbsp;|&nbsp;</li>
<li><a href="#method_detail">Method</a></li>
</ul>
</div>
<a name="skip-navbar_bottom">
<!--   -->
</a></div>
<!-- ======== END OF BOTTOM NAVBAR ======= -->
<p class="legalCopy"><small>Copyright &copy; <a href="https://www.apache.org/">The Apache Software Foundation</a>. All Rights Reserved.</small></p>
</body>
</html>