April 18, 2007
//module jdk2d.lang;

import std.stdio;
import std.string;

/**
* The <code>String</code> class represents character strings. All
* string literals in D programs, such as <code>String str=new
String("abc");</code>,
* <br /><code>str="Hello world";</code>
* are implemented as instances of this class.<br />
* final wchar[] value; The value is the String's value.<br />
* final int offset;    The offset is the first index of the storage that is
used.<br />
* final int count;     The count is the number of characters in the String.
<br />
* Authors:  Caoqi
* version: 0.022
* Date: April 5, 2007
* History: March 30,2007 V0.01
* License: BSD
* See_Also:
       My blog, <a href=" http://jinheking.javaeye.com/">
http://jinheking.javaeye.com/</a>

* <p>
*/




/// Documentation for String
public class  String{
 private:
  final wchar[] value; ///The value is the String's value.
  final int offset;    ///The offset is the first index of the storage that
is used.
  final int count;     ///The count is the number of characters in the
String.

 public:
  /**
   * Initializes a newly created {@code String} object so that it represents
   * an empty character sequence.  Note that use of this constructor is
   * unnecessary since Strings are immutable.
   */
  this(){
   this.offset = 0;
   this.count = 0;
   this.value = null;
  }
  /**
  * Params:wc = The initial value of the string
  * Return:
      *        String
      * <code>String str=new String("abc");</code><br />
  * <code>str="abcd";</code>
  */
  String opAssign(wchar[] wc) {
   this.offset = 0;
   this.count = wc.length;
   this.value = wc.dup;
   return this;
    }

  /**
  * <code>s1>s2</code>
  * Params: s = The initial value of the string
  * Return: int
  */
  int opCmp(String s){
   return std.string.cmp(cast(char[])this.value, cast(char[])s.value);
  }
  /**
  *Params: s = The initial value of the string
  *Return: bool
  *
  */
  bool equals(String s){
   if (this.value==s.value)
    return true;
   else
    return false;
  }
  /**
  * Params: beginIndex = begin index
  *         endIndex = end index
  * Return: String
  */
  String substring(int beginIndex, int endIndex){
   return new String(beginIndex,endIndex,this.value);
  }

  /*
       * Allocates a new {@code String} so that it represents the sequence
of
      * characters currently contained in the character array argument. The
        * contents of the character array are copied; subsequent
modification of
        * the character array does not affect the newly created string.
        *
        * Param:  value =  The initial value of the string
        */
      this(wchar[] value) {
   int size = value.length;
   this.offset = 0;
   this.count = size;
   this.value = value;
      }
  /**
  *Params: value =  The initial value of the string
  * offset = begin index
  * count  = string length
  */
  this(int offset, int count, wchar[] value){
   if(offset>count){
    this.offset = 0;
                         this.count = 0;
                         this.value = "";
   }else{
    if(count>value.length){
     count=value.length;
    }
    if(offset<0)
     offset=0;
    this.offset=0;
    this.count=count-offset;
    this.value=value[offset..count];
   }
  }
  /**
     * Returns the length of this string.
     * The length is equal to the number of <a
href="Character.html#unicode">Unicode
     * code units</a> in the string.
     *
     * Return:  The length of the sequence of characters represented by this
     *          object.
     */
    public int length() {
        return this.value.length;
    }

    /**
     * Returns <tt>true</tt> if, and only if, {@link #length()} is
<tt>0</tt>.
     *
     * Return <tt>true</tt> if {@link #length()} is <tt>0</tt>, otherwise
     * <tt>false</tt>
     */
    public bool isEmpty() {
    return count == 0;
    }
  /**
     * Returns the index within this string of the first occurrence of the
     * specified substring. The integer returned is the smallest value
     * <i>k</i> such that:
     * <blockquote><pre>
     * this.startsWith(str, <i>k</i>)
     * </pre></blockquote>
     * is <code>true</code>.
     *
     * Params:   str =  any String.
     * Return:  if the string argument occurs as a substring within this
     *          object, then the index of the first character of the first
     *          such substring is returned; if it does not occur as a
     *          substring, <code>-1</code> is returned.
     */

    public int indexOf(String str) {
   return indexOf(str, 0);
    }
    /**
     * Returns the index within this string of the first occurrence of the
     * specified substring. The integer returned is the smallest value
     * <i>k</i> such that:
     * <blockquote><pre>
     * this.startsWith(str, <i>k</i>)
     * </pre></blockquote>
     * is <code>true</code>.
     *
     * Params:   str =  any String.
     * Return:  if the string argument occurs as a substring within this
     *          object, then the index of the first character of the first
     *          such substring is returned; if it does not occur as a
     *          substring, <code>-1</code> is returned.
     */
    public int indexOf(wchar[] str) {
   return indexOf(str, 0);
    }

    /**
     * Returns the index within this string of the first occurrence of the
     * specified substring, starting at the specified index.  The integer
     * returned is the smallest value <tt>k</tt> for which:
     * <blockquote><pre>
     *     k &gt;= Math.min(fromIndex, this.length()) &&
this.startsWith(str, k)
     * </pre></blockquote>
     * If no such value of <i>k</i> exists, then -1 is returned.
     *
     * Param:   str    =     the substring for which to search.
     * Param:   fromIndex  = the index from which to start the search.
     * Return:  the index within this string of the first occurrence of the
     *          specified substring, starting at the specified index.
     */
    public int indexOf(String str, int fromIndex) {
        return indexOf(value, offset, count,
                       str.value, str.offset, str.count, fromIndex);
    }
     /**
     * Returns the index within this string of the first occurrence of the
     * specified substring, starting at the specified index.  The integer
     * returned is the smallest value <tt>k</tt> for which:
     * <blockquote><pre>
     *     k &gt;= Math.min(fromIndex, this.length()) &&
this.startsWith(str, k)
     * </pre></blockquote>
     * If no such value of <i>k</i> exists, then -1 is returned.
     *
     * Param:   str    =     the substring for which to search.
     * Param:   fromIndex  = the index from which to start the search.
     * Return:  the index within this string of the first occurrence of the
     *          specified substring, starting at the specified index.
     */
    public int indexOf(wchar[] wstr, int fromIndex) {
       String str=new String(wstr);
        return indexOf(value, offset, count,
                       str.value, str.offset, str.count, fromIndex);
    }

    /**
     * Code shared by String and StringBuffer to do searches. The
     * source is the character array being searched, and the target
     * is the string being searched for.
     *
     * Params:   source =      the characters being searched.
     * Params:   sourceOffset= offset of the source string.
     * Params:   sourceCount=  count of the source string.
     * Params:   target   =    the characters being searched for.
     * Params:   targetOffset =offset of the target string.
     * Params:   targetCount = count of the target string.
     * Params:   fromIndex  =  the index to begin searching from.
     * Return:  the index within this string of the first occurrence of the
     *          specified substring, starting at the specified index.
     */
    static int indexOf(wchar[] source, int sourceOffset, int sourceCount,
                       wchar[] target, int targetOffset, int targetCount,
                       int fromIndex) {
   if (fromIndex >= sourceCount) {
              return (targetCount == 0 ? sourceCount : -1);
   }
       if (fromIndex < 0) {
           fromIndex = 0;
       }
   if (targetCount == 0) {
       return fromIndex;
   }

          wchar first  = target[targetOffset];
          int max = sourceOffset + (sourceCount - targetCount);

          for (int i = sourceOffset + fromIndex; i <= max; i++) {
              /* Look for first character. */
              if (source[i] != first) {
                i++;
                  while (i <= max && source[i] != first){
                   i++;
                  }
              }

              /* Found first character, now look at the rest of v2 */
              if (i <= max) {
                  int j = i + 1;
                  int end = j + targetCount - 1;
                  for (int k = targetOffset + 1; j < end && (source[j] ==
target[k]);j++){
                    k++;
                  }

                  if (j == end) {
                      /* Found whole string. */
                      return i - sourceOffset;
                  }
              }
          }
          return -1;
      }
 /**
 * Return:The String's value
 */
 char[] toString(){
  return cast(char[])std.utf.toUTF8(this.value);
 }
}
/++++++++++++++++++++++++
  + Our function.
  + Example:
  + --------------------------
  +  import std.stdio;
  +
  +  void foo()
  +  {
  +      String str=new String("Hi,jdk2d String,I need you!") ;
  +      writefln(str);  /* print the string */
  +      str="Next,I calculate the str's length"
  +      writefln(str);  /* print the string */
  +      printf("%d\n",str.length());
  +  }
  + --------------------------
  +/
public static void  main() {
   String str = new String("The quick brown fox jumped over the lazy dog.");
   String s1 = new String("abc");
   s1="abc";
   String s2=new String("ab");

   writef("s1=");
   writefln(s1);
   writef("s2=");
   writefln(s2);

   if(s1>s2)
    printf("s1>s2=%.*s\n","true");
   else
    printf("s1>s2=%.*s\n","false");
   String s3=new String("ab");
   String s4=new String("abc");

   writef("s3=");
   writefln(s3);
   writef("s4=");
   writefln(s4);
   if(s3>s4)
    printf("s3>s4=%.*s\n","true");
   else
    printf("s3>s4=%.*s\n","false");

   printf("%d\n",str.indexOf("z"));
   printf("%d\n",str.isEmpty());

   s1="12";s2="123" ;
   printf("%d\n",s1.equals(s2)) ;
   String s5=new String(-2,22,"0123456789");
   s5=s5.substring(0,1);
   writef("s5:");
   writef(s5);
   writefln("!");
}


April 18, 2007
alias char[] string;
Top | Discussion index | About this forum | D home