diff --git a/latest/CCNTime.js b/latest/CCNTime.js
new file mode 100644
index 0000000..fc6d2ae
--- /dev/null
+++ b/latest/CCNTime.js
@@ -0,0 +1,226 @@
+
+var CCNTime = function CCNTime(
+                               //long 
+msec) {
+
+
+
+	//byte [] 
+	//this.binarytime = null;
+	
+
+	this.NANOS_MAX = 999877929;
+	
+	this.date = new Date(msec);
+};
+
+
+//public CCNTime(long msec) {
+	//this((msec/1000) * 1000, (msec % 1000) * 1000000L);
+//}
+
+	/**
+	 * Create a CCNTime
+	 * @param timestamp source timestamp to initialize from, some precision will be lost
+	 */
+	//public CCNTime(Timestamp timestamp) {
+		//this(timestamp.getTime(), timestamp.getNanos());
+	//}
+	
+	/**
+	 * Create a CCNTime
+	 * @param time source Date to initialize from, some precision will be lost
+	 * as CCNTime does not round to unitary milliseconds
+	 */
+CCNTime.prototype.setDate = function(
+	//Date 
+		date) {
+
+	this.date = date;
+};
+	
+	/**
+	 * Create a CCNTime from its binary encoding
+	 * @param binaryTime12 the binary representation of a CCNTime
+	 */
+CCNTime.prototype.setDateBinary = function(
+	//byte [] 
+		binaryTime12) {
+
+
+	if ((null == binaryTime12) || (binaryTime12.length == 0)) {
+		throw new IllegalArgumentException("Invalid binary time!");
+	}
+	
+
+	value = 0;
+	for(i = 0; i < binaryTime12.length; i++) {
+		value = value << 8;
+		// Java will assume the byte is signed, so extend it and trim it.
+		b = (binaryTime12[i]) & 0xFF;
+		value |= b;
+	}
+	
+	this.date = new Date(value);
+
+};
+
+//byte[]
+CCNTime.prototype.toBinaryTime = function() {
+	
+	
+
+	return unsignedLongToByteArray(this.date.getTime());
+
+}
+
+unsignedLongToByteArray= function( value) {
+	if( 0 == value )
+		return [0];
+
+	if( 0 <= value && value <= 0x00FF ) {
+		//byte [] 
+		bb = new Array[1];
+		bb[0] = (value & 0x00FF);
+		return bb;
+	}
+
+	
+	//byte [] 
+	out = null;
+	//int
+	offset = -1;
+	for(var i = 7; i >=0; --i) {
+		//byte
+		b = ((value >> (i * 8)) & 0xFF);
+		if( out == null && b != 0 ) {
+			out = new Array(i+1);//byte[i+1];
+			offset = i;
+		}
+		if( out != null )
+			out[ offset - i ] = b;
+	}
+	return out;
+}
+	
+/**
+ * Generate the binary representation of a CCNTime
+ * @return the binary representation we use for encoding
+ */
+//byte [] 
+/*CCCCNTime.prototype.toBinaryTime = function() {
+
+		if( null == _binarytime ) {
+			byte [] b = DataUtils.unsignedLongToByteArray(toBinaryTimeAsLong());
+			_binarytime = b;
+		}
+		return _binarytime;
+};*/
+	
+	/**
+	 * Generate the internal long representation of a CCNTime, useful for comparisons
+	 * and used internally
+	 * @return the long representation of this time in our internal units
+	 */
+	//public long toBinaryTimeAsLong() {
+		//return toBinaryTimeAsLong(getTime(), getNanos());
+	//}
+	
+	/**
+	 * Static method to convert from milliseconds and nanoseconds to our
+	 * internal long representation.
+	 * Assumes that nanos also contains the integral milliseconds for this
+	 * time. Ignores msec component in msec.
+	 * @param msec milliseconds
+	 * @param nanos nanoseconds
+	 * @return
+	 */
+	//public static long toBinaryTimeAsLong(long msec, long nanos) {
+		//long timeVal = (msec / 1000) * 4096L + (nanos * 4096L + 500000000L) / 1000000000L;
+		//return timeVal;		
+	//}
+	
+	/*protected void setFromBinaryTimeAsLong(long binaryTimeAsLong) {
+		_binarytime = null;
+		super.setTime((binaryTimeAsLong / 4096L) * 1000L);
+		super.setNanos((int)(((binaryTimeAsLong % 4096L) * 1000000000L) / 4096L));
+	}*/
+	
+	/*@Override
+	public void setTime(long msec) {
+		_binarytime = null;
+		long binaryTimeAsLong = toBinaryTimeAsLong((msec/1000) * 1000, (msec % 1000) * 1000000L);
+		super.setTime((binaryTimeAsLong / 4096L) * 1000L);
+		super.setNanos((int)(((binaryTimeAsLong % 4096L) * 1000000000L) / 4096L));
+	}*/
+
+	/*@Override
+	public void setNanos(int nanos) {
+		_binarytime = null;
+		int quantizedNanos = (int)(((((nanos * 4096L + 500000000L) / 1000000000L)) * 1000000000L) / 4096L);
+		if ((quantizedNanos < 0) || (quantizedNanos > 999999999)) {
+			System.out.println("Quantizing nanos " + nanos + " resulted in out of range value " + quantizedNanos + "!");
+		}
+	   	super.setNanos(quantizedNanos);
+	}*/
+
+	/*public void addNanos(int nanos) {
+		_binarytime = null;
+		setNanos(nanos + getNanos());
+	}*/
+	
+	/*
+	public void increment(int timeUnits) {
+		_binarytime = null;
+		long binaryTimeAsLong = toBinaryTimeAsLong();
+		binaryTimeAsLong += timeUnits;
+		setFromBinaryTimeAsLong(binaryTimeAsLong);
+	}
+
+	@Override
+	public boolean equals(Timestamp ts) {
+		return super.equals(new CCNTime(ts));
+	}
+
+	@Override
+	public int compareTo(Date o) {
+		return super.compareTo(new CCNTime(o));
+	}
+
+	@Override
+	public int compareTo(Timestamp ts) {
+		return super.compareTo(new CCNTime(ts));
+	}
+
+	@Override
+	public boolean before(Timestamp ts) {
+		return super.before(new CCNTime(ts));
+	}
+
+	@Override
+	public boolean after(Timestamp ts) {
+		return super.after(new CCNTime(ts));
+	}
+
+	@Override
+	public boolean before(Date when) {
+		return super.before(new CCNTime(when));
+	}
+	
+	@Override
+	public boolean after(Date when) {
+		return super.after(new CCNTime(when));
+	}
+
+
+	public static CCNTime now() {
+		return new CCNTime();
+	}
+	
+
+	public String toShortString() {
+		// use . instead of : as URI printer will make it look nicer in the logs
+		SimpleDateFormat df = new SimpleDateFormat("yy-MM-dd-HH.mm.ss");
+		return df.format(this);
+	}
+}*/