Merge branch 'master' of github.com:mongodb/mongo-java-driver

Author: jyemin

src/main/com/mongodb/MongoOptions.java

@@ -21,7 +21,8 @@
 import javax.net.SocketFactory;
 
 /**
- * Various settings for the driver
+ * Various settings for the driver.
+ * Not thread safe.
  */
 public class MongoOptions {
 
@@ -186,8 +187,8 @@ else if (safe)
      */
     public boolean safe;
 
-    /**
-     * The "w" value of the global WriteConcern.
+    /** 
+     * The "w" value, (number of writes), of the global WriteConcern.
      * Default is 0.
      */
     public int w;
@@ -200,12 +201,14 @@ else if (safe)
 
     /**
      * The "fsync" value of the global WriteConcern.
+     * true indicates writes should wait for data to be written to server data file
      * Default is false.
      */
     public boolean fsync;
 
     /**
      * The "j" value of the global WriteConcern.
+     * true indicates writes should wait for a journaling group commit
      * Default is false.
      */
     public boolean j;
@@ -237,4 +240,276 @@ public String toString(){
         return buf.toString();
     }
 
+    /**
+     * @return The description for <code>Mongo</code> instances created with these options
+     */
+    public synchronized String getDescription() {
+        return description;
+    }
+
+    /**
+     * 
+     * @param desc The description for <code>Mongo</code> instances created with these options
+     */
+    public synchronized void setDescription(String desc) {
+        description = desc;
+    }
+
+    /**
+     * 
+     * @return the maximum number of connections allowed per host for this Mongo instance
+     */
+    public synchronized int getConnectionsPerHost() {
+        return connectionsPerHost;
+    }
+
+    /**
+     * 
+     * @param connections sets the maximum number of connections allowed per host for this Mongo instance
+     */
+    public synchronized void setConnectionsPerHost(int connections) {
+        connectionsPerHost = connections;
+    }
+
+    /**
+     * 
+     * @return the maximum number of threads that
+     * may be waiting for a connection
+     */
+    public synchronized int getThreadsAllowedToBlockForConnectionMultiplier() {
+        return threadsAllowedToBlockForConnectionMultiplier;
+    }
+
+    /**
+     * 
+     * @param this multiplied with connectionsPerHost, sets the maximum number of threads that
+     * may be waiting for a connection
+     */
+    public synchronized void setThreadsAllowedToBlockForConnectionMultiplier(int threads) {
+        threadsAllowedToBlockForConnectionMultiplier = threads;
+    }
+    
+    /**
+     * 
+     * @return The maximum time in milliseconds that threads wait for a connection
+     */
+    public synchronized int getMaxWaitTime() {
+        return maxWaitTime;
+    }
+
+    /**
+     * 
+     * @param timeMS set the maximum time in milliseconds that threads wait for a connection
+     */
+    public synchronized void setMaxWaitTime(int timeMS) {
+        maxWaitTime = timeMS;
+    }
+
+    /**
+     * 
+     * @return the connection timeout in milliseconds.
+     */
+    public synchronized int getConnectTimeout() {
+        return connectTimeout;
+    }
+
+    /**
+     * 
+     * @param timeoutMS set the connection timeout in milliseconds.
+     */
+    public synchronized void setConnectTimeout(int timeoutMS) {
+        connectTimeout = timeoutMS;
+    }
+
+    /**
+     * 
+     * @return The socket timeout in milliseconds
+     */
+    public synchronized int getSocketTimeout() {
+        return socketTimeout;
+    }
+
+    /**
+     * 
+     * @param timeoutMS set the socket timeout in milliseconds
+     */
+    public synchronized void setSocketTimeout(int timeoutMS) {
+        socketTimeout = timeoutMS;
+    }
+
+    /**
+     * 
+     * @return connection keep-alive flag
+     */
+    public synchronized boolean isSocketKeepAlive() {
+        return socketKeepAlive;
+    }
+
+    /**
+     * 
+     * @param keepAlive set connection keep-alive flag
+     */
+    public synchronized void setSocketKeepAlive(boolean keepAlive) {
+        socketKeepAlive = keepAlive;
+    }
+
+    /**
+     * 
+     * @return keep trying connection flag
+     */
+    public synchronized boolean isAutoConnectRetry() {
+        return autoConnectRetry;
+    }
+
+    /**
+     * 
+     * @param retry sets keep trying connection flag
+     */
+    public synchronized void setAutoConnectRetry(boolean retry) {
+        autoConnectRetry = retry;
+    }
+
+    /**
+     * 
+     * @return max time in MS to retrying open connection
+     */
+    public synchronized long getMaxAutoConnectRetryTime() {
+        return maxAutoConnectRetryTime;
+    }
+
+    /**
+     * 
+     * @param retryTimeMS set max time in MS to retrying open connection
+     */
+    public synchronized void setMaxAutoConnectRetryTime(long retryTimeMS) {
+        maxAutoConnectRetryTime = retryTimeMS;
+    }
+
+    /**
+     * 
+     * @return the DBCallback decoding factory
+     */
+    public synchronized DBDecoderFactory getDbDecoderFactory() {
+        return dbDecoderFactory;
+    }
+
+    /**
+     * 
+     * @param factory sets the DBCallback decoding factory
+     */
+    public synchronized void setDbDecoderFactory(DBDecoderFactory factory) {
+        dbDecoderFactory = factory;
+    }
+
+    /**
+     * 
+     * @return the encoding factory
+     */
+    public synchronized DBEncoderFactory getDbEncoderFactory() {
+        return dbEncoderFactory;
+    }
+
+    /**
+     * 
+     * @param factory sets the encoding factory
+     */
+    public synchronized void setDbEncoderFactory(DBEncoderFactory factory) {
+        dbEncoderFactory = factory;
+    }
+
+    /**
+     * 
+     * @return true if driver uses WriteConcern.SAFE for all operations.
+     */
+    public synchronized boolean isSafe() {
+        return safe;
+    }
+
+    /**
+     * 
+     * @param isSafe true if driver uses WriteConcern.SAFE for all operations.
+     */
+    public synchronized void setSafe(boolean isSafe) {
+        safe = isSafe;
+    }
+
+    /**
+     * 
+     * @return value returns the number of writes of the global WriteConcern.
+     */
+    public synchronized int getW() {
+        return w;
+    }
+
+    /**
+     * 
+     * @param val set the number of writes of the global WriteConcern.
+     */
+    public synchronized void setW(int val) {
+        w = val;
+    }
+
+    /**
+     * 
+     * @return timeout for write operation
+     */
+    public synchronized int getWtimeout() {
+        return wtimeout;
+    }
+
+    /**
+     * 
+     * @param timeoutMS sets timeout for write operation
+     */
+    public synchronized void setWtimeout(int timeoutMS) {
+        wtimeout = timeoutMS;
+    }
+
+    /**
+     * 
+     * @return true if global write concern is set to fsync
+     */
+    public synchronized boolean isFsync() {
+        return fsync;
+    }
+
+    /**
+     * 
+     * @param sync sets global write concern's fsync safe value
+     */
+    public synchronized void setFsync(boolean sync) {
+        fsync = sync;
+    }
+
+    /**
+     * 
+     * @return true if global write concern is set to journal safe
+     */
+    public synchronized boolean isJ() {
+        return j;
+    }
+
+    /**
+     * 
+     * @param safe sets global write concern's journal safe value
+     */
+    public synchronized void setJ(boolean safe) {
+        j = safe;
+    }
+
+    /**
+     * 
+     * @return the socket factory for creating sockets to mongod
+     */
+    public synchronized SocketFactory getSocketFactory() {
+        return socketFactory;
+    }
+
+    /**
+     * 
+     * @param factory sets the socket factory for creating sockets to mongod
+     */
+    public synchronized void setSocketFactory(SocketFactory factory) {
+        socketFactory = factory;
+    }
 }

src/main/com/mongodb/gridfs/GridFSDBFile.java

@@ -64,7 +64,7 @@ public long writeTo( String filename ) throws IOException {
      * @throws IOException
      */
     public long writeTo( File f ) throws IOException {
-    	
+        
     	FileOutputStream out = null;
     	try{
     		out = new FileOutputStream( f );
@@ -138,6 +138,7 @@ public int read(){
         public int read(byte[] b){
             return read( b , 0 , b.length );
         }
+
         public int read(byte[] b, int off, int len){
 
             if ( _data == null || _offset >= _data.length ){
@@ -166,35 +167,29 @@ public long skip(long numBytesToSkip) throws IOException {
                 //Don't count those extra bytes to skip in with the return value
                 return 0;
 
-            if (_offset + numBytesToSkip <= _chunkSize) {
-                //We're skipping over bytes in the current chunk, adjust the offset accordingly
-                _offset += numBytesToSkip;
-                if (_data == null && _currentChunkIdx < _numChunks)
-                    _data = getChunk(_currentChunkIdx);
-
-                return numBytesToSkip;
+            // offset in the whole file
+            long offsetInFile = 0;
+            if (_currentChunkIdx >= 0)
+                offsetInFile = _currentChunkIdx * _chunkSize + _offset;
+            if (numBytesToSkip + offsetInFile >= _length) {
+                _currentChunkIdx = _numChunks;
+                _data = null;
+                return _length - offsetInFile;
             }
 
-            //We skipping over the remainder of this chunk, could do this less recursively...
-            ++_currentChunkIdx;
-            long skippedBytes = 0;
-            if (_currentChunkIdx < _numChunks)
-                skippedBytes = _chunkSize - _offset;
-            else
-                skippedBytes = _lastChunkSize;
-
-            _offset = 0;
-            _data = null;
+            int temp = _currentChunkIdx;
+            _currentChunkIdx = (int)((numBytesToSkip + offsetInFile) / _chunkSize);
+            if (temp != _currentChunkIdx)
+                _data = getChunk(_currentChunkIdx);
+            _offset = (int)((numBytesToSkip + offsetInFile) % _chunkSize);
 
-            return skippedBytes + skip(numBytesToSkip - skippedBytes);
+            return numBytesToSkip;
         }
 
         final int _numChunks;
-        //Math trick to ensure the _lastChunkSize is between 1 and _chunkSize
-        final long _lastChunkSize = ((_length - 1) % _chunkSize) + 1;
 
         int _currentChunkIdx = -1;
-        int _offset;
+        int _offset = 0;
         byte[] _data = null;
     }