wvdotnet/wvutils.cs

   1 #define DEBUG
   2 #define TRACE
   3
   4 using System;
   5 using System.Collections;
   6 using System.Collections.Generic;
   7 using System.Diagnostics;
   8 using System.IO;
   9 using System.Security.Cryptography;
  10 using System.Text;
  11 using System.Threading;
  12 using System.Web;
  13
  14 namespace Wv
  15 {
  16     public partial class wv
  17     {
  18         public static void sleep(int msec_delay)
  19         {
  20             if (msec_delay < 0)
  21                 Thread.Sleep(Int32.MaxValue);
  22             else
  23                 Thread.Sleep(msec_delay);
  24         }
  25
  26         public static string shift(ref string[] array, int index)
  27         {
  28             string s = array[index];
  29             string[] outa = new string[array.Length-1];
  30             Array.Copy(array, 0, outa, 0, index);
  31             Array.Copy(array, index+1, outa, index, array.Length-index-1);
  32             array = outa;
  33             return s;
  34         }
  35
  36         public static string shift(ref string[] array)
  37         {
  38             return shift(ref array, 0);
  39         }
  40
  41         public static void assert(bool b, string msg)
  42         {
  43             if (!b)
  44                 throw new System.ArgumentException(msg);
  45         }
  46
  47         public static void assert(bool b)
  48         {
  49             assert(b, "Assertion Failure");
  50         }
  51
  52         public static void assert()
  53         {
  54             assert(false);
  55         }
  56
  57         public static DateTime date(object s)
  58         {
  59             try
  60             {
  61                 return DateTime.Parse(s.ToString());
  62             }
  63             catch (FormatException)
  64             {
  65                 return DateTime.MinValue;
  66             }
  67         }
  68
  69         public static string httpdate(DateTime d)
  70         {
  71             return d.ToUniversalTime()
  72                 .ToString("ddd, dd MMM yyyy HH:mm:ss") + " GMT";
  73         }
  74
  75         static string intclean(object o, bool allow_dot)
  76         {
  77             if (o == null) return "0";
  78
  79             // All this nonsense is to make it so that we can parse
  80             // strings a little more liberally.  Double.Parse() would
  81             // give up in case of invalid characters; we just ignore
  82             // anything after that point instead, like C would do.
  83             string s = o.ToString();
  84
  85             char[] ca = s.ToCharArray();
  86             int i = 0;
  87             if (ca.Length > 0 && ca[0] == '-')
  88                 i++;
  89             bool saw_dot = false;
  90             for (; i < ca.Length; i++)
  91             {
  92                 if (ca[i] == '.')
  93                 {
  94                     if (saw_dot || !allow_dot)
  95                         break;
  96                     saw_dot = true;
  97                 }
  98                 if ("0123456789.".IndexOf(ca[i]) < 0)
  99                     break;
 100             }
 101
 102             return s.Substring(0, i);
 103         }
 104
 105         public static double atod(object o)
 106         {
 107             try {
 108                 return Double.Parse(intclean(o, true));
 109             } catch (FormatException) {
 110                 return 0.0;
 111             }
 112         }
 113
 114         public static int atoi(object o)
 115         {
 116             try {
 117                 return Int32.Parse(intclean(o, false));
 118             } catch (FormatException) {
 119                 return 0;
 120             }
 121         }
 122
 123         public static long atol(object o)
 124         {
 125             try {
 126                 return Int64.Parse(intclean(o, false));
 127             } catch (FormatException) {
 128                 return 0;
 129             }
 130         }
 131
 132         public static bool isempty(string s)
 133         {
 134             return s == null || s == "";
 135         }
 136
 137         public static bool isempty(DateTime d)
 138         {
 139             return d == DateTime.MinValue;
 140         }
 141
 142         public static bool isempty(TimeSpan t)
 143         {
 144             return t == TimeSpan.Zero;
 145         }
 146
 147         public static string fmt(string format, params object[] args)
 148         {
 149             return String.Format(format, args);
 150         }
 151
 152         public static void print(string format, params object[] args)
 153         {
 154             Console.Write(format, args);
 155         }
 156
 157         public static void printerr(string format, params object[] args)
 158         {
 159             Console.Error.Write(format, args);
 160         }
 161
 162         public static Array sort(ICollection keys, IComparer comparer)
 163         {
 164             object[] sorted = new object[keys.Count];
 165             keys.CopyTo(sorted, 0);
 166             Array.Sort(sorted, comparer);
 167             return sorted;
 168         }
 169
 170         public static Array sort(ICollection keys)
 171         {
 172             return sort(keys, Comparer.Default);
 173         }
 174
 175         public static string[] stringify(ICollection keys)
 176         {
 177             string[] a = new string[keys.Count];
 178             int i = 0;
 179             foreach (object o in keys)
 180                 a[i++] = o.ToString();
 181             return a;
 182         }
 183
 184         public static string getenv(string key)
 185         {
 186             string o = Environment.GetEnvironmentVariable(key);
 187             if (o != null)
 188                 return o;
 189             else
 190                 return "";
 191         }
 192
 193         public static string urldecode(string s)
 194         {
 195             return HttpUtility.UrlDecode(s);
 196         }
 197
 198         public static string urlencode(string s)
 199         {
 200             return HttpUtility.UrlEncode(s);
 201         }
 202
 203         public static void urlsplit(Dictionary<string,string> d, string query)
 204         {
 205             // Multiple values separated by & signs, as in URLs
 206             foreach (string ent in query.Split('&'))
 207             {
 208                 string[] kv = ent.Split("=".ToCharArray(), 2);
 209                 string k = HttpUtility.UrlDecode(kv[0]);
 210                 string v =
 211                     kv.Length>1 ? HttpUtility.UrlDecode(kv[1]) : "1";
 212                 d.Remove(k);
 213                 d.Add(k, v);
 214             }
 215         }
 216
 217         public static void cookiesplit(Dictionary<string,string> d,
 218                                        string query)
 219         {
 220             // Multiple values separated by & signs, as in URLs
 221             foreach (string ent in query.Split(';'))
 222             {
 223                 string[] kv = ent.Split("=".ToCharArray(), 2);
 224                 string k = wv.urldecode(kv[0].Trim());
 225                 string v = kv.Length>1 ? wv.urldecode(kv[1]) : "1";
 226                 d.Remove(k);
 227                 d.Add(k, v);
 228             }
 229         }
 230
 231         static RandomNumberGenerator randserv = null;
 232         public static byte[] randombytes(int num)
 233         {
 234             // lazy initialization, since it might be expensive.  But we'll
 235             // keep it around to ensure "maximum randomness"
 236             if (randserv == null)
 237                 randserv = new RNGCryptoServiceProvider();
 238
 239             byte[] b = new byte[num];
 240             randserv.GetBytes(b);
 241             return b;
 242         }
 243
 244         /**
 245          * A handy tool for making timeout loops.  Use it like this:
 246          *
 247          * foreach (int remain in wv.until(t)) {
 248          *     do_stuff();
 249          *     if (exit_condition) break;
 250          * }
 251          *
 252          * New iterations of the loop will continue until DateTime.Now==t,
 253          * or you exit the loop by hand.
 254          *
 255          * If t==DateTime.MinValue, loop will continue forever.
 256          *
 257          * 'remain' at each iteration will be the number of milliseconds
 258          * remaining, or -1 if t==DateTime.MinValue.
 259          *
 260          * Even if the timeout is in the past, this is guaranteed to return
 261          * at least once.
 262          */
 263         public static IEnumerable<int> until(DateTime t)
 264         {
 265             bool forever = (t == DateTime.MinValue);
 266             DateTime n = DateTime.Now;
 267             bool once = false;
 268
 269             while (!once || t==DateTime.MinValue || n < t)
 270             {
 271                 once = true;
 272                 if (forever)
 273                     yield return -1;
 274                 else
 275                 {
 276                     int s = (int)((n-t).TotalMilliseconds);
 277                     if (s < 0)
 278                         s = 0;
 279                     yield return s;
 280                 }
 281                 n = DateTime.Now;
 282             }
 283         }
 284
 285         /**
 286          * Like until(DateTime t), but works with a timeout in msec instead
 287          * of an exact time.
 288          *
 289          * A negative timeout means "forever".
 290          */
 291         public static IEnumerable<int> until(int msec_timeout)
 292         {
 293             DateTime t;
 294             if (msec_timeout < 0)
 295                 t = DateTime.MinValue;
 296             else
 297                 t = DateTime.Now + TimeSpan.FromMilliseconds(msec_timeout);
 298             foreach (var i in until(t))
 299                 yield return i;
 300         }
 301
 302         public static string add_breaks_to_newlines(string orig)
 303         {
 304             StringBuilder retval = new StringBuilder();
 305             // Add a bit of space, since we expect to get a few newlines.
 306             retval.EnsureCapacity(orig.Length + 32);
 307             string[] split = orig.Split('\n');
 308             for (int i = 0; i < split.Length; i++)
 309             {
 310                 string s = split[i];
 311                 retval.Append(s);
 312                 // Don't do anything to the very end of the string
 313                 if (i != split.Length - 1)
 314                 {
 315                     string trimmed = s.Trim();
 316                     if (!trimmed.EndsWith("<br>") && !trimmed.EndsWith("<br/>")
 317                         && !trimmed.EndsWith("<br />"))
 318                     {
 319                         retval.Append("<br/>\n");
 320                     }
 321                     else
 322                         retval.Append("\n");
 323                 }
 324             }
 325             return retval.ToString();
 326         }
 327
 328         // Extend Path.Combine to work on more than two path elements.
 329         public static string PathCombine(string first, params string[] rest)
 330         {
 331             string combined = first;
 332             foreach (string elem in rest)
 333                 combined = Path.Combine(combined, elem);
 334             return combined;
 335         }
 336
 337         public static bool IsMono()
 338         {
 339             return Type.GetType("Mono.Runtime") != null;
 340         }
 341     }
 342 }
 343
 344 namespace Wv.Obsolete
 345 {
 346     public class Log
 347     {
 348         protected string logname;
 349
 350         static int refs = 0;
 351         static TraceListener mytrace = null;
 352         static bool disable_mytrace = false;
 353
 354         public Log(string logname)
 355         {
 356             refs++;
 357             if (mytrace == null && !disable_mytrace
 358                 && Trace.Listeners.Count < 2)
 359             {
 360                 mytrace = new TextWriterTraceListener(Console.Error);
 361                 Trace.Listeners.Add(mytrace);
 362             }
 363
 364             //Trace.WriteLine(String.Format("Log constructor for '{0}'.",
 365             //   logname));
 366             Trace.Flush();
 367             this.logname = logname;
 368         }
 369
 370         ~Log()
 371         {
 372             refs--;
 373             if (refs == 0)
 374             {
 375                 if (mytrace != null)
 376                     Trace.Listeners.Remove(mytrace);
 377                 mytrace = null;
 378             }
 379         }
 380
 381         public static void no_default_listener()
 382         {
 383             disable_mytrace = true;
 384             if (mytrace != null)
 385             {
 386                 Trace.Listeners.Remove(mytrace);
 387                 mytrace = null;
 388             }
 389         }
 390
 391         public virtual void log(string format, params object [] arg)
 392         {
 393             // Console.Error.WriteLine("<" + logname + "> " + format, arg);
 394             Trace.WriteLine(String.Format
 395                             ("[" + logname + "] " + format, arg));
 396             Trace.Flush();
 397         }
 398
 399         public void log(string s)
 400         {
 401             log("{0}", s);
 402         }
 403     }
 404
 405     public class SilentLog : Log
 406     {
 407         public SilentLog(string logname) : base(logname)
 408         {
 409         }
 410
 411         public override void log(string format, params object [] arg)
 412         {
 413         }
 414     }
 415
 416     // This is intended to work sort of like PHP arrays, which are a mix of
 417     // hash tables and lists.  Looking up an entry in the hash is O(1), but
 418     // when you iterate through all the entries, the ordering is well-defined.
 419     //
 420     // So far, this implementation is pretty limited and lacks a bunch of the
 421     // things PHP can do, such as assigning to a particular array index.
 422     public class SortedHash : IEnumerable
 423     {
 424         ArrayList array = new ArrayList();
 425         Hashtable hash = new Hashtable();
 426
 427         public IEnumerator GetEnumerator()
 428         {
 429             return array.GetEnumerator();
 430         }
 431
 432         public void Add(string key, object value)
 433         {
 434             array.Add(value);
 435             if (!hash.Contains(key))
 436                 hash.Add(key, value);
 437         }
 438
 439         public int Count
 440         {
 441             get { return hash.Count; }
 442         }
 443
 444         public bool Contains(object key)
 445         {
 446             return hash.Contains(key);
 447         }
 448
 449         public object Find(string key)
 450         {
 451             return hash[key];
 452         }
 453
 454         public virtual object this[int index]
 455         {
 456             get { return array[index]; }
 457         }
 458
 459         public virtual void Sort()
 460         {
 461             array.Sort();
 462         }
 463
 464         public virtual void Sort(IComparer comparer)
 465         {
 466             array.Sort(comparer);
 467         }
 468
 469         public void Clear()
 470         {
 471             array.Clear();
 472             hash.Clear();
 473         }
 474
 475         public static explicit operator ArrayList(SortedHash x)
 476         {
 477             return ArrayList.ReadOnly(x.array);
 478         }
 479     }
 480
 481     public class ObjectCounter : Hashtable
 482     {
 483         public new virtual int this [object key]
 484         {
 485             get
 486             {
 487                 if (!Contains(key))
 488                     Add(key, 0);
 489                 return (int)base[key];
 490             }
 491
 492             set
 493             {
 494                 if (Contains(key))
 495                     Remove(key);
 496                 Add(key, (int)value);
 497             }
 498         }
 499     }
 500 }
 501