fixed bug in decoder for binary data, off by a byte at subtype; implemented LazyBSONList and added a writeable lazy bson object (needed for testing with morphia).

scotthernandez · scotthernandez · commit 9701ea6017f5 · 2011-10-24T14:02:29.000+11:00
diff --git a/src/main/com/mongodb/LazyDBCallback.java b/src/main/com/mongodb/LazyDBCallback.java
@@ -15,11 +15,11 @@
  */
 package com.mongodb;
 
-import org.bson.*;
-import org.bson.types.*;
+import java.util.Iterator;
+import java.util.logging.Logger;
 
-import java.util.*;
-import java.util.logging.*;
+import org.bson.LazyBSONCallback;
+import org.bson.types.ObjectId;
 
 /**
  *
@@ -51,5 +51,5 @@ public Object createDBRef( String ns, ObjectId id ){
 
     final DBCollection _collection;
     final DB _db;
-    private static final Logger log = Logger.getLogger( "com.mongodb.LazyDBCallback" );
+    private static final Logger log = Logger.getLogger( LazyDBCallback.class.getName() );
 }
diff --git a/src/main/com/mongodb/LazyDBObject.java b/src/main/com/mongodb/LazyDBObject.java
@@ -17,17 +17,16 @@
 
 import org.bson.LazyBSONCallback;
 import org.bson.LazyBSONObject;
-import org.bson.io.BSONByteBuffer; 
-
-import java.io.*;
+import org.bson.io.BSONByteBuffer;
 
 public class LazyDBObject extends LazyBSONObject implements DBObject {
 
-    public void markAsPartialObject() {
+	public void markAsPartialObject() {
+	_partial = true;
     }
 
     public boolean isPartialObject() {
-        return false;
+        return _partial;
     }
 
     public LazyDBObject(BSONByteBuffer buff, LazyBSONCallback cbk){ 
@@ -46,4 +45,6 @@ public LazyDBObject(byte[] data, LazyBSONCallback cbk){
     public LazyDBObject(byte[] data, int offset, LazyBSONCallback cbk){
         super(data, offset, cbk);
     }
+
+    private boolean _partial = false;
 }
diff --git a/src/main/com/mongodb/LazyWriteableDBCallback.java b/src/main/com/mongodb/LazyWriteableDBCallback.java
@@ -0,0 +1,45 @@
+/**
+ *      Copyright (C) 2008 10gen Inc.
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ */
+package com.mongodb;
+
+import java.util.Iterator;
+import java.util.logging.Logger;
+
+/**
+ *
+ */
+public class LazyWriteableDBCallback extends LazyDBCallback {
+
+    public LazyWriteableDBCallback( DBCollection coll ){
+	super(coll);
+    }
+
+    @Override
+    public Object createObject( byte[] data, int offset ){
+        LazyWriteableDBObject o = new LazyWriteableDBObject( data, offset, this );
+        //log.info("Created inner BSONObject: " + o);
+        // need to detect DBRef but must make sure we dont search through all fields
+        // $ref must be 1st key
+        Iterator it = o.keySet().iterator();
+        if ( it.hasNext() && it.next().equals( "$ref" ) &&
+             o.containsField( "$id" ) ){
+            return new DBRef( _db, o );
+        }
+        return o;
+    }
+
+    private static final Logger log = Logger.getLogger( LazyWriteableDBCallback.class.getName() );
+}
diff --git a/src/main/com/mongodb/LazyWriteableDBDecoder.java b/src/main/com/mongodb/LazyWriteableDBDecoder.java
@@ -0,0 +1,36 @@
+/**
+ *      Copyright (C) 2008 10gen Inc.
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ */
+package com.mongodb;
+
+
+/**
+ *
+ */
+public class LazyWriteableDBDecoder extends LazyDBDecoder {
+    static class LazyDBDecoderFactory implements DBDecoderFactory {
+        @Override
+        public DBDecoder create( ){
+            return new LazyWriteableDBDecoder();
+        }
+    }
+
+    public static DBDecoderFactory FACTORY = new LazyDBDecoderFactory();
+
+    public DBCallback getDBCallback(DBCollection collection) {
+        return new LazyWriteableDBCallback(collection);
+    }
+
+}
diff --git a/src/main/com/mongodb/LazyWriteableDBObject.java b/src/main/com/mongodb/LazyWriteableDBObject.java
@@ -0,0 +1,120 @@
+/**
+ *      Copyright (C) 2008 10gen Inc.
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ */
+package com.mongodb;
+
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+
+import org.bson.BSONObject;
+import org.bson.LazyBSONCallback;
+import org.bson.io.BSONByteBuffer;
+
+public class LazyWriteableDBObject extends LazyDBObject {
+
+    public LazyWriteableDBObject(BSONByteBuffer buff, LazyBSONCallback cbk){
+        super(buff, cbk);
+    }
+
+    public LazyWriteableDBObject(BSONByteBuffer buff, int offset, LazyBSONCallback cbk){
+        super(buff, offset, cbk);
+    }
+
+
+    public LazyWriteableDBObject(byte[] data, LazyBSONCallback cbk){
+        this(data, 0, cbk);
+    }
+
+    public LazyWriteableDBObject(byte[] data, int offset, LazyBSONCallback cbk){
+        super(data, offset, cbk);
+    }
+
+    /* (non-Javadoc)
+	 * @see org.bson.LazyBSONObject#put(java.lang.String, java.lang.Object)
+	 */
+	@Override
+	public Object put(String key, Object v) {
+		return writeable.put(key, v);
+	}
+
+	/* (non-Javadoc)
+	 * @see org.bson.LazyBSONObject#putAll(org.bson.BSONObject)
+	 */
+	@Override
+	public void putAll(BSONObject o) {
+		for(String key : o.keySet()){
+			put(key, o.get(key));
+		}
+	}
+
+	/* (non-Javadoc)
+	 * @see org.bson.LazyBSONObject#putAll(java.util.Map)
+	 */
+	@SuppressWarnings("rawtypes")
+	@Override
+	public void putAll(Map m) {
+		writeable.putAll(m);
+	}
+
+	/* (non-Javadoc)
+	 * @see org.bson.LazyBSONObject#get(java.lang.String)
+	 */
+	@Override
+	public Object get(String key) {
+		Object o = writeable.get(key);
+		return (o!=null) ? o : super.get(key);
+	}
+
+	/* (non-Javadoc)
+	 * @see org.bson.LazyBSONObject#removeField(java.lang.String)
+	 */
+	@Override
+	public Object removeField(String key) {
+		Object o = writeable.remove(key);
+		return (o!=null) ? o : super.removeField(key);
+	}
+
+	/* (non-Javadoc)
+	 * @see org.bson.LazyBSONObject#containsField(java.lang.String)
+	 */
+	@Override
+	public boolean containsField(String s) {
+		boolean has = writeable.containsKey(s);
+		return (has) ? has : super.containsField(s);
+	}
+
+	/* (non-Javadoc)
+	 * @see org.bson.LazyBSONObject#keySet()
+	 */
+	@Override
+	public Set<String> keySet() {
+		Set<String> combined = new HashSet<String>();
+		combined.addAll(writeable.keySet());
+		combined.addAll(super.keySet());
+		return combined;
+	}
+
+	/* (non-Javadoc)
+	 * @see org.bson.LazyBSONObject#isEmpty()
+	 */
+	@Override
+	public boolean isEmpty() {
+		return writeable.isEmpty() || super.isEmpty();
+	}
+
+	final private HashMap<String, Object> writeable = new HashMap<String, Object>();
+}
diff --git a/src/main/org/bson/LazyBSONCallback.java b/src/main/org/bson/LazyBSONCallback.java
@@ -15,9 +15,10 @@
  */
 package org.bson;
 
-import org.bson.types.*;
+import java.util.List;
+import java.util.logging.Logger;
 
-import java.util.logging.*;
+import org.bson.types.ObjectId;
 
 /**
  *
@@ -57,10 +58,14 @@ public void setRootObject( Object root ){
     }
 
     public Object createObject( byte[] data, int offset ){
-        // TODO - LazyBSONList ?
         return new LazyBSONObject( data, offset, this );
     }
 
+    @SuppressWarnings("rawtypes")
+	public List createArray( byte[] data, int offset ){
+        return new LazyDBList( data, offset, this );
+    }
+
     public Object createDBRef( String ns, ObjectId id ){
         return new BasicBSONObject( "$ns", ns ).append( "$id", id );
     }
diff --git a/src/main/org/bson/LazyBSONList.java b/src/main/org/bson/LazyBSONList.java
@@ -79,7 +79,7 @@ public int size(){
 
     public class LazyBSONListIterator implements Iterator {
         ArrayList<ElementRecord> elements;
-        int pos;
+        int pos=0;
         
         public LazyBSONListIterator() {
             elements = getElementsToKey( null );
@@ -92,7 +92,7 @@ public boolean hasNext(){
 
         @Override
         public Object next(){
-            return elements.get(++pos);
+            return getElementValue(elements.get(pos++));
         }
 
         @Override
diff --git a/src/main/org/bson/LazyBSONObject.java b/src/main/org/bson/LazyBSONObject.java
@@ -24,6 +24,7 @@
 import java.util.UUID;
 import java.util.logging.Logger;
 import java.util.regex.Pattern;
+
 import org.bson.io.BSONByteBuffer;
 import org.bson.types.BSONTimestamp;
 import org.bson.types.Code;
@@ -393,7 +394,7 @@ protected Object getElementValue( ElementRecord record ){
             case BSON.OBJECT:
                 return _callback.createObject( _input.array(), record.valueOffset );
             case BSON.ARRAY:
-                return _callback.createObject( _input.array(), record.valueOffset );
+                return _callback.createArray( _input.array(), record.valueOffset );
             case BSON.BINARY:
                 return readBinary( record.valueOffset );
             case BSON.REGEX:
@@ -411,6 +412,7 @@ private Object readBinary( int valueOffset ){
         final int totalLen = _input.getInt( valueOffset );
         valueOffset += 4;
         final byte bType = _input.get( valueOffset );
+        valueOffset += 1;
 
         byte[] bin;
         switch ( bType ){
diff --git a/src/main/org/bson/LazyDBList.java b/src/main/org/bson/LazyDBList.java
@@ -0,0 +1,41 @@
+/**
+ *
+ */
+package org.bson;
+
+import org.bson.io.BSONByteBuffer;
+
+import com.mongodb.DBObject;
+import com.mongodb.util.JSON;
+
+/**
+ * @author scotthernandez
+ *
+ */
+public class LazyDBList extends LazyBSONList implements DBObject {
+    private static final long serialVersionUID = -4415279469780082174L;
+
+	public LazyDBList(byte[] data, LazyBSONCallback callback) { super(data, callback); }
+	public LazyDBList(byte[] data, int offset, LazyBSONCallback callback) { super(data, offset, callback); }
+	public LazyDBList(BSONByteBuffer buffer, LazyBSONCallback callback) { super(buffer, callback); }
+	public LazyDBList(BSONByteBuffer buffer, int offset, LazyBSONCallback callback) { super(buffer, offset, callback); }
+
+    /**
+     * Returns a JSON serialization of this object
+     * @return JSON serialization
+     */
+    @Override
+    public String toString(){
+        return JSON.serialize( this );
+    }
+
+    public boolean isPartialObject(){
+        return _isPartialObject;
+    }
+
+    public void markAsPartialObject(){
+        _isPartialObject = true;
+    }
+
+    private boolean _isPartialObject;
+}
diff --git a/src/test/com/mongodb/JavaClientTest.java b/src/test/com/mongodb/JavaClientTest.java
@@ -512,7 +512,7 @@ public void testMapReduceInlineSecondary() throws Exception {
         c.save( new BasicDBObject( "x" , new String[]{ "a" , "b" } ) );
         c.save( new BasicDBObject( "x" , new String[]{ "b" , "c" } ) );
         WriteResult wr = c.save( new BasicDBObject( "x" , new String[]{ "c" , "d" } ) );
-        if(mongo.getReplicaSetStatus() != null )
+        if(mongo.getReplicaSetStatus() != null  && mongo.getReplicaSetStatus().getName() != null)
 		wr.getLastError(WriteConcern.REPLICAS_SAFE);
 
         MapReduceOutput out =
@@ -531,9 +531,9 @@ public void testMapReduceInlineSecondary() throws Exception {
         assertEquals( 1 , m.get( "d" ).intValue() );
         ReplicaSetStatus replStatus = mongo.getReplicaSetStatus();
         //if it is a replicaset, and there is no master, or master is not the secondary
-        if(replStatus!= null && ((replStatus.getMaster() == null) || (replStatus.getMaster() != null && !replStatus.getMaster().equals(replStatus.getASecondary()))))
-            assertTrue( !mongo.getReplicaSetStatus().isMaster( out.getCommandResult().getServerUsed() ), "Had a replicaset but didn't use secondary! replSetStatus : " + mongo.getReplicaSetStatus() + " \n Used: " +
-                    out.getCommandResult().getServerUsed() + " \n ");
+        if( replStatus!= null && replStatus.getName() != null && ((replStatus.getMaster() == null) || (replStatus.getMaster() != null && !replStatus.getMaster().equals(replStatus.getASecondary()))))
+            assertTrue( !mongo.getReplicaSetStatus().isMaster( out.getCommandResult().getServerUsed() ), 
+            		"Had a replicaset but didn't use secondary! replSetStatus : " + mongo.getReplicaSetStatus() + " \n Used: " + out.getCommandResult().getServerUsed() + " \n ");
     }
 
     @Test
diff --git a/src/test/com/mongodb/LazyDBObjectTest.java b/src/test/com/mongodb/LazyDBObjectTest.java

Original file line number	Diff line number	Diff line change
`@@ -17,17 +17,16 @@`
`17`	`17`
`18`	`18`	`import org.bson.LazyBSONCallback;`
`19`	`19`	`import org.bson.LazyBSONObject;`
`20`		`-import org.bson.io.BSONByteBuffer;`
`21`		`-`
`22`		`-import java.io.*;`
	`20`	`+import org.bson.io.BSONByteBuffer;`
`23`	`21`
`24`	`22`	`public class LazyDBObject extends LazyBSONObject implements DBObject {`
`25`	`23`
`26`		`- public void markAsPartialObject() {`
	`24`	`+ public void markAsPartialObject() {`
	`25`	`+ _partial = true;`
`27`	`26`	`}`
`28`	`27`
`29`	`28`	`public boolean isPartialObject() {`
`30`		`- return false;`
	`29`	`+ return _partial;`
`31`	`30`	`}`
`32`	`31`
`33`	`32`	`public LazyDBObject(BSONByteBuffer buff, LazyBSONCallback cbk){`
`@@ -46,4 +45,6 @@ public LazyDBObject(byte[] data, LazyBSONCallback cbk){`
`46`	`45`	`public LazyDBObject(byte[] data, int offset, LazyBSONCallback cbk){`
`47`	`46`	`super(data, offset, cbk);`
`48`	`47`	`}`
	`48`	`+`
	`49`	`+ private boolean _partial = false;`
`49`	`50`	`}`
Original file line number	Diff line number	Diff line change
`@@ -15,9 +15,10 @@`
`15`	`15`	`*/`
`16`	`16`	`package org.bson;`
`17`	`17`
`18`		`-import org.bson.types.*;`
	`18`	`+import java.util.List;`
	`19`	`+import java.util.logging.Logger;`
`19`	`20`
`20`		`-import java.util.logging.*;`
	`21`	`+import org.bson.types.ObjectId;`
`21`	`22`
`22`	`23`	`/**`
`23`	`24`	`*`
`@@ -57,10 +58,14 @@ public void setRootObject( Object root ){`
`57`	`58`	`}`
`58`	`59`
`59`	`60`	`public Object createObject( byte[] data, int offset ){`
`60`		`- // TODO - LazyBSONList ?`
`61`	`61`	`return new LazyBSONObject( data, offset, this );`
`62`	`62`	`}`
`63`	`63`
	`64`	`+ @SuppressWarnings("rawtypes")`
	`65`	`+ public List createArray( byte[] data, int offset ){`
	`66`	`+ return new LazyDBList( data, offset, this );`
	`67`	`+ }`
	`68`	`+`
`64`	`69`	`public Object createDBRef( String ns, ObjectId id ){`
`65`	`70`	`return new BasicBSONObject( "$ns", ns ).append( "$id", id );`
`66`	`71`	`}`