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

comparison dwt/dwthelper/utils.d @ 311:77fa7f3ab37e

Additions for jface.text

author	Frank Benoit <benoit@tionex.de>
date	Mon, 08 Sep 2008 01:33:00 +0200
parents	7ca3f26319f1
children	0f7ac29ac726

comparison

equal deleted inserted replaced

-:7ca3f26319f1
+:77fa7f3ab37e
 import tango.io.Stdout;
 import tango.io.Print;
 static import tango.stdc.stringz;
 static import tango.text.Util;
 static import tango.text.Text;
+static import tango.text.Ascii;
 import tango.text.Unicode;
 import tango.text.convert.Utf;
 import tango.core.Exception;
 import tango.stdc.stdlib : exit;
 import tango.util.log.Trace;
 import tango.text.UnicodeData;
-static import tango.util.collection.model.Seq;
 alias char[] String;
 alias tango.text.Text.Text!(char) StringBuffer;
+alias ArrayBoundsException ArrayIndexOutOfBoundsException;
 void implMissing( String file, uint line ){
 Stderr.formatln( "implementation missing in file {} line {}", file, line );
 Stderr.formatln( "exiting ..." );
 exit(1);
 return FALSE;
 }
 public static Boolean valueOf( bool b ){
 return b ? TRUE : FALSE;
 }
+public static bool getBoolean(String name){
+return tango.text.Ascii.icompare(System.getProperty(name, "false"), "true" ) is 0;
+}
 }
 alias Boolean    ValueWrapperBool;
 }
 }
 this( byte value ){
 super( value );
 }
+public static String toString( byte i ){
+return tango.text.convert.Integer.toString(i);
+}
 }
 alias Byte ValueWrapperByte;
 class Integer : ValueWrapperT!(int) {
 }
 public static String toString( double value ){
 implMissing( __FILE__, __LINE__ );
 return null;
 }
+public static double parseDouble(String s){
+implMissing( __FILE__, __LINE__ );
+return 0.0;
+}
 }
 class Float : ValueWrapperT!(float) {
 public static float POSITIVE_INFINITY = (1.0f / 0.0f);
 searchRelCp++;
 }
 }
 return i;
 }
+dchar getRelativeCodePoint( String str, int startIndex, int searchRelCp ){
+int dummy;
+return getRelativeCodePoint( str, startIndex, dummy );
+}
 dchar getRelativeCodePoint( String str, int startIndex, int searchRelCp, out int relIndex ){
 relIndex = getRelativeCodePointOffset( str, startIndex, searchRelCp );
 int ignore;
 return firstCodePoint( str[ startIndex+relIndex .. $ ], ignore );
 }
 Trace.formatln( "utf8OffsetDecr {}->{}", offset, res );
 Trace.memory( str );
 return res;
 }
+class Character {
+public static bool isUpperCase( dchar c ){
+implMissing( __FILE__, __LINE__);
+return false;
+}
+public static dchar toUpperCase( dchar c ){
+dchar[] r = tango.text.Unicode.toUpper( [c] );
+return r[0];
+}
+public static dchar toLowerCase( dchar c ){
+dchar[] r = tango.text.Unicode.toLower( [c] );
+return r[0];
+}
+public static bool isWhitespace( dchar c ){
+return tango.text.Unicode.isWhitespace( c );
+}
+public static bool isDigit( dchar c ){
+return tango.text.Unicode.isDigit( c );
+}
+public static bool isLetterOrDigit( dchar c ){
+return isDigit(c) || isLetter(c);
+}
+public static bool isUnicodeIdentifierPart(char ch){
+implMissing( __FILE__, __LINE__);
+return false;
+}
+public static bool isUnicodeIdentifierStart(char ch){
+implMissing( __FILE__, __LINE__);
+return false;
+}
+public static bool isIdentifierIgnorable(char ch){
+implMissing( __FILE__, __LINE__);
+return false;
+}
+public static bool isJavaIdentifierPart(char ch){
+implMissing( __FILE__, __LINE__);
+return false;
+}
+this( char c ){
+// must be correct for container storage
+implMissing( __FILE__, __LINE__);
+}
+}
+String new_String( String cont, int offset, int len ){
+return cont[ offset .. offset+len ].dup;
+}
+String new_String( String cont ){
+return cont.dup;
+}
+String String_valueOf( bool v ){
+return v ? "true" : "false";
+}
+String String_valueOf( int v ){
+return tango.text.convert.Integer.toString(v);
+}
+String String_valueOf( long v ){
+return tango.text.convert.Integer.toString(v);
+}
+String String_valueOf( float v ){
+return tango.text.convert.Float.toString(v);
+}
+String String_valueOf( double v ){
+return tango.text.convert.Float.toString(v);
+}
+String String_valueOf( dchar v ){
+return dcharToString(v);
+}
+String String_valueOf( char[] v ){
+return v.dup;
+}
+String String_valueOf( char[] v, int offset, int len ){
+return v[ offset .. offset+len ].dup;
+}
+String String_valueOf( Object v ){
+return v is null ? "null" : v.toString();
+}
 bool CharacterIsDefined( dchar ch ){
 return (ch in tango.text.UnicodeData.unicodeData) !is null;
 }
 dchar CharacterFirstToLower( String str ){
 int consumed;
 dchar[1] buf;
 buf[0] = firstCodePoint( str, consumed );
 dchar[] r = tango.text.Unicode.toLower( buf );
 return r[0];
 }
+int length( String str ){
+return str.length;
+}
 dchar CharacterToLower( dchar c ){
 dchar[] r = tango.text.Unicode.toLower( [c] );
 return r[0];
 }
 dchar CharacterToUpper( dchar c ){
 bool CharacterIsLetter( dchar c ){
 return tango.text.Unicode.isLetter( c );
 }
 public String toUpperCase( String str ){
 return tango.text.Unicode.toUpper( str );
+}
+public String replaceFirst( String str, String regex, String replacement ){
+implMissing(__FILE__,__LINE__);
+return str;
 }
 public int indexOf( String str, char searched ){
 int res = tango.text.Util.locate( str, searched );
 if( res is str.length ) res = -1;
 int res = tango.text.Util.locatePatternPrior( str, ch, start );
 if( res is str.length ) res = -1;
 return res;
 }
+public String replaceAll( String str, String regex, String replacement ){
+implMissing(__FILE__,__LINE__);
+return null;
+}
 public String replace( String str, char from, char to ){
 return tango.text.Util.replace( str.dup, from, to );
 }
 public String substring( String str, int start ){
 public void getChars( String src, int srcBegin, int srcEnd, String dst, int dstBegin){
 dst[ dstBegin .. dstBegin + srcEnd - srcBegin ] = src[ srcBegin .. srcEnd ];
 }
-public wchar[] toCharArray( String str ){
+public char[] toCharArray( String str ){
-return toString16( str );
+return str;
 }
 public bool endsWith( String src, String pattern ){
 if( src.length < pattern.length ){
 return false;
 class ParseException : Exception {
 this( String e = null ){
 super(e);
 }
 }
+class ClassCastException : Exception {
+this( String e = null ){
+super(e);
+}
+}
 interface Cloneable{
 }
 interface Comparable {
 }
 exception = exception.next;
 }
 }
-interface Reader{
+class Reader{
+protected Object   lock;
+protected this(){
+implMissing(__FILE__,__LINE__);
+}
+protected this(Object lock){
+implMissing(__FILE__,__LINE__);
+}
+abstract  void  close();
+void mark(int readAheadLimit){
+implMissing(__FILE__,__LINE__);
+}
+bool markSupported(){
+implMissing(__FILE__,__LINE__);
+return false;
+}
+int read(){
+implMissing(__FILE__,__LINE__);
+return 0;
+}
+int read(char[] cbuf){
+implMissing(__FILE__,__LINE__);
+return 0;
+}
+abstract int read(char[] cbuf, int off, int len);
+bool ready(){
+implMissing(__FILE__,__LINE__);
+return false;
+}
+void reset(){
+implMissing(__FILE__,__LINE__);
+}
+long skip(long n){
+implMissing(__FILE__,__LINE__);
+return 0;
+}
 }
 interface Writer{
 }
 }
 }
 return true;
 }
-int SeqIndexOf(T)( tango.util.collection.model.Seq.Seq!(T) s, T src ){
+/+int SeqIndexOf(T)( tango.util.collection.model.Seq.Seq!(T) s, T src ){
 int idx;
 foreach( e; s ){
 if( e == src ){
 return idx;
 }
 idx++;
 }
 return -1;
-}
+}+/
 int arrayIndexOf(T)( T[] arr, T v ){
 int res = -1;
 int idx = 0;
 foreach( p; arr ){
 if( p == v){
 idx++;
 }
 return res;
 }
-int seqIndexOf( tango.util.collection.model.Seq.Seq!(Object) seq, Object v ){
+// int seqIndexOf( tango.util.collection.model.Seq.Seq!(Object) seq, Object v ){
-int res = -1;
+//     int res = -1;
-int idx = 0;
+//     int idx = 0;
-foreach( p; seq ){
+//     foreach( p; seq ){
-if( p == v){
+//         if( p == v){
-res = idx;
+//             res = idx;
-break;
+//             break;
-}
+//         }
-idx++;
+//         idx++;
-}
+//     }
-return res;
+//     return res;
-}
+// }
 void PrintStackTrace( int deepth = 100, String prefix = "trc" ){
 auto e = new Exception( null );
 int idx = 0;
 const start = 3;
 template getImportData(String name ){
 const ImportData getImportData = ImportData( import(name), name );
 }
 interface CharSequence {
-wchar           charAt(int index);
+char           charAt(int index);
 int             length();
 CharSequence    subSequence(int start, int end);
 String          toString();
 }
+class StringCharSequence : CharSequence {
+private String str;
+this( String str ){
+this.str = str;
+}
+char           charAt(int index){
+return str[index];
+}
+int             length(){
+return str.length;
+}
+CharSequence    subSequence(int start, int end){
+return new StringCharSequence( str[ start .. end ]);
+}
+String          toString(){
+return str;
+}
+}

Mercurial > projects > dwt-linux

comparison dwt/dwthelper/utils.d @ 311:77fa7f3ab37e