Get a Collection instance with the default settings.
481731
def _collection_default_options(self, name, **kargs):
        """"""
        wc = (self.write_concern
              if self.write_concern.acknowledged else WriteConcern())
        return self.get_collection(
            name, codec_options=DEFAULT_CODEC_OPTIONS,
            read_preference=ReadPreference.PRIMARY,
            write_concern=wc)
260259
def get_default_config(self):
        
        config = super(MemoryCollector, self).get_default_config()
        config.update({
            'path': 'memory',
            'method': 'Threaded',
            'force_psutil': 'False'
            # Collect all the nodes or just a few standard ones?
            # Uncomment to enable
            # 'detailed': 'True'
        })
        return config
164575
def get_default_config(self):
        
        config = super(MonitCollector, self).get_default_config()
        config.update({
            'host':         '127.0.0.1',
            'port':         2812,
            'user':         'monit',
            'passwd':       'monit',
            'path':         'monit',
            'byte_unit':    ['byte'],
            'send_totals':  False,
        })
        return config
1309948
function applyDefaults(params, defaults) {
    var settings = params || {};

    for(var setting in defaults) {
      if(defaults.hasOwnProperty(setting) && !settings[setting]) {
        settings[setting] = defaults[setting];
      }
    }

    return settings;
  }
1069879
def default(self):
        """"""

        if self._default is None or self._default not in self:
            self._default = list(self.keys())[0] if self else None

        return self._default
1047654
public static <K, T extends Collection<K>> Collection<K> instantiateCollectionType(Class<T> collectionType) {
        return instantiateCollectionType(collectionType, DEFAULT_COLLECTION_SIZE);
    }
845714
def defaults(current: dict, *args: AnyMapping) -> dict:
    
    """
    for data in args:
        for key, value in data.items():
            current.setdefault(key, value)
    return current
300935
def get_default_config(self):
        
        config = super(PostqueueCollector, self).get_default_config()
        config.update({
            'path':             'postqueue',
            'bin':              '/usr/bin/postqueue',
            'use_sudo':         False,
            'sudo_cmd':         '/usr/bin/sudo',
        })
        return config
705404
def get_default_config(self):
        
        config = super(MongoDBCollector, self).get_default_config()
        config.update({
            'path': 'mongo',
            'hosts': ['localhost'],
            'user': None,
            'passwd': None,
            'databases': '.*',
            'ignore_collections': '^tmp\.mr\.',
            'network_timeout': None,
            'simple': 'False',
            'translate_collections': 'False',
            'collection_sample_rate': 1,
            'ssl': False,
            'replica': False,
            'replset_node_name': '_id'
        })
        return config
1031521
def get_setting(self, key, default=NOT_SET):
        
        if self._arca is None:
            raise LazySettingProperty.SettingsNotReady
        return self._arca.settings.get(*self.get_settings_keys(key), default=default)
1367800
def GetDefault(self, fd=None, default=None):
    """"""
    if callable(self.default):
      return self.default(fd)

    if self.default is not None:
      # We can't return mutable objects here or the default might change for all
      # objects of this class.
      if isinstance(self.default, rdfvalue.RDFValue):
        default = self.default.Copy()
        default.attribute_instance = self
        return self(default)
      else:
        return self(self.default)

    if isinstance(default, rdfvalue.RDFValue):
      default = default.Copy()
      default.attribute_instance = self

    return default
338633
public Collection<Object> getPropertyOrDefault(final String name, final Collection<Object> defaultValues) {
        if (this.properties.containsKey(name)) {
            return this.properties.get(name);
        }
        return defaultValues;
    }
465980
def [](namespace = :default, index)
      obj = get_setting(namespace, index)
      return obj.read_attribute(setting_value_field) if obj
      SettingsDB::Defaults[namespace, index]
    end
487128
def get_default_config(self):
        
        config = super(OpenvzCollector, self).get_default_config()
        config.update({
            'path': 'openvz',
            'bin': '/usr/sbin/vzlist',
            'keyname': 'hostname'
        })
        return config
908078
def get_default_config_help(self):
        
        config_help = super(UsersCollector, self).get_default_config_help()
        config_help.update({
        })
        return config_help
47933
protected function getCollection(): Collection
    {
        $conn = $this->connPool->getConnection();
        $database = $conn->defaultDatabase;
        $collection = $this->schema->collection;

        return $conn->getRawConnection()->$database->$collection;
    }
1341876
public static Map<String, ISettings> makeDefaultSettings()
  {
    Map<String, ISettings> settings = new TreeMap<>();

    AppearanceSettings appearanceSettings = new AppearanceSettings();
    appearanceSettings.resetToDefaultSettings( null );
    settings.put( appearanceSettings.getPath(), appearanceSettings );

    return settings;
  }