On set gc grace.

@param cfDef
the cf def
@param cfProperties
the cf properties
@param builder
the builder
516380
private void onSetGcGrace(CfDef cfDef, Properties cfProperties, StringBuilder builder)
    {
        String gcGraceSeconds = cfProperties.getProperty(CassandraConstants.GC_GRACE_SECONDS);
        if (gcGraceSeconds != null)
        {
            try
            {
                if (builder != null)
                {
                    appendPropertyToBuilder(builder, gcGraceSeconds, CassandraConstants.GC_GRACE_SECONDS);
                }
                else
                {
                    cfDef.setGc_grace_seconds(Integer.parseInt(gcGraceSeconds));
                }
            }
            catch (NumberFormatException nfe)
            {
                log.error("GC_GRACE_SECONDS should be numeric type, Caused by: .", nfe);
                throw new SchemaGenerationException(nfe);
            }
        }
    }
228320
private void appendPropertyToBuilder(StringBuilder builder, String replicateOnWrite, String keyword)
    {
        String replicateOn_Write = CQLTranslator.getKeyword(keyword);
        builder.append(replicateOn_Write);
        builder.append(CQLTranslator.EQ_CLAUSE);
        builder.append(replicateOnWrite);
        builder.append(CQLTranslator.AND_CLAUSE);
    }
81365
protected void configureKeepAlive(final T builder, final String name) {
        final GrpcChannelProperties properties = getPropertiesFor(name);
        if (properties.isEnableKeepAlive()) {
            builder.keepAliveTime(properties.getKeepAliveTime().toNanos(), TimeUnit.NANOSECONDS)
                    .keepAliveTimeout(properties.getKeepAliveTimeout().toNanos(), TimeUnit.NANOSECONDS)
                    .keepAliveWithoutCalls(properties.isKeepAliveWithoutCalls());
        }
    }
725634
private void addKeyToTuple(Tuple tuple, ByteBuffer key, CfDef cfDef, AbstractType comparator) throws IOException
    {
        if( comparator instanceof AbstractCompositeType )
        {
            setTupleValue(tuple, 0, composeComposite((AbstractCompositeType)comparator,key));
        }
        else
        {
            setTupleValue(tuple, 0, cassandraToObj(getDefaultMarshallers(cfDef).get(MarshallerType.KEY_VALIDATOR), key));
        }

    }
609466
public void initCf(UUID cfId, String cfName, boolean loadSSTables)
    {
        ColumnFamilyStore cfs = columnFamilyStores.get(cfId);

        if (cfs == null)
        {
            // CFS being created for the first time, either on server startup or new CF being added.
            // We don't worry about races here; startup is safe, and adding multiple idential CFs
            // simultaneously is a "don't do that" scenario.
            ColumnFamilyStore oldCfs = columnFamilyStores.putIfAbsent(cfId, ColumnFamilyStore.createColumnFamilyStore(this, cfName, loadSSTables));
            // CFS mbean instantiation will error out before we hit this, but in case that changes...
            if (oldCfs != null)
                throw new IllegalStateException("added multiple mappings for cf id " + cfId);
        }
        else
        {
            // re-initializing an existing CF.  This will happen if you cleared the schema
            // on this node and it's getting repopulated from the rest of the cluster.
            assert cfs.name.equals(cfName);
            cfs.metadata.reload();
            cfs.reload();
        }
    }
82346
function _gpfDefineBuildTypedEntity (definition) {
    var EntityBuilder = _gpfDefineRead$TypedProperties(definition),
        entityDefinition;
    if (!EntityBuilder) {
        EntityBuilder = _gpfDefineCheck$TypeProperty(definition);
    }
    entityDefinition = new EntityBuilder(definition);
    entityDefinition.check();
    return entityDefinition;
}
785038
private void setProperties(KsDef ksDef, Map<String, String> strategy_options)
    {
        Schema schema = CassandraPropertyReader.csmd.getSchema(databaseName);
        if (schema != null && schema.getName() != null && schema.getName().equalsIgnoreCase(databaseName)
                && schema.getSchemaProperties() != null)
        {
            setKeyspaceProperties(ksDef, schema.getSchemaProperties(), strategy_options, schema.getDataCenters());
        }
        else
        {
            setDefaultReplicationFactor(strategy_options);
        }
    }
610755
void onBuildChildNode(Object childObject, EntityMetadata childMetadata, PersistenceDelegator delegator,
            PersistenceCache pc, Node node, Relation relation)
    {
        Node childNode = generate(childObject, delegator, pc, null);
        if (childNode != null)
        {
            assignNodeLinkProperty(node, relation, childNode);
        }
    }
1153180
@Override
    public void setConsumer(IDataSetConsumer consumer) {
        logger.debug("setConsumer(consumer) - start");

        if (this._columnSensing) {
            _consumer = new BufferedConsumer(consumer);
        } else {
            _consumer = consumer;
        }
    }
1094559
protected void setupDefaultSettings(GsonBuilder builder) {
        registerStringAdapter(builder);
        registerNumberAdapter(builder);
        registerJava8TimeAdapter(builder);
        registerBooleanAdapter(builder);
        registerCollectionAdapter(builder);
        registerDBFluteAdapter(builder);
        registerUtilDateFormat(builder);
        setupFieldPolicy(builder);
        setupYourCollectionSettings(builder);
        setupYourScalarSettings(builder);
        setupYourUltimateSettings(builder);
    }
721037
private void onSetKeyValidation(CfDef cfDef, Properties cfProperties, StringBuilder builder)
    {
        String keyValidationClass = cfProperties.getProperty(CassandraConstants.KEY_VALIDATION_CLASS);
        if (keyValidationClass != null)
        {
            if (builder != null)
            {
                // nothing available.
            }
            else
            {
                cfDef.setKey_validation_class(keyValidationClass);
            }
        }
    }
378283
@Nonnull
	public static <T, R> LObjIntByteFunction<T, R> objIntByteFunctionFrom(Consumer<LObjIntByteFunctionBuilder<T, R>> buildingFunction) {
		LObjIntByteFunctionBuilder builder = new LObjIntByteFunctionBuilder();
		buildingFunction.accept(builder);
		return builder.build();
	}
719914
public static void addConstructorArgReference(BeanDefinitionBuilder builder, String beanReference) {
        if (StringUtils.hasText(beanReference)) {
            builder.addConstructorArgReference(beanReference);
        }
    }
677440
@Nonnull
	public static <T> LObjIntDblPredicate<T> objIntDblPredicateFrom(Consumer<LObjIntDblPredicateBuilder<T>> buildingFunction) {
		LObjIntDblPredicateBuilder builder = new LObjIntDblPredicateBuilder();
		buildingFunction.accept(builder);
		return builder.build();
	}
367191
protected void configure(final T builder) {
        configureServices(builder);
        configureKeepAlive(builder);
        configureSecurity(builder);
        configureLimits(builder);
        for (final GrpcServerConfigurer serverConfigurer : this.serverConfigurers) {
            serverConfigurer.accept(builder);
        }
    }
1020582
@Nonnull
	public static <T> LTieFltFunction<T> tieFltFunctionFrom(Consumer<LTieFltFunctionBuilder<T>> buildingFunction) {
		LTieFltFunctionBuilder builder = new LTieFltFunctionBuilder();
		buildingFunction.accept(builder);
		return builder.build();
	}
242896
public synchronized void gc() {
        if (!configuration.isUseGc()) {
            LOG.trace("GC deactivated, no beans will be removed!");
            return;
        }

        LOG.trace("Garbage collection started! GC will remove {} beans!", removeOnGC.size());

        onRemoveCallback.onReject(removeOnGC.keySet());

        for (Map.Entry<Instance, Object> entry : removeOnGC.entrySet()) {
            Instance removedInstance = entry.getKey();
            for (Property property : removedInstance.getProperties()) {
                propertyToParent.remove(property);
            }
            for (ObservableList list : removedInstance.getLists()) {
                listToParent.remove(list);
            }
            allInstances.remove(entry.getValue());
        }

        removedBeansCount = removedBeansCount + removeOnGC.size();
        removeOnGC.clear();
        gcCalls = gcCalls + 1;

        LOG.trace("Garbage collection done! GC currently manages {} referenced beans!", allInstances.size());
    }