/*
   XBN Java:  Generically useful, non-GUI Java code.
   http://sourceforge.net/projects/xbnjava

   Copyright (C) 1997-2003, Jeff Epstein
   All rights reserved.

   Modifications: No

   Redistribution in binary form, with or without modifications, are permitted provided that the following conditions are met:

      * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
      * If modifications are made to source code then this license should indicate that fact in the "Modifications" section above.
      * Neither the author, nor the contributors may be used to endorse or promote products derived from this software without specific prior written permission.

   THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

   [NOTE:  This license contains NO advertising clause.]
 */
package xbn.string;
   import xbn.placeholder.i_i;

/**
   <P>Random functions for java.lang.StringBuffers.  See <A HREF="~JD~sb~EJD~">StringBuffer</A>.</P>

   <P><CODE><I><B>Source code:</B> &nbsp;<A HREF="../../../CODE/xbn/string/UtilStringBuffer.java">UtilStringBuffer.java</A>. &nbsp;<B>Unit tests:</B> &nbsp;See the unit tests for <A HREF="~JD~utilsob~EJD~">UtilSOB</A>.</I></CODE></P>

   @version  0.9b
   @author  Jeff Epstein, <A HREF="http://sourceforge.net/projects/xbnjava">http://sourceforge.net/projects/xbnjava</A>.
 **/
public class UtilStringBuffer extends UtilSOB  {
   /**
      <P>To shorten code and Javadoc.</P>

      <P>Equal to <B>"xbn.string.UtilStringBuffer."</B></P>
    **/
   public static final String sUSB = "xbn.string.UtilStringBuffer.";
   /**
      <P>Create a UtilStringBuffer.  This constructor does nothing.</P>
    **/
   public UtilStringBuffer()  {
   }

   private static final String sGQL = "getQuotedLines";

   /**
      <P>Get a copy of the StringBuffer where each line is quoted.</P>

      @return  <CODE>((<A HREF="~JD~ssb~EJD~">SOBStringBuffer</A>)<A HREF="~JD~utilsob#getQuotedLines(sob)~EJD~">getQuotedLines</A>(<A HREF="~JD~getSOBSB(sb,s)~EJD~">getSOBSB</A>(str_buffer, <A HREF="#sUSB">sUSB</A> + "getQuotedLines"))).<A HREF="~JD~ssb~EJD~#getStringBuffer()">getStringBuffer</A>()</CODE>
    **/
   public final StringBuffer getQuotedLines(StringBuffer str_buffer)  {
      return ((SOBStringBuffer)getQuotedLines(getSOBSB(str_buffer, sUSB + sGQL))).getStringBuffer();
   }

   /**
      <P>Get a copy of the StringBuffer where each line is quoted.</P>

      @return  <CODE>((<A HREF="~JD~ssb~EJD~">SOBStringBuffer</A>)<A HREF="~JD~utilsob#getQuotedLines(sob,s)~EJD~">getQuotedLines</A>(<A HREF="~JD~getSOBSB(sb,s)~EJD~">getSOBSB</A>(str_buffer, <A HREF="#sUSB">sUSB</A> + "getQuotedLines"), s_quote)).<A HREF="~JD~ssb~EJD~#getStringBuffer()">getStringBuffer</A>()</CODE>
    **/
   public final StringBuffer getQuotedLines(StringBuffer str_buffer, String s_quote)  {
      return ((SOBStringBuffer)getQuotedLines(getSOBSB(str_buffer, sUSB + sGQL), s_quote)).getStringBuffer();
   }

   /**
      <P>Get a copy of the StringBuffer where each line is quoted.</P>

      @return  <CODE>((<A HREF="~JD~ssb~EJD~">SOBStringBuffer</A>)<A HREF="~JD~utilsob#getQuotedLines(sob,s,s)~EJD~">getQuotedLines</A>(<A HREF="~JD~getSOBSB(sb,s)~EJD~">getSOBSB</A>(str_buffer, <A HREF="#sUSB">sUSB</A> + "getQuotedLines"), s_quoteStart, s_quoteEnd)).<A HREF="~JD~ssb~EJD~#getStringBuffer()">getStringBuffer</A>()</CODE>
    **/
   public final StringBuffer getQuotedLines(StringBuffer str_buffer, String s_quoteStart, String s_quoteEnd)  {
      return ((SOBStringBuffer)getQuotedLines(getSOBSB(str_buffer, sUSB + sGQL), s_quoteStart, s_quoteEnd)).getStringBuffer();
   }


   /**
      <P>Get a copy of the StringBuffer (as a StringBuffer) where each line is quoted.</P>

      @return  <CODE>((<A HREF="~JD~ssb~EJD~">SOBStringBuffer</A>)<A HREF="~JD~utilsob#getQuotedLines(sob,s,s)~EJD~">getQuotedLines</A>(<A HREF="~JD~getSOBSB(sb,s)~EJD~">getSOBSB</A>(str_buffer, <A HREF="#sUSB">sUSB</A> + "getQuotedLines"), s_quoteStart, s_quoteEnd, s_lineSep)).<A HREF="~JD~ssb~EJD~#getStringBuffer()">getStringBuffer</A>()</CODE>
    **/
   public final StringBuffer getQuotedLines(StringBuffer str_buffer, String s_quoteStart, String s_quoteEnd, String s_lineSep)  {
      return ((SOBStringBuffer)getQuotedLines(getSOBSB(str_buffer, sUSB + sGQL), s_quoteStart, s_quoteEnd, s_lineSep)).getStringBuffer();
   }

   private static final String sQL = "quoteLines";

   /**
      <P>Quote each line within a StringBuffer.</P>

      <P>Equal to <CODE><A HREF="~JD~utilsob#quoteLines(sob,s)~EJD~">quoteLines</A>(str_buffer, <A HREF="#sUSB">sUSB</A> + "'")</CODE></P>
    **/
   public final void quoteLines(StringBuffer str_buffer)  {
      quoteLines(getSOBSB(str_buffer, sUSB + sQL));
   }

   /**
      <P>Quote each line within a StringBuffer.</P>

      <P>Equal to <CODE><A HREF="~JD~utilsob#quoteLines(sob,s)~EJD~">quoteLines</A>(<A HREF="~JD~getSOBSB(sb,s)~EJD~">getSOBSB</A>(str_buffer, <A HREF="#sUSB">sUSB</A> + "quoteLines"), s_quote)</CODE></P>
    **/
   public final void quoteLines(StringBuffer str_buffer, String s_quote)  {
      quoteLines(getSOBSB(str_buffer, sUSB + sQL), s_quote);
   }

   /**
      <P>Quote each line within a StringBuffer.</P>

      <P>Equal to <CODE><A HREF="~JD~utilsob#quoteLines(sob,s,s)~EJD~">quoteLines</A>(str_buffer, s_quoteStart, s_quoteEnd)</CODE></P>
    **/
   public final void quoteLines(StringBuffer str_buffer, String s_quoteStart, String s_quoteEnd)  {
      quoteLines(getSOBSB(str_buffer, sUSB + sQL), s_quoteStart, s_quoteEnd);
   }

   /**
      <P>Quote each line within a StringBuffer.</P>

    **/
   public final void quoteLines(StringBuffer str_buffer, String s_quoteStart, String s_quoteEnd, String s_lineSep)  {
      quoteLines(getSOBSB(str_buffer, sUSB + sQL), s_quoteStart, s_quoteEnd, s_lineSep);
   }



   /**
      <P>Return a copy of the provided StringBuffer, in which all occurances are replaced.</P>

      @return  <CODE><A HREF="~JD~utilsob#getReplaceAll(sob,s,s)~EJD~">getReplaceAll</A>(getSOBSB(str_buffer, <a href="#sUSB">sUSB</a> + "getReplaceAll"), s_replaceWhat, s_replaceWith).<A HREF="~JD~ssb~EJD~#getStringBuffer()">getStringBuffer</A>()</CODE>
    **/
   public final StringBuffer getReplaceAll(StringBuffer str_buffer, String s_replaceWhat, String s_replaceWith)  {
      return getReplaceAll(getSOBSB(str_buffer, sUSB + "getReplaceAll"), s_replaceWhat, s_replaceWith).getStringBuffer();
   }

   /**
      <P>Replace all occurances.</P>

      @return <CODE><A HREF="~JD~utilsob#replaceAll(sob,s,s)~EJD~">replaceAll</A>(<A HREF="~JD~getSOBSB(sb,s)~EJD~">getSOBSB</A>(str_buffer, <a href="#sUSB">sUSB</a> + "replaceAll"), s_replaceWhat, s_replaceWith)</CODE>
    **/
   public final int replaceAll(StringBuffer str_buffer, String s_replaceWhat, String s_replaceWith)  {
      return replaceAll(getSOBSB(str_buffer, sUSB + "replaceAll"), s_replaceWhat, s_replaceWith);
   }


   /**
      <P>Replace all occurances, with multiple passes, until no instances of the search string remain.</P>

      @return <CODE><A HREF="~JD~utilsob#getReplaceUntil(sob,s,s)~EJD~">getReplaceUntil</A>(<A HREF="~JD~getSOBSB(sb,s)~EJD~">getSOBSB</A>(str_buffer, <a href="#sUSB">sUSB</a> + "getReplaceUntil"), s_replaceWhat, s_replaceWith)</CODE>
    **/
   public final StringBuffer getReplaceUntil(StringBuffer str_buffer, String s_replaceWhat, String s_replaceWith)  {
      return getReplaceUntil(getSOBSB(str_buffer, sUSB + "replaceUntil"), s_replaceWhat, s_replaceWith).getStringBuffer();
   }

   /**
      <P>Replace all occurances, with multiple passes, until no instances of the search string remain.</P>

      @return <CODE><A HREF="~JD~utilsob#replaceUntil(sob,s,s)~EJD~">replaceUntil</A>(<A HREF="~JD~getSOBSB(sb,s)~EJD~">getSOBSB</A>(str_buffer, <a href="#sUSB">sUSB</a> + "replaceUntil"), s_replaceWhat, s_replaceWith)</CODE>
    **/
   public final i_i replaceUntil(StringBuffer str_buffer, String s_replaceWhat, String s_replaceWith)  {
      return replaceUntil(getSOBSB(str_buffer, sUSB + "replaceUntil"), s_replaceWhat, s_replaceWith);
   }

   /**
      <P>Is the value of the StringBuffer a valid hexidecimal number?</P>

      @return  <CODE><A HREF="~JD~utilsob#isHexidecimal(sob)~EJD~">isHexidecimal</A>(<A HREF="~JD~getSOBSB(sb,s)~EJD~">getSOBSB</A>(sb_potentialHex, "sb_potentialHex", "isHexidecimal"))</CODE>
    **/
   public boolean isHexidecimal(StringBuffer sb_potentialHex)  {
      return isHexidecimal(getSOBSB(sb_potentialHex, "sb_potentialHex", "isHexidecimal"));
   }

   /**
      <P>Does the StringBuffer contain only tabs and spaces?</P>

      @param  sb_potentialTabSpace  The StringBuffer analyzed, to see if it contains only tabs and spaces characters.  May not be null or zero characters in length.
      @return  <CODE><A HREF="~JD~utilsob#isTabSpace(sob)~EJD~">isTabSpace</A>(<A HREF="~JD~getSOBSB(sb,s)~EJD~">getSOBSB</A>(sb_potentialTabSpace, "sb_potentialTabSpace", "isTabSpace"))</CODE>
    **/
   public boolean isTabSpace(StringBuffer sb_potentialTabSpace)  {
      return isTabSpace(getSOBSB(sb_potentialTabSpace, "sb_potentialTabSpace", "isTabSpace"));
   }

   /**
      <P>Does the StringBuffer <I>not</I> contain any tabs and space characters?</P>

      @param  str_buffer  The StringBuffer analyzed, to see if it contains only non-tabs and non-space characters.  May not be null or zero characters in length.
      @return  <CODE><A HREF="~JD~utilsob#hasNoTabSpace(sob)~EJD~">hasNoTabSpace</A>(<A HREF="~JD~getSOBSB(sb,s)~EJD~">getSOBSB</A>(str_buffer, <A HREF="#sUSB">sUSB</A> + "hasNoTabSpace"))</CODE>
    **/
   public boolean hasNoTabSpace(StringBuffer str_buffer)  {
      return hasNoTabSpace(getSOBSB(str_buffer, sUSB + "hasNoTabSpace"));
   }

   /**
      <P>Append a duplicated string onto the StringBuffer.</P>

      <P>Equal to  <CODE><A HREF="~JD~utilsob#dupAppend(sob,s,i)~EJD~">dupAppend</A>(<A HREF="~JD~getSOBSB(sb,s)~EJD~">getSOBSB</A>(str_buffer, <A HREF="#sUSB">sUSB</A> + "dupAppend"), s_toDuplicate, i_dupCount)</CODE></P>
    **/
   public final void dupAppend(StringBuffer str_buffer, String s_toDuplicate, int i_dupCount)  {
      dupAppend(getSOBSB(str_buffer, sUSB + "dupAppend"), s_toDuplicate, i_dupCount);
   }


   /**
      <P>Get a copy of the StringBuffer, after appending a duplicated string onto it.</P>

      @return  <CODE>((<A HREF="~JD~ssb~EJD~">SOBStringBuffer</A>)<A HREF="~JD~utilsob#dupAppend(sob,s,i)~EJD~">dupAppend</A>(<A HREF="~JD~getSOBSB(sb,s)~EJD~">getSOBSB</A>(str_buffer, <A HREF="#sUSB">sUSB</A> + "getDupAppend"), s_toDuplicate, i_dupCount)).<A HREF="~JD~ssb~EJD~#getStringBuffer()">getStringBuffer</A>()</CODE>
    **/
   public final StringBuffer getDupAppend(StringBuffer str_buffer, String s_toDuplicate, int i_dupCount)  {
      return ((SOBStringBuffer)getDupAppend(getSOBSB(str_buffer, sUSB + "getDupAppend"), s_toDuplicate, i_dupCount)).getStringBuffer();
   }



   /**
      <P>Get the array index of the first non-white-space character.</P>

      @return  <CODE><A HREF="~JD~utilsob#getIdxOf1stNonWS(sob)~EJD~">getIdxOf1stNonWS</A>(<A HREF="~JD~getSOBSB(sb,s)~EJD~">getSOBSB</A>(str_buffer, <A HREF="#sUSB">sUSB</A> + "getIdxOf1stNonWS"))</CODE>
    **/
   public final int getIdxOf1stNonWS(StringBuffer str_buffer)  {
      return getIdxOf1stNonWS(getSOBSB(str_buffer, sUSB + "getIdxOf1stNonWS"));
   }

   /**
      <P>Get the array index of the last non-white-space character.</P>

      @return  <CODE><A HREF="~JD~utilsob#getIdxOfLastNonWS(sob)~EJD~">getIdxOfLastNonWS</A>(<A HREF="~JD~getSOBSB(sb,s)~EJD~">getSOBSB</A>(str_buffer, <A HREF="#sUSB">sUSB</A> + "getIdxOfLastNonWS"))</CODE>
    **/
   public final int getIdxOfLastNonWS(StringBuffer str_buffer)  {
      return getIdxOfLastNonWS(getSOBSB(str_buffer, sUSB + "getIdxOfLastNonWS"));
   }

   private static final String sGIO1CNIA = "getIdxOf1stCharNIA";

   /**
      <P>Get the array index of the first character that is not a member of the array.</P>

      @return  <CODE><A HREF="~JD~utilsob#getIdxOf1stCharNIA(sob,c[])~EJD~">getIdxOf1stCharNIA</A>(<A HREF="~JD~getSOBSB(sb,s)~EJD~">getSOBSB</A>(str_buffer, <A HREF="#sUSB">sUSB</A> + "getIdxOf1stCharNIA"), a_char)</CODE>
    **/
   public final int getIdxOf1stCharNIA(StringBuffer str_buffer, char[] a_char)  {
      return getIdxOf1stCharNIA(getSOBSB(str_buffer, sUSB + sGIO1CNIA), a_char);
   }

   /**
      <P>Get the array index of the first character that is not a member of the array.</P>

      @return  <CODE><A HREF="~JD~utilsob#getIdxOf1stCharNIA(sob,c[],i,i,b)~EJD~">getIdxOf1stCharNIA</A>(<A HREF="~JD~getSOBSB(sb,s)~EJD~">getSOBSB</A>(str_buffer, <A HREF="#sUSB">sUSB</A> + "getIdxOf1stCharNIA"), a_char, 0, <A HREF="~JD~sob~EJD~#length()">str_buffer</A>.<A HREF="~JD~sb~EJD~#length()">length</A>(), b_validateAOC)</CODE>
    **/
   public final int getIdxOf1stCharNIA(StringBuffer str_buffer, char[] a_char, boolean b_validateAOC)  {
      try  {
         return getIdxOf1stCharNIA(getSOBSB(str_buffer, sUSB + sGIO1CNIA), a_char, 0, str_buffer.length(), b_validateAOC);
      }  catch(NullPointerException npx)  {
         throwAX("getIdxOf1stCharNIA:  str_buffer is null.");
      }

      //Never reached.  Required for compile.
      return -1;
   }

   /**
      <P>Get the array index of the first character that is not a member of the array.</P>

      @return  <CODE><A HREF="~JD~utilsob#getIdxOf1stCharNIA(sob,c[],i,i)~EJD~">getIdxOf1stCharNIA</A>(<A HREF="~JD~getSOBSB(sb,s)~EJD~">getSOBSB</A>(str_buffer, <A HREF="#sUSB">sUSB</A> + "getIdxOf1stCharNIA"), a_char, i_idxStart, i_idxAfterEnd)</CODE>
    **/
   public final int getIdxOf1stCharNIA(StringBuffer str_buffer, char[] a_char, int i_idxStart, int i_idxAfterEnd)  {
      return getIdxOf1stCharNIA(getSOBSB(str_buffer, sUSB + sGIO1CNIA), a_char, i_idxStart, i_idxAfterEnd);
   }

   /**
      <P>Get the array index of the first character that does not exist in the array.</P>

      @return  <CODE><A HREF="~JD~utilsob#getIdxOf1stCharNIA(sob,c[],i,i,b)~EJD~">getIdxOf1stCharNIA</A>(<A HREF="~JD~getSOBSB(sb,s)~EJD~">getSOBSB</A>(str_buffer, <A HREF="#sUSB">sUSB</A> + "getIdxOf1stCharNIA"), a_char, i_idxStart, i_idxAfterEnd, b_validateAOC)</CODE>
    **/
   public final int getIdxOf1stCharNIA(StringBuffer str_buffer, char[] a_char, int i_idxStart, int i_idxAfterEnd, boolean b_validateAOC)  {
      return getIdxOf1stCharNIA(getSOBSB(str_buffer, sUSB + sGIO1CNIA), a_char, i_idxStart, i_idxAfterEnd, b_validateAOC);
   }

   private static final String sGIOLCNIA = "getIdxOfLastCharNIA";


   /**
      <P>Get the array index of the last character that is not a member of the array.</P>

      @return  <CODE><A HREF="~JD~utilsob#getIdxOfLastCharNIA(sob,c[])~EJD~">getIdxOfLastCharNIA</A>(<A HREF="~JD~getSOBSB(sb,s)~EJD~">getSOBSB</A>(str_buffer, <A HREF="#sUSB">sUSB</A> + "getIdxOfLastCharNIA"), a_char)</CODE>
    **/
   public final int getIdxOfLastCharNIA(StringBuffer str_buffer, char[] a_char)  {
      return getIdxOfLastCharNIA(getSOBSB(str_buffer, sUSB + sGIOLCNIA), a_char);
   }

   /**
      <P>Get the array index of the last character that is not a member of the array.</P>

      @return  <CODE><A HREF="~JD~utilsob#getIdxOfLastCharNIA(sob,c[],i,i,b)~EJD~">getIdxOfLastCharNIA</A>(<A HREF="~JD~getSOBSB(sb,s)~EJD~">getSOBSB</A>(str_buffer, <A HREF="#sUSB">sUSB</A> + "getIdxOfLastCharNIA"), a_char, 0, <A HREF="~JD~sb~EJD~#length()">length</A>(), b_validateAOC)</CODE>
    **/
   public final int getIdxOfLastCharNIA(StringBuffer str_buffer, char[] a_char, boolean b_validateAOC)  {
      try  {
         return getIdxOfLastCharNIA(getSOBSB(str_buffer, sUSB + sGIOLCNIA), a_char, 0, str_buffer.length(), b_validateAOC);
      }  catch(NullPointerException npx)  {
         throwAX("getIdxOf1stCharNIA:  str_buffer is null.");
      }

      //Never reached.  Required for compile.
      return -1;
   }

   /**
      <P>Get the array index of the last character that is not a member of the array.</P>

      @return  <CODE><A HREF="~JD~utilsob#getIdxOfLastCharNIA(sob,c[],i,i)~EJD~">getIdxOfLastCharNIA</A>(<A HREF="~JD~getSOBSB(sb,s)~EJD~">getSOBSB</A>(str_buffer, <A HREF="#sUSB">sUSB</A> + "getIdxOfLastCharNIA"), a_char, i_idxStart, i_idxAfterEnd)</CODE>
    **/
   public final int getIdxOfLastCharNIA(StringBuffer str_buffer, char[] a_char, int i_idxStart, int i_idxAfterEnd)  {
      return getIdxOfLastCharNIA(getSOBSB(str_buffer, sUSB + sGIOLCNIA), a_char, i_idxStart, i_idxAfterEnd);
   }

   /**
      <P>Get the array index of the last character that does not exist in the array.</P>

      @return  <CODE><A HREF="~JD~utilsob#getIdxOfLastCharNIA(sob,c[],i,i,b)~EJD~">getIdxOfLastCharNIA</A>(<A HREF="~JD~getSOBSB(sb,s)~EJD~">getSOBSB</A>(str_buffer, <A HREF="#sUSB">sUSB</A> + "getIdxOfLastCharNIA"), a_char, i_idxStart, i_idxAfterEnd, b_validateAOC)</CODE>
    **/
   public final int getIdxOfLastCharNIA(StringBuffer str_buffer, char[] a_char, int i_idxStart, int i_idxAfterEnd, boolean b_validateAOC)  {
      return getIdxOfLastCharNIA(getSOBSB(str_buffer, sUSB + sGIOLCNIA), a_char, i_idxStart, i_idxAfterEnd, b_validateAOC);
   }


   /**
      <P>Get a copy of the StringBuffer, where the contents' invisible characters are made visible.</P>

      @return  <CODE>((<A HREF="~JD~ssb~EJD~">SOBStringBuffer</A>)<A HREF="~JD~utilsob#getVisible(sob)~EJD~">getVisible</A>(<A HREF="~JD~getSOBSB(sb,s)~EJD~">getSOBSB</A>(str_buffer, <A HREF="#sUSB">sUSB</A> + "getVisible")).<A HREF="~JD~ssb~EJD~#getStringBuffer()">getStringBuffer</A>()</CODE>
    **/
   public final StringBuffer getVisible(StringBuffer str_buffer)  {
      return ((SOBStringBuffer)getVisible(getSOBSB(str_buffer, sUSB + "getVisible"))).getStringBuffer();
   }


   /**
      <P>Translate the contents of a StringBuffer, so all invisible characters are made visible.</P>

      <P>Equal to <CODE><A HREF="~JD~utilsob#makeVisible(sob)~EJD~">makeVisible</A>(<A HREF="~JD~getSOBSB(sb,s)~EJD~">getSOBSB</A>(str_buffer, <A HREF="#sUSB">sUSB</A> + "getVisible"))</CODE></P>
    **/
   public final void makeVisible(StringBuffer str_buffer)  {
      makeVisible(getSOBSB(str_buffer, sUSB + "getVisible"));
   }

   /**
      <P>Does the string contain only letters, digits and underscores?</P>

      @return <CODE><A HREF="~JD~utilsob#isLetterDigitUnderscore(sob)~EJD~">isLetterDigitUnderscore</A>(<A HREF="~JD~getSOBSB(sb,s)~EJD~">getSOBSB</A>(str_buffer, <A HREF="#sUSB">sUSB</A> + "isLetterDigitUnderscore"))</CODE>
    **/
   public boolean isLetterDigitUnderscore(StringBuffer str_buffer)  {
      return isLetterDigitUnderscore(getSOBSB(str_buffer, sUSB + "isLetterDigitUnderscore"));
   }


   /**
      <P>Does the string contain only letters and (other provided) legal characters?</P>

      @return <CODE><A HREF="~JD~utilsob#hasLettersOrInAOC(sob,b,c[])~EJD~">hasLettersOrInAOC</A>(<A HREF="~JD~getSOBSB(sb,s)~EJD~">getSOBSB</A>(str_buffer, <A HREF="#sUSB">sUSB</A> + "hasLettersOrInAOC"), b_digitsOkOpt, ac_legal)</CODE>
    **/
   public boolean hasLettersOrInAOC(StringBuffer str_buffer, boolean b_digitsOkOpt, char[] ac_legal)  {
      return hasLettersOrInAOC(getSOBSB(str_buffer, sUSB + "hasLettersOrInAOC"), b_digitsOkOpt, ac_legal);
   }

   /**
      <P>Does the string contain only letters and (other provided) legal characters?</P>

      @return  <CODE><A HREF="~JD~utilsob#hasLettersOrInAOC(sob,b,c[],b)~EJD~">hasLettersOrInAOC</A>(<A HREF="~JD~getSOBSB(sb,s)~EJD~">getSOBSB</A>(str_buffer, <A HREF="#sUSB">sUSB</A> + "hasLettersOrInAOC"), b_digitsOkOpt, ac_legal, b_validateAOC)</CODE>
    **/
   public boolean hasLettersOrInAOC(StringBuffer str_buffer, boolean b_digitsOkOpt, char[] ac_legal, boolean b_validateAOC)  {
      return hasLettersOrInAOC(getSOBSB(str_buffer, sUSB + "hasLettersOrInAOC"), b_digitsOkOpt, ac_legal, b_validateAOC);
   }

   /**
      <P>Does the string contain only digits and (other provided) legal characters?</P>

      @return  <CODE><A HREF="~JD~utilsob#hasDigitsOrInAOC(sob,b,c[])~EJD~">hasDigitsOrInAOC</A>(<A HREF="~JD~getSOBSB(sb,s)~EJD~">getSOBSB</A>(str_buffer, <A HREF="#sUSB">sUSB</A> + "hasDigitsOrInAOC"), b_lettersOkOpt, ac_legal)</CODE>
    **/
   public boolean hasDigitsOrInAOC(StringBuffer str_buffer, boolean b_lettersOkOpt, char[] ac_legal)  {
      return hasDigitsOrInAOC(getSOBSB(str_buffer, sUSB + "hasDigitsOrInAOC"), b_lettersOkOpt, ac_legal);
   }
   /**
      <P>Does the string contain only digits and (other provided) legal characters?</P>

      @return  <CODE><A HREF="~JD~utilsob#hasDigitsOrInAOC(sob,b,c[],b)~EJD~">hasDigitsOrInAOC</A>(<A HREF="~JD~getSOBSB(sb,s)~EJD~">getSOBSB</A>(str_buffer, <A HREF="#sUSB">sUSB</A> + "hasDigitsOrInAOC"), b_lettersOkOpt, ac_legal, b_validateAOC)</CODE>
    **/
   public boolean hasDigitsOrInAOC(StringBuffer str_buffer, boolean b_lettersOkOpt, char[] ac_legal, boolean b_validateAOC)  {
      return hasDigitsOrInAOC(getSOBSB(str_buffer, sUSB + "hasDigitsOrInAOC"), b_lettersOkOpt, ac_legal, b_validateAOC);
   }

   /**
      <P>Does the string contain only letters, digits and (other provided) legal characters?</P>

      @return  <CODE><A HREF="~JD~utilsob#hasLDOrInAOC(sob,c[])~EJD~">hasLDOrInAOC</A>(<A HREF="~JD~getSOBSB(sb,s)~EJD~">getSOBSB</A>(str_buffer, <A HREF="#sUSB">sUSB</A> + "hasLDOrInAOC"), ac_legal)</CODE>
    **/
   public boolean hasLDOrInAOC(StringBuffer str_buffer, char[] ac_legal)  {
      return hasLDOrInAOC(getSOBSB(str_buffer, sUSB + "hasLDOrInAOC"), ac_legal);
   }
   /**
      <P>Does the string contain only letters, digits and (other provided) legal characters?</P>

      @return  <CODE><A HREF="~JD~utilsob#hasLDOrInAOC(sob,c[],b)~EJD~">hasLDOrInAOC</A>(<A HREF="~JD~getSOBSB(sb,s)~EJD~">getSOBSB</A>(str_buffer, <A HREF="#sUSB">sUSB</A> + "hasLDOrInAOC"), ac_legal, b_validateAOC)</CODE>
    **/
   public boolean hasLDOrInAOC(StringBuffer str_buffer, char[] ac_legal, boolean b_validateAOC)  {
      return hasLDOrInAOC(getSOBSB(str_buffer, sUSB + "hasLDOrInAOC"), ac_legal, b_validateAOC);
   }

   /**
      <P>Does the string contain only legal characters?</P>

      @return <CODE><A HREF="~JD~utilsob#hasLegalChars(sob,c[])~EJD~">hasLegalChars</A>(<A HREF="~JD~getSOBSB(sb,s)~EJD~">getSOBSB</A>(str_buffer, <A HREF="#sUSB">sUSB</A> + "hasLegalChars"), ac_legal)</CODE>
    **/
   public boolean hasLegalChars(StringBuffer str_buffer, char[] ac_legal)  {
      return hasLegalChars(getSOBSB(str_buffer, sUSB + "hasLegalChars"), ac_legal);
   }


   /**
      <P>Does the string contain only legal characters?</P>

      @return <CODE><A HREF="~JD~utilsob#isLegal(sob,b,b,c[],b)~EJD~">isLegal</A>(<A HREF="~JD~getSOBSB(sb,s)~EJD~">getSOBSB</A>(str_buffer, <A HREF="#sUSB">sUSB</A> + "hasLegalChars"), false, false, ac_legal, b_validateAOC)</CODE>
    **/
   public boolean hasLegalChars(StringBuffer str_buffer, char[] ac_legal, boolean b_validateAOC)  {
      return isLegal(getSOBSB(str_buffer, sUSB + "hasLegalChars"), false, false, ac_legal, b_validateAOC);
   }

   /**
      <P>Does the string contain only legal characters?</P>

      @return  <CODE><A HREF="~JD~utilsob#isLegal(sob,b,b,c[])~EJD~">isLegal</A>(<A HREF="~JD~getSOBSB(sb,s)~EJD~">getSOBSB</A>(str_buffer, <A HREF="#sUSB">sUSB</A> + "isLegal"), b_lettersOkOpt, b_digitsOkOpt, ac_legal)</CODE>
    **/
   public boolean isLegal(StringBuffer str_buffer, boolean b_lettersOkOpt, boolean b_digitsOkOpt, char[] ac_legal)  {
      return isLegal(getSOBSB(str_buffer, sUSB + "isLegal"), b_lettersOkOpt, b_digitsOkOpt, ac_legal);
   }

   /**
      <P>Does the string contain only legal characters?</P>

      @return  <CODE><A HREF="~JD~utilsob#isLegal(sob,b,b,c[],b)~EJD~">isLegal</A>(<A HREF="~JD~getSOBSB(sb,s)~EJD~">getSOBSB</A>(str_buffer, <A HREF="#sUSB">sUSB</A> + "isLegal"), b_lettersOkOpt, b_digitsOkOpt, ac_legal, b_validateAOC)</CODE>
    **/
   public boolean isLegal(StringBuffer str_buffer, boolean b_lettersOkOpt, boolean b_digitsOkOpt, char[] ac_legal, boolean b_validateAOC)  {
      return isLegal(getSOBSB(str_buffer, sUSB + "isLegal"), b_lettersOkOpt, b_digitsOkOpt, ac_legal, b_validateAOC);
   }



   /**
      <P>Does the string <I>not</I> contain any letters or (other provided) illegal characters?</P>

      @return  <CODE><A HREF="~JD~utilsob#isNotLettersOrInAOC(sob,b,c[])~EJD~">isNotLettersOrInAOC</A>(<A HREF="~JD~getSOBSB(sb,s)~EJD~">getSOBSB</A>(str_buffer, <A HREF="#sUSB">sUSB</A> + "isNotLettersOrInAOC"), b_digitsBadOpt, ac_legal)</CODE>
    **/
   public boolean isNotLettersOrInAOC(StringBuffer str_buffer, boolean b_digitsBadOpt, char[] ac_legal)  {
      return isNotLettersOrInAOC(getSOBSB(str_buffer, sUSB + "isNotLettersOrInAOC"), b_digitsBadOpt, ac_legal);
   }
   /**
      <P>Does the string <I>not</I> contain any letters or (other provided) illegal characters?</P>

      @return  <CODE><A HREF="~JD~utilsob#isNotLettersOrInAOC(sob,b,c[],b)~EJD~">isNotLettersOrInAOC</A>(<A HREF="~JD~getSOBSB(sb,s)~EJD~">getSOBSB</A>(str_buffer, <A HREF="#sUSB">sUSB</A> + "isNotLettersOrInAOC"), b_digitsBadOpt, ac_legal, b_validateAOC)</CODE>
    **/
   public boolean isNotLettersOrInAOC(StringBuffer str_buffer, boolean b_digitsBadOpt, char[] ac_legal, boolean b_validateAOC)  {
      return isNotLettersOrInAOC(getSOBSB(str_buffer, sUSB + "isNotLettersOrInAOC"), b_digitsBadOpt, ac_legal, b_validateAOC);
   }

   /**
      <P>Does the string <I>not</I> contain any digits or (other provided) illegal characters?</P>

      @return  <CODE><A HREF="~JD~utilsob#isNotDigitsOrInAOC(sob,b,c[])~EJD~">isNotDigitsOrInAOC</A>(<A HREF="~JD~getSOBSB(sb,s)~EJD~">getSOBSB</A>(str_buffer, <A HREF="#sUSB">sUSB</A> + "isNotDigitsOrInAOC"), b_digitsBadOpt, ac_legal)</CODE>
    **/
   public boolean isNotDigitsOrInAOC(StringBuffer str_buffer, boolean b_lettersBadOpt, char[] ac_legal)  {
      return isNotDigitsOrInAOC(getSOBSB(str_buffer, sUSB + "isNotDigitsOrInAOC"), b_lettersBadOpt, ac_legal);
   }
   /**
      <P>Does the string <I>not</I> contain any digits or (other provided) illegal characters?</P>

      @return  <CODE><A HREF="~JD~utilsob#isNotDigitsOrInAOC(sob,b,c[],b)~EJD~">isNotDigitsOrInAOC</A>(<A HREF="~JD~getSOBSB(sb,s)~EJD~">getSOBSB</A>(str_buffer, <A HREF="#sUSB">sUSB</A> + "isNotDigitsOrInAOC"), b_lettersBadOpt, ac_legal, b_validateAOC)</CODE>
    **/
   public boolean isNotDigitsOrInAOC(StringBuffer str_buffer, boolean b_lettersBadOpt, char[] ac_legal, boolean b_validateAOC)  {
      return isNotDigitsOrInAOC(getSOBSB(str_buffer, sUSB + "isNotDigitsOrInAOC"), b_lettersBadOpt, ac_legal, b_validateAOC);
   }

   /**
      <P>Does the string <I>not</I> contain any letters, digits or (other provided) illegal characters?</P>

      @return  <CODE><A HREF="~JD~utilsob#isNotLDOrInAOC(sob,c[])~EJD~">isNotLDOrInAOC</A>(<A HREF="~JD~getSOBSB(sb,s)~EJD~">getSOBSB</A>(str_buffer, <A HREF="#sUSB">sUSB</A> + "isNotLDOrInAOC"), ac_legal)</CODE>
    **/
   public boolean isNotLDOrInAOC(StringBuffer str_buffer, char[] ac_legal)  {
      return isNotLDOrInAOC(getSOBSB(str_buffer, sUSB + "isNotLDOrInAOC"), ac_legal);
   }
   /**
      <P>Does the string <I>not</I> contain any letters, digits or (other provided) illegal characters?</P>

      @return  <CODE><A HREF="~JD~utilsob#isNotLDOrInAOC(sob,c[],b)~EJD~">isNotLDOrInAOC</A>(<A HREF="~JD~getSOBSB(sb,s)~EJD~">getSOBSB</A>(str_buffer, <A HREF="#sUSB">sUSB</A> + "isNotLDOrInAOC"), ac_legal, b_validateAOC)</CODE>
    **/
   public boolean isNotLDOrInAOC(StringBuffer str_buffer, char[] ac_legal, boolean b_validateAOC)  {
      return isNotLDOrInAOC(getSOBSB(str_buffer, sUSB + "isNotLDOrInAOC"), ac_legal, b_validateAOC);
   }

   /**
      <P>Does the string <I>not</I> contain any illegal characters?</P>

      @return <CODE><A HREF="~JD~utilsob#hasNoIllegalChars(sob,c[])~EJD~">hasNoIllegalChars</A>(<A HREF="~JD~getSOBSB(sb,s)~EJD~">getSOBSB</A>(str_buffer, <A HREF="#sUSB">sUSB</A> + "hasNoIllegalChars"), ac_illegal)</CODE>
    **/
   public boolean hasNoIllegalChars(StringBuffer str_buffer, char[] ac_illegal)  {
      return hasNoIllegalChars(getSOBSB(str_buffer, sUSB + "hasNoIllegalChars"), ac_illegal);
   }


   /**
      <P>Does the string <I>not</I> contain any illegal characters?</P>

      @return <CODE><A HREF="~JD~utilsob#isNotIllegal(sob,b,b,c[],b)~EJD~">isNotIllegal</A>(<A HREF="~JD~getSOBSB(sb,s)~EJD~">getSOBSB</A>(str_buffer, <A HREF="#sUSB">sUSB</A> + "hasNoIllegalChars"), false, false, ac_illegal, b_validateAOC)</CODE>
    **/
   public boolean hasNoIllegalChars(StringBuffer str_buffer, char[] ac_illegal, boolean b_validateAOC)  {
      return isLegal(getSOBSB(str_buffer, sUSB + "hasNoIllegalChars"), false, false, ac_illegal, b_validateAOC);
   }

   /**
      <P>Does the string <I>not</I> contain any illegal characters?</P>

      @return  <CODE><A HREF="~JD~utilsob#isNotIllegal(sob,b,b,c[])~EJD~">isNotIllegal</A>(<A HREF="~JD~getSOBSB(sb,s)~EJD~">getSOBSB</A>(str_buffer, <A HREF="#sUSB">sUSB</A> + "isNotIllegal"), b_lettersBadOpt, b_digitsBadOpt, ac_illegal)</CODE>
    **/
   public boolean isNotIllegal(StringBuffer str_buffer, boolean b_lettersBadOpt, boolean b_digitsBadOpt, char[] ac_illegal)  {
      return isNotIllegal(getSOBSB(str_buffer, sUSB + "isNotIllegal"), b_lettersBadOpt, b_digitsBadOpt, ac_illegal);
   }

   /**
      <P>Does the string <I>not</I> contain any illegal characters?</P>

      @return  <CODE><A HREF="~JD~utilsob#isNotIllegal(sob,b,b,c[],b)~EJD~">isNotIllegal</A>(<A HREF="~JD~getSOBSB(sb,s)~EJD~">getSOBSB</A>(str_buffer, <A HREF="#sUSB">sUSB</A> + "isNotLegal"), b_lettersBadOpt, b_digitsBadOpt, ac_illegal, b_validateAOC)</CODE>
    **/
   public boolean isNotIllegal(StringBuffer str_buffer, boolean b_lettersBadOpt, boolean b_digitsBadOpt, char[] ac_illegal, boolean b_validateAOC)  {
      return isNotIllegal(getSOBSB(str_buffer, sUSB + "isNotLegal"), b_lettersBadOpt, b_digitsBadOpt, ac_illegal, b_validateAOC);
   }



   /**
      <P>Create an SOBString from the StringBuffer.</P>

      @return  <CODE><A HREF="~JD~getSOBS(sb,s,s)~EJD~">getSOBS</A>(str_buffer, <A HREF="#sUSB">sUSB</A> + "str_buffer", s_callingClsFnc)</CODE>
    **/
   public final SOBString getSOBS(StringBuffer str_buffer, String s_callingClsFnc)  {
      return getSOBS(str_buffer, sUSB + "str_buffer", s_callingClsFnc);
   }
   /**
      <P>Create an SOBString from the StringBuffer.</P>

      @param  str_buffer  The StringBuffer to create a new SOBString with.  May not be null.
      @param  s_sDescription  The descriptive name of str_buffer, for potential error messages.
      @param  s_callingClsFnc  The function from which the potential error message should appear as if it is coming from.
      @return  <CODE>(new <A HREF="~JD~ss#ss(s)~EJD~">SOBString</A>(str_buffer.<A HREF="~JD~sb~EJD~#toString()">toString</A>()))</CODE>
    **/
   public final SOBString getSOBS(StringBuffer str_buffer, String s_sbDesc, String s_callingClsFnc)  {
      try  {
         return new SOBString(str_buffer.toString());
      }  catch(NullPointerException npx)  {
         throwAXSpoof(s_callingClsFnc + ":  " + s_sbDesc + " is null.");
      }

      //Never reached.  Required for compile.
      return null;
   }

   /**
      <P>Create an SOBStringBuffer from the StringBuffer.</P>

      @return  <CODE><A HREF="~JD~getSOBSB(sb,s,s)~EJD~">getSOBSB</A>(str_buffer, <A HREF="#sUSB">sUSB</A> + "str_buffer", s_callingClsFnc)</CODE>
    **/
   public final SOBStringBuffer getSOBSB(StringBuffer str_buffer, String s_callingClsFnc)  {
      return getSOBSB(str_buffer, "str_buffer", s_callingClsFnc);
   }
   /**
      <P>Create an SOBStringBuffer from the StringBuffer.</P>

      @param  str_buffer  The StringBuffer to create a new SOBStringBuffer with.  May not be null.
      @param  s_sDescription  The descriptive name of str_buffer, for potential error messages.
      @param  s_callingClsFnc  The function from which the potential error message should appear as if it is coming from.
      @return  <CODE>(new <A HREF="~JD~ssb#ssb(sb)~EJD~">SOBStringBuffer</A>(str_buffer))</CODE>
    **/
   public final SOBStringBuffer getSOBSB(StringBuffer str_buffer, String s_sbDesc, String s_callingClsFnc)  {
      try  {
         return (new SOBStringBuffer(str_buffer));
      }  catch(NullPointerException npx)  {
         throwAXSpoof(s_callingClsFnc + ":  " + s_sbDesc + " is null.");
      }

      //Never reached.  Required for compile.
      return null;
   }


   /**
      <P>Get an array of SOBStrings from the array of StringBuffers.</P>

      @param  a_stringBuffer  The array of strings to create an array of SOBStrings from.
      @return  <B>null</B>  If a_stringBuffer is null.
      <BR>An <B>array of SOBStrings</B> where each element has contents equalling that in the corresponding member of a_stringBuffer.  <B>Note:</B>  If a_stringBuffer[X] is null then the X-th element in the returned array is also null (it is not possible to have the contents of an SOBString equal null).
    **/
   public final SOBString[] getAOSOBS(StringBuffer[] a_stringBuffer)  {
      if(a_stringBuffer == null)  {
         return null;
      }

      SOBString[] ass = new SOBString[a_stringBuffer.length];
      for(int i = 0; i < a_stringBuffer.length; i++)  {
         if(a_stringBuffer[i] == null)  {
            ass[i] = null;

         }  else  {
            ass[i] = new SOBString(a_stringBuffer[i].toString());
         }
      }

      return ass;
   }

   /**
      <P>Get an array of SOBStringBuffers from the array of StringBuffers.</P>

      @param  a_stringBuffer  The array of strings to create an array of SOBStringBuffers from.
      @return  <B>null</B>  If a_stringBuffer is null.
      <BR>An <B>array of SOBStringBuffers</B> where each element has contents equalling that in the corresponding member of a_stringBuffer.  <B>Note:</B>  If a_stringBuffer[X] is null then the X-th element in the returned array is also null (it is not possible to have the contents of an SOBStringBuffer equal null).
    **/
   public final SOBStringBuffer[] getAOSOBSB(StringBuffer[] a_stringBuffer)  {
      if(a_stringBuffer == null)  {
         return null;
      }

      SOBStringBuffer[] assb = new SOBStringBuffer[a_stringBuffer.length];
      for(int i = 0; i < a_stringBuffer.length; i++)  {
         if(a_stringBuffer[i] == null)  {
            assb[i] = null;

         }  else  {
            assb[i] = new SOBStringBuffer(a_stringBuffer[i]);
         }
      }

      return assb;
   }
}