text:
package us.kbase.cdmientityapi;

import java.util.HashMap;
import java.util.Map;
import javax.annotation.Generated;
import com.fasterxml.jackson.annotation.JsonAnyGetter;
import com.fasterxml.jackson.annotation.JsonAnySetter;
import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.fasterxml.jackson.annotation.JsonPropertyOrder;

/**
 *
Original spec-file type: fields_IsConservedDomainModelFor

 *
 *
 */
@JsonInclude(JsonInclude.Include.NON_NULL)
@Generated("com.googlecode.jsonschema2pojo")
@JsonPropertyOrder({
    "from_link",
    "to_link",
    "percent_identity",
    "alignment_length",
    "mismatches",
    "gap_openings",
    "protein_start",
    "protein_end",
    "domain_start",
    "domain_end",
    "e_value",
    "bit_score"
})
public class FieldsIsConservedDomainModelFor {

    @JsonProperty("from_link")
    private Long fromLink;
    @JsonProperty("to_link")
    private String toLink;
    @JsonProperty("percent_identity")
    private Double percentIdentity;
    @JsonProperty("alignment_length")
    private Long alignmentLength;
    @JsonProperty("mismatches")
    private Long mismatches;
    @JsonProperty("gap_openings")
    private Long gapOpenings;
    @JsonProperty("protein_start")
    private Long proteinStart;
    @JsonProperty("protein_end")
    private Long proteinEnd;
    @JsonProperty("domain_start")
    private Long domainStart;
    @JsonProperty("domain_end")
    private Long domainEnd;
    @JsonProperty("e_value")
    private Double eValue;
    @JsonProperty("bit_score")
    private Double bitScore;
    private Map<String, Object> additionalProperties = new HashMap<String, Object>();

    @JsonProperty("from_link")
    public Long getFromLink() {
        return fromLink;
    }

    @JsonProperty("from_link")
    public void setFromLink(Long fromLink) {
        this.fromLink = fromLink;
    }

    public FieldsIsConservedDomainModelFor withFromLink(Long fromLink) {
        this.fromLink = fromLink;
        return this;
    }

    @JsonProperty("to_link")
    public String getToLink() {
        return toLink;
    }

    @JsonProperty("to_link")
    public void setToLink(String toLink) {
        this.toLink = toLink;
    }

    public FieldsIsConservedDomainModelFor withToLink(String toLink) {
        this.toLink = toLink;
        return this;
    }

    @JsonProperty("percent_identity")
    public Double getPercentIdentity() {
        return percentIdentity;
    }

    @JsonProperty("percent_identity")
    public void setPercentIdentity(Double percentIdentity) {
        this.percentIdentity = percentIdentity;
    }

    public FieldsIsConservedDomainModelFor withPercentIdentity(Double percentIdentity) {
        this.percentIdentity = percentIdentity;
        return this;
    }

    @JsonProperty("alignment_length")
    public Long getAlignmentLength() {
        return alignmentLength;
    }

    @JsonProperty("alignment_length")
    public void setAlignmentLength(Long alignmentLength) {
        this.alignmentLength = alignmentLength;
    }

    public FieldsIsConservedDomainModelFor withAlignmentLength(Long alignmentLength) {
        this.alignmentLength = alignmentLength;
        return this;
    }

    @JsonProperty("mismatches")
    public Long getMismatches() {
        return mismatches;
    }

    @JsonProperty("mismatches")
    public void setMismatches(Long mismatches) {
        this.mismatches = mismatches;
    }

    public FieldsIsConservedDomainModelFor withMismatches(Long mismatches) {
        this.mismatches = mismatches;
        return this;
    }

    @JsonProperty("gap_openings")
    public Long getGapOpenings() {
        return gapOpenings;
    }

    @JsonProperty("gap_openings")
    public void setGapOpenings(Long gapOpenings) {
        this.gapOpenings = gapOpenings;
    }

    public FieldsIsConservedDomainModelFor withGapOpenings(Long gapOpenings) {
        this.gapOpenings = gapOpenings;
        return this;
    }

    @JsonProperty("protein_start")
    public Long getProteinStart() {
        return proteinStart;
    }

    @JsonProperty("protein_start")
    public void setProteinStart(Long proteinStart) {
        this.proteinStart = proteinStart;
    }

    public FieldsIsConservedDomainModelFor withProteinStart(Long proteinStart) {
        this.proteinStart = proteinStart;
        return this;
    }

    @JsonProperty("protein_end")
    public Long getProteinEnd() {
        return proteinEnd;
    }

    @JsonProperty("protein_end")
    public void setProteinEnd(Long proteinEnd) {
        this.proteinEnd = proteinEnd;
    }

    public FieldsIsConservedDomainModelFor withProteinEnd(Long proteinEnd) {
        this.proteinEnd = proteinEnd;
        return this;
    }

    @JsonProperty("domain_start")
    public Long getDomainStart() {
        return domainStart;
    }

    @JsonProperty("domain_start")
    public void setDomainStart(Long domainStart) {
        this.domainStart = domainStart;
    }

    public FieldsIsConservedDomainModelFor withDomainStart(Long domainStart) {
        this.domainStart = domainStart;
        return this;
    }

    @JsonProperty("domain_end")
    public Long getDomainEnd() {
        return domainEnd;
    }

    @JsonProperty("domain_end")
    public void setDomainEnd(Long domainEnd) {
        this.domainEnd = domainEnd;
    }

    public FieldsIsConservedDomainModelFor withDomainEnd(Long domainEnd) {
        this.domainEnd = domainEnd;
        return this;
    }

    @JsonProperty("e_value")
    public Double getEValue() {
        return eValue;
    }

    @JsonProperty("e_value")
    public void setEValue(Double eValue) {
        this.eValue = eValue;
    }

    public FieldsIsConservedDomainModelFor withEValue(Double eValue) {
        this.eValue = eValue;
        return this;
    }

    @JsonProperty("bit_score")
    public Double getBitScore() {
        return bitScore;
    }

    @JsonProperty("bit_score")
    public void setBitScore(Double bitScore) {
        this.bitScore = bitScore;
    }

    public FieldsIsConservedDomainModelFor withBitScore(Double bitScore) {
        this.bitScore = bitScore;
        return this;
    }

    @JsonAnyGetter
    public Map<String, Object> getAdditionalProperties() {
        return this.additionalProperties;
    }

    @JsonAnySetter
    public void setAdditionalProperties(String name, Object value) {
        this.additionalProperties.put(name, value);
    }

    @Override
    public String toString() {
        return ((((((((((((((((((((((((((("FieldsIsConservedDomainModelFor"+" [fromLink=")+ fromLink)+", toLink=")+ toLink)+", percentIdentity=")+ percentIdentity)+", alignmentLength=")+ alignmentLength)+", mismatches=")+ mismatches)+", gapOpenings=")+ gapOpenings)+", proteinStart=")+ proteinStart)+", proteinEnd=")+ proteinEnd)+", domainStart=")+ domainStart)+", domainEnd=")+ domainEnd)+", eValue=")+ eValue)+", bitScore=")+ bitScore)+", additionalProperties=")+ additionalProperties)+"]");
    }

}


text:
<resources>

    <!-- Base application theme. -->
    <style name="AppTheme" parent="Theme.AppCompat.Light.DarkActionBar">
        <!-- Customize your theme here. -->
        <item name="colorPrimary">@color/colorPrimary</item>
        <item name="colorPrimaryDark">@color/colorPrimaryDark</item>
        <item name="colorAccent">@color/colorAccent</item>
    </style>

    <style name="AppTheme.NoActionBar">
        <item name="windowActionBar">false</item>
        <item name="windowNoTitle">true</item>
    </style>

    <style name="AppTheme.AppBarOverlay" parent="ThemeOverlay.AppCompat.Dark.ActionBar" />

    <style name="AppTheme.PopupOverlay" parent="ThemeOverlay.AppCompat.Light" />

    <style name="InhalerPaletteDefault">
        <item name="inhaler_colour">#ffffff</item>
    </style>

    <style name="InhalerPaletteBlue" parent="InhalerPaletteDefault">
        <item name="inhaler_colour">#82a6b4</item>
    </style>

    <style name="InhalerPaletteBrown" parent="InhalerPaletteDefault">
        <item name="inhaler_colour">#ffa07a</item>
    </style>

    <style name="InhalerPaletteRed" parent="InhalerPaletteDefault">
        <item name="inhaler_colour">#eb263c</item>
    </style>

</resources>

redpajama_set_name: RedPajamaGithub


text:
package de.larma.arthook.avers;

import java.nio.ByteBuffer;
import java.nio.ByteOrder;

import de.larma.arthook.ArtMethod;
import de.larma.arthook.Memory;
import de.larma.arthook.Native;
import de.larma.arthook.Unsafe;

import static de.larma.arthook.ArtMethod.FIELD_ENTRY_POINT_FROM_INTERPRETER;
import static de.larma.arthook.ArtMethod.FIELD_ENTRY_POINT_FROM_JNI;
import static de.larma.arthook.ArtMethod.FIELD_ENTRY_POINT_FROM_QUICK_COMPILED_CODE;

public class LMR1 extends LMR0 {
    private static final int FIELD_ENTRY_POINT_FROM_INTERPRETER_NATIVE_INDEX = 0;
    private static final int FIELD_ENTRY_POINT_FROM_JNI_NATIVE_INDEX = 1;
    private static final int FIELD_ENTRY_POINT_FROM_QUICK_COMPILED_CODE_NATIVE_INDEX = 2;

    private static final int LMR1_MIRROR_FIELDS = Native.is64Bit() ? 40 : 36;
    private static final int LMR1_NATIVE_FIELDS_32 = 12;
    private static final int LMR1_NATIVE_FIELDS_64 = 24;
    private static final int LMR1_NATIVE_FIELDS = Native.is64Bit() ? LMR1_NATIVE_FIELDS_64 : LMR1_NATIVE_FIELDS_32;
    private static final int LMR1_OBJECT_SIZE = LMR1_NATIVE_FIELDS + LMR1_MIRROR_FIELDS;

    @Override
    public Object getArtMethodFieldNative(ArtMethod artMethod, String name) {
        switch (name) {
            case FIELD_ENTRY_POINT_FROM_INTERPRETER:
                return getNative(artMethod, FIELD_ENTRY_POINT_FROM_INTERPRETER_NATIVE_INDEX);
            case FIELD_ENTRY_POINT_FROM_JNI:
                return getNative(artMethod, FIELD_ENTRY_POINT_FROM_JNI_NATIVE_INDEX);
            case FIELD_ENTRY_POINT_FROM_QUICK_COMPILED_CODE:
                return getNative(artMethod, FIELD_ENTRY_POINT_FROM_QUICK_COMPILED_CODE_NATIVE_INDEX);
        }
        return super.getArtMethodFieldNative(artMethod, name);
    }

    private long getNative(ArtMethod artMethod, int num) {
        long objectAddress = Unsafe.getObjectAddress(artMethod.artMethod);
        int intSize = Native.is64Bit() ? 8 : 4;
        byte[] bytes = Memory.get(objectAddress + LMR1_MIRROR_FIELDS + intSize * num, intSize);
        if (Native.is64Bit()) {
            return ByteBuffer.wrap(bytes).order(ByteOrder.LITTLE_ENDIAN).getLong();
        } else {
            return ByteBuffer.wrap(bytes).order(ByteOrder.LITTLE_ENDIAN).getInt() & 0xFFFFFFFFL;
        }
    }

    @Override
    public boolean setArtMethodFieldNative(ArtMethod artMethod, String name, Object value) {
        switch (name) {
            case FIELD_ENTRY_POINT_FROM_INTERPRETER:
                setNative(artMethod, FIELD_ENTRY_POINT_FROM_INTERPRETER_NATIVE_INDEX, (Long) value);
                return true;
            case FIELD_ENTRY_POINT_FROM_JNI:
                setNative(artMethod, FIELD_ENTRY_POINT_FROM_JNI_NATIVE_INDEX, (Long) value);
                return true;
            case FIELD_ENTRY_POINT_FROM_QUICK_COMPILED_CODE:
                setNative(artMethod, FIELD_ENTRY_POINT_FROM_QUICK_COMPILED_CODE_NATIVE_INDEX, (Long) value);
                return true;
        }
        return super.setArtMethodFieldNative(artMethod, name, value);
    }

    private void setNative(ArtMethod artMethod, int num, long value) {
        long objectAddress = Unsafe.getObjectAddress(artMethod.artMethod);
        int intSize = Native.is64Bit() ? 8 : 4;
        byte[] bytes;
        if (Native.is64Bit()) {
            bytes = ByteBuffer.allocate(intSize).order(ByteOrder.LITTLE_ENDIAN).putLong(value).array();
        } else {
            bytes = ByteBuffer.allocate(intSize).order(ByteOrder.LITTLE_ENDIAN).putInt((int) value).array();
        }
        Memory.put(bytes, objectAddress + LMR1_MIRROR_FIELDS + intSize * num);
    }

    @Override
    public void copy(ArtMethod src, ArtMethod dst) {
        super.copy(src, dst);
        dst.setEntryPointFromInterpreter(src.getEntryPointFromInterpreter());
        dst.setEntryPointFromJni(src.getEntryPointFromJni());
        dst.setEntryPointFromQuickCompiledCode(src.getEntryPointFromQuickCompiledCode());
    }
}


text:
namespace chrome {
namespace android {

// static
bool ChromiumApplication::RegisterBindings(JNIEnv* env) {
  return RegisterNativesImpl(env);
}

void ChromiumApplication::OpenProtectedContentSettings() {
  Java_ChromiumApplication_openProtectedContentSettings(
      base::android::AttachCurrentThread(),
      base::android::GetApplicationContext());
}

void ChromiumApplication::ShowSyncSettings() {
  Java_ChromiumApplication_showSyncSettings(
      base::android::AttachCurrentThread(),
      base::android::GetApplicationContext());
}

void ChromiumApplication::ShowTermsOfServiceDialog() {
  Java_ChromiumApplication_showTermsOfServiceDialog(
      base::android::AttachCurrentThread(),
      base::android::GetApplicationContext());
}

bool ChromiumApplication::AreParentalControlsEnabled() {
  return Java_ChromiumApplication_areParentalControlsEnabled(
      base::android::AttachCurrentThread(),
      base::android::GetApplicationContext());
}

}  // namespace android
}  // namespace chrome


text:
.. _minio-mc-alias-list:

=================
``mc alias list``
=================

.. default-domain:: minio

.. contents:: Table of Contents
   :local:
   :depth: 2

.. mc:: mc alias list

Syntax
------

.. start-mc-alias-list-desc

The :mc:`mc alias list` command lists all aliases in the local
:program:`mc` configuration.

.. end-mc-alias-list-desc

The command output includes the configured access key and secret key associated
to each alias.

.. tab-set::

   .. tab-item:: EXAMPLE

      The following command lists all :ref:`aliases <alias>` configured
      on the local host machine:

      .. code-block:: shell
         :class: copyable

         mc alias list

   .. tab-item:: SYNTAX

      The :mc-cmd:`mc alias list` command has the following syntax:

      .. code-block:: shell

         mc [GLOBALFLAGS] alias list [ALIAS]

      .. include:: /includes/common-minio-mc.rst
         :start-after: start-minio-syntax
         :end-before: end-minio-syntax

Parameters
~~~~~~~~~~

.. mc-cmd:: ALIAS

   *Optional* The name of a specific alias to display.

Global Flags
~~~~~~~~~~~~

.. include:: /includes/common-minio-mc.rst
   :start-after: start-minio-mc-globals
   :end-before: end-minio-mc-globals

Examples
--------

List All Configured Aliases
~~~~~~~~~~~~~~~~~~~~~~~~~~~

.. tab-set::

   .. tab-item:: Example

      The following :mc-cmd:`mc alias list` command lists all configured aliases
      in the local :program:`mc` configuration.

      .. code-block:: shell
         :class: copyable

         mc alias list

   .. tab-item:: Syntax

      .. code-block:: shell
         :class: copyable

         mc alias list

List a Specific Alias
~~~~~~~~~~~~~~~~~~~~~

.. tab-set::

   .. tab-item:: Example

      The following :mc-cmd:`mc alias list` command lists the details of a
      specific alias in the local :program:`mc` configuration.

      .. code-block:: shell
         :class: copyable

         mc alias list myminio

   .. tab-item:: Syntax

      .. code-block:: shell
         :class: copyable

         mc alias list ALIAS

      - Replace ``ALIAS`` with the the name of the alias to return.

Behavior
--------

S3 Compatibility
~~~~~~~~~~~~~~~~

.. include:: /includes/common-minio-mc.rst
   :start-after: start-minio-mc-s3-compatibility
   :end-before: end-minio-mc-s3-compatibility


text:
#pragma once

//   This file is part of Gusty's Serpents, licensed under the terms of the MIT License
//   (further described below).
//
//   Copyright (C) 2009-2014  Augustin Preda (thegusty999@gmail.com)
//
//   Permission is hereby granted, free of charge, to any person obtaining a copy
//   of this software and associated documentation files (the "Software"), to deal
//   in the Software without restriction, including without limitation the rights
//   to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
//   copies of the Software, and to permit persons to whom the Software is
//   furnished to do so, subject to the following conditions:
//
//   The above copyright notice and this permission notice shall be included in
//   all copies or substantial portions of the Software.
//
//   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
//   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
//   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
//   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
//   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
//   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
//   THE SOFTWARE.
//
//   Helper class for shader based operations.
//
//    Last change:  $LastChangedDate$
//    Revision:    $Revision$

//
// Includes
//

//
// C++ system headers.
//

#include <string>

//
// Other libraries' headers
//

// Forward declaration to avoid inclusion of header.
namespace Ogre
{
  namespace RTShader
  {
    class ShaderGenerator;
  }

  class SceneManager;
  class PSSMShadowCameraSetup;
}

namespace Serpents
{
  /**
    A structure that stores settings to be used for shading control.
  */
  struct ShadingSettings
  {
  public:
    std::string preferredShadingLanguage;
    bool storeRtssCacheInMemory;

    ShadingSettings()
      : preferredShadingLanguage("cg"),
        storeRtssCacheInMemory(false)
    {
    }
  };

  /**
    Shading helper class. Dependent on OGRE.
    Will use the OGRE RTSS component.
  */
  class ShadingHelper
  {
  private:
    Ogre::RTShader::ShaderGenerator* shaderGeneratorPtr_;      // The Shader generator instance.
    ShadingSettings startupSettingsCopy_;
    Ogre::SceneManager* usedSceneManager_;

    class Impl;
    Impl* impl_;

  public:
    /**
      Constructor.
    */
    ShadingHelper();

    /**
      Destructor.
    */
    virtual ~ShadingHelper();

    /**
      Initialize the RTSS component, using the default settings.
    */
    virtual bool initializeRTShaderSystem(Ogre::SceneManager* sceneMgr);

    /**
      Initialize the RTSS component using custom start-up settings.
    */
    virtual bool initializeRTShaderSystem(
        Ogre::SceneManager* sceneMgr,
        const ShadingSettings& startupSettings);

    /**
      Setter for the shader generator to use.
    */
    void setShaderGenerator(Ogre::RTShader::ShaderGenerator* shaderGenerator);

    /**
      Getter for the shader generator to use.
    */
    Ogre::RTShader::ShaderGenerator* getShaderGenerator();

    /**
      Perform a cleanup of the RTSS group resources.
    */
    void cleanupRTSGResources();

    /**
      Reload the resources part of the RTSS group.
      This may be a simple cleanup and re-initialization.
    */
    void reloadRTSGResources();

    /**
      Getter for the default schema name.
    */
    std::string getDefaultSchemaName();

    /**
      Invalidate the active RTSS scheme. Will most likely be the same as the default scheme.
    */
    void invalidateActiveScheme();

    /**
      Grab the active scheme render state and apply a SSLM_PerVertexLighting lighting model.
    */
    void addPerVertexLightingToActiveScheme();

    /**
      Add PSSM specific render state for RTSS.
    */
    void addIntegratedPSSMRenderState(Ogre::PSSMShadowCameraSetup* cameraSetup);

    /**
      Remove all lighting information from the active
    */
    void removeActiveLightingSettings();

    /**
      Apply a shadow technique to use.
      @param shadowTechniqueId The identifier of the shadow technique. Possible values include, but are not limited to:
        0 = SHADOWTYPE_NONE
        1 = SHADOWTYPE_STENCIL_MODULATIVE
        2 = SHADOWTYPE_STENCIL_ADDITIVE
        3 = SHADOWTYPE_TEXTURE_ADDITIVE
        4 = SHADOWTYPE_TEXTURE_MODULATIVE
        5 = SHADOWTYPE_TEXTURE_ADDITIVE_INTEGRATED
        6 = SHADOWTYPE_TEXTURE_MODULATIVE_INTEGRATED
      @see See the definition of [enum ShadowTechnique] in [OgreCommon.h].
      Note that the values of the technique ID differ.
    */
    void setShadowTechnique(int shadowTechniqueId);

    /**
      Get the name of a used shadow techniqueId.
      Note: this is meant to be used mostly for debug info.
      @param shadowTechniqueId The identifier of the shadow technique. Possible values include, but are not limited to:
        0 = SHADOWTYPE_NONE
        1 = SHADOWTYPE_STENCIL_MODULATIVE
        2 = SHADOWTYPE_STENCIL_ADDITIVE
        3 = SHADOWTYPE_TEXTURE_ADDITIVE
        4 = SHADOWTYPE_TEXTURE_MODULATIVE
        5 = SHADOWTYPE_TEXTURE_ADDITIVE_INTEGRATED
        6 = SHADOWTYPE_TEXTURE_MODULATIVE_INTEGRATED
      @see See the definition of [enum ShadowTechnique] in [OgreCommon.h].
      Note that the values of the technique ID differ.
    */
    std::string getShadowTechniqueName(int shadowTechniqueId) const;
  };
}


text:
package org.apache.cassandra.config;

import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
import java.util.function.Supplier;

import com.google.common.base.Joiner;
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.Sets;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import org.apache.cassandra.audit.AuditLogOptions;
import org.apache.cassandra.db.ConsistencyLevel;
import org.apache.cassandra.fql.FullQueryLoggerOptions;
import org.apache.cassandra.service.StartupChecks.StartupCheckType;

/**
 * A class that contains configuration properties for the cassandra node it runs within.
 *
 * Properties declared as volatile can be mutated via JMX.
 */
public class Config
{
    private static final Logger logger = LoggerFactory.getLogger(Config.class);

    public static Set<String> splitCommaDelimited(String src)
    {
        if (src == null)
            return ImmutableSet.of();
        String[] split = src.split(",\\s*");
        ImmutableSet.Builder<String> builder = ImmutableSet.builder();
        for (String s : split)
        {
            s = s.trim();
            if (!s.isEmpty())
                builder.add(s);
        }
        return builder.build();
    }
    /*
     * Prefix for Java properties for internal Cassandra configuration options
     */
    public static final String PROPERTY_PREFIX = "cassandra.";

    public String cluster_name = "Test Cluster";
    public String authenticator;
    public String authorizer;
    public String role_manager;
    public String network_authorizer;
    @Replaces(oldName = "permissions_validity_in_ms", converter = Converters.MILLIS_DURATION, deprecated = true)
    public volatile SmallestDurationMilliseconds permissions_validity = new SmallestDurationMilliseconds("2s");
    public volatile int permissions_cache_max_entries = 1000;
    @Replaces(oldName = "permissions_update_interval_in_ms", converter = Converters.MILLIS_CUSTOM_DURATION, deprecated = true)
    public volatile SmallestDurationMilliseconds permissions_update_interval = new SmallestDurationMilliseconds("0ms");
    public volatile boolean permissions_cache_active_update = false;
    @Replaces(oldName = "roles_validity_in_ms", converter = Converters.MILLIS_DURATION, deprecated = true)
    public volatile SmallestDurationMilliseconds roles_validity = new SmallestDurationMilliseconds("2s");
    public volatile int roles_cache_max_entries = 1000;
    @Replaces(oldName = "roles_update_interval_in_ms", converter = Converters.MILLIS_CUSTOM_DURATION, deprecated = true)
    public volatile SmallestDurationMilliseconds roles_update_interval= new SmallestDurationMilliseconds("0ms");
    public volatile boolean roles_cache_active_update = false;
    @Replaces(oldName = "credentials_validity_in_ms", converter = Converters.MILLIS_DURATION, deprecated = true)
    public volatile SmallestDurationMilliseconds credentials_validity = new SmallestDurationMilliseconds("2s");
    public volatile int credentials_cache_max_entries = 1000;
    @Replaces(oldName = "credentials_update_interval_in_ms", converter = Converters.MILLIS_CUSTOM_DURATION, deprecated = true)
    public volatile SmallestDurationMilliseconds credentials_update_interval= new SmallestDurationMilliseconds("0ms");
    public volatile boolean credentials_cache_active_update = false;

    /* Hashing strategy Random or OPHF */
    public String partitioner;

    public boolean auto_bootstrap = true;
    public volatile boolean hinted_handoff_enabled = true;
    public Set<String> hinted_handoff_disabled_datacenters = Sets.newConcurrentHashSet();
    @Replaces(oldName = "max_hint_window_in_ms", converter = Converters.MILLIS_DURATION, deprecated = true)
    public volatile SmallestDurationMilliseconds max_hint_window = new SmallestDurationMilliseconds("3h");
    public String hints_directory;
    public boolean hint_window_persistent_enabled = true;

    public volatile boolean force_new_prepared_statement_behaviour = false;

    public ParameterizedClass seed_provider;
    public DiskAccessMode disk_access_mode = DiskAccessMode.auto;

    public DiskFailurePolicy disk_failure_policy = DiskFailurePolicy.ignore;
    public CommitFailurePolicy commit_failure_policy = CommitFailurePolicy.stop;

    public volatile boolean use_deterministic_table_id = false;

    /* initial token in the ring */
    public String initial_token;
    public Integer num_tokens;
    /** Triggers automatic allocation of tokens if set, using the replication strategy of the referenced keyspace */
    public String allocate_tokens_for_keyspace = null;
    /** Triggers automatic allocation of tokens if set, based on the provided replica count for a datacenter */
    public Integer allocate_tokens_for_local_replication_factor = null;

    @Replaces(oldName = "native_transport_idle_timeout_in_ms", converter = Converters.MILLIS_DURATION, deprecated = true)
    public SmallestDurationMilliseconds native_transport_idle_timeout = new SmallestDurationMilliseconds("0ms");

    @Replaces(oldName = "request_timeout_in_ms", converter = Converters.MILLIS_DURATION, deprecated = true)
    public volatile SmallestDurationMilliseconds request_timeout = new SmallestDurationMilliseconds("10000ms");

    @Replaces(oldName = "read_request_timeout_in_ms", converter = Converters.MILLIS_DURATION, deprecated = true)
    public volatile SmallestDurationMilliseconds read_request_timeout = new SmallestDurationMilliseconds("5000ms");

    @Replaces(oldName = "range_request_timeout_in_ms", converter = Converters.MILLIS_DURATION, deprecated = true)
    public volatile SmallestDurationMilliseconds range_request_timeout = new SmallestDurationMilliseconds("10000ms");

    @Replaces(oldName = "write_request_timeout_in_ms", converter = Converters.MILLIS_DURATION, deprecated = true)
    public volatile SmallestDurationMilliseconds write_request_timeout = new SmallestDurationMilliseconds("2000ms");

    @Replaces(oldName = "counter_write_request_timeout_in_ms", converter = Converters.MILLIS_DURATION, deprecated = true)
    public volatile SmallestDurationMilliseconds counter_write_request_timeout = new SmallestDurationMilliseconds("5000ms");

    @Replaces(oldName = "cas_contention_timeout_in_ms", converter = Converters.MILLIS_DURATION, deprecated = true)
    public volatile SmallestDurationMilliseconds cas_contention_timeout = new SmallestDurationMilliseconds("1800ms");

    @Replaces(oldName = "truncate_request_timeout_in_ms", converter = Converters.MILLIS_DURATION, deprecated = true)
    public volatile SmallestDurationMilliseconds truncate_request_timeout = new SmallestDurationMilliseconds("60000ms");

    public volatile Long repair_request_timeout_in_ms = 120000L;

    public Integer streaming_connections_per_host = 1;
    @Replaces(oldName = "streaming_keep_alive_period_in_secs", converter = Converters.SECONDS_DURATION, deprecated = true)
    public SmallestDurationSeconds streaming_keep_alive_period = new SmallestDurationSeconds("300s");

    @Replaces(oldName = "cross_node_timeout", converter = Converters.IDENTITY, deprecated = true)
    public boolean internode_timeout = true;

    @Replaces(oldName = "slow_query_log_timeout_in_ms", converter = Converters.MILLIS_DURATION, deprecated = true)
    public volatile SmallestDurationMilliseconds slow_query_log_timeout = new SmallestDurationMilliseconds("500ms");

    public volatile double phi_convict_threshold = 8.0;

    public int concurrent_reads = 32;
    public int concurrent_writes = 32;
    public int concurrent_counter_writes = 32;
    public int concurrent_materialized_view_writes = 32;
    public int available_processors = -1;

    @Deprecated
    public Integer concurrent_replicates = null;

    public int memtable_flush_writers = 0;
    @Replaces(oldName = "memtable_heap_space_in_mb", converter = Converters.MEBIBYTES_DATA_STORAGE, deprecated = true)
    public SmallestDataStorageMebibytes memtable_heap_space;
    @Replaces(oldName = "memtable_offheap_space_in_mb", converter = Converters.MEBIBYTES_DATA_STORAGE, deprecated = true)
    public SmallestDataStorageMebibytes memtable_offheap_space;
    public Float memtable_cleanup_threshold = null;

    // Limit the maximum depth of repair session merkle trees
    @Deprecated
    public volatile Integer repair_session_max_tree_depth = null;
    @Replaces(oldName = "repair_session_space_in_mb", converter = Converters.MEBIBYTES_DATA_STORAGE, deprecated = true)
    public volatile SmallestDataStorageMebibytes repair_session_space = null;

    public volatile boolean use_offheap_merkle_trees = true;

    public int storage_port = 7000;
    public int ssl_storage_port = 7001;
    public String listen_address;
    public String listen_interface;
    public boolean listen_interface_prefer_ipv6 = false;
    public String broadcast_address;
    public boolean listen_on_broadcast_address = false;
    public String internode_authenticator;

    public boolean traverse_auth_from_root = false;

    /*
     * RPC address and interface refer to the address/interface used for the native protocol used to communicate with
     * clients. It's still called RPC in some places even though Thrift RPC is gone. If you see references to native
     * address or native port it's derived from the RPC address configuration.
     *
     * native_transport_port is the port that is paired with RPC address to bind on.
     */
    public String rpc_address;
    public String rpc_interface;
    public boolean rpc_interface_prefer_ipv6 = false;
    public String broadcast_rpc_address;
    public boolean rpc_keepalive = true;

    @Replaces(oldName = "internode_max_message_size_in_bytes", converter = Converters.BYTES_DATASTORAGE, deprecated=true)
    public DataStorageSpec internode_max_message_size;

    @Replaces(oldName = "internode_socket_send_buffer_size_in_bytes", converter = Converters.BYTES_DATASTORAGE, deprecated = true)
    @Replaces(oldName = "internode_send_buff_size_in_bytes", converter = Converters.BYTES_DATASTORAGE, deprecated = true)
    public DataStorageSpec internode_socket_send_buffer_size = new DataStorageSpec("0B");
    @Replaces(oldName = "internode_socket_receive_buffer_size_in_bytes", converter = Converters.BYTES_DATASTORAGE, deprecated = true)
    @Replaces(oldName = "internode_recv_buff_size_in_bytes", converter = Converters.BYTES_DATASTORAGE, deprecated = true)
    public DataStorageSpec internode_socket_receive_buffer_size = new DataStorageSpec("0B");

    // TODO: derive defaults from system memory settings?
    @Replaces(oldName = "internode_application_send_queue_capacity_in_bytes", converter = Converters.BYTES_DATASTORAGE, deprecated = true)
    public DataStorageSpec internode_application_send_queue_capacity = new DataStorageSpec("4MiB");
    @Replaces(oldName = "internode_application_send_queue_reserve_endpoint_capacity_in_bytes", converter = Converters.BYTES_DATASTORAGE, deprecated = true)
    public DataStorageSpec internode_application_send_queue_reserve_endpoint_capacity = new DataStorageSpec("128MiB");
    @Replaces(oldName = "internode_application_send_queue_reserve_global_capacity_in_bytes", converter = Converters.BYTES_DATASTORAGE, deprecated = true)
    public DataStorageSpec internode_application_send_queue_reserve_global_capacity = new DataStorageSpec("512MiB");

    @Replaces(oldName = "internode_application_receive_queue_capacity_in_bytes", converter = Converters.BYTES_DATASTORAGE, deprecated = true)
    public DataStorageSpec internode_application_receive_queue_capacity = new DataStorageSpec("4MiB");
    @Replaces(oldName = "internode_application_receive_queue_reserve_endpoint_capacity_in_bytes", converter = Converters.BYTES_DATASTORAGE, deprecated = true)
    public DataStorageSpec internode_application_receive_queue_reserve_endpoint_capacity = new DataStorageSpec("128MiB");
    @Replaces(oldName = "internode_application_receive_queue_reserve_global_capacity_in_bytes", converter = Converters.BYTES_DATASTORAGE, deprecated = true)
    public DataStorageSpec internode_application_receive_queue_reserve_global_capacity = new DataStorageSpec("512MiB");

    // Defensive settings for protecting Cassandra from true network partitions. See (CASSANDRA-14358) for details.
    // The amount of time to wait for internode tcp connections to establish.
    @Replaces(oldName = "internode_tcp_connect_timeout_in_ms", converter = Converters.MILLIS_DURATION, deprecated = true)
    public volatile SmallestDurationMilliseconds internode_tcp_connect_timeout = new SmallestDurationMilliseconds("2s");
    // The amount of time unacknowledged data is allowed on a connection before we throw out the connection
    // Note this is only supported on Linux + epoll, and it appears to behave oddly above a setting of 30000
    // (it takes much longer than 30s) as of Linux 4.12. If you want something that high set this to 0
    // (which picks up the OS default) and configure the net.ipv4.tcp_retries2 sysctl to be ~8.
    @Replaces(oldName = "internode_tcp_user_timeout_in_ms", converter = Converters.MILLIS_DURATION, deprecated = true)
    public volatile SmallestDurationMilliseconds internode_tcp_user_timeout = new SmallestDurationMilliseconds("30s");
    // Similar to internode_tcp_user_timeout but used specifically for streaming connection.
    // The default is 5 minutes. Increase it or set it to 0 in order to increase the timeout.
    @Replaces(oldName = "internode_streaming_tcp_user_timeout_in_ms", converter = Converters.MILLIS_DURATION, deprecated = true)
    public volatile SmallestDurationMilliseconds internode_streaming_tcp_user_timeout = new SmallestDurationMilliseconds("300s"); // 5 minutes

    public boolean start_native_transport = true;
    public int native_transport_port = 9042;
    public Integer native_transport_port_ssl = null;
    public int native_transport_max_threads = 128;
    @Replaces(oldName = "native_transport_max_frame_size_in_mb", converter = Converters.MEBIBYTES_DATA_STORAGE, deprecated = true)
    public SmallestDataStorageMebibytes native_transport_max_frame_size = new SmallestDataStorageMebibytes("16MiB");
    public volatile long native_transport_max_concurrent_connections = -1L;
    public volatile long native_transport_max_concurrent_connections_per_ip = -1L;
    public boolean native_transport_flush_in_batches_legacy = false;
    public volatile boolean native_transport_allow_older_protocols = true;
    public volatile long native_transport_max_concurrent_requests_in_bytes_per_ip = -1L;
    public volatile long native_transport_max_concurrent_requests_in_bytes = -1L;
    public volatile boolean native_transport_rate_limiting_enabled = false;
    public volatile int native_transport_max_requests_per_second = 1000000;
    // not exposed in the yaml
    public int native_transport_receive_queue_capacity_in_bytes = 1 << 20; // 1MiB

    @Deprecated
    public Integer native_transport_max_negotiable_protocol_version = null;

    /**
     * Max size of values in SSTables, in MebiBytes.
     * Default is the same as the native protocol frame limit: 256MiB.
     * See AbstractType for how it is used.
     */
    @Replaces(oldName = "max_value_size_in_mb", converter = Converters.MEBIBYTES_DATA_STORAGE, deprecated = true)
    public SmallestDataStorageMebibytes max_value_size = new SmallestDataStorageMebibytes("256MiB");

    public boolean snapshot_before_compaction = false;
    public boolean auto_snapshot = true;
    public volatile long snapshot_links_per_second = 0;

    /* if the size of columns or super-columns are more than this, indexing will kick in */
    @Replaces(oldName = "column_index_size_in_kb", converter = Converters.KIBIBYTES_DATASTORAGE, deprecated = true)
    public volatile SmallestDataStorageKibibytes column_index_size = new SmallestDataStorageKibibytes("64KiB");
    @Replaces(oldName = "column_index_cache_size_in_kb", converter = Converters.KIBIBYTES_DATASTORAGE, deprecated = true)
    public volatile SmallestDataStorageKibibytes column_index_cache_size = new SmallestDataStorageKibibytes("2KiB");
    @Replaces(oldName = "batch_size_warn_threshold_in_kb", converter = Converters.KIBIBYTES_DATASTORAGE, deprecated = true)
    public volatile SmallestDataStorageKibibytes batch_size_warn_threshold = new SmallestDataStorageKibibytes("5KiB");
    @Replaces(oldName = "batch_size_fail_threshold_in_kb", converter = Converters.KIBIBYTES_DATASTORAGE, deprecated = true)
    public volatile SmallestDataStorageKibibytes batch_size_fail_threshold = new SmallestDataStorageKibibytes("50KiB");

    public Integer unlogged_batch_across_partitions_warn_threshold = 10;
    public volatile Integer concurrent_compactors;
    @Replaces(oldName = "compaction_throughput_mb_per_sec", converter = Converters.MEBIBYTES_PER_SECOND_DATA_RATE, deprecated = true)
    public volatile DataRateSpec compaction_throughput = new DataRateSpec("16MiB/s");
    @Replaces(oldName = "compaction_large_partition_warning_threshold_mb", converter = Converters.MEBIBYTES_DATA_STORAGE, deprecated = true)
    public volatile SmallestDataStorageMebibytes compaction_large_partition_warning_threshold = new SmallestDataStorageMebibytes("100MiB");
    @Replaces(oldName = "min_free_space_per_drive_in_mb", converter = Converters.MEBIBYTES_DATA_STORAGE, deprecated = true)
    public SmallestDataStorageMebibytes min_free_space_per_drive = new SmallestDataStorageMebibytes("50MiB");
    public volatile Integer compaction_tombstone_warning_threshold = 100000;

    public volatile int concurrent_materialized_view_builders = 1;
    public volatile int reject_repair_compaction_threshold = Integer.MAX_VALUE;

    /**
     * @deprecated retry support removed on CASSANDRA-10992
     */
    @Deprecated
    public int max_streaming_retries = 3;

    @Replaces(oldName = "stream_throughput_outbound_megabits_per_sec", converter = Converters.MEGABITS_TO_MEBIBYTES_PER_SECOND_DATA_RATE, deprecated = true)
    public volatile DataRateSpec stream_throughput_outbound = new DataRateSpec("24MiB/s");
    @Replaces(oldName = "inter_dc_stream_throughput_outbound_megabits_per_sec", converter = Converters.MEGABITS_TO_MEBIBYTES_PER_SECOND_DATA_RATE, deprecated = true)
    public volatile DataRateSpec inter_dc_stream_throughput_outbound = new DataRateSpec("24MiB/s");

    public volatile DataRateSpec entire_sstable_stream_throughput_outbound = new DataRateSpec("24MiB/s");
    public volatile DataRateSpec entire_sstable_inter_dc_stream_throughput_outbound = new DataRateSpec("24MiB/s");

    public String[] data_file_directories = new String[0];

    /**
     * The directory to use for storing the system keyspaces data.
     * If unspecified the data will be stored in the first of the data_file_directories.
     */
    public String local_system_data_file_directory;

    public String saved_caches_directory;

    // Commit Log
    public String commitlog_directory;
    @Replaces(oldName = "commitlog_total_space_in_mb", converter = Converters.MEBIBYTES_DATA_STORAGE, deprecated = true)
    public SmallestDataStorageMebibytes commitlog_total_space;
    public CommitLogSync commitlog_sync;

    /**
     * @deprecated since 4.0 This value was near useless, and we're not using it anymore
     */
    public double commitlog_sync_batch_window_in_ms = Double.NaN;
    @Replaces(oldName = "commitlog_sync_group_window_in_ms", converter = Converters.MILLIS_DOUBLE_DURATION, deprecated = true)
    public SmallestDurationMilliseconds commitlog_sync_group_window = new SmallestDurationMilliseconds("0ms");
    @Replaces(oldName = "commitlog_sync_period_in_ms", converter = Converters.MILLIS_DURATION, deprecated = true)
    public SmallestDurationMilliseconds commitlog_sync_period = new SmallestDurationMilliseconds("0ms");
    @Replaces(oldName = "commitlog_segment_size_in_mb", converter = Converters.MEBIBYTES_DATA_STORAGE, deprecated = true)
    public SmallestDataStorageMebibytes commitlog_segment_size = new SmallestDataStorageMebibytes("32MiB");
    public ParameterizedClass commitlog_compression;
    public FlushCompression flush_compression = FlushCompression.fast;
    public int commitlog_max_compression_buffers_in_pool = 3;
    @Replaces(oldName = "periodic_commitlog_sync_lag_block_in_ms", converter = Converters.MILLIS_DURATION, deprecated = true)
    public SmallestDurationMilliseconds periodic_commitlog_sync_lag_block;
    public TransparentDataEncryptionOptions transparent_data_encryption_options = new TransparentDataEncryptionOptions();

    @Replaces(oldName = "max_mutation_size_in_kb", converter = Converters.KIBIBYTES_DATASTORAGE, deprecated = true)
    public SmallestDataStorageKibibytes max_mutation_size;

    // Change-data-capture logs
    public boolean cdc_enabled = false;
    // When true, new CDC mutations are rejected/blocked when reaching max CDC storage.
    // When false, new CDC mutations can always be added. But it will remove the oldest CDC commit log segment on full.
    public volatile boolean cdc_block_writes = true;
    public String cdc_raw_directory;
    @Replaces(oldName = "cdc_total_space_in_mb", converter = Converters.MEBIBYTES_DATA_STORAGE, deprecated = true)
    public SmallestDataStorageMebibytes cdc_total_space = new SmallestDataStorageMebibytes("0MiB");
    @Replaces(oldName = "cdc_free_space_check_interval_ms", converter = Converters.MILLIS_DURATION, deprecated = true)
    public SmallestDurationMilliseconds cdc_free_space_check_interval = new SmallestDurationMilliseconds("250ms");

    @Deprecated
    public int commitlog_periodic_queue_size = -1;

    public String endpoint_snitch;
    public boolean dynamic_snitch = true;
    @Replaces(oldName = "dynamic_snitch_update_interval_in_ms", converter = Converters.MILLIS_DURATION, deprecated = true)
    public SmallestDurationMilliseconds dynamic_snitch_update_interval = new SmallestDurationMilliseconds("100ms");
    @Replaces(oldName = "dynamic_snitch_reset_interval_in_ms", converter = Converters.MILLIS_DURATION, deprecated = true)
    public SmallestDurationMilliseconds dynamic_snitch_reset_interval = new SmallestDurationMilliseconds("10m");
    public double dynamic_snitch_badness_threshold = 1.0;

    public String failure_detector = "FailureDetector";

    public EncryptionOptions.ServerEncryptionOptions server_encryption_options = new EncryptionOptions.ServerEncryptionOptions();
    public EncryptionOptions client_encryption_options = new EncryptionOptions();

    public InternodeCompression internode_compression = InternodeCompression.none;

    @Replaces(oldName = "hinted_handoff_throttle_in_kb", converter = Converters.KIBIBYTES_DATASTORAGE, deprecated = true)
    public SmallestDataStorageKibibytes hinted_handoff_throttle = new SmallestDataStorageKibibytes("1024KiB");
    @Replaces(oldName = "batchlog_replay_throttle_in_kb", converter = Converters.KIBIBYTES_DATASTORAGE, deprecated = true)
    public SmallestDataStorageKibibytes batchlog_replay_throttle = new SmallestDataStorageKibibytes("1024KiB");
    public int max_hints_delivery_threads = 2;
    @Replaces(oldName = "hints_flush_period_in_ms", converter = Converters.MILLIS_DURATION, deprecated = true)
    public SmallestDurationMilliseconds hints_flush_period = new SmallestDurationMilliseconds("10s");
    @Replaces(oldName = "max_hints_file_size_in_mb", converter = Converters.MEBIBYTES_DATA_STORAGE, deprecated = true)
    public SmallestDataStorageMebibytes max_hints_file_size = new SmallestDataStorageMebibytes("128MiB");
    public volatile DataStorageSpec max_hints_size_per_host = new DataStorageSpec("0B"); // 0 means disabled

    public ParameterizedClass hints_compression;
    public volatile boolean auto_hints_cleanup_enabled = false;

    public volatile boolean incremental_backups = false;
    public boolean trickle_fsync = false;
    @Replaces(oldName = "trickle_fsync_interval_in_kb", converter = Converters.KIBIBYTES_DATASTORAGE, deprecated = true)
    public SmallestDataStorageKibibytes trickle_fsync_interval = new SmallestDataStorageKibibytes("10240KiB");

    @Replaces(oldName = "sstable_preemptive_open_interval_in_mb", converter = Converters.MEBIBYTES_DATA_STORAGE, deprecated = true)
    public volatile SmallestDataStorageMebibytes sstable_preemptive_open_interval = new SmallestDataStorageMebibytes("50MiB");

    public volatile boolean key_cache_migrate_during_compaction = true;
    public volatile int key_cache_keys_to_save = Integer.MAX_VALUE;
    @Replaces(oldName = "key_cache_size_in_mb", converter = Converters.MEBIBYTES_DATA_STORAGE, deprecated = true)
    public SmallestDataStorageMebibytes key_cache_size = null;
    @Replaces(oldName = "key_cache_save_period", converter = Converters.SECONDS_CUSTOM_DURATION, deprecated = true)
    public volatile SmallestDurationSeconds key_cache_save_period = new SmallestDurationSeconds("4h");

    public String row_cache_class_name = "org.apache.cassandra.cache.OHCProvider";
    @Replaces(oldName = "row_cache_size_in_mb", converter = Converters.MEBIBYTES_DATA_STORAGE, deprecated = true)
    public SmallestDataStorageMebibytes row_cache_size = new SmallestDataStorageMebibytes("0MiB");
    @Replaces(oldName = "row_cache_save_period", converter = Converters.SECONDS_CUSTOM_DURATION, deprecated = true)
    public volatile SmallestDurationSeconds row_cache_save_period = new SmallestDurationSeconds("0s");
    public volatile int row_cache_keys_to_save = Integer.MAX_VALUE;

    @Replaces(oldName = "counter_cache_size_in_mb", converter = Converters.MEBIBYTES_DATA_STORAGE, deprecated = true)
    public SmallestDataStorageMebibytes counter_cache_size = null;
    @Replaces(oldName = "counter_cache_save_period", converter = Converters.SECONDS_CUSTOM_DURATION, deprecated = true)
    public volatile SmallestDurationSeconds counter_cache_save_period = new SmallestDurationSeconds("7200s");
    public volatile int counter_cache_keys_to_save = Integer.MAX_VALUE;

    public SmallestDataStorageMebibytes paxos_cache_size = null;

    @Replaces(oldName = "cache_load_timeout_seconds ", converter = Converters.SECONDS_DURATION, deprecated = true)
    public SmallestDurationSeconds cache_load_timeout = new SmallestDurationSeconds("30s");

    private static boolean isClientMode = false;
    private static Supplier<Config> overrideLoadConfig = null;

    @Replaces(oldName = "networking_cache_size_in_mb", converter = Converters.MEBIBYTES_DATA_STORAGE, deprecated = true)
    public SmallestDataStorageMebibytes networking_cache_size;

    @Replaces(oldName = "file_cache_size_in_mb", converter = Converters.MEBIBYTES_DATA_STORAGE, deprecated = true)
    public SmallestDataStorageMebibytes file_cache_size;

    public boolean file_cache_enabled = Boolean.getBoolean("cassandra.file_cache_enabled");

    /**
     * Because of the current {@link org.apache.cassandra.utils.memory.BufferPool} slab sizes of 64 KiB, we
     * store in the file cache buffers that divide 64 KiB, so we need to round the buffer sizes to powers of two.
     * This boolean controls weather they are rounded up or down. Set it to true to round up to the
     * next power of two, set it to false to round down to the previous power of two. Note that buffer sizes are
     * already rounded to 4 KiB and capped between 4 KiB minimum and 64 kb maximum by the {@link DiskOptimizationStrategy}.
     * By default, this boolean is set to round down when {@link #disk_optimization_strategy} is {@code ssd},
     * and to round up when it is {@code spinning}.
     */
    public Boolean file_cache_round_up;

    @Deprecated
    public boolean buffer_pool_use_heap_if_exhausted;

    public DiskOptimizationStrategy disk_optimization_strategy = DiskOptimizationStrategy.ssd;

    public double disk_optimization_estimate_percentile = 0.95;

    public double disk_optimization_page_cross_chance = 0.1;

    public boolean inter_dc_tcp_nodelay = true;

    public MemtableAllocationType memtable_allocation_type = MemtableAllocationType.heap_buffers;

    public final TrackWarnings track_warnings = new TrackWarnings();

    public volatile int tombstone_warn_threshold = 1000;
    public volatile int tombstone_failure_threshold = 100000;

    public final ReplicaFilteringProtectionOptions replica_filtering_protection = new ReplicaFilteringProtectionOptions();

    @Replaces(oldName = "index_summary_capacity_in_mb", converter = Converters.MEBIBYTES_DATA_STORAGE, deprecated = true)
    public volatile SmallestDataStorageMebibytes index_summary_capacity;
    @Replaces(oldName = "index_summary_resize_interval_in_minutes", converter = Converters.MINUTES_DURATION, deprecated = true)
    public volatile SmallestDurationMinutes index_summary_resize_interval = new SmallestDurationMinutes("60m");

    @Replaces(oldName = "gc_log_threshold_in_ms", converter = Converters.MILLIS_DURATION, deprecated = true)
    public SmallestDurationMilliseconds gc_log_threshold = new SmallestDurationMilliseconds("200ms");
    @Replaces(oldName = "gc_warn_threshold_in_ms", converter = Converters.MILLIS_DURATION, deprecated = true)
    public SmallestDurationMilliseconds gc_warn_threshold = new SmallestDurationMilliseconds("1s");

    // TTL for different types of trace events.
    @Replaces(oldName = "tracetype_query_ttl", converter = Converters.SECONDS_DURATION, deprecated=true)
    public SmallestDurationSeconds trace_type_query_ttl = new SmallestDurationSeconds("1d");
    @Replaces(oldName = "tracetype_repair_ttl", converter = Converters.SECONDS_DURATION, deprecated=true)
    public SmallestDurationSeconds trace_type_repair_ttl = new SmallestDurationSeconds("7d");

    /**
     * Maintain statistics on whether writes achieve the ideal consistency level
     * before expiring and becoming hints
     */
    public volatile ConsistencyLevel ideal_consistency_level = null;

    @Deprecated
    public int windows_timer_interval = 0;

    @Deprecated
    public String otc_coalescing_strategy = "DISABLED";

    @Deprecated
    public static final int otc_coalescing_window_us_default = 200;
    @Deprecated
    public int otc_coalescing_window_us = otc_coalescing_window_us_default;
    @Deprecated
    public int otc_coalescing_enough_coalesced_messages = 8;
    @Deprecated
    public static final int otc_backlog_expiration_interval_ms_default = 200;
    @Deprecated
    public volatile int otc_backlog_expiration_interval_ms = otc_backlog_expiration_interval_ms_default;

    /**
     * Size of the CQL prepared statements cache in MiB.
     * Defaults to 1/256th of the heap size or 10MiB, whichever is greater.
     */
    @Replaces(oldName = "prepared_statements_cache_size_mb", converter = Converters.MEBIBYTES_DATA_STORAGE, deprecated = true)
    public SmallestDataStorageMebibytes prepared_statements_cache_size = null;

    @Replaces(oldName = "enable_user_defined_functions", converter = Converters.IDENTITY, deprecated = true)
    public boolean user_defined_functions_enabled = false;
    @Replaces(oldName = "enable_scripted_user_defined_functions", converter = Converters.IDENTITY, deprecated = true)
    public boolean scripted_user_defined_functions_enabled = false;

    @Replaces(oldName = "enable_materialized_views", converter = Converters.IDENTITY, deprecated = true)
    public boolean materialized_views_enabled = false;

    @Replaces(oldName = "enable_transient_replication", converter = Converters.IDENTITY, deprecated = true)
    public boolean transient_replication_enabled = false;

    @Replaces(oldName = "enable_sasi_indexes", converter = Converters.IDENTITY, deprecated = true)
    public boolean sasi_indexes_enabled = false;

    @Replaces(oldName = "enable_drop_compact_storage", converter = Converters.IDENTITY, deprecated = true)
    public volatile boolean drop_compact_storage_enabled = false;

    public volatile boolean use_statements_enabled = true;

    /**
     * Optionally disable asynchronous UDF execution.
     * Disabling asynchronous UDF execution also implicitly disables the security-manager!
     * By default, async UDF execution is enabled to be able to detect UDFs that run too long / forever and be
     * able to fail fast - i.e. stop the Cassandra daemon, which is currently the only appropriate approach to
     * "tell" a user that there's something really wrong with the UDF.
     * When you disable async UDF execution, users MUST pay attention to read-timeouts since these may indicate
     * UDFs that run too long or forever - and this can destabilize the cluster.
     *
     * This requires allow_insecure_udfs to be true
     */
    // Below parameter is not presented in cassandra.yaml but to be on the safe side that no one was directly using it
    // I still added backward compatibility (CASSANDRA-15234)
    @Replaces(oldName = "enable_user_defined_functions_threads", converter = Converters.IDENTITY, deprecated = true)
    public boolean user_defined_functions_threads_enabled = true;

    /**
     * Set this to true to allow running insecure UDFs.
     */
    public boolean allow_insecure_udfs = false;

    /**
     * Set this to allow UDFs accessing java.lang.System.* methods, which basically allows UDFs to execute any arbitrary code on the system.
     */
    public boolean allow_extra_insecure_udfs = false;

    /**
     * Time in milliseconds after a warning will be emitted to the log and to the client that a UDF runs too long.
     * (Only valid, if user_defined_functions_threads_enabled==true)
     */
    //TO DO: transfer below parameter to the new config framework (DurationSpec)
    //Below parameter is in ms
    public long user_defined_function_warn_timeout = 500;
    /**
     * Time in milliseconds after a fatal UDF run-time situation is detected and action according to
     * user_function_timeout_policy will take place.
     * (Only valid, if user_defined_functions_threads_enabled==true)
     */
    //TO DO: transfer below parameter to the new config framework (DurationSpec)
    //Below parameter is in ms
    public long user_defined_function_fail_timeout = 1500;
    /**
     * Defines what to do when a UDF ran longer than user_defined_function_fail_timeout.
     * Possible options are:
     * - 'die' - i.e. it is able to emit a warning to the client before the Cassandra Daemon will shut down.
     * - 'die_immediate' - shut down C* daemon immediately (effectively prevent the chance that the client will receive a warning).
     * - 'ignore' - just log - the most dangerous option.
     * (Only valid, if user_defined_functions_threads_enabled==true)
     */
    public UserFunctionTimeoutPolicy user_function_timeout_policy = UserFunctionTimeoutPolicy.die;

    @Deprecated
    public volatile boolean back_pressure_enabled = false;
    @Deprecated
    public volatile ParameterizedClass back_pressure_strategy;

    public volatile int concurrent_validations;
    public RepairCommandPoolFullStrategy repair_command_pool_full_strategy = RepairCommandPoolFullStrategy.queue;
    public int repair_command_pool_size = concurrent_validations;

    /**
     * When a node first starts up it intially considers all other peers as DOWN and is disconnected from all of them.
     * To be useful as a coordinator (and not introduce latency penalties on restart) this node must have successfully
     * opened all three internode TCP connections (gossip, small, and large messages) before advertising to clients.
     * Due to this, by default, Casssandra will prime these internode TCP connections and wait for all but a single
     * node to be DOWN/disconnected in the local datacenter before offering itself as a coordinator, subject to a
     * timeout. See CASSANDRA-13993 and CASSANDRA-14297 for more details.
     *
     * We provide two tunables to control this behavior as some users may want to block until all datacenters are
     * available (global QUORUM/EACH_QUORUM), some users may not want to block at all (clients that already work
     * around the problem), and some users may want to prime the connections but not delay startup.
     *
     * block_for_peers_timeout_in_secs: controls how long this node will wait to connect to peers. To completely disable
     * any startup connectivity checks set this to -1. To trigger the internode connections but immediately continue
     * startup, set this to to 0. The default is 10 seconds.
     *
     * block_for_peers_in_remote_dcs: controls if this node will consider remote datacenters to wait for. The default
     * is to _not_ wait on remote datacenters.
     */
    public int block_for_peers_timeout_in_secs = 10;
    public boolean block_for_peers_in_remote_dcs = false;

    public volatile boolean automatic_sstable_upgrade = false;
    public volatile int max_concurrent_automatic_sstable_upgrades = 1;
    public boolean stream_entire_sstables = true;

    public volatile AuditLogOptions audit_logging_options = new AuditLogOptions();
    public volatile FullQueryLoggerOptions full_query_logging_options = new FullQueryLoggerOptions();

    public CorruptedTombstoneStrategy corrupted_tombstone_strategy = CorruptedTombstoneStrategy.disabled;

    public volatile boolean diagnostic_events_enabled = false;

    // Default and minimum keyspace replication factors allow validation of newly created keyspaces
    // and good defaults if no replication factor is provided by the user
    public volatile int default_keyspace_rf = 1;
    public volatile int minimum_keyspace_rf = 0;

    /**
     * flags for enabling tracking repaired state of data during reads
     * separate flags for range & single partition reads as single partition reads are only tracked
     * when CL > 1 and a digest mismatch occurs. Currently, range queries don't use digests so if
     * enabled for range reads, all such reads will include repaired data tracking. As this adds
     * some overhead, operators may wish to disable it whilst still enabling it for partition reads
     */
    public volatile boolean repaired_data_tracking_for_range_reads_enabled = false;
    public volatile boolean repaired_data_tracking_for_partition_reads_enabled = false;
    /* If true, unconfirmed mismatches (those which cannot be considered conclusive proof of out of
     * sync repaired data due to the presence of pending repair sessions, or unrepaired partition
     * deletes) will increment a metric, distinct from confirmed mismatches. If false, unconfirmed
     * mismatches are simply ignored by the coordinator.
     * This is purely to allow operators to avoid potential signal:noise issues as these types of
     * mismatches are considerably less actionable than their confirmed counterparts. Setting this
     * to true only disables the incrementing of the counters when an unconfirmed mismatch is found
     * and has no other effect on the collection or processing of the repaired data.
     */
    public volatile boolean report_unconfirmed_repaired_data_mismatches = false;
    /*
     * If true, when a repaired data mismatch is detected at read time or during a preview repair,
     * a snapshot request will be issued to each particpating replica. These are limited at the replica level
     * so that only a single snapshot per-table per-day can be taken via this method.
     */
    public volatile boolean snapshot_on_repaired_data_mismatch = false;

    /**
     * number of seconds to set nowInSec into the future when performing validation previews against repaired data
     * this (attempts) to prevent a race where validations on different machines are started on different sides of
     * a tombstone being compacted away
     */
    public volatile int validation_preview_purge_head_start_in_sec = 60 * 60;

    public boolean auth_cache_warming_enabled = false;

    // Using String instead of ConsistencyLevel here to keep static initialization from cascading and starting
    // threads during tool usage mode. See CASSANDRA-12988 and DatabaseDescriptorRefTest for details
    public volatile String auth_read_consistency_level = "LOCAL_QUORUM";
    public volatile String auth_write_consistency_level = "EACH_QUORUM";

    /** This feature allows denying access to operations on certain key partitions, intended for use by operators to
     * provide another tool to manage cluster health vs application access. See CASSANDRA-12106 and CEP-13 for more details.
     */
    public volatile boolean partition_denylist_enabled = false;

    public volatile boolean denylist_writes_enabled = true;

    public volatile boolean denylist_reads_enabled = true;

    public volatile boolean denylist_range_reads_enabled = true;

    public SmallestDurationSeconds denylist_refresh = new SmallestDurationSeconds("600s");

    public SmallestDurationSeconds denylist_initial_load_retry = new SmallestDurationSeconds("5s");

    /** We cap the number of denylisted keys allowed per table to keep things from growing unbounded. Operators will
     * receive warnings and only denylist_max_keys_per_table in natural query ordering will be processed on overflow.
     */
    public volatile int denylist_max_keys_per_table = 1000;

    /** We cap the total number of denylisted keys allowed in the cluster to keep things from growing unbounded.
     * Operators will receive warnings on initial cache load that there are too many keys and be directed to trim
     * down the entries to within the configured limits.
     */
    public volatile int denylist_max_keys_total = 10000;

    /** Since the denylist in many ways serves to protect the health of the cluster from partitions operators have identified
     * as being in a bad state, we usually want more robustness than just CL.ONE on operations to/from these tables to
     * ensure that these safeguards are in place. That said, we allow users to configure this if they're so inclined.
     */
    public ConsistencyLevel denylist_consistency_level = ConsistencyLevel.QUORUM;

    /**
     * The intial capacity for creating RangeTombstoneList.
     */
    public volatile int initial_range_tombstone_list_allocation_size = 1;
    /**
     * The growth factor to enlarge a RangeTombstoneList.
     */
    public volatile double range_tombstone_list_growth_factor = 1.5;

    /**
     * @deprecated migrate to {@link DatabaseDescriptor#isClientInitialized()}
     */
    @Deprecated
    public static boolean isClientMode()
    {
        return isClientMode;
    }

    /**
     * If true, when rows with duplicate clustering keys are detected during a read or compaction
     * a snapshot will be taken. In the read case, each a snapshot request will be issued to each
     * replica involved in the query, for compaction the snapshot will be created locally.
     * These are limited at the replica level so that only a single snapshot per-day can be taken
     * via this method.
     *
     * This requires check_for_duplicate_rows_during_reads and/or check_for_duplicate_rows_during_compaction
     * below to be enabled
     */
    public volatile boolean snapshot_on_duplicate_row_detection = false;
    /**
     * If these are enabled duplicate keys will get logged, and if snapshot_on_duplicate_row_detection
     * is enabled, the table will get snapshotted for offline investigation
     */
    public volatile boolean check_for_duplicate_rows_during_reads = true;
    public volatile boolean check_for_duplicate_rows_during_compaction = true;

    public boolean autocompaction_on_startup_enabled = Boolean.parseBoolean(System.getProperty("cassandra.autocompaction_on_startup_enabled", "true"));

    // see CASSANDRA-3200 / CASSANDRA-16274
    public volatile boolean auto_optimise_inc_repair_streams = false;
    public volatile boolean auto_optimise_full_repair_streams = false;
    public volatile boolean auto_optimise_preview_repair_streams = false;

    // see CASSANDRA-17048 and the comment in cassandra.yaml
    public boolean enable_uuid_sstable_identifiers = false;

    /**
     * Client mode means that the process is a pure client, that uses C* code base but does
     * not read or write local C* database files.
     *
     * @deprecated migrate to {@link DatabaseDescriptor#clientInitialization(boolean)}
     */
    @Deprecated
    public static void setClientMode(boolean clientMode)
    {
        isClientMode = clientMode;
    }

    @Deprecated // this warning threshold will be replaced by an equivalent guardrail
    public volatile int table_count_warn_threshold = 150;
    @Deprecated // this warning threshold will be replaced by an equivalent guardrail
    public volatile int keyspace_count_warn_threshold = 40;

    public volatile int consecutive_message_errors_threshold = 1;

    public volatile SubnetGroups client_error_reporting_exclusions = new SubnetGroups();
    public volatile SubnetGroups internode_error_reporting_exclusions = new SubnetGroups();

    public static final int DISABLED_GUARDRAIL = -1;
    public static final DataStorageSpec DISABLED_SIZE_GUARDRAIL = DataStorageSpec.inBytes(0);
    public volatile boolean guardrails_enabled = false;
    public volatile int keyspaces_warn_threshold = DISABLED_GUARDRAIL;
    public volatile int keyspaces_fail_threshold = DISABLED_GUARDRAIL;
    public volatile int tables_warn_threshold = DISABLED_GUARDRAIL;
    public volatile int tables_fail_threshold = DISABLED_GUARDRAIL;
    public volatile int columns_per_table_warn_threshold = DISABLED_GUARDRAIL;
    public volatile int columns_per_table_fail_threshold = DISABLED_GUARDRAIL;
    public volatile int secondary_indexes_per_table_warn_threshold = DISABLED_GUARDRAIL;
    public volatile int secondary_indexes_per_table_fail_threshold = DISABLED_GUARDRAIL;
    public volatile int materialized_views_per_table_warn_threshold = DISABLED_GUARDRAIL;
    public volatile int materialized_views_per_table_fail_threshold = DISABLED_GUARDRAIL;
    public volatile int page_size_warn_threshold = DISABLED_GUARDRAIL;
    public volatile int page_size_fail_threshold = DISABLED_GUARDRAIL;
    public volatile int partition_keys_in_select_warn_threshold = DISABLED_GUARDRAIL;
    public volatile int partition_keys_in_select_fail_threshold = DISABLED_GUARDRAIL;
    public volatile int in_select_cartesian_product_warn_threshold = DISABLED_GUARDRAIL;
    public volatile int in_select_cartesian_product_fail_threshold = DISABLED_GUARDRAIL;
    public volatile Set<String> table_properties_warned = Collections.emptySet();
    public volatile Set<String> table_properties_ignored = Collections.emptySet();
    public volatile Set<String> table_properties_disallowed = Collections.emptySet();
    public volatile Set<ConsistencyLevel> read_consistency_levels_warned = Collections.emptySet();
    public volatile Set<ConsistencyLevel> read_consistency_levels_disallowed = Collections.emptySet();
    public volatile Set<ConsistencyLevel> write_consistency_levels_warned = Collections.emptySet();
    public volatile Set<ConsistencyLevel> write_consistency_levels_disallowed = Collections.emptySet();
    public volatile boolean user_timestamps_enabled = true;
    public volatile boolean read_before_write_list_operations_enabled = true;
    public volatile DataStorageSpec collection_size_warn_threshold = DISABLED_SIZE_GUARDRAIL;
    public volatile DataStorageSpec collection_size_fail_threshold = DISABLED_SIZE_GUARDRAIL;
    public volatile int items_per_collection_warn_threshold = DISABLED_GUARDRAIL;
    public volatile int items_per_collection_fail_threshold = DISABLED_GUARDRAIL;
    public volatile int fields_per_udt_warn_threshold = DISABLED_GUARDRAIL;
    public volatile int fields_per_udt_fail_threshold = DISABLED_GUARDRAIL;

    public volatile DurationSpec streaming_state_expires = DurationSpec.inDays(3);
    public volatile DataStorageSpec streaming_state_size = DataStorageSpec.inMebibytes(40);

    /** The configuration of startup checks. */
    public volatile Map<StartupCheckType, Map<String, Object>> startup_checks = new HashMap<>();

    public volatile DurationSpec repair_state_expires = DurationSpec.inDays(3);
    public volatile int repair_state_size = 100_000;

    /**
     * The variants of paxos implementation and semantics supported by Cassandra.
     */
    public enum PaxosVariant
    {
        /**
         * v1 Paxos lacks most optimisations. Expect 4RTs for a write and 2RTs for a read.
         *
         * With legacy semantics for read/read and rejected write linearizability, i.e. not guaranteed.
         */
        v1_without_linearizable_reads_or_rejected_writes,

        /**
         * v1 Paxos lacks most optimisations. Expect 4RTs for a write and 3RTs for a read.
         */
        v1,

        /**
         * v2 Paxos. With PaxosStatePurging.repaired safe to use ANY Commit consistency.
         * Expect 2RTs for a write and 1RT for a read.
         *
         * With legacy semantics for read/read linearizability, i.e. not guaranteed.
         */
        v2_without_linearizable_reads,

        /**
         * v2 Paxos. With PaxosStatePurging.repaired safe to use ANY Commit consistency.
         * Expect 2RTs for a write and 1RT for a read.
         *
         * With legacy semantics for read/read and rejected write linearizability, i.e. not guaranteed.
         */
        v2_without_linearizable_reads_or_rejected_writes,

        /**
         * v2 Paxos. With PaxosStatePurging.repaired safe to use ANY Commit consistency.
         * Expect 2RTs for a write, and either 1RT or 2RT for a read.
         */
        v2
    }

    /**
     * Select the kind of paxos state purging to use. Migration to repaired is recommended, but requires that
     * regular paxos repairs are performed (which by default run as part of incremental repair).
     *
     * Once migrated from legacy it is unsafe to return to legacy, but gc_grace mode may be used in its place
     * and performs a very similar cleanup process.
     *
     * Should only be modified once paxos_variant = v2.
     */
    public enum PaxosStatePurging
    {
        /**
         * system.paxos records are written and garbage collected with TTLs. Unsafe to use with Commit consistency ANY.
         * Once migrated from, cannot be migrated back to safely. Must use gc_grace or repaired instead, as TTLs
         * will not have been set.
         */
        legacy,

        /**
         * Functionally similar to legacy, but the gc_grace expiry is applied at compaction and read time rather than
         * using TTLs, so may be safely enabled at any point.
         */
        gc_grace,

        /**
         * Clears system.paxos records only once they are known to be persisted to a quorum of replica's base tables
         * through the use of paxos repair. Requires that regular paxos repairs are performed on the cluster
         * (which by default are included in incremental repairs if paxos_variant = v2).
         *
         * This setting permits the use of Commit consistency ANY or LOCAL_QUORUM without any loss of durability or consistency,
         * saving 1 RT.
         */
        repaired;

        public static PaxosStatePurging fromBoolean(boolean enabled)
        {
            return enabled ? repaired : gc_grace;
        }
    }

    /**
     * See {@link PaxosVariant}. Defaults to v1, recommend upgrading to v2 at earliest opportunity.
     */
    public volatile PaxosVariant paxos_variant = PaxosVariant.v1;

    /**
     * If true, paxos topology change repair will not run on a topology change - this option should only be used in
     * rare operation circumstances e.g. where for some reason the repair is impossible to perform (e.g. too few replicas)
     * and an unsafe topology change must be made
     */
    public volatile boolean skip_paxos_repair_on_topology_change = Boolean.getBoolean("cassandra.skip_paxos_repair_on_topology_change");

    /**
     * A safety margin when purging paxos state information that has been safely replicated to a quorum.
     * Data for transactions initiated within this grace period will not be expunged.
     */
    public volatile DurationSpec paxos_purge_grace_period = new SmallestDurationSeconds("60s");

    /**
     * A safety mechanism for detecting incorrect paxos state, that may be down either to a bug or incorrect usage of LWTs
     * (most likely due to unsafe mixing of SERIAL and LOCAL_SERIAL operations), and rejecting
     */
    public enum PaxosOnLinearizabilityViolation
    {
        // reject an operation when a linearizability violation is detected.
        // note this does not guarantee a violation has been averted,
        // as it may be a prior operation that invalidated the state.
        fail,
        // log any detected linearizability violation
        log,
        // ignore any detected linearizability violation
        ignore
    }

    /**
     * See {@link PaxosOnLinearizabilityViolation}.
     *
     * Default is to ignore, as applications may readily mix SERIAL and LOCAL_SERIAL and this is the most likely source
     * of linearizability violations. this facility should be activated only for debugging Cassandra or by power users
     * who are investigating their own application behaviour.
     */
    public volatile PaxosOnLinearizabilityViolation paxos_on_linearizability_violations = PaxosOnLinearizabilityViolation.ignore;

    /**
     * See {@link PaxosStatePurging} default is legacy.
     */
    public volatile PaxosStatePurging paxos_state_purging;

    /**
     * Enable/disable paxos repair. This is a global flag that not only determines default behaviour but overrides
     * explicit paxos repair requests, paxos repair on topology changes and paxos auto repairs.
     */
    public volatile boolean paxos_repair_enabled = true;

    /**
     * If true, paxos topology change repair only requires a global quorum of live nodes. If false,
     * it requires a global quorum as well as a local quorum for each dc (EACH_QUORUM), with the
     * exception explained in paxos_topology_repair_strict_each_quorum
     */
    public boolean paxos_topology_repair_no_dc_checks = false;

    /**
     * If true, a quorum will be required for the global and local quorum checks. If false, we will
     * accept a quorum OR n - 1 live nodes. This is to allow for topologies like 2:2:2, where paxos queries
     * always use SERIAL, and a single node down in a dc should not preclude a paxos repair
     */
    public boolean paxos_topology_repair_strict_each_quorum = false;

    /**
     * If necessary for operational purposes, permit certain keyspaces to be ignored for paxos topology repairs
     */
    public volatile Set<String> skip_paxos_repair_on_topology_change_keyspaces = splitCommaDelimited(System.getProperty("cassandra.skip_paxos_repair_on_topology_change_keyspaces"));

    /**
     * See {@link org.apache.cassandra.service.paxos.ContentionStrategy}
     */
    public String paxos_contention_wait_randomizer;

    /**
     * See {@link org.apache.cassandra.service.paxos.ContentionStrategy}
     */
    public String paxos_contention_min_wait;

    /**
     * See {@link org.apache.cassandra.service.paxos.ContentionStrategy}
     */
    public String paxos_contention_max_wait;

    /**
     * See {@link org.apache.cassandra.service.paxos.ContentionStrategy}
     */
    public String paxos_contention_min_delta;

    /**
     * The amount of disk space paxos uncommitted key files can consume before we begin automatically scheduling paxos repairs.
     * Note that these repairs are uncoordinated and so do not contribute to expunging system.paxos records.
     */
    public volatile int paxos_auto_repair_threshold_mb = 32;

    /**
     * The number of keys we may simultaneously attempt to finish incomplete paxos operations for.
     */
    public volatile int paxos_repair_parallelism = -1;

    public static Supplier<Config> getOverrideLoadConfig()
    {
        return overrideLoadConfig;
    }

    public static void setOverrideLoadConfig(Supplier<Config> loadConfig)
    {
        overrideLoadConfig = loadConfig;
    }

    public enum CommitLogSync
    {
        periodic,
        batch,
        group
    }

    public enum FlushCompression
    {
        none,
        fast,
        table
    }

    public enum InternodeCompression
    {
        all, none, dc
    }

    public enum DiskAccessMode
    {
        auto,
        mmap,
        mmap_index_only,
        standard,
    }

    public enum MemtableAllocationType
    {
        unslabbed_heap_buffers,
        unslabbed_heap_buffers_logged,
        heap_buffers,
        offheap_buffers,
        offheap_objects
    }

    public enum DiskFailurePolicy
    {
        best_effort,
        stop,
        ignore,
        stop_paranoid,
        die
    }

    public enum CommitFailurePolicy
    {
        stop,
        stop_commit,
        ignore,
        die,
    }

    public enum UserFunctionTimeoutPolicy
    {
        ignore,
        die,
        die_immediate
    }

    public enum DiskOptimizationStrategy
    {
        ssd,
        spinning
    }

    public enum RepairCommandPoolFullStrategy
    {
        queue,
        reject
    }

    public enum CorruptedTombstoneStrategy
    {
        disabled,
        warn,
        exception
    }

    private static final List<String> SENSITIVE_KEYS = new ArrayList<String>() {{
        add("client_encryption_options");
        add("server_encryption_options");
    }};

    public static void log(Config config)
    {
        Map<String, String> configMap = new TreeMap<>();
        for (Field field : Config.class.getFields())
        {
            // ignore the constants
            if (Modifier.isFinal(field.getModifiers()))
                continue;

            String name = field.getName();
            if (SENSITIVE_KEYS.contains(name))
            {
                configMap.put(name, "<REDACTED>");
                continue;
            }

            String value;
            try
            {
                // Field.get() can throw NPE if the value of the field is null
                value = field.get(config).toString();
            }
            catch (NullPointerException | IllegalAccessException npe)
            {
                value = "null";
            }
            configMap.put(name, value);
        }

        logger.info("Node configuration:[{}]", Joiner.on("; ").join(configMap.entrySet()));
    }
}


text:
		Unesp Foundation - Documentação

Utilização

Introdução

Estrutura

Media Queries

Visibilidade

Grid

Block Grid

Classes Utilitárias

Utilitários JavaScript

Navegação

Off-canvas JS

Top Bar JS


text:
#include "postgres.h"
#include "fmgr.h"

#include "access/reloptions.h"
#include "catalog/catquery.h"
#include "catalog/pg_attribute_encoding.h"
#include "catalog/pg_compression.h"
#include "catalog/dependency.h"
#include "parser/analyze.h"
#include "utils/builtins.h"
#include "utils/datum.h"
#include "utils/fmgroids.h"
#include "utils/formatting.h"
#include "utils/lsyscache.h"
#include "utils/rel.h"
#include "utils/relcache.h"
#include "utils/syscache.h"

/*
 * Add a single attribute encoding entry.
 */
static void
add_attribute_encoding_entry(Oid relid, AttrNumber attnum, Datum attoptions)
{
	Datum values[Natts_pg_attribute_encoding];
	bool nulls[Natts_pg_attribute_encoding];
	HeapTuple tuple;
	cqContext	   *pcqCtx;

	Insist(attnum != InvalidAttrNumber);

	pcqCtx = caql_beginscan(
			NULL,
			cql("INSERT INTO pg_attribute_encoding",
				NULL));

	MemSet(nulls, 0, sizeof(nulls));
	values[Anum_pg_attribute_encoding_attrelid - 1] = ObjectIdGetDatum(relid);
	values[Anum_pg_attribute_encoding_attnum - 1] = Int16GetDatum(attnum);
	values[Anum_pg_attribute_encoding_attoptions - 1] = attoptions;

	tuple = caql_form_tuple(pcqCtx, values, nulls);

	/* insert a new tuple */
	caql_insert(pcqCtx, tuple); /* implicit update of index as well */

	heap_freetuple(tuple);

	caql_endscan(pcqCtx);
}

/*
 * Get the set of functions implementing a compression algorithm.
 *
 * Intercept requests for "none", since that is not a real compression
 * implementation but a fake one to indicate no compression desired.
 */
PGFunction *
get_funcs_for_compression(char *compresstype)
{
	PGFunction *func = NULL;

	if (compresstype == NULL ||
		compresstype[0] == '\0' ||
		pg_strcasecmp("none", compresstype) == 0)
	{
		return func;
	}
	else
	{
		func = GetCompressionImplementation(compresstype);

		Insist(PointerIsValid(func));
	}
	return func;
}

/*
 * Get datum representations of the attoptions field in pg_attribute_encoding
 * for the given relation.
 */
Datum *
get_rel_attoptions(Oid relid, AttrNumber max_attno)
{
	Form_pg_attribute attform;
	HeapTuple		tuple;
	cqContext		cqc;
	cqContext	   *pcqCtx;
	Datum		   *dats;
	Relation 		pgae = heap_open(AttributeEncodingRelationId,
									 AccessShareLock);

	/* used for attbyval and len below */
	attform = pgae->rd_att->attrs[Anum_pg_attribute_encoding_attoptions - 1];

	dats = palloc0(max_attno * sizeof(Datum));

	pcqCtx = caql_beginscan(
			caql_addrel(cqclr(&cqc), pgae),
			cql("SELECT * FROM pg_attribute_encoding "
				" WHERE attrelid = :1 ",
				ObjectIdGetDatum(relid)));

	while (HeapTupleIsValid(tuple = caql_getnext(pcqCtx)))
	{
		Form_pg_attribute_encoding a =
			(Form_pg_attribute_encoding)GETSTRUCT(tuple);
		int16 attnum = a->attnum;
		Datum attoptions;
		bool isnull;

		Insist(attnum > 0 && attnum <= max_attno);

		attoptions = heap_getattr(tuple, Anum_pg_attribute_encoding_attoptions,
								  RelationGetDescr(pgae), &isnull);
		Insist(!isnull);

		dats[attnum - 1] = datumCopy(attoptions,
									 attform->attbyval,
									 attform->attlen);
	}

	caql_endscan(pcqCtx);

	heap_close(pgae, AccessShareLock);

	return dats;

}

/*
 * Add pg_attribute_encoding entries for newrelid. Make them identical to those
 * stored for oldrelid.
 */
void
cloneAttributeEncoding(Oid oldrelid, Oid newrelid, AttrNumber max_attno)
{
	Datum *attoptions = get_rel_attoptions(oldrelid, max_attno);
	AttrNumber n;

	for (n = 0; n < max_attno; n++)
	{
		if (DatumGetPointer(attoptions[n]) != NULL)
			add_attribute_encoding_entry(newrelid,
										 n + 1,
										 attoptions[n]);
	}
	CommandCounterIncrement();
}

List **
RelationGetUntransformedAttributeOptions(Relation rel)
{
	List **l;
	int i;
	Datum *dats = get_rel_attoptions(RelationGetRelid(rel),
									 RelationGetNumberOfAttributes(rel));

	l = palloc0(RelationGetNumberOfAttributes(rel) * sizeof(List *));

	for (i = 0; i < RelationGetNumberOfAttributes(rel); i++)
	{
		l[i] = untransformRelOptions(dats[i]);
	}

	return l;
}

/*
 * Get all storage options for all user attributes of the table.
 */
StdRdOptions **
RelationGetAttributeOptions(Relation rel)
{
	Datum *dats;
	StdRdOptions **opts;
	int i;

	opts = palloc0(RelationGetNumberOfAttributes(rel) * sizeof(StdRdOptions *));

	dats = get_rel_attoptions(RelationGetRelid(rel),
							  RelationGetNumberOfAttributes(rel));

	for (i = 0; i < RelationGetNumberOfAttributes(rel); i++)
	{
		if (DatumGetPointer(dats[i]) != NULL)
		{
			opts[i] = (StdRdOptions *)heap_reloptions(
					RELKIND_RELATION, dats[i], false);
			pfree(DatumGetPointer(dats[i]));
		}
	}
	pfree(dats);

	return opts;
}

/*
 * Return an array of compression function arrays for
 * each attribute in a table.
 *
 * Set NULL for columns without storage options.
 */
PGFunction **
RelationGetColumnCompressionFuncs(Relation rel)
{
	StdRdOptions  **opts = RelationGetAttributeOptions(rel);
	PGFunction	  **funcs = palloc0(RelationGetNumberOfAttributes(rel)
									* sizeof(PGFunction *));
	int 			i;

	for (i = 0; i < RelationGetNumberOfAttributes(rel); i++)
	{
		if (opts[i])
		{
			funcs[i] = get_funcs_for_compression(opts[i]->compresstype);
		}
	}
	return funcs;
}

/*
 * Given a WITH(...) clause and no other column encoding directives -- such as
 * in the case of CREATE TABLE WITH () AS SELECT -- fill in the column encoding
 * catalog entries for that relation.
 */
void
AddDefaultRelationAttributeOptions(Relation rel, List *options)
{
	Datum opts;
	AttrNumber attno;
	List *ce;

	/* only supported on AOCO at this stage */
	if (!RelationIsAoCols(rel))
		return;

 	ce = form_default_storage_directive(options);
	if (!ce)
		ce = default_column_encoding_clause();

	ce = transformStorageEncodingClause(ce);

	opts = transformRelOptions(PointerGetDatum(NULL), ce, true, false);

	for (attno = 1; attno <= RelationGetNumberOfAttributes(rel); attno++)
		add_attribute_encoding_entry(RelationGetRelid(rel),
									 attno,
									 opts);
	CommandCounterIncrement();
}

/*
 * Work horse underneath DefineRelation().
 *
 * Simply adds user specified ENCODING () clause information to
 * pg_attribute_encoding. Should be absolutely valid at this point.
 */
void
AddRelationAttributeEncodings(Relation rel, List *attr_encodings)
{
	Oid relid = RelationGetRelid(rel);
	ListCell *lc;

	foreach(lc, attr_encodings)
	{
		Datum attoptions;
		ColumnReferenceStorageDirective *c = lfirst(lc);
		List *encoding;
		AttrNumber attnum;

		Insist(IsA(c, ColumnReferenceStorageDirective));

		attnum = get_attnum(relid, c->column);

		if (attnum == InvalidAttrNumber)
			elog(ERROR, "column \"%s\" does not exist", c->column);

		if (attnum < 0)
			elog(ERROR, "column \"%s\" is a system column", c->column);

		encoding = c->encoding;

		if (!encoding)
			continue;

		attoptions = transformRelOptions(PointerGetDatum(NULL),
										 encoding,
										 true,
										 false);

		add_attribute_encoding_entry(relid, attnum, attoptions);
	}
}

void
RemoveAttributeEncodingsByRelid(Oid relid)
{
	bool 		found = false;

	found = (0 != caql_getcount(
					 NULL,
					 cql("DELETE FROM pg_attribute_encoding "
						 " WHERE attrelid = :1 ",
						 ObjectIdGetDatum(relid))));
}


text:
Script: OTA updater
===================

This script will allow you to send an OTA update to your device.

## Installation

`pip install -r requirements.txt`

## Usage

```text
usage: ota_updater.py [-h] -l BROKER_HOST -p BROKER_PORT [-u BROKER_USERNAME]
                      [-d BROKER_PASSWORD] [-t BASE_TOPIC] -i DEVICE_ID
                      firmware

ota firmware update scirpt for ESP8226 implemenation of the Homie mqtt IoT
convention.

positional arguments:
  firmware              path to the firmware to be sent to the device

arguments:
  -h, --help            show this help message and exit
  -l BROKER_HOST, --broker-host BROKER_HOST
                        host name or ip address of the mqtt broker
  -p BROKER_PORT, --broker-port BROKER_PORT
                        port of the mqtt broker
  -u BROKER_USERNAME, --broker-username BROKER_USERNAME
                        username used to authenticate with the mqtt broker
  -d BROKER_PASSWORD, --broker-password BROKER_PASSWORD
                        password used to authenticate with the mqtt broker
  -t BASE_TOPIC, --base-topic BASE_TOPIC
                        base topic of the homie devices on the broker
  -i DEVICE_ID, --device-id DEVICE_ID
                        homie device id
```

* `BROKER_HOST` and `BROKER_PORT` defaults to 127.0.0.1 and 1883 respectively if not set.
* `BROKER_USERNAME` and `BROKER_PASSWORD` are optional.
* `BASE_TOPIC` has to end with a slash, defaults to `homie/` if not set.

### Example:

```bash
python ota_updater.py -l localhost -u admin -d secure -t "homie/" -i "device-id" /path/to/firmware.bin
```


text:
We have encountered CM-Well clients that manage an internal queue for write requests to CM-Well. The internal queue often ends up being a performance bottleneck, especially for queue packages with persistent storage like Apache Kafka. Using a queue that's internal to the client is unnecessary, as CM-Well manages its own request queues. In the rare case where a write request receives a 504 HTTP error ("gateway timeout"), the best practice is to perform a brief sleep and retry the request.

Similarly, there is no need to use a client queue to store read requests, and again, doing so may create a performance bottleneck. For bulk read operations, the best practice is to use CM-Well's **consume** or **bulk-consume** APIs. In case of an error during the read process, to ensure that no data was lost, simply resume reading while supplying the position token you received from the last successful read.

### Don't Use the CM-Well Prefix in Triples/Quads Data

When you direct a query to CM-Well, you provide the HTTP address of the CM-Well environment you're targeting as the host name. For example, the following query is directed to the CM-Well pre-production environment:

    <cm-well-host>?op=search&qp=type.rdf:http://data.com/Person&recursive

However, when you provide triple/quad data to upload to CM-Well, neither the explicit host name (perhaps "cm-well-ppe.int.thomsonreuters.com", "cm-well-prod.int.thomsonreuters.com", etc.) nor the "virtual" host name ("cmwell://") should appear **in the data** (although it still appears as the host name parameter). CM-Well infoton URIs shold be provided in their "relative path" form, which is "http://" followed by the path under the CM-Well root.

For example:

    <http://example.org/Individuals/FredFredson> a <http://data.com/Person>.

The path `http://example.org/Individuals/FredFredson` is then mapped to the full path, as appropriate for the specific CM-Well host, e.g. `<cm-well-host>/example.org/Individuals/FredFredson` for the production environment, `<cm-well-host>/example.org/Individuals/FredFredson` for the PPE environment, and so on.

Using an explicit or virtual CM-Well path in uploaded data may result in the creation of unexpected path names.

**Don't** provide triples/quad data such as:

    <cmwell://example.org/Individuals/FredFredson> a <http://data.com/Person>.
    <cmwell/example.org/Individuals/FredFredson> a <http://data.com/Person>.

### Don't Mix URL-Encoded and Non-Encoded Characters in the Same SPARQL Query

If you need to include non-English characters in a SPARQL query (including the PATHS sections), add the `Content Type: text/plain;charset=utf-8` header to the HTTP request. If you choose to URL-encode the non-English characters, make sure to encode *all* of them (don't mix URL-encoded and non-encoded characters in the same query). This is because once CM-Well detects URL-encoding, it will assume that all characters are URL-encoded.

**Examples:**

Encode *all* non-English characters:

    curl -X POST <cm-well-host>/_sp?format=json -H "Content-Type:text/plain;charset=utf-8" --data-binary 'PATHS
    /data.com?op=search&qp=*[organizationNameLocalAka.fedapioa:%D0%9E%D0%A2%D0%9A%D0%A0%D0%AB%D0%A2%D0%9E%D0%95%20%D0%90%D0%9A%D0%A6%D0%98%D0%9E%D0%9D%D0%95%D0%A0%D0%9D%D0%9E%D0%95%20%D0%9E%D0%91%D0%A9%D0%95%D0%A1%D0%A2%D0%92%D0%9E]&xg=1&with-data&length=100

    SPARQL
    SELECT * WHERE { ?s ?p ?o }'

Encode *no* non-English characters:

    curl -X POST <cm-well-host>/_sp?format=json -H "Content-Type:text/plain;charset=utf-8" --data-binary 'PATHS
    /data.com?op=search&qp=*[organizationNameLocalAka.fedapioa:ОТКРЫТОЕ АКЦИОНЕРНОЕ ОБЩЕСТВО]&xg=1&with-data&length=100

    SPARQL
    SELECT * WHERE { ?s ?p ?o }'

### Don't Use Blank Nodes

Several types of RDF notation support **blank nodes** (also known as **bnodes**;  resources represented by blank nodes are also called **anonymous resources**). These are RDF nodes that have no defined URI. (see the [Wikipedia Blank Node entry](https://en.wikipedia.org/wiki/Blank_node) to learn more.) It's possible to define a temporary ID for the node such as **x**. However, such temporary identifiers are limited in scope only to a serialization of a particular RDF graph.

While supported in certain notations (RDF/XML, RDFa, Turtle, N3 and N-Triples) and providing short term convenience for defining complex structures and for protecting sensitive information from browser access, as a rule **using blank nodes is considered bad practice when working with large linked data stores like CM-Well, and is therefore discouraged**. Best practice for linked data is to produce reusable, permanent URIs for objects.

Disadvantages of using blank nodes include:

* They're limited to the document in which they appear.
* They reduce the potential for interlinking between different linked data sources.
* They make it much more difficult to merge data from different sources.

CM-Well does not support blank nodes in its own data, and therefore when it encounters one, it creates an arbitrary URI for it. Since this is the case, we recommend not using blank nodes in data you intend to upload to CM-Well, and instead creating an informative URI for the relevant node, such as one containing a hash of its field values.

## Dos

### Use Correct Syntax in Windows/Unix Command-Line

If you're using the Curl command-line utility to submit calls to CM-Well, you may encounter syntax errors that arise from differences between the command-line syntax for Windows and for Unix operating systems. See [Using the Curl Utility to Call CM-Well](DevGuide.CurlUtility.md) to learn more.

### Minimize the Number of Infoton Fields

Sometimes infoton fields contain links to other infotons, in order to express a relationship between two entities. For example, an infoton representing a company might refer to another company infoton as its parent company, or its supplier.

However, if you find you're creating many such infoton link fields in one infoton, you should consider creating intermediate objects that encapsulate several fields.

For example, instead of a company infoton that contains 5 SuppliesTo fields and 4 SuppliedBy fields, you can create a SupplierRelationship object that contains all 9 relationships, and refer to it in a single field of the company infoton.

This is better for CM-Well performance because:

* Multiple inbound/outbound links in one infoton can result in long processing times for queries that traverse these links. Such calls may even time out.
* Because of CM-Well's "immutable data" principle, every update of an infoton creates a new copy of the infoton. The more fields it has, the more storage these copies use. In the case of relationships that are relatively static over time, this is unnecessary and avoidable.

### Leave %50-%60 of Disk Space Free on a CM-Well Node

When using a CM-Well node in an operational or near-operational scenario, make sure that about %50-%60 of free disk space is maintained. This is because storage maintenance operations that CM-Well performs may temporarily use large amounts of disk space.

This recommendation is also relevant for installations of CM-Well Docker that are run in near-operational conditions.


text:
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const main_1 = require("./main");
const httpAddr = '0.0.0.0:8500';
describe('consul', () => {
    it('info', () => {
        const options = new main_1.Options(
        /* httpAddr */ httpAddr,
        /* currentWorkingDirectory */ null);
        const consul = new main_1.Consul(options);
        return consul.command('info').then((data) => {
            //console.log('data = ', util.inspect(data, { depth: 10 }));
            expect(data).toBeDefined();
        });
    });
    it('info with callback', () => {
        const options = new main_1.Options(
        /* httpAddr */ httpAddr,
        /* currentWorkingDirectory */ null);
        const consul = new main_1.Consul(options);
        return consul.command('info', '', (err, data) => {
            //console.log('data = ', util.inspect(data, { depth: 10 }));
            expect(data).toBeDefined();
        });
    });
    it('members', () => {
        const options = new main_1.Options(
        /* httpAddr */ httpAddr,
        /* currentWorkingDirectory */ null);
        const consul = new main_1.Consul(options);
        return consul.command('members').then((data) => {
            //console.log('data = ', util.inspect(data, { depth: 10 }));
            expect(data).toBeDefined();
            expect(data.members).toBeDefined();
        });
    });
    // it('join', () => {
    //   const options = new Options(
    //     /* httpAddr */ httpAddr,
    //     /* currentWorkingDirectory */ null,
    //   );
    //   const consul = new Consul(options);
    //   return consul.command('join', '0.0.0.0').then( (data) => {
    //     console.log('data = ', util.inspect(data, { depth: 10 }));
    //     expect(data).toBeDefined();
    //   });
    // });
});
//# sourceMappingURL=main.spec.js.map