Create Reactive Redisson instance with provided config

@param config for Redisson
@return Redisson instance
327962
public static RedissonReactiveClient createReactive(Config config) {
        RedissonReactive react = new RedissonReactive(config);
        if (config.isReferenceEnabled()) {
            react.enableRedissonReferenceSupport();
        }
        return react;
    }
1685
public static Observable<RxComapiClient> initialise(@NonNull Application app, @NonNull ComapiConfig config) {

        String error = checkIfCanInitialise(app, config, false);
        if (!TextUtils.isEmpty(error)) {
            return Observable.error(new Exception(error));
        }

        RxComapiClient client = new RxComapiClient(config);
        return client.initialise(app, config.getCallbackAdapter() != null ? config.getCallbackAdapter() : new CallbackAdapter(), client);
    }
927685
public static LazyGauge gauge(MonitorConfig config) {
    return new LazyGauge(Registry::gauge, registry, createId(config));
  }
1089960
public static CmsUgcSessionQueue createQueue(CmsUgcConfiguration config) {

        CmsUgcSessionQueue queue = new CmsUgcSessionQueue(
            config.needsQueue(),
            config.getQueueInterval().isPresent() ? config.getQueueInterval().get().longValue() : 0,
            config.getMaxQueueLength().isPresent() ? config.getMaxQueueLength().get().intValue() : Integer.MAX_VALUE);
        return queue;
    }
1092448
public static ThriftRangeUtils build(CassandraDeepJobConfig config) {
        String host = config.getHost();
        int rpcPort = config.getRpcPort();
        int splitSize = config.getSplitSize();
        String keyspace = config.getKeyspace();
        String columnFamily = config.getColumnFamily();
        String partitionerClassName = config.getPartitionerClassName();
        IPartitioner partitioner = Utils.newTypeInstance(partitionerClassName, IPartitioner.class);
        return new ThriftRangeUtils(partitioner, host, rpcPort, keyspace, columnFamily, splitSize);
    }
579075
public static function create($config, $instanceOf = null)
    {
        // Closure check
        if (is_callable($config)) {
            return static::createFromCallable($config, $instanceOf);
        }

        // Get class from config
        $class = static::checkConfig($config, $instanceOf);

        // New object
        return new $class($config);
    }
149395
function createEvent(config) {
  const { type, target } = config;
  const eventObject = new Event(type);

  if (target) {
    eventObject.target = target;
    eventObject.srcElement = target;
    eventObject.currentTarget = target;
  }

  return eventObject;
}
701103
function(config) {
  INIT(config)
  this.__init__()

  this.log = LOG
  this.jobs = JOBS

  MEM = new MemChecker(this, CONF.memChecker)

  this._ = {
     www: WWW
    ,redis: JOBS._rawQueue.client
  }
}
934821
function makeMoment(config) {
        var input = config._i,
            format = config._f;

        if (input === null || (format === undefined && input === '')) {
            return moment.invalid({nullInput: true});
        }

        if (typeof input === 'string') {
            config._i = input = getLangDefinition().preparse(input);
        }

        if (moment.isMoment(input)) {
            config = cloneMoment(input);

            config._d = new Date(+input._d);
        } else if (format) {
            if (isArray(format)) {
                makeDateFromStringAndArray(config);
            } else {
                makeDateFromStringAndFormat(config);
            }
        } else {
            makeDateFromInput(config);
        }

        return new Moment(config);
    }
807930
static JmxMeasurementConfig from(Config config) {
    String name = config.getString("name");
    Map<String, String> tags = config.getConfigList("tags")
        .stream()
        .collect(Collectors.toMap(c -> c.getString("key"), c -> c.getString("value")));
    String value = config.getString("value");
    boolean counter = config.hasPath("counter") && config.getBoolean("counter");
    return new JmxMeasurementConfig(name, tags, value, counter);
  }
529391
public static RedissonRxClient createRx(Config config) {
        RedissonRx react = new RedissonRx(config);
        if (config.isReferenceEnabled()) {
            react.enableRedissonReferenceSupport();
        }
        return react;
    }
398082
protected StaticFsServiceFactory createServiceFactory(ServletConfig config)
	{
		StaticFsServiceFactory staticFsServiceFactory = new StaticFsServiceFactory();
		DefaultFsService fsService = createFsService();

		staticFsServiceFactory.setFsService(fsService);
		return staticFsServiceFactory;
	}
429795
public BucketingSink<T> setFSConfig(org.apache.hadoop.conf.Configuration config) {
		this.fsConfig = new Configuration();
		for (Map.Entry<String, String> entry : config) {
			fsConfig.setString(entry.getKey(), entry.getValue());
		}
		return this;
	}
97641
@NonNull
  public RequestCreator config(@NonNull Bitmap.Config config) {
    data.config(config);
    return this;
  }
1307240
public RDD<Cells> createHDFSRDD(ExtractorConfig<Cells> config) {

        Serializable host = config.getValues().get(ExtractorConstants.HOST);
        Serializable port = config.getValues().get(ExtractorConstants.PORT);
        Serializable path = config.getValues().get(ExtractorConstants.FS_FILE_PATH);

        final TextFileDataTable textFileDataTable = UtilFS.createTextFileMetaDataFromConfig(config, this);

        String filePath = path.toString();
        if (config.getExtractorImplClassName().equals(ExtractorConstants.HDFS)) {
            filePath = ExtractorConstants.HDFS_PREFIX + host.toString() + ":" + port + path.toString();
        }

        return createRDDFromFilePath(filePath, textFileDataTable);
    }
757207
@SuppressWarnings("unchecked")
    public CassandraJavaPairRDD<K, V> withReadConf(ReadConf config) {
        CassandraRDD<Tuple2<K, V>> newRDD = rdd().withReadConf(config);
        return wrap(newRDD);
    }
1231662
MapWithProtoValuesFluentAssertion<M> usingConfig(FluentEqualityConfig newConfig) {
    Subject.Factory<MapWithMessageValuesSubject<K, M>, Map<K, M>> factory =
        mapWithProtoValues(newConfig);
    MapWithMessageValuesSubject<K, M> newSubject = check().about(factory).that(actual());
    if (internalCustomName() != null) {
      newSubject = newSubject.named(internalCustomName());
    }
    return new MapWithProtoValuesFluentAssertionImpl<>(newSubject);
  }