projects/dwt-win: dwt/dwthelper/utils.d comparison

comparison dwt/dwthelper/utils.d @ 212:ab60f3309436

reverted the char[] to String and use the an alias.

author	Frank Benoit <benoit@tionex.de>
date	Mon, 05 May 2008 00:12:38 +0200
parents	cca980503056
children	679fb4a215dc

comparison

equal deleted inserted replaced

-:ff59aeb96cac
+:ab60f3309436
 // alias tango.util.collection.HashMap.HashMap!(Object,Object) HashMap;
 alias char[] String;
 alias tango.text.Text.Text!(char) StringBuffer;
-void implMissing( char[] file, uint line ){
+void implMissing( String file, uint line ){
 Stderr.formatln( "implementation missing in file {} line {}", file, line );
 Stderr.formatln( "exiting ..." );
 exit(1);
 }
 return false;
 }
 public bool booleanValue(){
 return value;
 }
-public static Boolean valueOf( char[] s ){
+public static Boolean valueOf( String s ){
 if( s == "yes" || s == "true" ){
 return TRUE;
 }
 return FALSE;
 }
 alias Boolean    ValueWrapperBool;
 class Byte : ValueWrapperT!(byte) {
-public static byte parseByte( char[] s ){
+public static byte parseByte( String s ){
 try{
 int res = tango.text.convert.Integer.parse( s );
 if( res < byte.min || res > byte.max ){
 throw new NumberFormatException( "out of range" );
 }
 public this ( int value ){
 super( value );
 }
-public this ( char[] s ){
+public this ( String s ){
 super(parseInt(s));
 }
-public static char[] toString( int i, int radix ){
+public static String toString( int i, int radix ){
 switch( radix ){
 case 2:
 return toBinaryString(i);
 case 8:
 return toOctalString(i);
 implMissing( __FILE__, __LINE__ );
 return null;
 }
 }
-public static char[] toHexString( int i ){
+public static String toHexString( int i ){
 return tango.text.convert.Integer.toString(i, tango.text.convert.Integer.Style.Hex );
 }
-public static char[] toOctalString( int i ){
+public static String toOctalString( int i ){
 return tango.text.convert.Integer.toString(i, tango.text.convert.Integer.Style.Octal );
 }
-public static char[] toBinaryString( int i ){
+public static String toBinaryString( int i ){
 return tango.text.convert.Integer.toString(i, tango.text.convert.Integer.Style.Binary );
 }
-public static char[] toString( int i ){
+public static String toString( int i ){
 return tango.text.convert.Integer.toString(i);
 }
-public static int parseInt( char[] s, int radix ){
+public static int parseInt( String s, int radix ){
 try{
 return tango.text.convert.Integer.parse( s, cast(uint)radix );
 }
 catch( IllegalArgumentException e ){
 throw new NumberFormatException( e );
 }
 }
-public static int parseInt( char[] s ){
+public static int parseInt( String s ){
 try{
 return tango.text.convert.Integer.parse( s );
 }
 catch( IllegalArgumentException e ){
 throw new NumberFormatException( e );
 }
 }
-public static Integer valueOf( char[] s, int radix ){
+public static Integer valueOf( String s, int radix ){
 implMissing( __FILE__, __LINE__ );
 return null;
 }
-public static Integer valueOf( char[] s ){
+public static Integer valueOf( String s ){
 return valueOf( parseInt(s));
 }
 public static Integer valueOf( int i ){
 return new Integer(i);
 public override  hash_t toHash(){
 return intValue();
 }
-public override char[] toString(){
+public override String toString(){
 return tango.text.convert.Integer.toString( value );
 }
 }
 alias Integer ValueWrapperInt;
 class Double : ValueWrapperT!(double) {
 this( double value ){
 super(value);
 }
-this( char[] str ){
+this( String str ){
 implMissing( __FILE__, __LINE__ );
 super(0.0);
 }
 public double doubleValue(){
 return value;
 }
-public static char[] toString( double value ){
+public static String toString( double value ){
 implMissing( __FILE__, __LINE__ );
 return null;
 }
 }
 public static int SIZE = 32;
 this( float value ){
 super(value);
 }
-this( char[] str ){
+this( String str ){
 implMissing( __FILE__, __LINE__ );
 super(0.0);
 }
 public float floatValue(){
 return value;
 }
-public static char[] toString( float value ){
+public static String toString( float value ){
 implMissing( __FILE__, __LINE__ );
 return null;
 }
-public static float parseFloat( char[] s ){
+public static float parseFloat( String s ){
 try{
 return tango.text.convert.Float.toFloat( s );
 }
 catch( IllegalArgumentException e ){
 throw new NumberFormatException( e );
 }
 class Long : ValueWrapperT!(long) {
 this( long value ){
 super(value);
 }
-this( char[] str ){
+this( String str ){
 implMissing( __FILE__, __LINE__ );
 super(0);
 }
 public long longValue(){
 return value;
 }
-public static long parseLong(char[] s){
+public static long parseLong(String s){
 implMissing( __FILE__, __LINE__ );
 return 0;
 }
-public static char[] toString( double value ){
+public static String toString( double value ){
 implMissing( __FILE__, __LINE__ );
 return null;
 }
 }
 alias Long ValueWrapperLong;
 alias ArrayWrapperT!(byte)    ArrayWrapperByte;
 alias ArrayWrapperT!(int)     ArrayWrapperInt;
 alias ArrayWrapperT!(Object)  ArrayWrapperObject;
 alias ArrayWrapperT!(char)    ArrayWrapperString;
-alias ArrayWrapperT!(char[])  ArrayWrapperString2;
+alias ArrayWrapperT!(String)  ArrayWrapperString2;
 Object[] StringArrayToObjectArray( String[] strs ){
 Object[] res = new Object[strs.length];
 foreach( idx, str; strs ){
 res[idx] = new ArrayWrapperString(str);
 }
 return res;
 }
-int codepointIndexToIndex( char[] str, int cpIndex ){
+int codepointIndexToIndex( String str, int cpIndex ){
 int cps = cpIndex;
 int res = 0;
 while( cps > 0 ){
 cps--;
 if( str[res] < 0x80 ){
 res+=4;
 }
 }
 return res;
 }
-int indexToCodepointIndex( char[] str, int index ){
+int indexToCodepointIndex( String str, int index ){
 int i = 0;
 int res = 0;
 while( i < index ){
 if( str[i] < 0x80 ){
 i+=1;
 res++;
 }
 return res;
 }
-char[] firstCodePointStr( char[] str, out int consumed ){
+String firstCodePointStr( String str, out int consumed ){
 dchar[1] buf;
 uint ate;
 dchar[] res = str.toString32( buf, &ate );
 consumed = ate;
 return str[ 0 .. ate ];
 }
-dchar firstCodePoint( char[] str ){
+dchar firstCodePoint( String str ){
 int dummy;
 return firstCodePoint( str, dummy );
 }
-dchar firstCodePoint( char[] str, out int consumed ){
+dchar firstCodePoint( String str, out int consumed ){
 dchar[1] buf;
 uint ate;
 dchar[] res = str.toString32( buf, &ate );
 consumed = ate;
 if( ate is 0 || res.length is 0 ){
 assert( ate > 0 );
 assert( res.length is 1 );
 return res[0];
 }
-char[] dcharToString( dchar key ){
+String dcharToString( dchar key ){
 dchar[1] buf;
 buf[0] = key;
 return tango.text.convert.Utf.toString( buf );
 }
-int codepointCount( char[] str ){
+int codepointCount( String str ){
 scope dchar[] buf = new dchar[]( str.length );
 uint ate;
 dchar[] res = tango.text.convert.Utf.toString32( str, buf, &ate );
 assert( ate is str.length );
 return res.length;
 }
 alias tango.text.convert.Utf.toString16 toString16;
 alias tango.text.convert.Utf.toString toString;
-int getRelativeCodePointOffset( char[] str, int startIndex, int searchRelCp ){
+int getRelativeCodePointOffset( String str, int startIndex, int searchRelCp ){
 int ignore;
 int i = startIndex;
 if( searchRelCp > 0 ){
 while( searchRelCp !is 0 ){
 searchRelCp++;
 }
 }
 return i - startIndex;
 }
-dchar getRelativeCodePoint( char[] str, int startIndex, int searchRelCp, out int relIndex ){
+dchar getRelativeCodePoint( String str, int startIndex, int searchRelCp, out int relIndex ){
 relIndex = getRelativeCodePointOffset( str, startIndex, searchRelCp );
 int ignore;
 return firstCodePoint( str[ startIndex+relIndex .. $ ], ignore );
 }
-int utf8AdjustOffset( char[] str, int offset ){
+int utf8AdjustOffset( String str, int offset ){
 if( str.length <= offset || offset <= 0 ){
 return offset;
 }
 while(( str[offset] & 0xC0 ) is 0x80 ){
 offset--;
 }
 bool CharacterIsDefined( dchar ch ){
 return (ch in tango.text.UnicodeData.unicodeData) !is null;
 }
-dchar CharacterFirstToLower( char[] str ){
+dchar CharacterFirstToLower( String str ){
 int consumed;
 return CharacterFirstToLower( str, consumed );
 }
-dchar CharacterFirstToLower( char[] str, out int consumed ){
+dchar CharacterFirstToLower( String str, out int consumed ){
 dchar[1] buf;
 buf[0] = firstCodePoint( str, consumed );
 dchar[] r = tango.text.Unicode.toLower( buf );
 return r[0];
 }
 return tango.text.Unicode.isDigit( c );
 }
 bool CharacterIsLetter( dchar c ){
 return tango.text.Unicode.isLetter( c );
 }
-public char[] toUpperCase( char[] str ){
+public String toUpperCase( String str ){
 return tango.text.Unicode.toUpper( str );
 }
-public int indexOf( char[] str, char searched ){
+public int indexOf( String str, char searched ){
 int res = tango.text.Util.locate( str, searched );
 if( res is str.length ) res = -1;
 return res;
 }
-public int indexOf( char[] str, char searched, int startpos ){
+public int indexOf( String str, char searched, int startpos ){
 int res = tango.text.Util.locate( str, searched, startpos );
 if( res is str.length ) res = -1;
 return res;
 }
-public int indexOf(char[] str, char[] ch){
+public int indexOf(String str, String ch){
 return indexOf( str, ch, 0 );
 }
-public int indexOf(char[] str, char[] ch, int start){
+public int indexOf(String str, String ch, int start){
 int res = tango.text.Util.locatePattern( str, ch, start );
 if( res is str.length ) res = -1;
 return res;
 }
-public int lastIndexOf(char[] str, char ch){
+public int lastIndexOf(String str, char ch){
 return lastIndexOf( str, ch, str.length );
 }
-public int lastIndexOf(char[] str, char ch, int formIndex){
+public int lastIndexOf(String str, char ch, int formIndex){
 int res = tango.text.Util.locatePrior( str, ch, formIndex );
 if( res is str.length ) res = -1;
 return res;
 }
-public int lastIndexOf(char[] str, char[] ch ){
+public int lastIndexOf(String str, String ch ){
 return lastIndexOf( str, ch, str.length );
 }
-public int lastIndexOf(char[] str, char[] ch, int start ){
+public int lastIndexOf(String str, String ch, int start ){
 int res = tango.text.Util.locatePatternPrior( str, ch, start );
 if( res is str.length ) res = -1;
 return res;
 }
-public char[] replace( char[] str, char from, char to ){
+public String replace( String str, char from, char to ){
 return tango.text.Util.replace( str.dup, from, to );
 }
-public char[] substring( char[] str, int start ){
+public String substring( String str, int start ){
 return str[ start .. $ ].dup;
 }
-public char[] substring( char[] str, int start, int end ){
+public String substring( String str, int start, int end ){
 return str[ start .. end ].dup;
 }
 public wchar[] substring( wchar[] str, int start ){
 return str[ start .. $ ].dup;
 public wchar[] substring( wchar[] str, int start, int end ){
 return str[ start .. end ].dup;
 }
-public char charAt( char[] str, int pos ){
+public char charAt( String str, int pos ){
 return str[ pos ];
 }
-public void getChars( char[] src, int srcBegin, int srcEnd, char[] dst, int dstBegin){
+public void getChars( String src, int srcBegin, int srcEnd, String dst, int dstBegin){
 dst[ dstBegin .. dstBegin + srcEnd - srcBegin ] = src[ srcBegin .. srcEnd ];
 }
-public wchar[] toCharArray( char[] str ){
+public wchar[] toCharArray( String str ){
 return toString16( str );
 }
-public bool endsWith( char[] src, char[] pattern ){
+public bool endsWith( String src, String pattern ){
 if( src.length < pattern.length ){
 return false;
 }
 return src[ $-pattern.length .. $ ] == pattern;
 }
-public bool equals( char[] src, char[] other ){
+public bool equals( String src, String other ){
 return src == other;
 }
-public bool equalsIgnoreCase( char[] src, char[] other ){
+public bool equalsIgnoreCase( String src, String other ){
 return tango.text.Unicode.toFold(src) == tango.text.Unicode.toFold(other);
 }
-public bool startsWith( char[] src, char[] pattern ){
+public bool startsWith( String src, String pattern ){
 if( src.length < pattern.length ){
 return false;
 }
 return src[ 0 .. pattern.length ] == pattern;
 }
-public char[] toLowerCase( char[] src ){
+public String toLowerCase( String src ){
 return tango.text.Unicode.toLower( src );
 }
-public hash_t toHash( char[] src ){
+public hash_t toHash( String src ){
-return typeid(char[]).getHash(&src);
+return typeid(String).getHash(&src);
 }
-public char[] trim( char[] str ){
+public String trim( String str ){
 return tango.text.Util.trim( str ).dup;
 }
-public char[] intern( char[] str ){
+public String intern( String str ){
 return str;
 }
-public char* toStringzValidPtr( char[] src ){
+public char* toStringzValidPtr( String src ){
 if( src ){
 return src.toStringz();
 }
 else{
-static const char[] nullPtr = "\0";
+static const String nullPtr = "\0";
 return nullPtr.ptr;
 }
 }
-static char[] toHex(uint value, bool prefix = true, int radix = 8){
+static String toHex(uint value, bool prefix = true, int radix = 8){
 return tango.text.convert.Integer.toString(
 value,
 radix is 10 ? tango.text.convert.Integer.Style.Signed :
 radix is  8 ? tango.text.convert.Integer.Style.Octal  :
 radix is 16 ? tango.text.convert.Integer.Style.Hex    :
 prefix ? tango.text.convert.Integer.Flags.Prefix : tango.text.convert.Integer.Flags.None
 );
 }
 class RuntimeException : Exception {
-this( char[] e = null){
+this( String e = null){
 super(e);
 }
 this( Exception e ){
 super(e.toString);
 next = e;
 return next;
 }
 }
 class IndexOutOfBoundsException : Exception {
-this( char[] e = null){
+this( String e = null){
 super(e);
 }
 }
 class UnsupportedOperationException : RuntimeException {
-this( char[] e = null){
+this( String e = null){
 super(e);
 }
 this( Exception e ){
 super(e.toString);
 }
 }
 class NumberFormatException : IllegalArgumentException {
-this( char[] e ){
+this( String e ){
 super(e);
 }
 this( Exception e ){
 super(e.toString);
 }
 }
 class NullPointerException : Exception {
-this( char[] e = null ){
+this( String e = null ){
 super(e);
 }
 this( Exception e ){
 super(e.toString);
 }
 }
 class IllegalStateException : Exception {
-this( char[] e = null ){
+this( String e = null ){
 super(e);
 }
 this( Exception e ){
 super(e.toString);
 }
 }
 class InterruptedException : Exception {
-this( char[] e = null ){
+this( String e = null ){
 super(e);
 }
 this( Exception e ){
 super(e.toString);
 }
 }
 class InvocationTargetException : Exception {
 Exception cause;
-this( Exception e = null, char[] msg = null ){
+this( Exception e = null, String msg = null ){
 super(msg);
 cause = e;
 }
 alias getCause getTargetException;
 Exception getCause(){
 return cause;
 }
 }
 class MissingResourceException : Exception {
-char[] classname;
+String classname;
-char[] key;
+String key;
-this( char[] msg, char[] classname, char[] key ){
+this( String msg, String classname, String key ){
 super(msg);
 this.classname = classname;
 this.key = key;
 }
 }
 class ParseException : Exception {
-this( char[] e = null ){
+this( String e = null ){
 super(e);
 }
 }
 interface Cloneable{
 public Object getSource() {
 return source;
 }
-public override char[] toString() {
+public override String toString() {
 return this.classinfo.name ~ "[source=" ~ source.toString() ~ "]";
 }
 }
 private struct GCStats {
 return(res);
 }
 }
 }
-char[] stringcast( Object o ){
+String stringcast( Object o ){
 if( auto str = cast(ArrayWrapperString) o ){
 return str.array;
 }
 return null;
 }
-char[][] stringcast( Object[] objs ){
+String[] stringcast( Object[] objs ){
-char[][] res = new char[][](objs.length);
+String[] res = new String[](objs.length);
 foreach( idx, obj; objs ){
 res[idx] = stringcast(obj);
 }
 return res;
 }
-ArrayWrapperString stringcast( char[] str ){
+ArrayWrapperString stringcast( String str ){
 return new ArrayWrapperString( str );
 }
-ArrayWrapperString[] stringcast( char[][] strs ){
+ArrayWrapperString[] stringcast( String[] strs ){
 ArrayWrapperString[] res = new ArrayWrapperString[ strs.length ];
 foreach( idx, str; strs ){
 res[idx] = stringcast(str);
 }
 return res;
 idx++;
 }
 return res;
 }
-void PrintStackTrace( int deepth = 100, char[] prefix = "trc" ){
+void PrintStackTrace( int deepth = 100, String prefix = "trc" ){
 auto e = new Exception( null );
 int idx = 0;
 const start = 3;
 foreach( msg; e.info ){
 if( idx >= start && idx < start+deepth ) {
 }
 }
 struct ImportData{
 void[] data;
-char[] name;
+String name;
-public static ImportData opCall( void[] data, char[] name ){
+public static ImportData opCall( void[] data, String name ){
 ImportData res;
 res.data = data;
 res.name = name;
 return res;
 }
 }
-template getImportData(char[] name ){
+template getImportData(String name ){
 const ImportData getImportData = ImportData( import(name), name );
 }

Mercurial > projects > dwt-win

comparison dwt/dwthelper/utils.d @ 212:ab60f3309436