Rename Date to DateTime.

samples/chat/chat_server_lib.dart

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library chat_server;
 import 'dart:async';
 import 'dart:io';
 import 'dart:isolate';
 import 'dart:json' as json;
 import 'dart:math';
@@ skipping 46 matching lines @@
 
 
 class User {
   static int nextSessionId = 0;
 
   User(this._handle) {
     _sessionId = "a${nextSessionId++}";
     markActivity();
   }
 
-  void markActivity() { _lastActive = new Date.now(); }
-  Duration idleTime(Date now) => now.difference(_lastActive);
+  void markActivity() { _lastActive = new DateTime.now(); }
+  Duration idleTime(DateTime now) => now.difference(_lastActive);
 
   String get handle => _handle;
   String get sessionId => _sessionId;
 
   String _handle;
   String _sessionId;
-  Date _lastActive;
+  DateTime _lastActive;
 }
 
 
 class Message {
   static const int JOIN = 0;
   static const int MESSAGE = 1;
   static const int LEAVE = 2;
   static const int TIMEOUT = 3;
   static const List<String> _typeName =
       const [ "join", "message", "leave", "timeout"];
 
   Message.join(this._from)
-      : _received = new Date.now(), _type = JOIN;
+      : _received = new DateTime.now(), _type = JOIN;
   Message(this._from, this._message)
-      : _received = new Date.now(), _type = MESSAGE;
+      : _received = new DateTime.now(), _type = MESSAGE;
   Message.leave(this._from)
-      : _received = new Date.now(), _type = LEAVE;
+      : _received = new DateTime.now(), _type = LEAVE;
   Message.timeout(this._from)
-      : _received = new Date.now(), _type = TIMEOUT;
+      : _received = new DateTime.now(), _type = TIMEOUT;
 
   User get from => _from;
-  Date get received => _received;
+  DateTime get received => _received;
   String get message => _message;
   void set messageNumber(int n) { _messageNumber = n; }
 
   Map toMap() {
     Map map = new Map();
     map["from"] = _from.handle;
     map["received"] = _received.toString();
     map["type"] = _typeName[_type];
     if (_type == MESSAGE) map["message"] = _message;
     map["number"] = _messageNumber;
     return map;
   }
 
   User _from;
-  Date _received;
+  DateTime _received;
   int _type;
   String _message;
   int _messageNumber;
 }
 
 
 class Topic {
   static const int DEFAULT_IDLE_TIMEOUT = 60 * 60 * 1000;  // One hour.
   Topic()
       : _activeUsers = new Map(),
@@ skipping 66 matching lines @@
     }
   }
 
   void registerChangeCallback(String sessionId, var callback) {
     _callbacks[sessionId] = callback;
   }
 
   void _handleTimer(Timer timer) {
     Set inactiveSessions = new Set();
     // Collect all sessions which have not been active for some time.
-    Date now = new Date.now();
+    DateTime now = new DateTime.now();
     _activeUsers.forEach((String sessionId, User user) {
       if (user.idleTime(now).inMilliseconds > DEFAULT_IDLE_TIMEOUT) {
         inactiveSessions.add(sessionId);
       }
     });
     // Terminate the inactive sessions.
     inactiveSessions.forEach((String sessionId) {
       Function callback = _callbacks.remove(sessionId);
       if (callback != null) callback(null);
       User user = _activeUsers.remove(sessionId);
@@ skipping 285 matching lines @@
         if (sessionId != null && nextMessage != null) {
 
           void sendResponse(messages) {
             // Send response.
             Map responseData = new Map();
             responseData["response"] = "receive";
             if (messages != null) {
               responseData["messages"] = messages;
               responseData["activeUsers"] = _topic.activeUsers;
               responseData["upTime"] =
-                  new Date.now().difference(_serverStart).inMilliseconds;
+                  new DateTime.now().difference(_serverStart).inMilliseconds;
             } else {
               responseData["disconnect"] = true;
             }
             _sendJSONResponse(response, responseData);
           }
 
           // Receive request from user.
           List messages = _topic.messagesFrom(nextMessage, maxMessages);
           if (messages == null) {
             _topic.registerChangeCallback(sessionId, sendResponse);
           } else {
             sendResponse(messages);
           }
 
         } else {
           _protocolError(request, response);
         }
       } else {
         _protocolError(request, response);
       }
     };
   }
 
   void init() {
     _logRequests = false;
     _topic = new Topic();
-    _serverStart = new Date.now();
+    _serverStart = new DateTime.now();
     _messageCount = 0;
     _messageRate = new Rate();
 
     // Start a timer for cleanup events.
     _cleanupTimer =
         new Timer.repeating(10000, (timer) => _topic._handleTimer(timer));
   }
 
   // Start timer for periodic logging.
   void _handleLogging(Timer timer) {
@@ skipping 66 matching lines @@
   }
 
   String _host;
   int _port;
   HttpServer _server;  // HTTP server instance.
   bool _logRequests;
 
   Topic _topic;
   Timer _cleanupTimer;
   Timer _loggingTimer;
-  Date _serverStart;
+  DateTime _serverStart;
 
   bool _logging;
   int _messageCount;
   Rate _messageRate;
 
   // Static HTML.
   List<int> _redirectPage;
   List<int> _notFoundPage;
 }
 
 
 // Calculate the rate of events over a given time range. The time
 // range is split over a number of buckets where each bucket collects
 // the number of events happening in that time sub-range. The first
 // constructor arument specifies the time range in milliseconds. The
 // buckets are in the list _buckets organized at a circular buffer
 // with _currentBucket marking the bucket where an event was last
 // recorded. A current sum of the content of all buckets except the
 // one pointed a by _currentBucket is kept in _sum.
 class Rate {
   Rate([int timeRange = 1000, int buckets = 10])
       : _timeRange = timeRange,
         _buckets = new List.fixedLength(buckets + 1),  // Current bucket is not in the sum.
         _currentBucket = 0,
-        _currentBucketTime = new Date.now().millisecondsSinceEpoch,
+        _currentBucketTime = new DateTime.now().millisecondsSinceEpoch,
         _sum = 0 {
     _bucketTimeRange = (_timeRange / buckets).toInt();
     for (int i = 0; i < _buckets.length; i++) {
       _buckets[i] = 0;
     }
   }
 
   // Record the specified number of events.
   void record(int count) {
     _timePassed();
     _buckets[_currentBucket] = _buckets[_currentBucket] + count;
   }
 
   // Returns the current rate of events for the time range.
   num get rate {
     _timePassed();
     return _sum;
   }
 
   // Update the current sum as time passes. If time has passed by the
   // current bucket add it to the sum and move forward to the bucket
   // matching the current time. Subtract all buckets vacated from the
   // sum as bucket for current time is located.
   void _timePassed() {
-    int time = new Date.now().millisecondsSinceEpoch;
+    int time = new DateTime.now().millisecondsSinceEpoch;
     if (time < _currentBucketTime + _bucketTimeRange) {
       // Still same bucket.
       return;
     }
 
     // Add collected bucket to the sum.
     _sum += _buckets[_currentBucket];
 
     // Find the bucket for the current time. Subtract all buckets
     // reused from the sum.
     while (time >= _currentBucketTime + _bucketTimeRange) {
       _currentBucket = (_currentBucket + 1) % _buckets.length;
       _sum -= _buckets[_currentBucket];
       _buckets[_currentBucket] = 0;
       _currentBucketTime += _bucketTimeRange;
     }
   }
 
   int _timeRange;
   List<int> _buckets;
   int _currentBucket;
   int _currentBucketTime;
   num _bucketTimeRange;
   int _sum;
 }