/*::.
==================================================================================================================================
=================================================¦ Copyright © 2007 Allen Baker ¦=================================================
                                                 +------------------------------+
File:       NCString.java
Originator: Allen Baker (2007.01.20 22:24)
LayoutRev:  5
================================================================================================================================== */



/*.
==========================================================================================
Package
------------------------------------------------------------------------------------------ */
package cosmicabyss.com.lib;



/*.
==========================================================================================
Imports
------------------------------------------------------------------------------------------ */
import java.io.*;
import java.util.*;
import java.nio.charset.*;



/*::
======================================================================================================================== *//**
This class is intended to act as a full, and more powerful replacement for Java's String class for representing Strings
without case-distinctions. In other words, all the methods of this class ignore case.<P>

The Java String class (String) is final, meaning that you cannot add methods to it or improve it in any way by creating
a subclass of it. This is an annoyance because it forces the user to create a separate String utility class containing
any additional methods the user needs for Strings, and to then switch back and forth between the String class and the
String utility class.<P>

This class provides methods that are equivalent to all the String class's instance and static methods. In other words,
it replicates the String class's entire API. As an improvement over the String class, the methods of this class accept
generic types in place of Java's String parameter. This means that objects of any class that can be converted into a
String can be passed into any of the NCString methods where the corresponding String method requires Strings.<P>

nCString goes further by providing additional methods not found in the String class. These additional methods greatly
extend the power of NCString beyond that of String.<P>

Taken together, the above mentioned characteristics of NCString result in a class that can be used as a more powerful
replacement for the String class. The one thing that is lost when using NCString instead of String is Java's support for
direct assignment of String literals to String variables. NCString does not have this support and all NCStrings must be
created with an NCString constructor. For example, the following code:<P>
   <BLOCKQUOTE>
      <PRE id="unindent">
         String exampleString = "This is a test";
         someClass.someMethodThatTakesAStringParameter(exampleString);
      </PRE>
   </BLOCKQUOTE>

Would have to change as follows when using NCString as a substitute for String:
   <BLOCKQUOTE>
      <PRE id="unindent">
         NCString exampleString = new NCString("This is a test");
         someClass.someMethodThatTakesAStringParameter(exampleString.toString());
      </PRE>
   </BLOCKQUOTE>

The most obvious differences between this class and the standard Java String class are:<P>
   <BLOCKQUOTE>
      => Strings of this class are case-insensitive. (The name NCString means "No-Case String".)<BR>
      => Unlike the String class, this NCString class is not final. Therefore, it is possible to add methods to it at
         Any Time.<BR>
      => Most of the methods of this class take generic parameters where the corresponding methods of the standard Java
         String class would take concrete parameter types.<BR>
      => While providing exactly the same methods as the String class, this class also offers numerous additional
         Methods That make NCStrings much more powerful than Strings.
   </BLOCKQUOTE>

Subclass
   This class is derived from the XString class. The abstraction it layers on top of XString includes the following:
      <BLOCKQUOTE>
         => It ignores the case of all the strings it operates upon.
      </BLOCKQUOTE>

<P>
   <DL>
      <DT>
         <B>
            Example usage:
         </B>
         <DD>
            <BLOCKQUOTE>
               <PRE id="unindent">
                  no example provided
               </PRE>
            </BLOCKQUOTE>
         </DD>
      </DT>
      <DT>
         <B>
            View Source:
         </B>
         <DD>
            <A href="NCString.java.html">
               nCString.java
            </A>
         </DD>
      </DT>
      <DT>
         <B>
            Author:
         </B>
         <DD>
            <A href="mailto:sourcecode.v01@cosmicabyss.com">
               Allen Baker
            </A>
         </DD>
      </DT>
   </DL>
*//*
======================================================================================================================== */
public class NCString extends XString
   {



   /*:                                    
   ====================================================================================================
   [][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][]
   ==================================================================================================== *//**
   This method creates a NCString class object.

   <P><B>Implementation: </B><A HREF="NCString.java.html#000">View source</A>

   *//*
   ---------------------------------------------------------------------------------------------------- */
   public <Type1> NCString(Type1 pStr)
      {
      super(pStr);
      }



   /*:.
   ==============================================================================================================
   <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<[  The String API  ]>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
   ============================================================================================================== */



   /*:                                    
   ====================================================================================================
   [][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][]
   ==================================================================================================== *//**
   The description of this method is the same as the one for the method of the same name in the XString
   class documentation except that this NCString ignores the case of the letters in its string as it
   performs this operation.<P>

      <B>
         Documentation:
      </B>
       <A HREF="XString.html">
         View the XString Class
      </A>

   <P><B>Implementation: </B><A HREF="NCString.java.html#001">View source</A>

   *//*
   ---------------------------------------------------------------------------------------------------- */
   public boolean equals(Object anObject)
      {
      return super.equalsIgnoreCase(anObject);
      }



   /*:                                    
   ====================================================================================================
   [][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][]
   ==================================================================================================== *//**
   The description of this method is the same as the one for the method of the same name in the XString
   class documentation except that this NCString ignores the case of the letters in its string as it
   performs this operation.<P>

      <B>
         Documentation:
      </B>
       <A HREF="XString.html">
         View the XString Class
      </A>

   <P><B>Implementation: </B><A HREF="NCString.java.html#002">View source</A>

   *//*
   ---------------------------------------------------------------------------------------------------- */
   public boolean contentEquals(StringBuffer sb)
      {
      return super.contentEqualsIgnoreCase(sb);
      }



   /*:                                    
   ====================================================================================================
   [][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][]
   ==================================================================================================== *//**
   The description of this method is the same as the one for the method of the same name in the XString
   class documentation except that this NCString ignores the case of the letters in its string as it
   performs this operation.<P>

      <B>
         Documentation:
      </B>
       <A HREF="XString.html">
         View the XString Class
      </A>

   <P><B>Implementation: </B><A HREF="NCString.java.html#003">View source</A>

   *//*
   ---------------------------------------------------------------------------------------------------- */
   public boolean contentEquals(CharSequence cs)
      {
      return super.contentEqualsIgnoreCase(cs);
      }
   public <Type1> boolean contentEquals(Type1 cs)
      {
      return super.contentEqualsIgnoreCase(cs);
      }



   /*:                                    
   ====================================================================================================
   [][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][]
   ==================================================================================================== *//**
   The description of this method is the same as the one for the method of the same name in the XString
   class documentation except that this NCString ignores the case of the letters in its string as it
   performs this operation.<P>

      <B>
         Documentation:
      </B>
       <A HREF="XString.html">
         View the XString Class
      </A>

   <P><B>Implementation: </B><A HREF="NCString.java.html#004">View source</A>

   *//*
   ---------------------------------------------------------------------------------------------------- */
   public int compareTo(XString anotherString)
      {
      return super.compareToIgnoreCase(anotherString);
      }



   /*:                                    
   ====================================================================================================
   [][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][]
   ==================================================================================================== *//**
   The description of this method is the same as the one for the method of the same name in the XString
   class documentation except that this NCString ignores the case of the letters in its string as it
   performs this operation.<P>

      <B>
         Documentation:
      </B>
       <A HREF="XString.html">
         View the XString Class
      </A>

   <P><B>Implementation: </B><A HREF="NCString.java.html#005">View source</A>

   *//*
   ---------------------------------------------------------------------------------------------------- */
   public <Type1> boolean regionMatches(int toffset, Type1 other, int ooffset, int len)
      {
      return super.regionMatchesIgnoreCase(toffset,other,ooffset,len);
      }



   /*:                                    
   ====================================================================================================
   [][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][]
   ==================================================================================================== *//**
   The description of this method is the same as the one for the method of the same name in the XString
   class documentation except that this NCString ignores the case of the letters in its string as it
   performs this operation.<P>

      <B>
         Documentation:
      </B>
       <A HREF="XString.html">
         View the XString Class
      </A>

   <P><B>Implementation: </B><A HREF="NCString.java.html#006">View source</A>

   *//*
   ---------------------------------------------------------------------------------------------------- */
   public <Type1> boolean regionMatches(boolean ignoreCase, int toffset, Type1 other, int ooffset, int len)
      {
      return super.regionMatchesIgnoreCase(toffset,other,ooffset,len);
      }



   /*:                                    
   ====================================================================================================
   [][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][]
   ==================================================================================================== *//**
   The description of this method is the same as the one for the method of the same name in the XString
   class documentation except that this NCString ignores the case of the letters in its string as it
   performs this operation.<P>

      <B>
         Documentation:
      </B>
       <A HREF="XString.html">
         View the XString Class
      </A>

   <P><B>Implementation: </B><A HREF="NCString.java.html#007">View source</A>

   *//*
   ---------------------------------------------------------------------------------------------------- */
   public <Type1> boolean startsWith(Type1 prefix, int toffset)
      {
      return super.startsWithIgnoreCase(prefix,toffset);
      }



   /*:                                    
   ====================================================================================================
   [][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][]
   ==================================================================================================== *//**
   The description of this method is the same as the one for the method of the same name in the XString
   class documentation except that this NCString ignores the case of the letters in its string as it
   performs this operation.<P>

      <B>
         Documentation:
      </B>
       <A HREF="XString.html">
         View the XString Class
      </A>

   <P><B>Implementation: </B><A HREF="NCString.java.html#008">View source</A>

   *//*
   ---------------------------------------------------------------------------------------------------- */
   public <Type1> boolean startsWith(Type1 prefix)
      {
      return super.startsWithIgnoreCase(prefix);
      }



   /*:                                    
   ====================================================================================================
   [][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][]
   ==================================================================================================== *//**
   The description of this method is the same as the one for the method of the same name in the XString
   class documentation except that this NCString ignores the case of the letters in its string as it
   performs this operation.<P>

      <B>
         Documentation:
      </B>
       <A HREF="XString.html">
         View the XString Class
      </A>

   <P><B>Implementation: </B><A HREF="NCString.java.html#009">View source</A>

   *//*
   ---------------------------------------------------------------------------------------------------- */
   public <Type1> boolean endsWith(Type1 suffix)
      {
      return super.endsWithIgnoreCase(suffix);
      }



   /*:                                    
   ====================================================================================================
   [][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][]
   ==================================================================================================== *//**
   The description of this method is the same as the one for the method of the same name in the XString
   class documentation except that this NCString ignores the case of the letters in its string as it
   performs this operation.<P>

      <B>
         Documentation:
      </B>
       <A HREF="XString.html">
         View the XString Class
      </A>

   <P><B>Implementation: </B><A HREF="NCString.java.html#010">View source</A>

   *//*
   ---------------------------------------------------------------------------------------------------- */
   public int hashCode()
      {
      return super.hashCodeIgnoreCase();
      }



   /*:                                    
   ====================================================================================================
   [][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][]
   ==================================================================================================== *//**
   The description of this method is the same as the one for the method of the same name in the XString
   class documentation except that this NCString ignores the case of the letters in its string as it
   performs this operation.<P>

      <B>
         Documentation:
      </B>
       <A HREF="XString.html">
         View the XString Class
      </A>

   <P><B>Implementation: </B><A HREF="NCString.java.html#011">View source</A>

   *//*
   ---------------------------------------------------------------------------------------------------- */
   public int indexOf(int ch)
      {
      return super.indexOfIgnoreCase(ch);
      }



   /*:                                    
   ====================================================================================================
   [][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][]
   ==================================================================================================== *//**
   The description of this method is the same as the one for the method of the same name in the XString
   class documentation except that this NCString ignores the case of the letters in its string as it
   performs this operation.<P>

      <B>
         Documentation:
      </B>
       <A HREF="XString.html">
         View the XString Class
      </A>

   <P><B>Implementation: </B><A HREF="NCString.java.html#012">View source</A>

   *//*
   ---------------------------------------------------------------------------------------------------- */
   public int indexOf(int ch, int fromIndex)
      {
      return super.indexOfIgnoreCase(ch,fromIndex);
      }



   /*:                                    
   ====================================================================================================
   [][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][]
   ==================================================================================================== *//**
   The description of this method is the same as the one for the method of the same name in the XString
   class documentation except that this NCString ignores the case of the letters in its string as it
   performs this operation.<P>

      <B>
         Documentation:
      </B>
       <A HREF="XString.html">
         View the XString Class
      </A>

   <P><B>Implementation: </B><A HREF="NCString.java.html#013">View source</A>

   *//*
   ---------------------------------------------------------------------------------------------------- */
   public int lastIndexOf(int ch)
      {
      return super.lastIndexOfIgnoreCase(ch);
      }



   /*:                                    
   ====================================================================================================
   [][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][]
   ==================================================================================================== *//**
   The description of this method is the same as the one for the method of the same name in the XString
   class documentation except that this NCString ignores the case of the letters in its string as it
   performs this operation.<P>

      <B>
         Documentation:
      </B>
       <A HREF="XString.html">
         View the XString Class
      </A>

   <P><B>Implementation: </B><A HREF="NCString.java.html#014">View source</A>

   *//*
   ---------------------------------------------------------------------------------------------------- */
   public int lastIndexOf(int ch, int fromIndex)
      {
      return super.lastIndexOfIgnoreCase(ch,fromIndex);
      }



   /*:                                    
   ====================================================================================================
   [][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][]
   ==================================================================================================== *//**
   The description of this method is the same as the one for the method of the same name in the XString
   class documentation except that this NCString ignores the case of the letters in its string as it
   performs this operation.<P>

      <B>
         Documentation:
      </B>
       <A HREF="XString.html">
         View the XString Class
      </A>

   <P><B>Implementation: </B><A HREF="NCString.java.html#015">View source</A>

   *//*
   ---------------------------------------------------------------------------------------------------- */
   public <Type1> int indexOf(Type1 other)
      {
      return super.indexOfIgnoreCase(other);
      }



   /*:                                    
   ====================================================================================================
   [][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][]
   ==================================================================================================== *//**
   The description of this method is the same as the one for the method of the same name in the XString
   class documentation except that this NCString ignores the case of the letters in its string as it
   performs this operation.<P>

      <B>
         Documentation:
      </B>
       <A HREF="XString.html">
         View the XString Class
      </A>

   <P><B>Implementation: </B><A HREF="NCString.java.html#016">View source</A>

   *//*
   ---------------------------------------------------------------------------------------------------- */
   public <Type1> int indexOf(Type1 other, int fromIndex)
      {
      return super.indexOfIgnoreCase(other,fromIndex);
      }



   /*:                                    
   ====================================================================================================
   [][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][]
   ==================================================================================================== *//**
   The description of this method is the same as the one for the method of the same name in the XString
   class documentation except that this NCString ignores the case of the letters in its string as it
   performs this operation.<P>

      <B>
         Documentation:
      </B>
       <A HREF="XString.html">
         View the XString Class
      </A>

   <P><B>Implementation: </B><A HREF="NCString.java.html#017">View source</A>

   *//*
   ---------------------------------------------------------------------------------------------------- */
   public <Type1> int lastIndexOf(Type1 other)
      {
      return super.lastIndexOfIgnoreCase(other);
      }



   /*:                                    
   ====================================================================================================
   [][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][]
   ==================================================================================================== *//**
   The description of this method is the same as the one for the method of the same name in the XString
   class documentation except that this NCString ignores the case of the letters in its string as it
   performs this operation.<P>

      <B>
         Documentation:
      </B>
       <A HREF="XString.html">
         View the XString Class
      </A>

   <P><B>Implementation: </B><A HREF="NCString.java.html#018">View source</A>

   *//*
   ---------------------------------------------------------------------------------------------------- */
   public <Type1> int lastIndexOf(Type1 other, int fromIndex)
      {
      return super.lastIndexOfIgnoreCase(other,fromIndex);
      }



   /*:                                    
   ====================================================================================================
   [][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][]
   ==================================================================================================== *//**
   The description of this method is the same as the one for the method of the same name in the XString
   class documentation except that this NCString ignores the case of the letters in its string as it
   performs this operation.<P>

      <B>
         Documentation:
      </B>
       <A HREF="XString.html">
         View the XString Class
      </A>

   <P><B>Implementation: </B><A HREF="NCString.java.html#019">View source</A>

   *//*
   ---------------------------------------------------------------------------------------------------- */
   public NCString substring(int beginIndex)
      {
      return new NCString(super.substring(beginIndex));
      }



   /*:                                    
   ====================================================================================================
   [][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][]
   ==================================================================================================== *//**
   The description of this method is the same as the one for the method of the same name in the XString
   class documentation except that this NCString ignores the case of the letters in its string as it
   performs this operation.<P>

      <B>
         Documentation:
      </B>
       <A HREF="XString.html">
         View the XString Class
      </A>

   <P><B>Implementation: </B><A HREF="NCString.java.html#020">View source</A>

   *//*
   ---------------------------------------------------------------------------------------------------- */
   public NCString substring(int beginIndex, int endIndex)
      {
      return new NCString(super.substring(beginIndex,endIndex));
      }



   /*:                                    
   ====================================================================================================
   [][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][]
   ==================================================================================================== *//**
   The description of this method is the same as the one for the method of the same name in the XString
   class documentation except that this NCString ignores the case of the letters in its string as it
   performs this operation.<P>

      <B>
         Documentation:
      </B>
       <A HREF="XString.html">
         View the XString Class
      </A>

   <P><B>Implementation: </B><A HREF="NCString.java.html#021">View source</A>

   *//*
   ---------------------------------------------------------------------------------------------------- */
   public <Type1> NCString concat(Type1 other)
      {
      return new NCString(super.concat(other));
      }



   /*:                                    
   ====================================================================================================
   [][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][]
   ==================================================================================================== *//**
   The description of this method is the same as the one for the method of the same name in the XString
   class documentation except that this NCString ignores the case of the letters in its string as it
   performs this operation.<P>

      <B>
         Documentation:
      </B>
       <A HREF="XString.html">
         View the XString Class
      </A>

   <P><B>Implementation: </B><A HREF="NCString.java.html#022">View source</A>

   *//*
   ---------------------------------------------------------------------------------------------------- */
   public NCString replace(char oldChar, char newChar)
      {
      return new NCString(super.replaceIgnoreCase(oldChar,newChar));
      }



   /*:                                    
   ====================================================================================================
   [][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][]
   ==================================================================================================== *//**
   The description of this method is the same as the one for the method of the same name in the XString
   class documentation except that this NCString ignores the case of the letters in its string as it
   performs this operation.<P>

      <B>
         Documentation:
      </B>
       <A HREF="XString.html">
         View the XString Class
      </A>

   <P><B>Implementation: </B><A HREF="NCString.java.html#023">View source</A>

   *//*
   ---------------------------------------------------------------------------------------------------- */
   public <Type1> boolean matches(Type1 regex)
      {
      return super.matchesIgnoreCase(regex);
      }



   /*:                                    
   ====================================================================================================
   [][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][]
   ==================================================================================================== *//**
   The description of this method is the same as the one for the method of the same name in the XString
   class documentation except that this NCString ignores the case of the letters in its string as it
   performs this operation.<P>

      <B>
         Documentation:
      </B>
       <A HREF="XString.html">
         View the XString Class
      </A>

   <P><B>Implementation: </B><A HREF="NCString.java.html#024">View source</A>

   *//*
   ---------------------------------------------------------------------------------------------------- */
   public boolean contains(CharSequence s)
      {
      return super.containsIgnoreCase(s);
      }
   public <Type1> boolean contains(Type1 s)
      {
      return super.containsIgnoreCase(s);
      }



   /*:                                    
   ====================================================================================================
   [][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][]
   ==================================================================================================== *//**
   The description of this method is the same as the one for the method of the same name in the XString
   class documentation except that this NCString ignores the case of the letters in its string as it
   performs this operation.<P>

      <B>
         Documentation:
      </B>
       <A HREF="XString.html">
         View the XString Class
      </A>

   <P><B>Implementation: </B><A HREF="NCString.java.html#025">View source</A>

   *//*
   ---------------------------------------------------------------------------------------------------- */
   public <Type1, Type2> NCString replaceFirst(Type1 regex, Type2 replacement)
      {
      return new NCString(super.replaceFirstIgnoreCase(regex,replacement));
      }



   /*:                                    
   ====================================================================================================
   [][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][]
   ==================================================================================================== *//**
   The description of this method is the same as the one for the method of the same name in the XString
   class documentation except that this NCString ignores the case of the letters in its string as it
   performs this operation.<P>

      <B>
         Documentation:
      </B>
       <A HREF="XString.html">
         View the XString Class
      </A>

   <P><B>Implementation: </B><A HREF="NCString.java.html#026">View source</A>

   *//*
   ---------------------------------------------------------------------------------------------------- */
   public <Type1, Type2> NCString replaceAll(Type1 regex, Type2 replacement)
      {
      return new NCString(super.replaceAllIgnoreCase(regex,replacement));
      }



   /*:                                    
   ====================================================================================================
   [][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][]
   ==================================================================================================== *//**
   The description of this method is the same as the one for the method of the same name in the XString
   class documentation except that this NCString ignores the case of the letters in its string as it
   performs this operation.<P>

      <B>
         Documentation:
      </B>
       <A HREF="XString.html">
         View the XString Class
      </A>

   <P><B>Implementation: </B><A HREF="NCString.java.html#027">View source</A>

   *//*
   ---------------------------------------------------------------------------------------------------- */
   public NCString replace(CharSequence target, CharSequence replacement)
      {
      return new NCString(super.replaceIgnoreCase(target,replacement));
      }



   /*:                                    
   ====================================================================================================
   [][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][]
   ==================================================================================================== *//**
   The description of this method is the same as the one for the method of the same name in the XString
   class documentation except that this NCString ignores the case of the letters in its string as it
   performs this operation.<P>

      <B>
         Documentation:
      </B>
       <A HREF="XString.html">
         View the XString Class
      </A>

   <P><B>Implementation: </B><A HREF="NCString.java.html#028">View source</A>

   *//*
   ---------------------------------------------------------------------------------------------------- */
   public <Type1> NCString[] split(Type1 regex, int limit)
      {
      return NCString.toNCStringArray(super.splitIgnoreCase(regex,limit));
      }



   /*:                                    
   ====================================================================================================
   [][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][]
   ==================================================================================================== *//**
   The description of this method is the same as the one for the method of the same name in the XString
   class documentation except that this NCString ignores the case of the letters in its string as it
   performs this operation.<P>

      <B>
         Documentation:
      </B>
       <A HREF="XString.html">
         View the XString Class
      </A>

   <P><B>Implementation: </B><A HREF="NCString.java.html#029">View source</A>

   *//*
   ---------------------------------------------------------------------------------------------------- */
   public <Type1> NCString[] split(Type1 regex)
      {
      return NCString.toNCStringArray(super.splitIgnoreCase(regex));
      }



   /*:                                    
   ====================================================================================================
   [][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][]
   ==================================================================================================== *//**
   The description of this method is the same as the one for the method of the same name in the XString
   class documentation except that this NCString ignores the case of the letters in its string as it
   performs this operation.<P>

      <B>
         Documentation:
      </B>
       <A HREF="XString.html">
         View the XString Class
      </A>

   <P><B>Implementation: </B><A HREF="NCString.java.html#030">View source</A>

   *//*
   ---------------------------------------------------------------------------------------------------- */
   public NCString toLowerCase(Locale locale)
      {
      return new NCString(super.toLowerCase(locale));
      }



   /*:                                    
   ====================================================================================================
   [][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][]
   ==================================================================================================== *//**
   The description of this method is the same as the one for the method of the same name in the XString
   class documentation except that this NCString ignores the case of the letters in its string as it
   performs this operation.<P>

      <B>
         Documentation:
      </B>
       <A HREF="XString.html">
         View the XString Class
      </A>

   <P><B>Implementation: </B><A HREF="NCString.java.html#031">View source</A>

   *//*
   ---------------------------------------------------------------------------------------------------- */
   public NCString toLowerCase()
      {
      return new NCString(super.toLowerCase());
      }



   /*:                                    
   ====================================================================================================
   [][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][]
   ==================================================================================================== *//**
   The description of this method is the same as the one for the method of the same name in the XString
   class documentation except that this NCString ignores the case of the letters in its string as it
   performs this operation.<P>

      <B>
         Documentation:
      </B>
       <A HREF="XString.html">
         View the XString Class
      </A>

   <P><B>Implementation: </B><A HREF="NCString.java.html#032">View source</A>

   *//*
   ---------------------------------------------------------------------------------------------------- */
   public NCString toUpperCase(Locale locale)
      {
      return new NCString(super.toUpperCase(locale));
      }



   /*:                                    
   ====================================================================================================
   [][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][]
   ==================================================================================================== *//**
   The description of this method is the same as the one for the method of the same name in the XString
   class documentation except that this NCString ignores the case of the letters in its string as it
   performs this operation.<P>

      <B>
         Documentation:
      </B>
       <A HREF="XString.html">
         View the XString Class
      </A>

   <P><B>Implementation: </B><A HREF="NCString.java.html#033">View source</A>

   *//*
   ---------------------------------------------------------------------------------------------------- */
   public NCString toUpperCase()
      {
      return new NCString(super.toUpperCase());
      }



   /*:                                    
   ====================================================================================================
   [][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][]
   ==================================================================================================== *//**
   The description of this method is the same as the one for the method of the same name in the XString
   class documentation except that this NCString ignores the case of the letters in its string as it
   performs this operation.<P>

      <B>
         Documentation:
      </B>
       <A HREF="XString.html">
         View the XString Class
      </A>

   <P><B>Implementation: </B><A HREF="NCString.java.html#034">View source</A>

   *//*
   ---------------------------------------------------------------------------------------------------- */
   public NCString trim()
      {
      return new NCString(super.trim());
      }



   /*:                                    
   ====================================================================================================
   [][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][]
   ==================================================================================================== *//**
   The description of this method is the same as the one for the method of the same name in the XString
   class documentation except that this NCString ignores the case of the letters in its string as it
   performs this operation.<P>

      <B>
         Documentation:
      </B>
       <A HREF="XString.html">
         View the XString Class
      </A>

   <P><B>Implementation: </B><A HREF="NCString.java.html#035">View source</A>

   *//*
   ---------------------------------------------------------------------------------------------------- */
   public NCString intern()
      {
      return new NCString(super.intern());
      }



   /*:.
   ==============================================================================================================
   <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<[  The Extensions  ]>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
   ============================================================================================================== */



   /*:                                    
   ====================================================================================================
   [][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][]
   ==================================================================================================== *//**
   The description of this method is the same as the one for the method of the same name in the XString
   class documentation except that this NCString ignores the case of the letters in its string as it
   performs this operation.<P>

      <B>
         Documentation:
      </B>
       <A HREF="XString.html">
         View the XString Class
      </A>

   <P><B>Implementation: </B><A HREF="NCString.java.html#036">View source</A>

   *//*
   ---------------------------------------------------------------------------------------------------- */
   public NCString charSet()
      {
      return new NCString(super.charSet());
      }



   /*:                                    
   ====================================================================================================
   [][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][]
   ==================================================================================================== *//**
   The description of this method is the same as the one for the method of the same name in the XString
   class documentation except that this NCString ignores the case of the letters in its string as it
   performs this operation.<P>

      <B>
         Documentation:
      </B>
       <A HREF="XString.html">
         View the XString Class
      </A>

   <P><B>Implementation: </B><A HREF="NCString.java.html#037">View source</A>

   *//*
   ---------------------------------------------------------------------------------------------------- */
   public NCString charSetIgnoreCase()
      {
      return new NCString(super.charSetIgnoreCase());
      }



   /*:                                    
   ====================================================================================================
   [][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][]
   ==================================================================================================== *//**
   The description of this method is the same as the one for the method of the same name in the XString
   class documentation except that this NCString ignores the case of the letters in its string as it
   performs this operation.<P>

      <B>
         Documentation:
      </B>
       <A HREF="XString.html">
         View the XString Class
      </A>

   <P><B>Implementation: </B><A HREF="NCString.java.html#038">View source</A>

   *//*
   ---------------------------------------------------------------------------------------------------- */
   public NCString trimLeft()
      {
      return new NCString(super.trimLeft());
      }



   /*:                                    
   ====================================================================================================
   [][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][]
   ==================================================================================================== *//**
   The description of this method is the same as the one for the method of the same name in the XString
   class documentation except that this NCString ignores the case of the letters in its string as it
   performs this operation.<P>

      <B>
         Documentation:
      </B>
       <A HREF="XString.html">
         View the XString Class
      </A>

   <P><B>Implementation: </B><A HREF="NCString.java.html#039">View source</A>

   *//*
   ---------------------------------------------------------------------------------------------------- */
   public <Type1> NCString trimLeft(Type1 prefix)
      {
      return new NCString(super.trimLeftIgnoreCase(prefix));
      }



   /*:                                    
   ====================================================================================================
   [][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][]
   ==================================================================================================== *//**
   The description of this method is the same as the one for the method of the same name in the XString
   class documentation except that this NCString ignores the case of the letters in its string as it
   performs this operation.<P>

      <B>
         Documentation:
      </B>
       <A HREF="XString.html">
         View the XString Class
      </A>

   <P><B>Implementation: </B><A HREF="NCString.java.html#040">View source</A>

   *//*
   ---------------------------------------------------------------------------------------------------- */
   public <Type1> NCString trimLeftIgnoreCase(Type1 prefix)
      {
      return new NCString(super.trimLeftIgnoreCase(prefix));
      }



   /*:                                    
   ====================================================================================================
   [][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][]
   ==================================================================================================== *//**
   The description of this method is the same as the one for the method of the same name in the XString
   class documentation except that this NCString ignores the case of the letters in its string as it
   performs this operation.<P>

      <B>
         Documentation:
      </B>
       <A HREF="XString.html">
         View the XString Class
      </A>

   <P><B>Implementation: </B><A HREF="NCString.java.html#041">View source</A>

   *//*
   ---------------------------------------------------------------------------------------------------- */
   public NCString trimRight()
      {
      return new NCString(super.trimRight());
      }



   /*:                                    
   ====================================================================================================
   [][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][]
   ==================================================================================================== *//**
   The description of this method is the same as the one for the method of the same name in the XString
   class documentation except that this NCString ignores the case of the letters in its string as it
   performs this operation.<P>

      <B>
         Documentation:
      </B>
       <A HREF="XString.html">
         View the XString Class
      </A>

   <P><B>Implementation: </B><A HREF="NCString.java.html#042">View source</A>

   *//*
   ---------------------------------------------------------------------------------------------------- */
   public <Type1> NCString trimRight(Type1 suffix)
      {
      return new NCString(super.trimRightIgnoreCase(suffix));
      }



   /*:                                    
   ====================================================================================================
   [][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][]
   ==================================================================================================== *//**
   The description of this method is the same as the one for the method of the same name in the XString
   class documentation except that this NCString ignores the case of the letters in its string as it
   performs this operation.<P>

      <B>
         Documentation:
      </B>
       <A HREF="XString.html">
         View the XString Class
      </A>

   <P><B>Implementation: </B><A HREF="NCString.java.html#043">View source</A>

   *//*
   ---------------------------------------------------------------------------------------------------- */
   public <Type1> NCString trimRightIgnoreCase(Type1 suffix)
      {
      return new NCString(super.trimRightIgnoreCase(suffix));
      }



   /*:                                    
   ====================================================================================================
   [][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][]
   ==================================================================================================== *//**
   The description of this method is the same as the one for the method of the same name in the XString
   class documentation except that this NCString ignores the case of the letters in its string as it
   performs this operation.<P>

      <B>
         Documentation:
      </B>
       <A HREF="XString.html">
         View the XString Class
      </A>

   <P><B>Implementation: </B><A HREF="NCString.java.html#044">View source</A>

   *//*
   ---------------------------------------------------------------------------------------------------- */
   public NCString alignLeft(int pFieldSize, char pPadChar)
      {
      return new NCString(super.alignLeft(pFieldSize,pPadChar));
      }



   /*:                                    
   ====================================================================================================
   [][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][]
   ==================================================================================================== *//**
   The description of this method is the same as the one for the method of the same name in the XString
   class documentation except that this NCString ignores the case of the letters in its string as it
   performs this operation.<P>

      <B>
         Documentation:
      </B>
       <A HREF="XString.html">
         View the XString Class
      </A>

   <P><B>Implementation: </B><A HREF="NCString.java.html#045">View source</A>

   *//*
   ---------------------------------------------------------------------------------------------------- */
   public NCString alignRight(int pFieldSize, char pPadChar)
      {
      return new NCString(super.alignRight(pFieldSize,pPadChar));
      }



   /*:                                    
   ====================================================================================================
   [][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][]
   ==================================================================================================== *//**
   The description of this method is the same as the one for the method of the same name in the XString
   class documentation except that this NCString ignores the case of the letters in its string as it
   performs this operation.<P>

      <B>
         Documentation:
      </B>
       <A HREF="XString.html">
         View the XString Class
      </A>

   <P><B>Implementation: </B><A HREF="NCString.java.html#046">View source</A>

   *//*
   ---------------------------------------------------------------------------------------------------- */
   public NCString alignCenter(int pFieldSize, char pPadChar)
      {
      return new NCString(super.alignCenter(pFieldSize,pPadChar));
      }



   /*:                                    
   ====================================================================================================
   [][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][]
   ==================================================================================================== *//**
   The description of this method is the same as the one for the method of the same name in the XString
   class documentation except that this NCString ignores the case of the letters in its string as it
   performs this operation.<P>

      <B>
         Documentation:
      </B>
       <A HREF="XString.html">
         View the XString Class
      </A>

   <P><B>Implementation: </B><A HREF="NCString.java.html#047">View source</A>

   *//*
   ---------------------------------------------------------------------------------------------------- */
   public NCString detab(int pTabSize)
      {
      return new NCString(super.detab(pTabSize));
      }



   /*:                                    
   ====================================================================================================
   [][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][]
   ==================================================================================================== *//**
   The description of this method is the same as the one for the method of the same name in the XString
   class documentation except that this NCString ignores the case of the letters in its string as it
   performs this operation.<P>

      <B>
         Documentation:
      </B>
       <A HREF="XString.html">
         View the XString Class
      </A>

   <P><B>Implementation: </B><A HREF="NCString.java.html#048">View source</A>

   *//*
   ---------------------------------------------------------------------------------------------------- */
   public NCString entab(int pTabSize)
      {
      return new NCString(super.entab(pTabSize));
      }



   /*:                                    
   ====================================================================================================
   [][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][]
   ==================================================================================================== *//**
   The description of this method is the same as the one for the method of the same name in the XString
   class documentation except that this NCString ignores the case of the letters in its string as it
   performs this operation.<P>

      <B>
         Documentation:
      </B>
       <A HREF="XString.html">
         View the XString Class
      </A>

   <P><B>Implementation: </B><A HREF="NCString.java.html#049">View source</A>

   *//*
   ---------------------------------------------------------------------------------------------------- */
   public <Type1, Type2> NCString replace(Type1 target, Type2 replacement)
      {
      return new NCString(super.replaceIgnoreCase(target,replacement));
      }



   /*:                                    
   ====================================================================================================
   [][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][]
   ==================================================================================================== *//**
   The description of this method is the same as the one for the method of the same name in the XString
   class documentation except that this NCString ignores the case of the letters in its string as it
   performs this operation.<P>

      <B>
         Documentation:
      </B>
       <A HREF="XString.html">
         View the XString Class
      </A>

   <P><B>Implementation: </B><A HREF="NCString.java.html#050">View source</A>

   *//*
   ---------------------------------------------------------------------------------------------------- */
   public <Type1, Type2> NCString iteratingReplace(Type1 pOldString, Type2 pNewString)
      {
      return new NCString(super.iteratingReplaceIgnoreCase(pOldString,pNewString));
      }



   /*:                                    
   ====================================================================================================
   [][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][]
   ==================================================================================================== *//**
   The description of this method is the same as the one for the method of the same name in the XString
   class documentation except that this NCString ignores the case of the letters in its string as it
   performs this operation.<P>

      <B>
         Documentation:
      </B>
       <A HREF="XString.html">
         View the XString Class
      </A>

   <P><B>Implementation: </B><A HREF="NCString.java.html#051">View source</A>

   *//*
   ---------------------------------------------------------------------------------------------------- */
   public <Type1, Type2> NCString iteratingReplaceIgnoreCase(Type1 pOldString, Type2 pNewString)
      {
      return new NCString(super.iteratingReplaceIgnoreCase(pOldString,pNewString));
      }



   /*:                                    
   ====================================================================================================
   [][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][]
   ==================================================================================================== *//**
   The description of this method is the same as the one for the method of the same name in the XString
   class documentation except that this NCString ignores the case of the letters in its string as it
   performs this operation.<P>

      <B>
         Documentation:
      </B>
       <A HREF="XString.html">
         View the XString Class
      </A>

   <P><B>Implementation: </B><A HREF="NCString.java.html#052">View source</A>

   *//*
   ---------------------------------------------------------------------------------------------------- */
   public NCString asciiHash()
      {
      return new NCString(super.asciiHashIgnoreCase());
      }



   /*:                                    
   ====================================================================================================
   [][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][]
   ==================================================================================================== *//**
   The description of this method is the same as the one for the method of the same name in the XString
   class documentation except that this NCString ignores the case of the letters in its string as it
   performs this operation.<P>

      <B>
         Documentation:
      </B>
       <A HREF="XString.html">
         View the XString Class
      </A>

   <P><B>Implementation: </B><A HREF="NCString.java.html#053">View source</A>

   *//*
   ---------------------------------------------------------------------------------------------------- */
   public NCString asciiHashIgnoreCase()
      {
      return new NCString(super.asciiHashIgnoreCase());
      }



   /*:                                    
   ====================================================================================================
   [][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][]
   ==================================================================================================== *//**
   The description of this method is the same as the one for the method of the same name in the XString
   class documentation except that this NCString ignores the case of the letters in its string as it
   performs this operation.<P>

      <B>
         Documentation:
      </B>
       <A HREF="XString.html">
         View the XString Class
      </A>

   <P><B>Implementation: </B><A HREF="NCString.java.html#054">View source</A>

   *//*
   ---------------------------------------------------------------------------------------------------- */
   public NCString whitespacePrefix()
      {
      return new NCString(super.whitespacePrefix());
      }



   /*:                                    
   ====================================================================================================
   [][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][]
   ==================================================================================================== *//**
   The description of this method is the same as the one for the method of the same name in the XString
   class documentation except that this NCString ignores the case of the letters in its string as it
   performs this operation.<P>

      <B>
         Documentation:
      </B>
       <A HREF="XString.html">
         View the XString Class
      </A>

   <P><B>Implementation: </B><A HREF="NCString.java.html#055">View source</A>

   *//*
   ---------------------------------------------------------------------------------------------------- */
   public ArrayList<XString> wordWrap()
      {
      ArrayList<XString>  aStr   = super.wordWrap();
      ArrayList<XString>  result = new ArrayList<XString>();
      for (XString str : aStr)
         {
         result.add(new NCString(str));
         }
      return result;
      }



   /*:                                    
   ====================================================================================================
   [][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][]
   ==================================================================================================== *//**
   The description of this method is the same as the one for the method of the same name in the XString
   class documentation except that this NCString ignores the case of the letters in its string as it
   performs this operation.<P>

      <B>
         Documentation:
      </B>
       <A HREF="XString.html">
         View the XString Class
      </A>

   <P><B>Implementation: </B><A HREF="NCString.java.html#056">View source</A>

   *//*
   ---------------------------------------------------------------------------------------------------- */
   public ArrayList<XString> wordWrap(UCapitalizer pCapitalizer)
      {
      ArrayList<XString>  aStr   = super.wordWrap(pCapitalizer);
      ArrayList<XString>  result = new ArrayList<XString>();
      for (XString str : aStr)
         {
         result.add(new NCString(str));
         }
      return result;
      }



   /*:                                    
   ====================================================================================================
   [][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][]
   ==================================================================================================== *//**
   The description of this method is the same as the one for the method of the same name in the XString
   class documentation except that this NCString ignores the case of the letters in its string as it
   performs this operation.<P>

      <B>
         Documentation:
      </B>
       <A HREF="XString.html">
         View the XString Class
      </A>

   <P><B>Implementation: </B><A HREF="NCString.java.html#057">View source</A>

   *//*
   ---------------------------------------------------------------------------------------------------- */
   public ArrayList<XString> wordWrap(int pLineLength)
      {
      ArrayList<XString>  aStr   = super.wordWrap(pLineLength);
      ArrayList<XString>  result = new ArrayList<XString>();
      for (XString str : aStr)
         {
         result.add(new NCString(str));
         }
      return result;
      }



   /*:                                    
   ====================================================================================================
   [][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][]
   ==================================================================================================== *//**
   The description of this method is the same as the one for the method of the same name in the XString
   class documentation except that this NCString ignores the case of the letters in its string as it
   performs this operation.<P>

      <B>
         Documentation:
      </B>
       <A HREF="XString.html">
         View the XString Class
      </A>

   <P><B>Implementation: </B><A HREF="NCString.java.html#058">View source</A>

   *//*
   ---------------------------------------------------------------------------------------------------- */
   public ArrayList<XString> wordWrap(int pLineLength, UCapitalizer pCapitalizer)
      {
      ArrayList<XString>  aStr   = super.wordWrap(pLineLength,pCapitalizer);
      ArrayList<XString>  result = new ArrayList<XString>();
      for (XString str : aStr)
         {
         result.add(new NCString(str));
         }
      return result;
      }



   /*:                                    
   ====================================================================================================
   [][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][]
   ==================================================================================================== *//**
   The description of this method is the same as the one for the method of the same name in the XString
   class documentation except that this NCString ignores the case of the letters in its string as it
   performs this operation.<P>

      <B>
         Documentation:
      </B>
       <A HREF="XString.html">
         View the XString Class
      </A>

   <P><B>Implementation: </B><A HREF="NCString.java.html#059">View source</A>

   *//*
   ---------------------------------------------------------------------------------------------------- */
   public ArrayList<XString> tokenizedMixedCaseString()
      {
      ArrayList<XString>  result = new ArrayList<XString>();
      result.add(new NCString(this));
      return result;
      }



   /*:                                    
   ====================================================================================================
   [][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][]
   ==================================================================================================== *//**
   The description of this method is the same as the one for the method of the same name in the XString
   class documentation except that this NCString ignores the case of the letters in its string as it
   performs this operation.<P>

      <B>
         Documentation:
      </B>
       <A HREF="XString.html">
         View the XString Class
      </A>

   <P><B>Implementation: </B><A HREF="NCString.java.html#060">View source</A>

   *//*
   ---------------------------------------------------------------------------------------------------- */
   public <Type1> ArrayList<XString> tokenizedString(Type1 pDelimiters)
      {
      ArrayList<XString>  aStr   = super.tokenizedStringIgnoreCase(pDelimiters);
      ArrayList<XString>  result = new ArrayList<XString>();
      for (XString str : aStr)
         {
         result.add(new NCString(str));
         }
      return result;
      }



   /*:                                    
   ====================================================================================================
   [][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][]
   ==================================================================================================== *//**
   The description of this method is the same as the one for the method of the same name in the XString
   class documentation except that this NCString ignores the case of the letters in its string as it
   performs this operation.<P>

      <B>
         Documentation:
      </B>
       <A HREF="XString.html">
         View the XString Class
      </A>

   <P><B>Implementation: </B><A HREF="NCString.java.html#061">View source</A>

   *//*
   ---------------------------------------------------------------------------------------------------- */
   public <Type1> ArrayList<XString> tokenizedStringIgnoreCase(Type1 pDelimiters)
      {
      ArrayList<XString>  aStr   = super.tokenizedStringIgnoreCase(pDelimiters);
      ArrayList<XString>  result = new ArrayList<XString>();
      for (XString str : aStr)
         {
         result.add(new NCString(str));
         }
      return result;
      }



   /*:                                    
   ====================================================================================================
   [][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][]
   ==================================================================================================== *//**
   The description of this method is the same as the one for the method of the same name in the XString
   class documentation except that this NCString ignores the case of the letters in its string as it
   performs this operation.<P>

      <B>
         Documentation:
      </B>
       <A HREF="XString.html">
         View the XString Class
      </A>

   <P><B>Implementation: </B><A HREF="NCString.java.html#062">View source</A>

   *//*
   ---------------------------------------------------------------------------------------------------- */
   public NCString removeLeadingZeros()
      {
      return new NCString(super.removeLeadingZeros());
      }



   /*:                                    
   ====================================================================================================
   [][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][]
   ==================================================================================================== *//**
   The description of this method is the same as the one for the method of the same name in the XString
   class documentation except that this NCString ignores the case of the letters in its string as it
   performs this operation.<P>

      <B>
         Documentation:
      </B>
       <A HREF="XString.html">
         View the XString Class
      </A>

   <P><B>Implementation: </B><A HREF="NCString.java.html#063">View source</A>

   *//*
   ---------------------------------------------------------------------------------------------------- */
   public <Type1> int containsCount(Type1 pOther)
      {
      return super.containsCountIgnoreCase(pOther);
      }



   /*:                                    
   ====================================================================================================
   [][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][]
   ==================================================================================================== *//**
   The description of this method is the same as the one for the method of the same name in the XString
   class documentation except that this NCString ignores the case of the letters in its string as it
   performs this operation.<P>

      <B>
         Documentation:
      </B>
       <A HREF="XString.html">
         View the XString Class
      </A>

   <P><B>Implementation: </B><A HREF="NCString.java.html#064">View source</A>

   *//*
   ---------------------------------------------------------------------------------------------------- */
   public boolean containsChar(char pChar)
      {
      return super.containsCharIgnoreCase(pChar);
      }



   /*:                                    
   ====================================================================================================
   [][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][]
   ==================================================================================================== *//**
   The description of this method is the same as the one for the method of the same name in the XString
   class documentation except that this NCString ignores the case of the letters in its string as it
   performs this operation.<P>

      <B>
         Documentation:
      </B>
       <A HREF="XString.html">
         View the XString Class
      </A>

   <P><B>Implementation: </B><A HREF="NCString.java.html#065">View source</A>

   *//*
   ---------------------------------------------------------------------------------------------------- */
   public <Type1> boolean containsAnyCharsInString(Type1 pChars)
      {
      return super.containsAnyCharsInStringIgnoreCase(pChars);
      }



   /*:                                    
   ====================================================================================================
   [][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][]
   ==================================================================================================== *//**
   The description of this method is the same as the one for the method of the same name in the XString
   class documentation except that this NCString ignores the case of the letters in its string as it
   performs this operation.<P>

      <B>
         Documentation:
      </B>
       <A HREF="XString.html">
         View the XString Class
      </A>

   <P><B>Implementation: </B><A HREF="NCString.java.html#066">View source</A>

   *//*
   ---------------------------------------------------------------------------------------------------- */
   public <Type1> boolean containsOnlyCharsInString(Type1 pChars)
      {
      return super.containsOnlyCharsInStringIgnoreCase(pChars);
      }



   /*:                                    
   ====================================================================================================
   [][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][]
   ==================================================================================================== *//**
   The description of this method is the same as the one for the method of the same name in the XString
   class documentation except that this NCString ignores the case of the letters in its string as it
   performs this operation.<P>

      <B>
         Documentation:
      </B>
       <A HREF="XString.html">
         View the XString Class
      </A>

   <P><B>Implementation: </B><A HREF="NCString.java.html#067">View source</A>

   *//*
   ---------------------------------------------------------------------------------------------------- */
   public NCString truncString(int pSize)
      {
      return new NCString(super.truncString(pSize));
      }



   /*:                                    
   ====================================================================================================
   [][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][]
   ==================================================================================================== *//**
   The description of this method is the same as the one for the method of the same name in the XString
   class documentation except that this NCString ignores the case of the letters in its string as it
   performs this operation.<P>

      <B>
         Documentation:
      </B>
       <A HREF="XString.html">
         View the XString Class
      </A>

   <P><B>Implementation: </B><A HREF="NCString.java.html#068">View source</A>

   *//*
   ---------------------------------------------------------------------------------------------------- */
   public NCString replaceIgnoreCase(char oldChar, char newChar)
      {
      return new NCString(super.replaceIgnoreCase(oldChar,newChar));
      }



   /*:                                    
   ====================================================================================================
   [][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][]
   ==================================================================================================== *//**
   The description of this method is the same as the one for the method of the same name in the XString
   class documentation except that this NCString ignores the case of the letters in its string as it
   performs this operation.<P>

      <B>
         Documentation:
      </B>
       <A HREF="XString.html">
         View the XString Class
      </A>

   <P><B>Implementation: </B><A HREF="NCString.java.html#069">View source</A>

   *//*
   ---------------------------------------------------------------------------------------------------- */
   public <Type1, Type2> NCString replaceFirstIgnoreCase(Type1 regex, Type2 replacement)
      {
      return new NCString(super.replaceFirstIgnoreCase(regex,replacement));
      }



   /*:                                    
   ====================================================================================================
   [][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][]
   ==================================================================================================== *//**
   The description of this method is the same as the one for the method of the same name in the XString
   class documentation except that this NCString ignores the case of the letters in its string as it
   performs this operation.<P>

      <B>
         Documentation:
      </B>
       <A HREF="XString.html">
         View the XString Class
      </A>

   <P><B>Implementation: </B><A HREF="NCString.java.html#070">View source</A>

   *//*
   ---------------------------------------------------------------------------------------------------- */
   public <Type1, Type2> NCString replaceAllIgnoreCase(Type1 regex, Type2 replacement)
      {
      return new NCString(super.replaceAllIgnoreCase(regex,replacement));
      }



   /*:                                    
   ====================================================================================================
   [][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][]
   ==================================================================================================== *//**
   The description of this method is the same as the one for the method of the same name in the XString
   class documentation except that this NCString ignores the case of the letters in its string as it
   performs this operation.<P>

      <B>
         Documentation:
      </B>
       <A HREF="XString.html">
         View the XString Class
      </A>

   <P><B>Implementation: </B><A HREF="NCString.java.html#071">View source</A>

   *//*
   ---------------------------------------------------------------------------------------------------- */
   public NCString replaceIgnoreCase(CharSequence target, CharSequence replacement)
      {
      return new NCString(super.replaceIgnoreCase(target,replacement));
      }



   /*:                                    
   ====================================================================================================
   [][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][]
   ==================================================================================================== *//**
   The description of this method is the same as the one for the method of the same name in the XString
   class documentation except that this NCString ignores the case of the letters in its string as it
   performs this operation.<P>

      <B>
         Documentation:
      </B>
       <A HREF="XString.html">
         View the XString Class
      </A>

   <P><B>Implementation: </B><A HREF="NCString.java.html#072">View source</A>

   *//*
   ---------------------------------------------------------------------------------------------------- */
   public <Type1> NCString[] splitIgnoreCase(Type1 regex, int limit)
      {
      return NCString.toNCStringArray(super.splitIgnoreCase(regex,limit));
      }



   /*:                                    
   ====================================================================================================
   [][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][]
   ==================================================================================================== *//**
   The description of this method is the same as the one for the method of the same name in the XString
   class documentation except that this NCString ignores the case of the letters in its string as it
   performs this operation.<P>

      <B>
         Documentation:
      </B>
       <A HREF="XString.html">
         View the XString Class
      </A>

   <P><B>Implementation: </B><A HREF="NCString.java.html#073">View source</A>

   *//*
   ---------------------------------------------------------------------------------------------------- */
   public <Type1> NCString[] splitIgnoreCase(Type1 regex)
      {
      return NCString.toNCStringArray(super.splitIgnoreCase(regex));
      }



   /*:                                    
   ====================================================================================================
   [][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][]
   ==================================================================================================== *//**
   The description of this method is the same as the one for the method of the same name in the XString
   class documentation except that this NCString ignores the case of the letters in its string as it
   performs this operation.<P>

      <B>
         Documentation:
      </B>
       <A HREF="XString.html">
         View the XString Class
      </A>

   <P><B>Implementation: </B><A HREF="NCString.java.html#074">View source</A>

   *//*
   ---------------------------------------------------------------------------------------------------- */
   public NCString setOut(ConsoleStream pConsole)
      {
      cOut = pConsole;
      return this;
      }



   /*:                                    
   ====================================================================================================
   [][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][]
   ==================================================================================================== *//**
   This boilerplate method is used for testing an instantiated object of this class and may include any
   code the developer chooses.

   <P><B>Implementation: </B><A HREF="NCString.java.html#075">View source</A>

   *//*
   ---------------------------------------------------------------------------------------------------- */
   public NCString test() throws Exception
      {
      cOut.titledPrintf
         (
         "\"HELLO WORLD!\"",
         "%s  %s  %s",
         "I'm an object of the", CLASS_NAME, "class, and I approved this message."
         );
      return this;
      }



   /*:.
   ==============================================================================================================
   @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@[  Protected  ]@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
   ============================================================================================================== */



   /*:.
   ==============================================================================================================
   @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@[  Private  ]@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
   ============================================================================================================== */



   /*.
   ==========================================================================================
   Class Constants
      CLASS_NAME : the name of this class DFLT_LINE_LEN : the default line length for word
      wrapping
   ------------------------------------------------------------------------------------------ */
   private static final XString  CLASS_NAME    = new XString(NCString.class.getName());
   private static final int      DFLT_LINE_LEN = ConsoleMessage.defaultLineLength();
   /*.
   ==========================================================================================
   Class variables
      cOut : console output.
   ------------------------------------------------------------------------------------------ */
   private static ConsoleStream  cOut = ConsoleStream.getSingleton();



   /*:.
   ==============================================================================================================
   @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@[  Inner Classes  ]@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
   ============================================================================================================== */



   /*:.
   ==============================================================================================================
   @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@[  Public Static Methods  ]@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
   ============================================================================================================== */



   /*:.
   ==============================================================================================================
   <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<[  The String API  ]>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
   ============================================================================================================== */



   /*:                                    
   ====================================================================================================
   [][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][]
   ==================================================================================================== *//**
   The description of this method is the same as the one for the method of the same name in the XString
   class documentation except that this NCString ignores the case of the letters in its string as it
   performs this operation.<P>

      <B>
         Documentation:
      </B>
       <A HREF="XString.html">
         View the XString Class
      </A>

   <P><B>Implementation: </B><A HREF="NCString.java.html#076">View source</A>

   *//*
   ---------------------------------------------------------------------------------------------------- */
   public static <Type1> NCString format(Type1 format, Object... args)
      {
      return new NCString(XString.format(format,args));
      }



   /*:                                    
   ====================================================================================================
   [][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][]
   ==================================================================================================== *//**
   The description of this method is the same as the one for the method of the same name in the XString
   class documentation except that this NCString ignores the case of the letters in its string as it
   performs this operation.<P>

      <B>
         Documentation:
      </B>
       <A HREF="XString.html">
         View the XString Class
      </A>

   <P><B>Implementation: </B><A HREF="NCString.java.html#077">View source</A>

   *//*
   ---------------------------------------------------------------------------------------------------- */
   public static <Type1> NCString format(Locale l, Type1 format, Object... args)
      {
      return new NCString(XString.format(l,format,args));
      }



   /*:                                    
   ====================================================================================================
   [][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][]
   ==================================================================================================== *//**
   The description of this method is the same as the one for the method of the same name in the XString
   class documentation except that this NCString ignores the case of the letters in its string as it
   performs this operation.<P>

      <B>
         Documentation:
      </B>
       <A HREF="XString.html">
         View the XString Class
      </A>

   <P><B>Implementation: </B><A HREF="NCString.java.html#078">View source</A>

   *//*
   ---------------------------------------------------------------------------------------------------- */
   public static NCString valueOf(Object obj)
      {
      return new NCString(XString.valueOf(obj));
      }



   /*:                                    
   ====================================================================================================
   [][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][]
   ==================================================================================================== *//**
   The description of this method is the same as the one for the method of the same name in the XString
   class documentation except that this NCString ignores the case of the letters in its string as it
   performs this operation.<P>

      <B>
         Documentation:
      </B>
       <A HREF="XString.html">
         View the XString Class
      </A>

   <P><B>Implementation: </B><A HREF="NCString.java.html#079">View source</A>

   *//*
   ---------------------------------------------------------------------------------------------------- */
   public static NCString valueOf(char data[])
      {
      return new NCString(XString.valueOf(data));
      }



   /*:                                    
   ====================================================================================================
   [][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][]
   ==================================================================================================== *//**
   The description of this method is the same as the one for the method of the same name in the XString
   class documentation except that this NCString ignores the case of the letters in its string as it
   performs this operation.<P>

      <B>
         Documentation:
      </B>
       <A HREF="XString.html">
         View the XString Class
      </A>

   <P><B>Implementation: </B><A HREF="NCString.java.html#080">View source</A>

   *//*
   ---------------------------------------------------------------------------------------------------- */
   public static NCString valueOf(char data[], int offset, int count)
      {
      return new NCString(XString.valueOf(data,offset,count));
      }



   /*:                                    
   ====================================================================================================
   [][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][]
   ==================================================================================================== *//**
   The description of this method is the same as the one for the method of the same name in the XString
   class documentation except that this NCString ignores the case of the letters in its string as it
   performs this operation.<P>

      <B>
         Documentation:
      </B>
       <A HREF="XString.html">
         View the XString Class
      </A>

   <P><B>Implementation: </B><A HREF="NCString.java.html#081">View source</A>

   *//*
   ---------------------------------------------------------------------------------------------------- */
   public static NCString copyValueOf(char data[], int offset, int count)
      {
      return new NCString(XString.copyValueOf(data,offset,count));
      }



   /*:                                    
   ====================================================================================================
   [][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][]
   ==================================================================================================== *//**
   The description of this method is the same as the one for the method of the same name in the XString
   class documentation except that this NCString ignores the case of the letters in its string as it
   performs this operation.<P>

      <B>
         Documentation:
      </B>
       <A HREF="XString.html">
         View the XString Class
      </A>

   <P><B>Implementation: </B><A HREF="NCString.java.html#082">View source</A>

   *//*
   ---------------------------------------------------------------------------------------------------- */
   public static NCString copyValueOf(char data[])
      {
      return new NCString(XString.copyValueOf(data));
      }



   /*:                                    
   ====================================================================================================
   [][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][]
   ==================================================================================================== *//**
   The description of this method is the same as the one for the method of the same name in the XString
   class documentation except that this NCString ignores the case of the letters in its string as it
   performs this operation.<P>

      <B>
         Documentation:
      </B>
       <A HREF="XString.html">
         View the XString Class
      </A>

   <P><B>Implementation: </B><A HREF="NCString.java.html#083">View source</A>

   *//*
   ---------------------------------------------------------------------------------------------------- */
   public static NCString valueOf(boolean b)
      {
      return new NCString(XString.valueOf(b));
      }



   /*:                                    
   ====================================================================================================
   [][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][]
   ==================================================================================================== *//**
   The description of this method is the same as the one for the method of the same name in the XString
   class documentation except that this NCString ignores the case of the letters in its string as it
   performs this operation.<P>

      <B>
         Documentation:
      </B>
       <A HREF="XString.html">
         View the XString Class
      </A>

   <P><B>Implementation: </B><A HREF="NCString.java.html#084">View source</A>

   *//*
   ---------------------------------------------------------------------------------------------------- */
   public static NCString valueOf(char c)
      {
      return new NCString(XString.valueOf(c));
      }



   /*:                                    
   ====================================================================================================
   [][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][]
   ==================================================================================================== *//**
   The description of this method is the same as the one for the method of the same name in the XString
   class documentation except that this NCString ignores the case of the letters in its string as it
   performs this operation.<P>

      <B>
         Documentation:
      </B>
       <A HREF="XString.html">
         View the XString Class
      </A>

   <P><B>Implementation: </B><A HREF="NCString.java.html#085">View source</A>

   *//*
   ---------------------------------------------------------------------------------------------------- */
   public static NCString valueOf(int i)
      {
      return new NCString(XString.valueOf(i));
      }



   /*:                                    
   ====================================================================================================
   [][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][]
   ==================================================================================================== *//**
   The description of this method is the same as the one for the method of the same name in the XString
   class documentation except that this NCString ignores the case of the letters in its string as it
   performs this operation.<P>

      <B>
         Documentation:
      </B>
       <A HREF="XString.html">
         View the XString Class
      </A>

   <P><B>Implementation: </B><A HREF="NCString.java.html#086">View source</A>

   *//*
   ---------------------------------------------------------------------------------------------------- */
   public static NCString valueOf(long l)
      {
      return new NCString(XString.valueOf(l));
      }



   /*:                                    
   ====================================================================================================
   [][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][]
   ==================================================================================================== *//**
   The description of this method is the same as the one for the method of the same name in the XString
   class documentation except that this NCString ignores the case of the letters in its string as it
   performs this operation.<P>

      <B>
         Documentation:
      </B>
       <A HREF="XString.html">
         View the XString Class
      </A>

   <P><B>Implementation: </B><A HREF="NCString.java.html#087">View source</A>

   *//*
   ---------------------------------------------------------------------------------------------------- */
   public static NCString valueOf(float f)
      {
      return new NCString(XString.valueOf(f));
      }



   /*:                                    
   ====================================================================================================
   [][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][]
   ==================================================================================================== *//**
   The description of this method is the same as the one for the method of the same name in the XString
   class documentation except that this NCString ignores the case of the letters in its string as it
   performs this operation.<P>

      <B>
         Documentation:
      </B>
       <A HREF="XString.html">
         View the XString Class
      </A>

   <P><B>Implementation: </B><A HREF="NCString.java.html#088">View source</A>

   *//*
   ---------------------------------------------------------------------------------------------------- */
   public static NCString valueOf(double d)
      {
      return new NCString(XString.valueOf(d));
      }



   /*:.
   ==============================================================================================================
   <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<[  The Extensions  ]>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
   ============================================================================================================== */



   /*:                                    
   ====================================================================================================
   [][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][]
   ==================================================================================================== *//**
   This method creates a NCString representation of pStr.<P>

   <P><B>Implementation: </B><A HREF="NCString.java.html#089">View source</A>

   @return
      A new NCString containing the NCString representation of pStr

   @param
      P is the primitive type value or object whose string representation will be returned.
   *//*
   ---------------------------------------------------------------------------------------------------- */
   public static <Type1> NCString toNCString(Type1 pStr)
      {
      if (pStr == null)
         {
         return null;
         }
      return new NCString(pStr);
      }



   /*:                                    
   ====================================================================================================
   [][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][]
   ==================================================================================================== *//**
   This method creates an NCString[] representation of pStr[].

   <P><B>Implementation: </B><A HREF="NCString.java.html#090">View source</A>

   @return
      A new NCString[] containing the NCString representation of the elements of pStr[]

   @param
      P is the array of primitive type values or objects that are converted into XStrings
   *//*
   ---------------------------------------------------------------------------------------------------- */
   public static <Type1> NCString[] toNCStringArray(Type1[] pStr)
      {
      NCString[]  result = new NCString[pStr.length];
      for (int i=0; i<pStr.length; i++)
         {
         result[i] = NCString.toNCString(pStr[i]);
         }
      return result;
      }



   /*:                                    
   ====================================================================================================
   [][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][]
   ==================================================================================================== *//**
   This method creates an XString[] representation of pStr[].

   <P><B>Implementation: </B><A HREF="NCString.java.html#091">View source</A>

   @return
      A new XString[] containing the NCString or XString representation of the elements of pStr[]

   @param
      P is the array of primitive type values or objects that are converted into XStrings
   *//*
   ---------------------------------------------------------------------------------------------------- */
   public static <Type1> XString[] toGenericXStringArray(Type1[] pStr)
      {
      XString[]  result = new XString[pStr.length];
      for (int i=0; i<pStr.length; i++)
         {
         result[i] = (pStr[i] instanceof NCString)? NCString.toNCString(pStr[i]) : XString.toXString(pStr[i]);
         }
      return result;
      }



   /*:                                    
   ====================================================================================================
   [][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][]
   ==================================================================================================== *//**
   This method creates an XString[] representation of pStr[].

   <P><B>Implementation: </B><A HREF="NCString.java.html#092">View source</A>

   @return
      A new XString[] containing the NCString or XString representation of the elements of pStr[]

   @param
      P is the array of primitive type values or objects that are converted into XStrings
   *//*
   ---------------------------------------------------------------------------------------------------- */
   public static <Type1> XString[] toGenericXStringArray(List<Type1> pStr)
      {
      Object[]  a = pStr.toArray();
      return NCString.toGenericXStringArray(a);
      }



   /*:                                    
   ====================================================================================================
   [][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][]
   ==================================================================================================== *//**
   This method creates an NCString[] representation of pStr[].

   <P><B>Implementation: </B><A HREF="NCString.java.html#093">View source</A>

   @return
      A new NCString[] containing the NCString representation of the elements of pStr[]

   @param
      P is the array of primitive type values or objects that are converted into XStrings
   *//*
   ---------------------------------------------------------------------------------------------------- */
   public static <Type1> NCString[] toNCStringArray(List<Type1> pStr)
      {
      Object[]  a = pStr.toArray();
      return NCString.toNCStringArray(a);
      }



   /*:                                    
   ====================================================================================================
   [][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][]
   ==================================================================================================== *//**
   This method creates an ArrayList<NCString> representation of pStr.

   <P><B>Implementation: </B><A HREF="NCString.java.html#094">View source</A>

   @return
      A new ArrayList<NCString> containing the NCString representation of the elements of pStr

   @param
      P is the list of primitive type values or objects that are converted into NCStrings
   *//*
   ---------------------------------------------------------------------------------------------------- */
   public static <Type1> ArrayList<NCString> toNCStringList(Type1[] pStr)
      {
      return new ArrayList<NCString>(Arrays.asList(toNCStringArray(pStr)));
      }



   /*:                                    
   ====================================================================================================
   [][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][]
   ==================================================================================================== *//**
   This method creates an ArrayList<NCString> representation of pStr.

   <P><B>Implementation: </B><A HREF="NCString.java.html#095">View source</A>

   @return
      A new ArrayList<NCString> containing the NCString representation of the elements of pStr

   @param
      P is the list of primitive type values or objects that are converted into XStrings
   *//*
   ---------------------------------------------------------------------------------------------------- */
   public static <Type1> ArrayList<NCString> toNCStringList(List<Type1> pStr)
      {
      Object[]  a = pStr.toArray();
      return new ArrayList<NCString>(Arrays.asList(toNCStringArray(a)));
      }



   /*:                                    
   ====================================================================================================
   [][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][]
   ==================================================================================================== *//**
   The description of this method is the same as the one for the method of the same name in the XString
   class documentation except that this NCString ignores the case of the letters in its string as it
   performs this operation.<P>

      <B>
         Documentation:
      </B>
       <A HREF="XString.html">
         View the XString Class
      </A>

   <P><B>Implementation: </B><A HREF="NCString.java.html#096">View source</A>

   *//*
   ---------------------------------------------------------------------------------------------------- */
   public static NCString noCase(NCString pStr)
      {
      return new NCString(XString.noCase(pStr));
      }



   /*:                                    
   ====================================================================================================
   [][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][]
   ==================================================================================================== *//**
   The description of this method is the same as the one for the method of the same name in the XString
   class documentation except that this NCString ignores the case of the letters in its string as it
   performs this operation.<P>

      <B>
         Documentation:
      </B>
       <A HREF="XString.html">
         View the XString Class
      </A>

   <P><B>Implementation: </B><A HREF="NCString.java.html#097">View source</A>

   *//*
   ---------------------------------------------------------------------------------------------------- */
   public static <Type1, Type2> NCString untokenizedArrayList(ArrayList<Type1> pArrayList, Type2 pDelimiter)
      {
      return new NCString(XString.untokenizedArrayList(pArrayList,pDelimiter));
      }



   /*:                                    
   ====================================================================================================
   [][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][]
   ==================================================================================================== *//**
   The description of this method is the same as the one for the method of the same name in the XString
   class documentation except that this NCString ignores the case of the letters in its string as it
   performs this operation.<P>

      <B>
         Documentation:
      </B>
       <A HREF="XString.html">
         View the XString Class
      </A>

   <P><B>Implementation: </B><A HREF="NCString.java.html#098">View source</A>

   *//*
   ---------------------------------------------------------------------------------------------------- */
   public static NCString toHexString(byte pByte)
      {
      return new NCString(XString.toHexString(pByte));
      }



   /*:                                    
   ====================================================================================================
   [][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][]
   ==================================================================================================== *//**
   The description of this method is the same as the one for the method of the same name in the XString
   class documentation except that this NCString ignores the case of the letters in its string as it
   performs this operation.<P>

      <B>
         Documentation:
      </B>
       <A HREF="XString.html">
         View the XString Class
      </A>

   <P><B>Implementation: </B><A HREF="NCString.java.html#099">View source</A>

   *//*
   ---------------------------------------------------------------------------------------------------- */
   public static NCString toHexString(byte[] pByte)
      {
      return new NCString(XString.toHexString(pByte));
      }



   /*:                                    
   ====================================================================================================
   [][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][]
   ==================================================================================================== *//**
   This method returns the indexs within this XString of the start and end of the first occurrence of a
   substring that matches a specified regular expression, found by a search starting at the specified
   index. If no match is found, -1s are returned.

   <P><B>Implementation: </B><A HREF="NCString.java.html#100">View source</A>

   @return
      This method returns an array of integers containg three elements:
         <BLOCKQUOTE>
            => Element 0 (i.e. Result[0]): contains the start index, i.e. The index OF the first
               Character In the first occurrence of the regex-specified substring, found by a search
               starting at the specified index, or -1 if there is no such occurrence.<BR>
            => Element 1 (i.e. Result[1]): contains the end index, i.e. The index AFTER the last
               Character In the first occurrence of the regex-specified substring, found by a search
               starting at the specified index, or -1 if there is no such occurrence.<BR>
            => Element 2 (i.e. Result[2]): contains the length of the first occurrence of the
               Regex-specified substring, found by a search starting at the specified index, i.e.
               Result[1] - result[0], or -1 if there is no such occurrence.<BR>
         </BLOCKQUOTE>

      Note that if a matching substring is not found, all three elements of the returned array of
      integers will contain a -1.

   @param
      pPattern is an Object whose String representation is used as the regular expression. For the
      specification of valid regular expression constructs, see:
         <BLOCKQUOTE>
            <A href="http://docs.oracle.com/javase/8/docs/api/index.html">
               Valid Regular Expression Constructs
            </A>
         </BLOCKQUOTE>
   @param
      pFromIndex is the index of the character in pStr from which to start the search.
   *//*
   ---------------------------------------------------------------------------------------------------- */
   public <Type1> int[] indexOfRegex(Type1 pPattern, int pFromIndex)
      {
      return UString.indexOfRegexIgnoreCase(this.iOrignlStr, pPattern, pFromIndex);
      }


   public <Type1> int[] indexOfRegexIgnoreCase(Type1 pPattern, int pFromIndex)
      {
      return UString.indexOfRegexIgnoreCase(this.iOrignlStr, pPattern, pFromIndex);
      }



   /*:                                    
   ====================================================================================================
   [][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][]
   ==================================================================================================== *//**
   This method allows this class file to be unit tested as a standalone application. It's the method
   that's called when the class is invoked from the command line by using the java application launcher
   - "java". Main() is not a required method, but the practice of putting one in each class and
   wrapping class test code within it allows easy unit testing of the class; and main does not need to
   be removed when testing is complete.

   <P>
      <DL>
         <DT>
            <B>
               Command line usage:
            </B>
            <DD>
               Java cosmicabyss.com.utl.NCString
            </DD>
         </DT>
      </DL>

   <P><B>Implementation: </B><A HREF="NCString.java.html#101">View source</A>

   @param
      pArgs contains the command line arguments with which this class was invoked as an application.
   *//*
   ---------------------------------------------------------------------------------------------------- */
   public static void main(String[] pArgs) throws Exception
      {
      /*.
      ==========================================================================================
      Greetings !
      ------------------------------------------------------------------------------------------ */
      cOut.banner(CLASS_NAME);
      /*.
      ==========================================================================================
      Create an object and send its output to the ConsoleStream
      ------------------------------------------------------------------------------------------ */
      NCString  obj = new NCString("ANewdeeFString-aAbBcCdDeEfF");
      /*.
      ==========================================================================================
      Test code
      ------------------------------------------------------------------------------------------ */
      obj.test();
      /*.
      ==========================================================================================
      ------------------------------------------------------------------------------------------ */
      System.out.println(obj.string());
      System.out.println(obj.replace('a','@').string());
      System.out.println(obj.replace("deeF"," ALLEN ").string());
      System.out.println(obj.replace("DeEf"," ALLEN ").string());


      obj = new NCString
         (
         "java cosmicabyss.com.DecryptCipherFile [-h -q] [-pStr password] [-i number] \"files\" ... \n" +
         "                                                                    \n" +
         "  -h means HELP                                                     \n" +
         "     and it causes this usage message to be displayed,              \n" +
         "     and terminates the program.  another sentence.                 \n" +
         "                                                                    \n" +
         "  -q means QUIET                                                    \n" +
         "     and it stops the program from sending log                      \n" +
         "     messages to stdout. The program sends log messages             \n" +
         "     to stdout by default; this option is the only way to           \n" +
         "     stop it from doing that.                                       \n" +
         "                                                                    \n" +
         "  -i means ITERATIONS                                               \n" +
         "     and it requires a number argument, and causes                  \n" +
         "     the program to run the decryption process on the files the     \n" +
         "     specified number of times.  if no iterations count is specified \n" +
         "     on the commandline, then the program runs the decryption       \n" +
         "     process on the files the default number of times.              \n" +
         "                                                                    \n" +
         "  files                                                             \n" +
         "     is a required parameter and is one or more file specifiers     \n" +
         "     that identifies the files that the program will process.       \n" +
         "                                                                    \n" +
         "     enclosing the files in quotes prevents the command             \n" +
         "     line interpreter from trying to replace wildcard               \n" +
         "     characters itself instead of letting                           \n" +
         "     DecryptCipherFile do it.                                       \n" +
         "     enclosing the files in quotes prevents the command             \n" +
         "     line interpreter from trying to replace wildcard               \n" +
         "     characters itself instead of letting                           \n" +
         "     DecryptCipherFile do it.                                       \n" +
         "                                                                    \n" +
         "                                                                    \n" +
         "     this is a test? this is a test!  this is a                     \n" +
         "     test.   this.is!test?this. is! test? this.                     \n" +
         "                                                                    \n" +
         "     the quotes surrounding the files are not needed if             \n" +
         "     there are no wildcard characters in them.                      \n"
         );

      NCString border = new NCString("====================================================================================");
      UString.BasicEnglishCapitalizerNoFirst capitalizer = new UString.BasicEnglishCapitalizerNoFirst();
      System.out.println("");
      System.out.println(border);
      ArrayList<XString>  lines = obj.wordWrap(border.length(),capitalizer);
      for (XString s : lines)
         {
         System.out.println(s.string());
         }
      System.out.println(border);

      System.out.println(NCString.toXString(border));

      cOut.println("USAGE",obj);
      }



   }  // class NCString



   /*:.
   ==============================================================================================================
   @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@[  Notes  ]@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
   ============================================================================================================== */