void SystemProperties::processProperty()

in cppcache/src/SystemProperties.cpp [257:357]
98 lines of code
42 McCabe index (conditional complexity)

void SystemProperties::processProperty(const std::string& property,
                                       const std::string& value) {
  if (property.compare(0, sizeof(DefaultSecurityPrefix) - 1,
                       DefaultSecurityPrefix) == 0) {
    m_securityPropertiesPtr->insert(property, value);

    if (property == SecurityClientDhAlgo) {
      throw IllegalArgumentException(
          "Diffie-Hellman based credentials encryption is not supported.");
    } else if (property == SecurityClientKsPath) {
      m_securityClientKsPath = value;
    }

    return;
  }

  if (property == ThreadPoolSize) {
    m_threadPoolSize = std::stoul(value);
  } else if (property == MaxSocketBufferSize) {
    m_maxSocketBufferSize = std::stol(value);
  } else if (property == PingInterval) {
    parseDurationProperty(property, std::string(value), m_pingInterval);
  } else if (property == RedundancyMonitorInterval) {
    parseDurationProperty(property, std::string(value),
                          m_redundancyMonitorInterval);
  } else if (property == NotifyAckInterval) {
    parseDurationProperty(property, std::string(value), m_notifyAckInterval);
  } else if (property == NotifyDupCheckLife) {
    parseDurationProperty(property, std::string(value), m_notifyDupCheckLife);
  } else if (property == StatisticsSampleInterval) {
    parseDurationProperty(property, std::string(value),
                          m_statisticsSampleInterval);
  } else if (property == DurableTimeout) {
    parseDurationProperty(property, std::string(value), m_durableTimeout);
  } else if (property == ConnectTimeout) {
    parseDurationProperty(property, std::string(value), m_connectTimeout);
  } else if (property == ConnectWaitTimeout) {
    parseDurationProperty(property, std::string(value), m_connectWaitTimeout);
  } else if (property == BucketWaitTimeout) {
    parseDurationProperty(property, std::string(value), m_bucketWaitTimeout);
  } else if (property == DisableShufflingEndpoint) {
    m_disableShufflingEndpoint = parseBooleanProperty(property, value);
  } else if (property == AutoReadyForEvents) {
    m_autoReadyForEvents = parseBooleanProperty(property, value);
  } else if (property == SslEnabled) {
    m_sslEnabled = parseBooleanProperty(property, value);
  } else if (property == TimeStatisticsEnabled) {
    m_timestatisticsEnabled = parseBooleanProperty(property, value);
  } else if (property == StatisticsEnabled) {
    m_statisticsEnabled = parseBooleanProperty(property, value);
  } else if (property == StatisticsArchiveFile) {
    m_statisticsArchiveFile = value;
  } else if (property == LogFilename) {
    m_logFilename = value;
  } else if (property == LogLevelProperty) {
    try {
      m_logLevel = Log::charsToLevel(value);
    } catch (IllegalArgumentException&) {
      throwError(
          ("SystemProperties: unknown log level " + property + "=" + value));
    }
  } else if (property == ConnectionPoolSize) {
    m_connectionPoolSize = std::stol(value);
  } else if (property == Name) {
    m_name = value;
  } else if (property == DurableClientId) {
    m_durableClientId = value;
  } else if (property == SslKeyStore) {
    m_sslKeyStore = value;
  } else if (property == SslTrustStore) {
    m_sslTrustStore = value;
  } else if (property == SslKeystorePassword) {
    m_sslKeystorePassword = value;
  } else if (property == ConflateEvents) {
    m_conflateEvents = value;
  } else if (property == CacheXMLFile) {
    m_cacheXMLFile = value;
  } else if (property == LogFileSizeLimit) {
    m_logFileSizeLimit = std::stol(value);
  } else if (property == LogDiskSpaceLimit) {
    m_logDiskSpaceLimit = std::stol(value);
  } else if (property == StatsFileSizeLimit) {
    m_statsFileSizeLimit = std::stol(value);
  } else if (property == StatsDiskSpaceLimit) {
    m_statsDiskSpaceLimit = std::stol(value);
  } else if (property == HeapLRULimit) {
    m_heapLRULimit = std::stol(value);
  } else if (property == HeapLRUDelta) {
    m_heapLRUDelta = std::stol(value);
  } else if (property == SuspendedTxTimeout) {
    parseDurationProperty(property, std::string(value), m_suspendedTxTimeout);
  } else if (property == TombstoneTimeoutInMSec) {
    parseDurationProperty(property, std::string(value), m_tombstoneTimeout);
  } else if (property == EnableChunkHandlerThread) {
    m_enableChunkHandlerThread = parseBooleanProperty(property, value);
  } else if (property == OnClientDisconnectClearPdxTypeIds) {
    m_onClientDisconnectClearPdxTypeIds = parseBooleanProperty(property, value);
  } else {
    throwError("SystemProperties: unknown property: " + property + "=" + value);
  }
}