http://www.mongodb.org: The MongoDB Java Driver uber-artifact, containing the legacy driver, the mongodb-driver, mongodb-driver-core, and bson
  • Various (MongoDB) 
/*
 * Copyright 2008-present MongoDB, 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.
 */

// MongoOptions.java

package com.mongodb;

import javax.net.SocketFactory;
import java.util.concurrent.TimeUnit;

import static com.mongodb.MongoClientOptions.Builder;


Various settings for a Mongo instance. Not thread safe, and superseded by MongoClientOptions.  This class may be deprecated in a future
release.

See Also:
Deprecated:Please use MongoClientOptions instead.
/**
 * Various settings for a Mongo instance. Not thread safe, and superseded by MongoClientOptions.  This class may be deprecated in a future
 * release.
 *
 * @see MongoClientOptions
 * @see MongoClient
 * @deprecated Please use {@link MongoClientOptions} instead.
 */
@Deprecated
public class MongoOptions {

    
The description for Mongo instances created with these options. This is used in various places like logging. 
/**
     * The description for {@code Mongo} instances created with these options. This is used in various places like logging.
     */
    public String description;

    
The maximum number of connections allowed per host for this Mongo instance. Those connections will be kept in a pool when idle. Once
the pool is exhausted, any operation requiring a connection will block waiting for an available connection. Default is 10.

See Also:
  • threadsAllowedToBlockForConnectionMultiplier.threadsAllowedToBlockForConnectionMultiplier
/**
     * The maximum number of connections allowed per host for this Mongo instance. Those connections will be kept in a pool when idle. Once
     * the pool is exhausted, any operation requiring a connection will block waiting for an available connection. Default is 10.
     *
     * @see MongoOptions#threadsAllowedToBlockForConnectionMultiplier
     */
    public int connectionsPerHost;

    
This multiplier, multiplied with the connectionsPerHost setting, gives the maximum number of threads that may be waiting for a
connection to become available from the pool. All further threads will get an exception right away. For example if connectionsPerHost
is 10 and threadsAllowedToBlockForConnectionMultiplier is 5, then up to 50 threads can wait for a connection. Default is 5.

/**
     * This multiplier, multiplied with the connectionsPerHost setting, gives the maximum number of threads that may be waiting for a
     * connection to become available from the pool. All further threads will get an exception right away. For example if connectionsPerHost
     * is 10 and threadsAllowedToBlockForConnectionMultiplier is 5, then up to 50 threads can wait for a connection. Default is 5.
     */
    public int threadsAllowedToBlockForConnectionMultiplier;

    
The maximum wait time in milliseconds that a thread may wait for a connection to become available. Default is 120,000. A value of 0
means that it will not wait.  A negative value means to wait indefinitely.

/**
     * The maximum wait time in milliseconds that a thread may wait for a connection to become available. Default is 120,000. A value of 0
     * means that it will not wait.  A negative value means to wait indefinitely.
     */
    public int maxWaitTime;

    
The connection timeout in milliseconds. A value of 0 means no timeout. It is used solely when establishing a new connection Socket.connect(SocketAddress, int) Default is 10,000. 
/**
     * The connection timeout in milliseconds.  A value of 0 means no timeout. It is used solely when establishing a new connection {@link
     * java.net.Socket#connect(java.net.SocketAddress, int) } Default is 10,000.
     */
    public int connectTimeout;

    
The socket timeout in milliseconds It is used for I/O socket read and write operations Socket.setSoTimeout(int) Default is 0 and means no timeout. 
/**
     * The socket timeout in milliseconds It is used for I/O socket read and write operations {@link java.net.Socket#setSoTimeout(int)}
     * Default is 0 and means no timeout.
     */
    public int socketTimeout;

    
This flag controls the socket keep alive feature that keeps a connection alive through firewalls Socket.setKeepAlive(boolean) Default is false. 
/**
     * This flag controls the socket keep alive feature that keeps a connection alive through firewalls {@link
     * java.net.Socket#setKeepAlive(boolean)} Default is false.
     */
    public boolean socketKeepAlive;

    
Specifies the read preference.

/**
     * Specifies the read preference.
     */
    public ReadPreference readPreference;

    
Override the DBCallback factory. Default is for the standard Mongo Java driver configuration.

/**
     * Override the DBCallback factory. Default is for the standard Mongo Java driver configuration.
     */
    public DBDecoderFactory dbDecoderFactory;

    
Override the encoding factory. Default is for the standard Mongo Java driver configuration.

/**
     * Override the encoding factory. Default is for the standard Mongo Java driver configuration.
     */
    public DBEncoderFactory dbEncoderFactory;

    
If true the driver will use a WriteConcern of WriteConcern.SAFE for all operations. If w, wtimeout, fsync or j are specified, this setting is ignored. Default is false. 
/**
     * If {@code true} the driver will use a WriteConcern of WriteConcern.SAFE for all operations. If w, wtimeout, fsync or j are specified,
     * this setting is ignored. Default is false.
     */
    public boolean safe;

    
The "w" value, (number of writes), of the global WriteConcern. Default is 0.

/**
     * The "w" value, (number of writes), of the global WriteConcern. Default is 0.
     */
    public int w;

    
The "wtimeout" value of the global WriteConcern. Default is 0.

/**
     * The "wtimeout" value of the global WriteConcern. Default is 0.
     */
    public int wtimeout;

    
The "fsync" value of the global WriteConcern. true indicates writes should wait for data to be written to server data file Default is
false.

/**
     * 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.

/**
     * The "j" value of the global WriteConcern. true indicates writes should wait for a journaling group commit Default is false.
     */
    public boolean j;

    
Sets the socket factory for creating sockets to mongod Default is SocketFactory.getDefault()

/**
     * Sets the socket factory for creating sockets to mongod Default is SocketFactory.getDefault()
     */
    public SocketFactory socketFactory;

    
Sets whether there is a a finalize method created that cleans up instances of DBCursor that the client does not close.  If you are
careful to always call the close method of DBCursor, then this can safely be set to false.


Default is true.


See Also:
  • close.close()
/**
     * <p>Sets whether there is a a finalize method created that cleans up instances of DBCursor that the client does not close.  If you are
     * careful to always call the close method of DBCursor, then this can safely be set to false.</p>
     *
     * <p>Default is true.</p>
     *
     * @see DBCursor#close()
     */
    public boolean cursorFinalizerEnabled;

    
Sets the write concern.  If this is not set, the write concern defaults to the combination of settings of the other write
concern-related fields.  If set, this will override all of the other write concern-related fields.

See Also:
/**
     * Sets the write concern.  If this is not set, the write concern defaults to the combination of settings of the other write
     * concern-related fields.  If set, this will override all of the other write concern-related fields.
     *
     * @see #w
     * @see #safe
     * @see #wtimeout
     * @see #fsync
     * @see #j
     */
    public WriteConcern writeConcern;

    
Sets whether JMX beans registered by the driver should always be MBeans, regardless of whether the VM is Java 6 or greater. If false,
the driver will use MXBeans if the VM is Java 6 or greater, and use MBeans if the VM is Java 5. 
 Default is false. 


/**
     * Sets whether JMX beans registered by the driver should always be MBeans, regardless of whether the VM is Java 6 or greater. If false,
     * the driver will use MXBeans if the VM is Java 6 or greater, and use MBeans if the VM is Java 5. <p> Default is false. </p>
     */
    public boolean alwaysUseMBeans;

    String requiredReplicaSetName;

    
Creates a new default MongoOptions. This class is deprecated, use MongoClientOptions. 
Deprecated:use MongoClientOptions
/**
     * Creates a new default {@code MongoOptions}. This class is deprecated, use {@link com.mongodb.MongoClientOptions}.
     *
     * @deprecated use {@link com.mongodb.MongoClientOptions}
     */
    @Deprecated
    public MongoOptions() {
        reset();
    }

    
Creates a new MongoOptions with the given options. This class is deprecated, use MongoClientOptions. 
Params:
  • options – the MongoClientOptions to copy values from into the new MongoOptions.
Deprecated:use MongoClientOptions
/**
     * Creates a new {@code MongoOptions} with the given options. This class is deprecated, use {@link com.mongodb.MongoClientOptions}.
     *
     * @param options the MongoClientOptions to copy values from into the new MongoOptions.
     * @deprecated use {@link com.mongodb.MongoClientOptions}
     */
    @SuppressWarnings("deprecation")
    @Deprecated
    public MongoOptions(final MongoClientOptions options) {
        connectionsPerHost = options.getConnectionsPerHost();
        threadsAllowedToBlockForConnectionMultiplier = options.getThreadsAllowedToBlockForConnectionMultiplier();
        maxWaitTime = options.getMaxWaitTime();
        connectTimeout = options.getConnectTimeout();
        socketFactory = options.getSocketFactory();
        socketTimeout = options.getSocketTimeout();
        socketKeepAlive = options.isSocketKeepAlive();
        readPreference = options.getReadPreference();
        dbDecoderFactory = options.getDbDecoderFactory();
        dbEncoderFactory = options.getDbEncoderFactory();
        description = options.getDescription();
        writeConcern = options.getWriteConcern();
        alwaysUseMBeans = options.isAlwaysUseMBeans();
        requiredReplicaSetName = options.getRequiredReplicaSetName();
    }

    
Reset all settings to the default.

/**
     * Reset all settings to the default.
     */
    public void reset() {
        connectionsPerHost = 10;
        threadsAllowedToBlockForConnectionMultiplier = 5;
        maxWaitTime = 1000 * 60 * 2;
        connectTimeout = 1000 * 10;
        socketFactory = SocketFactory.getDefault();
        socketTimeout = 0;
        socketKeepAlive = false;
        readPreference = null;
        writeConcern = null;
        safe = false;
        w = 0;
        wtimeout = 0;
        fsync = false;
        j = false;
        dbDecoderFactory = DefaultDBDecoder.FACTORY;
        dbEncoderFactory = DefaultDBEncoder.FACTORY;
        description = null;
        cursorFinalizerEnabled = true;
        alwaysUseMBeans = false;
        requiredReplicaSetName = null;
    }

    
Copy this MongoOptions instance into a new instance.

Returns:the new MongoOptions with the same settings as this instance.
/**
     * Copy this MongoOptions instance into a new instance.
     *
     * @return the new MongoOptions with the same settings as this instance.
     */
    public MongoOptions copy() {
        MongoOptions m = new MongoOptions();
        m.connectionsPerHost = connectionsPerHost;
        m.threadsAllowedToBlockForConnectionMultiplier = threadsAllowedToBlockForConnectionMultiplier;
        m.maxWaitTime = maxWaitTime;
        m.connectTimeout = connectTimeout;
        m.socketFactory = socketFactory;
        m.socketTimeout = socketTimeout;
        m.socketKeepAlive = socketKeepAlive;
        m.readPreference = readPreference;
        m.writeConcern = writeConcern;
        m.safe = safe;
        m.w = w;
        m.wtimeout = wtimeout;
        m.fsync = fsync;
        m.j = j;
        m.dbDecoderFactory = dbDecoderFactory;
        m.dbEncoderFactory = dbEncoderFactory;
        m.description = description;
        m.cursorFinalizerEnabled = cursorFinalizerEnabled;
        m.alwaysUseMBeans = alwaysUseMBeans;
        m.requiredReplicaSetName = requiredReplicaSetName;
        return m;
    }

    @SuppressWarnings("deprecation")
    MongoClientOptions toClientOptions() {
        Builder builder = MongoClientOptions.builder()
                                            .requiredReplicaSetName(requiredReplicaSetName)
                                            .connectionsPerHost(connectionsPerHost)
                                            .connectTimeout(connectTimeout)
                                            .dbDecoderFactory(dbDecoderFactory)
                                            .dbEncoderFactory(dbEncoderFactory)
                                            .description(description)
                                            .maxWaitTime(maxWaitTime)
                                            .socketFactory(socketFactory)
                                            .socketKeepAlive(socketKeepAlive)
                                            .socketTimeout(socketTimeout)
                                            .threadsAllowedToBlockForConnectionMultiplier(threadsAllowedToBlockForConnectionMultiplier)
                                            .cursorFinalizerEnabled(cursorFinalizerEnabled)
                                            .alwaysUseMBeans(alwaysUseMBeans);

        builder.writeConcern(getWriteConcern());

        if (readPreference != null) {
            builder.readPreference(getReadPreference());
        }
        return builder.build();
    }

    
Helper method to return the appropriate WriteConcern instance based on the current related options settings.

Returns:a WriteConcern for the current MongoOptions.
/**
     * Helper method to return the appropriate WriteConcern instance based on the current related options settings.
     *
     * @return a WriteConcern for the current MongoOptions.
     */
    @SuppressWarnings("deprecation")
    public WriteConcern getWriteConcern() {
        WriteConcern retVal;

        if (writeConcern != null) {
            retVal = writeConcern;
        } else if (w != 0 || wtimeout != 0 || fsync | j) {
            retVal = WriteConcern.ACKNOWLEDGED;
            if (w != 0) {
                retVal = retVal.withW(w);
            }
            if (wtimeout != 0) {
                retVal = retVal.withWTimeout(wtimeout, TimeUnit.MILLISECONDS);
            }
            if (fsync) {
                retVal = retVal.withFsync(fsync);
            }
            if (j) {
                retVal = retVal.withJ(j);
            }
        } else if (safe) {
            retVal = WriteConcern.ACKNOWLEDGED;
        } else {
            retVal = WriteConcern.UNACKNOWLEDGED;
        }
        return retVal;
    }

    
Sets the write concern.  If this is not set, the write concern defaults to the combination of settings of the other write
concern-related fields.  If set, this will override all of the other write concern-related fields.

Params:
  • writeConcern – sets the write concern
/**
     * Sets the write concern.  If this is not set, the write concern defaults to the combination of settings of the other write
     * concern-related fields.  If set, this will override all of the other write concern-related fields.
     *
     * @param writeConcern sets the write concern
     */
    public void setWriteConcern(final WriteConcern writeConcern) {
        this.writeConcern = writeConcern;
    }

    
Gets the socket factory for creating sockets to mongod. Default is SocketFactory.getDefault()

Returns:the socket factory for creating sockets to mongod
/**
     * Gets the socket factory for creating sockets to mongod. Default is SocketFactory.getDefault()
     *
     * @return the socket factory for creating sockets to mongod
     */
    public synchronized SocketFactory getSocketFactory() {
        return socketFactory;
    }

    
Sets the socket factory for creating sockets to mongod.

Params:
  • factory – sets the socket factory for creating sockets to mongod
/**
     * Sets the socket factory for creating sockets to mongod.
     *
     * @param factory sets the socket factory for creating sockets to mongod
     */
    public synchronized void setSocketFactory(final SocketFactory factory) {
        socketFactory = factory;
    }

    
Gets the description for Mongo instances created with these options. 
Returns:The description for MongoClient instances created with these options
/**
     * Gets the description for {@code Mongo} instances created with these options.
     *
     * @return The description for {@code MongoClient} instances created with these options
     */
    public synchronized String getDescription() {
        return description;
    }

    
Sets the description for Mongo instances created with these options. This is used in various places like logging. 
Params:
  • desc – The description for Mongo instances created with these options
/**
     * Sets the description for {@code Mongo} instances created with these options. This is used in various places like logging.
     *
     * @param desc The description for {@code Mongo} instances created with these options
     */
    public synchronized void setDescription(final String desc) {
        description = desc;
    }

    
Gets the maximum number of connections allowed per host for this Mongo instance.

Returns:the maximum number of connections allowed per host for this Mongo instance
/**
     * Gets the maximum number of connections allowed per host for this Mongo instance.
     *
     * @return the maximum number of connections allowed per host for this Mongo instance
     */
    public synchronized int getConnectionsPerHost() {
        return connectionsPerHost;
    }

    
Sets the maximum number of connections allowed per host for this Mongo instance. Those connections will be kept in a pool when idle.
Once the pool is exhausted, any operation requiring a connection will block waiting for an available connection. Default is 10.

Params:
  • connections – sets the maximum number of connections allowed per host for this Mongo instance
/**
     * Sets the maximum number of connections allowed per host for this Mongo instance. Those connections will be kept in a pool when idle.
     * Once the pool is exhausted, any operation requiring a connection will block waiting for an available connection. Default is 10.
     *
     * @param connections sets the maximum number of connections allowed per host for this Mongo instance
     */
    public synchronized void setConnectionsPerHost(final int connections) {
        connectionsPerHost = connections;
    }

    
Gets the multiplier which, when multiplied with the connectionsPerHost setting, gives the maximum number of threads that may be
waiting for a connection to become available from the pool.

Returns:the maximum number of threads that may be waiting for a connection
/**
     * Gets the multiplier which, when multiplied with the connectionsPerHost setting, gives the maximum number of threads that may be
     * waiting for a connection to become available from the pool.
     *
     * @return the maximum number of threads that may be waiting for a connection
     */
    public synchronized int getThreadsAllowedToBlockForConnectionMultiplier() {
        return threadsAllowedToBlockForConnectionMultiplier;
    }

    
Sets the multiplier which, when multiplied with the connectionsPerHost setting, gives the maximum number of threads that may be
waiting for a connection to become available from the pool. All further threads will get an exception right away. For example if
connectionsPerHost is 10 and threadsAllowedToBlockForConnectionMultiplier is 5, then up to 50 threads can wait for a connection.
Default is 5.

Params:
  • threads – multiplied with connectionsPerHost, sets the maximum number of threads that may be waiting for a connection
/**
     * Sets the multiplier which, when multiplied with the connectionsPerHost setting, gives the maximum number of threads that may be
     * waiting for a connection to become available from the pool. All further threads will get an exception right away. For example if
     * connectionsPerHost is 10 and threadsAllowedToBlockForConnectionMultiplier is 5, then up to 50 threads can wait for a connection.
     * Default is 5.
     *
     * @param threads multiplied with connectionsPerHost, sets the maximum number of threads that may be waiting for a connection
     */
    public synchronized void setThreadsAllowedToBlockForConnectionMultiplier(final int threads) {
        threadsAllowedToBlockForConnectionMultiplier = threads;
    }

    
Gets the maximum wait time in milliseconds that a thread may wait for a connection to become available.

Returns:The maximum time in milliseconds that threads wait for a connection
/**
     * Gets the maximum wait time in milliseconds that a thread may wait for a connection to become available.
     *
     * @return The maximum time in milliseconds that threads wait for a connection
     */
    public synchronized int getMaxWaitTime() {
        return maxWaitTime;
    }

    
Sets the maximum wait time in milliseconds that a thread may wait for a connection to become available. Default is 120, 000. A value
of 0 means that it will not wait.  A negative value means to wait indefinitely.

Params:
  • timeMS – set the maximum time in milliseconds that threads wait for a connection
/**
     * Sets the maximum wait time in milliseconds that a thread may wait for a connection to become available. Default is 120, 000. A value
     * of 0 means that it will not wait.  A negative value means to wait indefinitely.
     *
     * @param timeMS set the maximum time in milliseconds that threads wait for a connection
     */
    public synchronized void setMaxWaitTime(final int timeMS) {
        maxWaitTime = timeMS;
    }

    
Gets the connection timeout in milliseconds.  A value of 0 means no timeout.

Returns:the connection timeout in milliseconds.
/**
     * Gets the connection timeout in milliseconds.  A value of 0 means no timeout.
     *
     * @return the connection timeout in milliseconds.
     */
    public synchronized int getConnectTimeout() {
        return connectTimeout;
    }

    
Sets the connection timeout in milliseconds. A value of 0 means no timeout. It is used solely when establishing a new connection Socket.connect(SocketAddress, int) Default is 10,000. 
Params:
  • timeoutMS – set the connection timeout in milliseconds.
/**
     * Sets the connection timeout in milliseconds.  A value of 0 means no timeout. It is used solely when establishing a new connection
     * {@link java.net.Socket#connect(java.net.SocketAddress, int) } Default is 10,000.
     *
     * @param timeoutMS set the connection timeout in milliseconds.
     */
    public synchronized void setConnectTimeout(final int timeoutMS) {
        connectTimeout = timeoutMS;
    }

    
Gets the socket timeout in milliseconds. 0 means no timeout.

Returns:The socket timeout in milliseconds
/**
     * Gets the socket timeout in milliseconds. 0 means no timeout.
     *
     * @return The socket timeout in milliseconds
     */
    public synchronized int getSocketTimeout() {
        return socketTimeout;
    }

    
Sets the socket timeout in milliseconds It is used for I/O socket read and write operations Socket.setSoTimeout(int) Default is 0 and means no timeout. 
Params:
  • timeoutMS – set the socket timeout in milliseconds
/**
     * Sets the socket timeout in milliseconds It is used for I/O socket read and write operations {@link java.net.Socket#setSoTimeout
     * (int)} Default is 0 and means no timeout.
     *
     * @param timeoutMS set the socket timeout in milliseconds
     */
    public synchronized void setSocketTimeout(final int timeoutMS) {
        socketTimeout = timeoutMS;
    }

    
Gets the flag that controls the socket keep alive feature that keeps a connection alive through firewalls.

Returns:connection keep-alive flag
/**
     * Gets the flag that controls the socket keep alive feature that keeps a connection alive through firewalls.
     *
     * @return connection keep-alive flag
     */
    public synchronized boolean isSocketKeepAlive() {
        return socketKeepAlive;
    }

    
Sets the flag that controls the socket keep alive feature that keeps a connection alive through firewalls Socket.setKeepAlive(boolean) Default is false. 
Params:
  • keepAlive – set connection keep-alive flag
/**
     * Sets the flag that controls the socket keep alive feature that keeps a connection alive through firewalls {@link
     * java.net.Socket#setKeepAlive(boolean)} Default is false.
     *
     * @param keepAlive set connection keep-alive flag
     */
    public synchronized void setSocketKeepAlive(final boolean keepAlive) {
        socketKeepAlive = keepAlive;
    }

    
Gets the DBCallback factory.

Returns:the DBCallback decoding factory
/**
     * Gets the DBCallback factory.
     *
     * @return the DBCallback decoding factory
     */
    public synchronized DBDecoderFactory getDbDecoderFactory() {
        return dbDecoderFactory;
    }

    
Override the DBCallback factory. Default is for the standard Mongo Java driver configuration.

Params:
  • factory – sets the DBCallback decoding factory
/**
     * Override the DBCallback factory. Default is for the standard Mongo Java driver configuration.
     *
     * @param factory sets the DBCallback decoding factory
     */
    public synchronized void setDbDecoderFactory(final DBDecoderFactory factory) {
        dbDecoderFactory = factory;
    }

    
Gets the encoding factory.

Returns:the encoding factory
/**
     * Gets the encoding factory.
     *
     * @return the encoding factory
     */
    public synchronized DBEncoderFactory getDbEncoderFactory() {
        return dbEncoderFactory;
    }

    
Override the encoding factory. Default is for the standard Mongo Java driver configuration.

Params:
  • factory – sets the encoding factory
/**
     * Override the encoding factory. Default is for the standard Mongo Java driver configuration.
     *
     * @param factory sets the encoding factory
     */
    public synchronized void setDbEncoderFactory(final DBEncoderFactory factory) {
        dbEncoderFactory = factory;
    }

    
Returns whether the driver will use a WriteConcern of WriteConcern.ACKNOWLEDGED for all operations.

Returns:true if driver uses WriteConcern.SAFE for all operations.
/**
     * Returns whether the driver will use a WriteConcern of WriteConcern.ACKNOWLEDGED for all operations.
     *
     * @return true if driver uses WriteConcern.SAFE for all operations.
     */
    public synchronized boolean isSafe() {
        return safe;
    }

    
If true the driver will use a WriteConcern of WriteConcern.SAFE for all operations. If w, wtimeout, fsync or j are specified, this setting is ignored. Default is false. 
Params:
  • isSafe – true if driver uses WriteConcern.SAFE for all operations.
/**
     * If {@code true} the driver will use a WriteConcern of WriteConcern.SAFE for all operations. If w, wtimeout, fsync or j are specified,
     * this setting is ignored. Default is false.
     *
     * @param isSafe true if driver uses WriteConcern.SAFE for all operations.
     */
    public synchronized void setSafe(final boolean isSafe) {
        safe = isSafe;
    }

    
Gets the "w" value, (number of writes), of the global WriteConcern.

Returns:value returns the number of writes of the global WriteConcern.
/**
     * Gets the "w" value, (number of writes), of the global WriteConcern.
     *
     * @return value returns the number of writes of the global WriteConcern.
     */
    public synchronized int getW() {
        return w;
    }

    
Sets the "w" value, (number of writes), of the global WriteConcern. Default is 0.

Params:
  • val – set the number of writes of the global WriteConcern.
/**
     * Sets the "w" value, (number of writes), of the global WriteConcern. Default is 0.
     *
     * @param val set the number of writes of the global WriteConcern.
     */
    public synchronized void setW(final int val) {
        w = val;
    }

    
Gets the "wtimeout" value of the global WriteConcern.

Returns:timeout in millis for write operation
/**
     * Gets the "wtimeout" value of the global WriteConcern.
     *
     * @return timeout in millis for write operation
     */
    public synchronized int getWtimeout() {
        return wtimeout;
    }

    
Sets the "wtimeout" value of the global WriteConcern. Default is 0.

Params:
  • timeoutMS – sets timeout in millis for write operation
/**
     * Sets the "wtimeout" value of the global WriteConcern. Default is 0.
     *
     * @param timeoutMS sets timeout in millis for write operation
     */
    public synchronized void setWtimeout(final int timeoutMS) {
        wtimeout = timeoutMS;
    }

    
Gets the "fsync" value of the global WriteConcern. True indicates writes should wait for data to be written to server data file

Returns:true if global write concern is set to fsync
/**
     * Gets the "fsync" value of the global WriteConcern. True indicates writes should wait for data to be written to server data file
     *
     * @return true if global write concern is set to fsync
     */
    public synchronized boolean isFsync() {
        return fsync;
    }

    
Sets the "fsync" value of the global WriteConcern. True indicates writes should wait for data to be written to server data file
Default is false.

Params:
  • sync – sets global write concern's fsync safe value
/**
     * Sets the "fsync" value of the global WriteConcern. True indicates writes should wait for data to be written to server data file
     * Default is false.
     *
     * @param sync sets global write concern's fsync safe value
     */
    public synchronized void setFsync(final boolean sync) {
        fsync = sync;
    }

    
Gets the "j" value of the global WriteConcern. True indicates writes should wait for a journaling group commit

Returns:true if global write concern is set to journal safe
/**
     * Gets the "j" value of the global WriteConcern. True indicates writes should wait for a journaling group commit
     *
     * @return true if global write concern is set to journal safe
     */
    public synchronized boolean isJ() {
        return j;
    }

    
Sets the "j" value of the global WriteConcern. True indicates writes should wait for a journaling group commit. Default is false.

Params:
  • safe – sets global write concern's journal safe value
/**
     * Sets the "j" value of the global WriteConcern. True indicates writes should wait for a journaling group commit. Default is false.
     *
     * @param safe sets global write concern's journal safe value
     */
    public synchronized void setJ(final boolean safe) {
        j = safe;
    }

    
Gets the read preference.

Returns:the read preference
/**
     * Gets the read preference.
     *
     * @return the read preference
     */
    public ReadPreference getReadPreference() {
        return readPreference;
    }

    
Specifies the read preference.

Params:
  • readPreference – the read preference
/**
     * Specifies the read preference.
     *
     * @param readPreference the read preference
     */
    public void setReadPreference(final ReadPreference readPreference) {
        this.readPreference = readPreference;
    }

    
Gets whether there is a a finalize method created that cleans up instances of DBCursor that the client does not close.

Returns:whether DBCursor finalizer is enabled
/**
     * Gets whether there is a a finalize method created that cleans up instances of DBCursor that the client does not close.
     *
     * @return whether DBCursor finalizer is enabled
     */
    public boolean isCursorFinalizerEnabled() {
        return cursorFinalizerEnabled;
    }

    
Sets whether there is a a finalize method created that cleans up instances of DBCursor that the client does not close.  If you are
careful to always call the close method of DBCursor, then this can safely be set to false.  Default is true.

Params:
  • cursorFinalizerEnabled – whether cursor finalizer is enabled
/**
     * Sets whether there is a a finalize method created that cleans up instances of DBCursor that the client does not close.  If you are
     * careful to always call the close method of DBCursor, then this can safely be set to false.  Default is true.
     *
     * @param cursorFinalizerEnabled whether cursor finalizer is enabled
     */
    public void setCursorFinalizerEnabled(final boolean cursorFinalizerEnabled) {
        this.cursorFinalizerEnabled = cursorFinalizerEnabled;

    }

    
Gets whether JMX beans registered by the driver should always be MBeans, regardless of whether the VM is Java 6 or greater. If false,
the driver will use MXBeans if the VM is Java 6 or greater, and use MBeans if the VM is Java 5.

Returns:true if the driver should always use MBeans, regardless of VM
/**
     * Gets whether JMX beans registered by the driver should always be MBeans, regardless of whether the VM is Java 6 or greater. If false,
     * the driver will use MXBeans if the VM is Java 6 or greater, and use MBeans if the VM is Java 5.
     *
     * @return true if the driver should always use MBeans, regardless of VM
     */
    public boolean isAlwaysUseMBeans() {
        return alwaysUseMBeans;
    }

    
Sets whether JMX beans registered by the driver should always be MBeans, regardless of whether the VM is Java 6 or greater. If false,
the driver will use MXBeans if the VM is Java 6 or greater, and use MBeans if the VM is Java 5. Default is false.

Params:
  • alwaysUseMBeans – sets whether the driver should always use MBeans, regardless of VM
/**
     * Sets whether JMX beans registered by the driver should always be MBeans, regardless of whether the VM is Java 6 or greater. If false,
     * the driver will use MXBeans if the VM is Java 6 or greater, and use MBeans if the VM is Java 5. Default is false.
     *
     * @param alwaysUseMBeans sets whether the driver should always use MBeans, regardless of VM
     */
    public void setAlwaysUseMBeans(final boolean alwaysUseMBeans) {
        this.alwaysUseMBeans = alwaysUseMBeans;
    }

    
Gets the required replica set name that this client should be connecting to.

Returns:the required replica set name, or null if none is required
Since:2.12
/**
     * Gets the required replica set name that this client should be connecting to.
     *
     * @return the required replica set name, or null if none is required
     * @since 2.12
     */
    public String getRequiredReplicaSetName() {
        return requiredReplicaSetName;
    }


    @Override
    public boolean equals(final Object o) {
        if (this == o) {
            return true;
        }
        if (o == null || getClass() != o.getClass()) {
            return false;
        }

        MongoOptions options = (MongoOptions) o;

        if (alwaysUseMBeans != options.alwaysUseMBeans) {
            return false;
        }
        if (connectTimeout != options.connectTimeout) {
            return false;
        }
        if (connectionsPerHost != options.connectionsPerHost) {
            return false;
        }
        if (cursorFinalizerEnabled != options.cursorFinalizerEnabled) {
            return false;
        }
        if (fsync != options.fsync) {
            return false;
        }
        if (j != options.j) {
            return false;
        }
        if (maxWaitTime != options.maxWaitTime) {
            return false;
        }
        if (safe != options.safe) {
            return false;
        }
        if (socketKeepAlive != options.socketKeepAlive) {
            return false;
        }
        if (socketTimeout != options.socketTimeout) {
            return false;
        }
        if (threadsAllowedToBlockForConnectionMultiplier != options.threadsAllowedToBlockForConnectionMultiplier) {
            return false;
        }
        if (w != options.w) {
            return false;
        }
        if (wtimeout != options.wtimeout) {
            return false;
        }
        if (dbDecoderFactory != null ? !dbDecoderFactory.equals(options.dbDecoderFactory) : options.dbDecoderFactory != null) {
            return false;
        }
        if (dbEncoderFactory != null ? !dbEncoderFactory.equals(options.dbEncoderFactory) : options.dbEncoderFactory != null) {
            return false;
        }
        if (description != null ? !description.equals(options.description) : options.description != null) {
            return false;
        }
        if (readPreference != null ? !readPreference.equals(options.readPreference) : options.readPreference != null) {
            return false;
        }
        if (socketFactory != null ? !socketFactory.equals(options.socketFactory) : options.socketFactory != null) {
            return false;
        }
        if (writeConcern != null ? !writeConcern.equals(options.writeConcern) : options.writeConcern != null) {
            return false;
        }
        if (requiredReplicaSetName != null ? !requiredReplicaSetName.equals(options.requiredReplicaSetName)
                                           : options.requiredReplicaSetName != null) {
            return false;
        }
        return true;
    }

    @Override
    public int hashCode() {
        int result = description != null ? description.hashCode() : 0;
        result = 31 * result + connectionsPerHost;
        result = 31 * result + threadsAllowedToBlockForConnectionMultiplier;
        result = 31 * result + maxWaitTime;
        result = 31 * result + connectTimeout;
        result = 31 * result + socketTimeout;
        result = 31 * result + (socketKeepAlive ? 1 : 0);
        result = 31 * result + (readPreference != null ? readPreference.hashCode() : 0);
        result = 31 * result + (dbDecoderFactory != null ? dbDecoderFactory.hashCode() : 0);
        result = 31 * result + (dbEncoderFactory != null ? dbEncoderFactory.hashCode() : 0);
        result = 31 * result + (safe ? 1 : 0);
        result = 31 * result + w;
        result = 31 * result + wtimeout;
        result = 31 * result + (fsync ? 1 : 0);
        result = 31 * result + (j ? 1 : 0);
        result = 31 * result + (socketFactory != null ? socketFactory.hashCode() : 0);
        result = 31 * result + (cursorFinalizerEnabled ? 1 : 0);
        result = 31 * result + (writeConcern != null ? writeConcern.hashCode() : 0);
        result = 31 * result + (alwaysUseMBeans ? 1 : 0);
        result = 31 * result + (requiredReplicaSetName != null ? requiredReplicaSetName.hashCode() : 0);
        return result;
    }

    @Override
    public String toString() {
        return "MongoOptions{"
               + "description='" + description + '\''
               + ", connectionsPerHost=" + connectionsPerHost
               + ", threadsAllowedToBlockForConnectionMultiplier=" + threadsAllowedToBlockForConnectionMultiplier
               + ", maxWaitTime=" + maxWaitTime
               + ", connectTimeout=" + connectTimeout
               + ", socketTimeout=" + socketTimeout
               + ", socketKeepAlive=" + socketKeepAlive
               + ", readPreference=" + readPreference
               + ", dbDecoderFactory=" + dbDecoderFactory
               + ", dbEncoderFactory=" + dbEncoderFactory
               + ", safe=" + safe
               + ", w=" + w
               + ", wtimeout=" + wtimeout
               + ", fsync=" + fsync
               + ", j=" + j
               + ", socketFactory=" + socketFactory
               + ", cursorFinalizerEnabled=" + cursorFinalizerEnabled
               + ", writeConcern=" + writeConcern
               + ", alwaysUseMBeans=" + alwaysUseMBeans
               + ", requiredReplicaSetName=" + requiredReplicaSetName
               + '}';
    }
}