Add getters/setters to MongoOptions class

Author: breinero-zz

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/test/com/mongodb/MongoOptionsTest.java

@@ -70,5 +70,47 @@ public void testCopy() throws Exception {
         assertEquals(options.socketFactory, copy.socketFactory);
         assertEquals(options.description, copy.description);
     }
+    
+    @Test
+    public void testGetterSetters() throws Exception {
+
+        final MongoOptions options = new MongoOptions();
+
+        options.setConnectionsPerHost(100);
+        options.setThreadsAllowedToBlockForConnectionMultiplier(101);
+        options.setMaxWaitTime(102);
+        options.setConnectTimeout(103);
+        options.setSocketTimeout(104);
+        options.setSocketKeepAlive(true);
+        options.setAutoConnectRetry(true);
+        options.setMaxAutoConnectRetryTime(105);
+        options.setSafe(true);
+        options.setW(106);
+        options.setWtimeout(107);
+        options.setFsync(true);
+        options.setJ(false);
+        options.setDbDecoderFactory(null);
+        options.setDbEncoderFactory(null);
+        options.setSocketFactory(null);
+        options.setDescription("very cool");
+        
+        assertEquals(options.getConnectionsPerHost(), 100);
+        assertEquals(options.getThreadsAllowedToBlockForConnectionMultiplier(), 101);
+        assertEquals(options.getMaxWaitTime(), 102);
+        assertEquals(options.getConnectTimeout(), 103);
+        assertEquals(options.getSocketTimeout(), 104);
+        assertEquals(options.isSocketKeepAlive(), true);
+        assertEquals(options.isAutoConnectRetry(), true);
+        assertEquals(options.getMaxAutoConnectRetryTime(), 105);
+        assertEquals(options.isSafe(), true);
+        assertEquals(options.getW(), 106);
+        assertEquals(options.getWtimeout(), 107);
+        assertEquals(options.isFsync(), true);
+        assertEquals(options.isJ(), false);
+        assertEquals(options.getDbDecoderFactory(), null);
+        assertEquals(options.getDbEncoderFactory(), null);
+        assertEquals(options.getSocketFactory(), null);
+        assertEquals(options.getDescription(), "very cool");
+    }
 }