[nifi-minifi-cpp] branch main updated: MINIFICPP-2094 Change validators from shared to raw pointers

szaszm Mon, 17 Apr 2023 16:38:16 -0700

This is an automated email from the ASF dual-hosted git repository.

szaszm pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/nifi-minifi-cpp.git



The following commit(s) were added to refs/heads/main by this push:
     new 76f72ec3a MINIFICPP-2094 Change validators from shared to raw pointers
76f72ec3a is described below

commit 76f72ec3a67300f282bbb506c3a9612c1fcbecaa
Author: Ferenc Gerlits <[email protected]>
AuthorDate: Tue Apr 18 01:18:52 2023 +0200

    MINIFICPP-2094 Change validators from shared to raw pointers
    
    Closes #1553
    Signed-off-by: Marton Szasz <[email protected]>
---
 extensions/civetweb/processors/ListenHTTP.cpp      |   2 +-
 extensions/gps/GetGPS.cpp                          |  18 +-
 .../libarchive/BinFilesStaticDefinitions.cpp       |   6 +-
 extensions/librdkafka/ConsumeKafka.cpp             |   4 -
 extensions/librdkafka/ConsumeKafka.h               |   4 +-
 .../librdkafka/KafkaProcessorStaticDefinitions.cpp |   6 +-
 .../SourceInitiatedSubscriptionListener.cpp        |   2 +-
 .../splunk/SplunkHECProcessorStaticDefinitions.cpp |   2 +-
 .../processors/DefragmentText.cpp                  |   2 +-
 .../processors/ListenSyslog.cpp                    |   2 +-
 .../standard-processors/processors/ListenTCP.cpp   |   2 +-
 .../standard-processors/processors/ListenUDP.cpp   |   2 +-
 .../processors/RetryFlowFile.cpp                   |   2 +-
 libminifi/include/core/CachedValueValidator.h      |  54 +---
 libminifi/include/core/Property.h                  |  10 +-
 libminifi/include/core/PropertyBuilder.h           |  41 ++--
 libminifi/include/core/PropertyValidation.h        | 273 ++++++++++-----------
 libminifi/include/core/PropertyValue.h             |  18 +-
 .../include/core/state/nodes/AgentInformation.h    |   6 +-
 libminifi/include/properties/Configuration.h       |   2 +-
 libminifi/src/Configuration.cpp                    | 260 ++++++++++----------
 libminifi/src/core/Property.cpp                    |  17 +-
 libminifi/src/core/PropertyValidation.cpp          |  46 ----
 libminifi/src/properties/Properties.cpp            |  12 +-
 libminifi/test/unit/PropertyValidationTests.cpp    |   5 +-
 25 files changed, 347 insertions(+), 451 deletions(-)

diff --git a/extensions/civetweb/processors/ListenHTTP.cpp 
b/extensions/civetweb/processors/ListenHTTP.cpp
index 02e8d543e..ee30ce336 100644
--- a/extensions/civetweb/processors/ListenHTTP.cpp
+++ b/extensions/civetweb/processors/ListenHTTP.cpp
@@ -44,7 +44,7 @@ const core::Property ListenHTTP::Port(
     core::PropertyBuilder::createProperty("Listening Port")
         ->withDescription("The Port to listen on for incoming connections. 0 
means port is going to be selected randomly.")
         ->isRequired(true)
-        ->withDefaultValue<int>(80, 
core::StandardValidators::get().LISTEN_PORT_VALIDATOR)->build());
+        ->withDefaultValue<int>(80, 
core::StandardValidators::LISTEN_PORT_VALIDATOR)->build());
 
 const core::Property ListenHTTP::AuthorizedDNPattern("Authorized DN Pattern", 
"A Regular Expression to apply against the Distinguished Name of incoming"
                                                " connections. If the Pattern 
does not match the DN, the connection will be refused.",
diff --git a/extensions/gps/GetGPS.cpp b/extensions/gps/GetGPS.cpp
index 63f0a4b43..519e84818 100644
--- a/extensions/gps/GetGPS.cpp
+++ b/extensions/gps/GetGPS.cpp
@@ -37,17 +37,13 @@
 #include "core/PropertyValidation.h"
 #include "core/Resource.h"
 
-namespace org {
-namespace apache {
-namespace nifi {
-namespace minifi {
-namespace processors {
+namespace org::apache::nifi::minifi::processors {
 
 const core::Relationship GetGPS::Success("success", "All files are routed to 
success");
 
 const core::Property 
GetGPS::GPSDHost(core::PropertyBuilder::createProperty("GPSD 
Host")->withDescription("The host running the GPSD 
daemon")->withDefaultValue<std::string>("localhost")->build());
 const core::Property GetGPS::GPSDPort(
-    core::PropertyBuilder::createProperty("GPSD Port")->withDescription("The 
GPSD daemon port")->withDefaultValue<int64_t>(2947, 
core::StandardValidators::get().PORT_VALIDATOR)->build());
+    core::PropertyBuilder::createProperty("GPSD Port")->withDescription("The 
GPSD daemon port")->withDefaultValue<int64_t>(2947, 
core::StandardValidators::PORT_VALIDATOR)->build());
 const core::Property GetGPS::GPSDWaitTime(
     core::PropertyBuilder::createProperty("GPSD Wait 
Time")->withDescription("Timeout value for waiting for data from the GPSD 
instance")->withDefaultValue<uint64_t>(50000000)->build());
 
@@ -83,7 +79,7 @@ void GetGPS::onTrigger(const 
std::shared_ptr<core::ProcessContext>& /*context*/,
   try {
     gpsmm gps_rec(gpsdHost_.c_str(), gpsdPort_.c_str());
 
-    if (gps_rec.stream(WATCH_ENABLE | WATCH_JSON) == NULL) {
+    if (gps_rec.stream(WATCH_ENABLE | WATCH_JSON) == nullptr) {
       logger_->log_error("No GPSD running.");
       return;
     }
@@ -94,7 +90,7 @@ void GetGPS::onTrigger(const 
std::shared_ptr<core::ProcessContext>& /*context*/,
       if (!gps_rec.waiting(gpsdWaitTime_))
         continue;
 
-      if ((gpsdata = gps_rec.read()) == NULL) {
+      if ((gpsdata = gps_rec.read()) == nullptr) {
         logger_->log_error("Read error");
         return;
       } else {
@@ -146,8 +142,4 @@ void GetGPS::onTrigger(const 
std::shared_ptr<core::ProcessContext>& /*context*/,
 
 REGISTER_RESOURCE(GetGPS, Processor);
 
-} /* namespace processors */
-} /* namespace minifi */
-} /* namespace nifi */
-} /* namespace apache */
-} /* namespace org */
+}  // namespace org::apache::nifi::minifi::processors
diff --git a/extensions/libarchive/BinFilesStaticDefinitions.cpp 
b/extensions/libarchive/BinFilesStaticDefinitions.cpp
index 45a636184..7cc6d03bd 100644
--- a/extensions/libarchive/BinFilesStaticDefinitions.cpp
+++ b/extensions/libarchive/BinFilesStaticDefinitions.cpp
@@ -34,7 +34,7 @@ const core::Property BinFiles::MinSize(
 const core::Property BinFiles::MaxSize(
     core::PropertyBuilder::createProperty("Maximum Group Size")
     ->withDescription("The maximum size for the bundle. If not specified, 
there is no maximum.")
-    
->withType(core::StandardValidators::get().UNSIGNED_LONG_VALIDATOR)->build());
+    ->withType(core::StandardValidators::UNSIGNED_LONG_VALIDATOR)->build());
 const core::Property BinFiles::MinEntries(
     core::PropertyBuilder::createProperty("Minimum Number of Entries")
     ->withDescription("The minimum number of files to include in a bundle")
@@ -42,11 +42,11 @@ const core::Property BinFiles::MinEntries(
 const core::Property BinFiles::MaxEntries(
     core::PropertyBuilder::createProperty("Maximum Number of Entries")
     ->withDescription("The maximum number of files to include in a bundle. If 
not specified, there is no maximum.")
-    
->withType(core::StandardValidators::get().UNSIGNED_INT_VALIDATOR)->build());
+    ->withType(core::StandardValidators::UNSIGNED_INT_VALIDATOR)->build());
 const core::Property BinFiles::MaxBinAge(
     core::PropertyBuilder::createProperty("Max Bin Age")
     ->withDescription("The maximum age of a Bin that will trigger a Bin to be 
complete. Expected format is <duration> <time unit>")
-    
->withType(core::StandardValidators::get().TIME_PERIOD_VALIDATOR)->build());
+    ->withType(core::StandardValidators::TIME_PERIOD_VALIDATOR)->build());
 const core::Property BinFiles::MaxBinCount(
     core::PropertyBuilder::createProperty("Maximum number of Bins")
     ->withDescription("Specifies the maximum number of bins that can be held 
in memory at any one time")
diff --git a/extensions/librdkafka/ConsumeKafka.cpp 
b/extensions/librdkafka/ConsumeKafka.cpp
index c3144965d..6df31f54d 100644
--- a/extensions/librdkafka/ConsumeKafka.cpp
+++ b/extensions/librdkafka/ConsumeKafka.cpp
@@ -33,10 +33,6 @@ namespace org::apache::nifi::minifi {
 namespace core {
 // The upper limit for Max Poll Time is 4 seconds. This is because Watchdog 
would potentially start
 // reporting issues with the processor health otherwise
-ConsumeKafkaMaxPollTimeValidator::ConsumeKafkaMaxPollTimeValidator(const 
std::string &name)
-  : TimePeriodValidator(name) {
-}
-
 ValidationResult ConsumeKafkaMaxPollTimeValidator::validate(const std::string& 
subject, const std::string& input) const {
   auto parsed_value = 
utils::timeutils::StringToDuration<std::chrono::milliseconds>(input);
   return 
ValidationResult::Builder::createBuilder().withSubject(subject).withInput(input).isValid(
diff --git a/extensions/librdkafka/ConsumeKafka.h 
b/extensions/librdkafka/ConsumeKafka.h
index 634b5b83f..006e18300 100644
--- a/extensions/librdkafka/ConsumeKafka.h
+++ b/extensions/librdkafka/ConsumeKafka.h
@@ -24,6 +24,7 @@
 #include <vector>
 
 #include "KafkaProcessorBase.h"
+#include "PropertyValidation.h"
 #include "core/logging/LoggerConfiguration.h"
 #include "io/StreamPipe.h"
 #include "rdkafka.h"
@@ -38,8 +39,7 @@ class FlowFileRecord;
 namespace core {
 class ConsumeKafkaMaxPollTimeValidator : public TimePeriodValidator {
  public:
-  explicit ConsumeKafkaMaxPollTimeValidator(const std::string &name);
-  ~ConsumeKafkaMaxPollTimeValidator() override = default;
+  constexpr ~ConsumeKafkaMaxPollTimeValidator() override { }  // NOLINT see 
comment at grandparent
 
   [[nodiscard]] ValidationResult validate(const std::string& subject, const 
std::string& input) const override;
 };
diff --git a/extensions/librdkafka/KafkaProcessorStaticDefinitions.cpp 
b/extensions/librdkafka/KafkaProcessorStaticDefinitions.cpp
index 23cf1a6e8..d05e005b6 100644
--- a/extensions/librdkafka/KafkaProcessorStaticDefinitions.cpp
+++ b/extensions/librdkafka/KafkaProcessorStaticDefinitions.cpp
@@ -74,7 +74,7 @@ const core::Property KafkaProcessorBase::Password(
 
 const core::Property 
ConsumeKafka::KafkaBrokers(core::PropertyBuilder::createProperty("Kafka 
Brokers")
   ->withDescription("A comma-separated list of known Kafka Brokers in the 
format <host>:<port>.")
-  ->withDefaultValue("localhost:9092", 
core::StandardValidators::get().NON_BLANK_VALIDATOR)
+  ->withDefaultValue("localhost:9092", 
core::StandardValidators::NON_BLANK_VALIDATOR)
   ->supportsExpressionLanguage(true)
   ->isRequired(true)
   ->build());
@@ -160,10 +160,12 @@ const core::Property 
ConsumeKafka::MaxPollRecords(core::PropertyBuilder::createP
   ->withDefaultValue<unsigned int>(DEFAULT_MAX_POLL_RECORDS)
   ->build());
 
+constexpr core::ConsumeKafkaMaxPollTimeValidator 
CONSUME_KAFKA_MAX_POLL_TIME_VALIDATOR;
+
 const core::Property 
ConsumeKafka::MaxPollTime(core::PropertyBuilder::createProperty("Max Poll Time")
   ->withDescription("Specifies the maximum amount of time the consumer can use 
for polling data from the brokers. "
       "Polling is a blocking operation, so the upper limit of this value is 
specified in 4 seconds.")
-  ->withDefaultValue(DEFAULT_MAX_POLL_TIME, 
std::make_shared<core::ConsumeKafkaMaxPollTimeValidator>(std::string("ConsumeKafkaMaxPollTimeValidator")))
+  ->withDefaultValue(DEFAULT_MAX_POLL_TIME, 
CONSUME_KAFKA_MAX_POLL_TIME_VALIDATOR)
   ->isRequired(true)
   ->build());
 
diff --git 
a/extensions/openwsman/processors/SourceInitiatedSubscriptionListener.cpp 
b/extensions/openwsman/processors/SourceInitiatedSubscriptionListener.cpp
index ab8cb17d2..7d4f03d32 100644
--- a/extensions/openwsman/processors/SourceInitiatedSubscriptionListener.cpp
+++ b/extensions/openwsman/processors/SourceInitiatedSubscriptionListener.cpp
@@ -75,7 +75,7 @@ const core::Property 
SourceInitiatedSubscriptionListener::ListenHostname(
         ->isRequired(true)->build());
 const core::Property SourceInitiatedSubscriptionListener::ListenPort(
     core::PropertyBuilder::createProperty("Listen Port")->withDescription("The 
port to listen on.")
-        ->isRequired(true)->withDefaultValue<int64_t>(5986, 
core::StandardValidators::get().LISTEN_PORT_VALIDATOR)->build());
+        ->isRequired(true)->withDefaultValue<int64_t>(5986, 
core::StandardValidators::LISTEN_PORT_VALIDATOR)->build());
 const core::Property 
SourceInitiatedSubscriptionListener::SubscriptionManagerPath(
     core::PropertyBuilder::createProperty("Subscription Manager 
Path")->withDescription("The URI path that will be used for the WEC 
Subscription Manager endpoint.")
         
->isRequired(true)->withDefaultValue("/wsman/SubscriptionManager/WEC")->build());
diff --git a/extensions/splunk/SplunkHECProcessorStaticDefinitions.cpp 
b/extensions/splunk/SplunkHECProcessorStaticDefinitions.cpp
index 941c2ca4d..21b01a6eb 100644
--- a/extensions/splunk/SplunkHECProcessorStaticDefinitions.cpp
+++ b/extensions/splunk/SplunkHECProcessorStaticDefinitions.cpp
@@ -34,7 +34,7 @@ const core::Property 
SplunkHECProcessor::Hostname(core::PropertyBuilder::createP
 
 const core::Property 
SplunkHECProcessor::Port(core::PropertyBuilder::createProperty("Port")
     ->withDescription("The HTTP Event Collector HTTP Port Number.")
-    ->withDefaultValue<int>(8088, 
core::StandardValidators::get().PORT_VALIDATOR)->isRequired(true)->build());
+    ->withDefaultValue<int>(8088, 
core::StandardValidators::PORT_VALIDATOR)->isRequired(true)->build());
 
 const core::Property 
SplunkHECProcessor::Token(core::PropertyBuilder::createProperty("Token")
     ->withDescription("HTTP Event Collector token starting with the string 
Splunk. For example \'Splunk 1234578-abcd-1234-abcd-1234abcd\'")
diff --git a/extensions/standard-processors/processors/DefragmentText.cpp 
b/extensions/standard-processors/processors/DefragmentText.cpp
index 623534889..dd8115802 100644
--- a/extensions/standard-processors/processors/DefragmentText.cpp
+++ b/extensions/standard-processors/processors/DefragmentText.cpp
@@ -49,7 +49,7 @@ const core::Property DefragmentText::PatternLoc(
 const core::Property DefragmentText::MaxBufferSize(
     core::PropertyBuilder::createProperty("Max Buffer Size")
         ->withDescription("The maximum buffer size, if the buffer exceeds 
this, it will be transferred to failure. Expected format is <size> <data unit>")
-        
->withType(core::StandardValidators::get().DATA_SIZE_VALIDATOR)->build());
+        ->withType(core::StandardValidators::DATA_SIZE_VALIDATOR)->build());
 
 const core::Property DefragmentText::MaxBufferAge(
     core::PropertyBuilder::createProperty("Max Buffer Age")->
diff --git a/extensions/standard-processors/processors/ListenSyslog.cpp 
b/extensions/standard-processors/processors/ListenSyslog.cpp
index 003646862..f511dc23a 100644
--- a/extensions/standard-processors/processors/ListenSyslog.cpp
+++ b/extensions/standard-processors/processors/ListenSyslog.cpp
@@ -30,7 +30,7 @@ const core::Property ListenSyslog::Port(
     core::PropertyBuilder::createProperty("Listening Port")
         ->withDescription("The port for Syslog communication. (Well-known 
ports (0-1023) require root access)")
         ->isRequired(true)
-        ->withDefaultValue<int>(514, 
core::StandardValidators::get().LISTEN_PORT_VALIDATOR)->build());
+        ->withDefaultValue<int>(514, 
core::StandardValidators::LISTEN_PORT_VALIDATOR)->build());
 
 const core::Property ListenSyslog::ProtocolProperty(
     core::PropertyBuilder::createProperty("Protocol")
diff --git a/extensions/standard-processors/processors/ListenTCP.cpp 
b/extensions/standard-processors/processors/ListenTCP.cpp
index 05b14de6c..03672eb43 100644
--- a/extensions/standard-processors/processors/ListenTCP.cpp
+++ b/extensions/standard-processors/processors/ListenTCP.cpp
@@ -27,7 +27,7 @@ namespace org::apache::nifi::minifi::processors {
 const core::Property ListenTCP::Port(
     core::PropertyBuilder::createProperty("Listening Port")
         ->withDescription("The port to listen on for communication.")
-        ->withType(core::StandardValidators::get().LISTEN_PORT_VALIDATOR)
+        ->withType(core::StandardValidators::LISTEN_PORT_VALIDATOR)
         ->isRequired(true)
         ->build());
 
diff --git a/extensions/standard-processors/processors/ListenUDP.cpp 
b/extensions/standard-processors/processors/ListenUDP.cpp
index 70dd5ce61..62c67f9d6 100644
--- a/extensions/standard-processors/processors/ListenUDP.cpp
+++ b/extensions/standard-processors/processors/ListenUDP.cpp
@@ -26,7 +26,7 @@ namespace org::apache::nifi::minifi::processors {
 const core::Property ListenUDP::Port(
     core::PropertyBuilder::createProperty("Listening Port")
         ->withDescription("The port to listen on for communication.")
-        ->withType(core::StandardValidators::get().LISTEN_PORT_VALIDATOR)
+        ->withType(core::StandardValidators::LISTEN_PORT_VALIDATOR)
         ->isRequired(true)
         ->build());
 
diff --git a/extensions/standard-processors/processors/RetryFlowFile.cpp 
b/extensions/standard-processors/processors/RetryFlowFile.cpp
index 02ef23adb..246e43a4c 100644
--- a/extensions/standard-processors/processors/RetryFlowFile.cpp
+++ b/extensions/standard-processors/processors/RetryFlowFile.cpp
@@ -28,7 +28,7 @@ const core::Property 
RetryFlowFile::RetryAttribute(core::PropertyBuilder::create
         "The name of the attribute that contains the current retry count for 
the FlowFile."
         "WARNING: If the name matches an attribute already on the FlowFile 
that does not contain a numerical value, "
         "the processor will either overwrite that attribute with '1' or fail 
based on configuration.")
-    ->withDefaultValue("flowfile.retries", 
core::StandardValidators::get().NON_BLANK_VALIDATOR)
+    ->withDefaultValue("flowfile.retries", 
core::StandardValidators::NON_BLANK_VALIDATOR)
     ->supportsExpressionLanguage(true)
     ->isRequired(true)
     ->build());
diff --git a/libminifi/include/core/CachedValueValidator.h 
b/libminifi/include/core/CachedValueValidator.h
index 910224898..3d69e3d0c 100644
--- a/libminifi/include/core/CachedValueValidator.h
+++ b/libminifi/include/core/CachedValueValidator.h
@@ -1,5 +1,4 @@
 /**
- *
  * Licensed to the Apache Software Foundation (ASF) under one or more
  * contributor license agreements.  See the NOTICE file distributed with
  * this work for additional information regarding copyright ownership.
@@ -16,8 +15,7 @@
  * limitations under the License.
  */
 
-#ifndef LIBMINIFI_INCLUDE_CORE_CACHEDVALUEVALIDATOR_H_
-#define LIBMINIFI_INCLUDE_CORE_CACHEDVALUEVALIDATOR_H_
+#pragma once
 
 #include <utility>
 #include <memory>
@@ -25,11 +23,7 @@
 #include "PropertyValidation.h"
 #include "state/Value.h"
 
-namespace org {
-namespace apache {
-namespace nifi {
-namespace minifi {
-namespace core {
+namespace org::apache::nifi::minifi::core {
 
 class PropertyValue;
 
@@ -49,47 +43,23 @@ class CachedValueValidator {
 
   CachedValueValidator(const CachedValueValidator& other) : 
validator_(other.validator_) {}
 
-  CachedValueValidator(CachedValueValidator&& other) noexcept : 
validator_(std::move(other.validator_)) {}
-
   CachedValueValidator& operator=(const CachedValueValidator& other) {
     if (this == &other) {
       return *this;
     }
-    setValidator(other.validator_);
-    return *this;
-  }
-
-  CachedValueValidator& operator=(CachedValueValidator&& other) {
-    if (this == &other) {
-      return *this;
-    }
-    setValidator(std::move(other.validator_));
+    setValidator(*other.validator_);
     return *this;
   }
 
-  explicit CachedValueValidator(const std::shared_ptr<PropertyValidator>& 
other) : validator_(other) {}
-
-  explicit CachedValueValidator(std::shared_ptr<PropertyValidator>&& other) : 
validator_(std::move(other)) {}
-
-  CachedValueValidator& operator=(const 
gsl::not_null<std::shared_ptr<PropertyValidator>>& new_validator) {
+  CachedValueValidator& operator=(const PropertyValidator& new_validator) {
     setValidator(new_validator);
     return *this;
   }
 
-  CachedValueValidator& 
operator=(gsl::not_null<std::shared_ptr<PropertyValidator>>&& new_validator) {
-    setValidator(std::move(new_validator));
-    return *this;
-  }
-
-  const gsl::not_null<std::shared_ptr<PropertyValidator>>& operator*() const {
-    return validator_;
-  }
-
  private:
-  template<typename T>
-  void setValidator(T&& newValidator) {
+  void setValidator(const PropertyValidator& new_validator) {
     invalidateCachedResult();
-    validator_ = std::forward<T>(newValidator);
+    validator_ = gsl::make_not_null(&new_validator);
   }
 
   ValidationResult validate(const std::string& subject, const 
std::shared_ptr<state::response::Value>& value) const {
@@ -112,15 +82,9 @@ class CachedValueValidator {
     validation_result_ = Result::RECOMPUTE;
   }
 
-  gsl::not_null<std::shared_ptr<PropertyValidator>> 
validator_{StandardValidators::get().VALID_VALIDATOR};
+  gsl::not_null<const PropertyValidator*> 
validator_{&StandardValidators::VALID_VALIDATOR};
   mutable Result validation_result_{Result::RECOMPUTE};
 };
 
-} /* namespace internal */
-} /* namespace core */
-} /* namespace minifi */
-} /* namespace nifi */
-} /* namespace apache */
-} /* namespace org */
-
-#endif  // LIBMINIFI_INCLUDE_CORE_CACHEDVALUEVALIDATOR_H_
+}  // namespace internal
+}  // namespace org::apache::nifi::minifi::core
diff --git a/libminifi/include/core/Property.h 
b/libminifi/include/core/Property.h
index 205151b84..ae2efa8c0 100644
--- a/libminifi/include/core/Property.h
+++ b/libminifi/include/core/Property.h
@@ -96,7 +96,7 @@ class Property {
   std::string getDisplayName() const;
   std::vector<std::string> getAllowedTypes() const;
   std::string getDescription() const;
-  std::shared_ptr<PropertyValidator> getValidator() const;
+  const PropertyValidator& getValidator() const;
   const PropertyValue &getValue() const;
   bool getRequired() const;
   bool supportsExpressionLanguage() const;
@@ -118,7 +118,7 @@ class Property {
       values_.push_back(default_value_);
     }
     PropertyValue& vn = values_.back();
-    vn.setValidator(validator_);
+    vn.setValidator(*validator_);
     vn = value;
     ValidationResult result = vn.validate(name_);
     if (!result.valid()) {
@@ -134,7 +134,7 @@ class Property {
       values_.push_back(newValue);
     }
     PropertyValue& vn = values_.back();
-    vn.setValidator(validator_);
+    vn.setValidator(*validator_);
     ValidationResult result = vn.validate(name_);
     if (!result.valid()) {
       throw utils::internal::InvalidValueException(name_ + " value validation 
failed");
@@ -240,7 +240,7 @@ class Property {
       validator_ = StandardValidators::getValidator(ret.getValue());
     } else {
       ret = value;
-      validator_ = StandardValidators::get().VALID_VALIDATOR;
+      validator_ = gsl::make_not_null(&StandardValidators::VALID_VALIDATOR);
     }
     return ret;
   }
@@ -254,7 +254,7 @@ class Property {
   bool is_collection_;
   PropertyValue default_value_;
   std::vector<PropertyValue> values_;
-  gsl::not_null<std::shared_ptr<PropertyValidator>> 
validator_{StandardValidators::get().VALID_VALIDATOR};
+  gsl::not_null<const PropertyValidator*> 
validator_{&StandardValidators::VALID_VALIDATOR};
   std::string display_name_;
   std::vector<PropertyValue> allowed_values_;
   // types represents the allowable types for this property
diff --git a/libminifi/include/core/PropertyBuilder.h 
b/libminifi/include/core/PropertyBuilder.h
index 0c02e592a..72712d65c 100644
--- a/libminifi/include/core/PropertyBuilder.h
+++ b/libminifi/include/core/PropertyBuilder.h
@@ -68,25 +68,31 @@ class PropertyBuilder : public 
std::enable_shared_from_this<PropertyBuilder> {
   }
 
   template<typename T>
-  std::shared_ptr<PropertyBuilder> withDefaultValue(const T &df, const 
std::shared_ptr<PropertyValidator> &validator = nullptr) {
+  std::shared_ptr<PropertyBuilder> withDefaultValue(const T &df) {
     prop.default_value_ = df;
 
-    if (validator != nullptr) {
-      prop.default_value_.setValidator(gsl::make_not_null(validator));
-      prop.validator_ = gsl::make_not_null(validator);
-    } else {
-      prop.validator_ = 
StandardValidators::getValidator(prop.default_value_.getValue());
-      prop.default_value_.setValidator(prop.validator_);
-    }
+    prop.validator_ = 
StandardValidators::getValidator(prop.default_value_.getValue());
+    prop.default_value_.setValidator(*prop.validator_);
+
     // inspect the type and add a validator to this.
     // there may be cases in which the validator is typed differently
     // and a validator can be added for this.
     return shared_from_this();
   }
 
-  std::shared_ptr<PropertyBuilder> withType(const 
std::shared_ptr<PropertyValidator> &validator) {
-    prop.validator_ = gsl::make_not_null(validator);
-    prop.default_value_.setValidator(gsl::make_not_null(validator));
+  template<typename T>
+  std::shared_ptr<PropertyBuilder> withDefaultValue(const T &df, const 
PropertyValidator& validator) {
+    prop.default_value_ = df;
+
+    prop.default_value_.setValidator(validator);
+    prop.validator_ = gsl::make_not_null(&validator);
+
+    return shared_from_this();
+  }
+
+  std::shared_ptr<PropertyBuilder> withType(const PropertyValidator& 
validator) {
+    prop.validator_ = gsl::make_not_null(&validator);
+    prop.default_value_.setValidator(validator);
     return shared_from_this();
   }
 
@@ -105,11 +111,11 @@ class PropertyBuilder : public 
std::enable_shared_from_this<PropertyBuilder> {
   }
 
   template<typename T>
-  std::shared_ptr<PropertyBuilder> withDefaultValue(const std::string &df) {
-    prop.default_value_.operator=<T>(df);
+  std::shared_ptr<PropertyBuilder> withDefaultValue(std::string_view df) {
+    prop.default_value_.operator=<T>(std::string{df});
 
     prop.validator_ = 
StandardValidators::getValidator(prop.default_value_.getValue());
-    prop.default_value_.setValidator(prop.validator_);
+    prop.default_value_.setValidator(*prop.validator_);
 
     // inspect the type and add a validator to this.
     // there may be cases in which the validator is typed differently
@@ -156,7 +162,12 @@ class ConstrainedProperty : public 
std::enable_shared_from_this<ConstrainedPrope
     return this->shared_from_this();
   }
 
-  std::shared_ptr<ConstrainedProperty<T>> withDefaultValue(const T &df, const 
std::shared_ptr<PropertyValidator> &validator = nullptr) {
+  std::shared_ptr<ConstrainedProperty<T>> withDefaultValue(const T &df) {
+    builder_->withDefaultValue(df);
+    return this->shared_from_this();
+  }
+
+  std::shared_ptr<ConstrainedProperty<T>> withDefaultValue(const T &df, const 
PropertyValidator& validator) {
     builder_->withDefaultValue(df, validator);
     return this->shared_from_this();
   }
diff --git a/libminifi/include/core/PropertyValidation.h 
b/libminifi/include/core/PropertyValidation.h
index ca50e255f..941eb1102 100644
--- a/libminifi/include/core/PropertyValidation.h
+++ b/libminifi/include/core/PropertyValidation.h
@@ -15,8 +15,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-#ifndef LIBMINIFI_INCLUDE_CORE_PROPERTYVALIDATION_H_
-#define LIBMINIFI_INCLUDE_CORE_PROPERTYVALIDATION_H_
+#pragma once
 
 #include <limits>
 #include <memory>
@@ -26,26 +25,23 @@
 #include "core/Core.h"
 #include "core/state/Value.h"
 #include "TypedValues.h"
+#include "utils/Export.h"
 #include "utils/StringUtils.h"
 
-namespace org {
-namespace apache {
-namespace nifi {
-namespace minifi {
-namespace core {
+namespace org::apache::nifi::minifi::core {
 
 class ValidationResult;
 
 class ValidationResult {
  public:
-  bool valid() const {
+  [[nodiscard]] bool valid() const {
     return valid_;
   }
 
   class Builder {
    public:
     static Builder createBuilder() {
-      return Builder();
+      return {};
     }
     Builder &isValid(bool valid) {
       valid_ = valid;
@@ -61,7 +57,7 @@ class ValidationResult {
     }
 
     ValidationResult build() {
-      return ValidationResult(*this);
+      return *this;
     }
 
    protected:
@@ -87,22 +83,17 @@ class ValidationResult {
 
 class PropertyValidator {
  public:
-  PropertyValidator(std::string name) // NOLINT
-      : name_(std::move(name)) {
-  }
-  virtual ~PropertyValidator() = default;
+  virtual constexpr ~PropertyValidator() {}  // NOLINT can't use = default 
because of gcc bug: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=93413
 
-  std::string getName() const {
-    return name_;
-  }
+  [[nodiscard]] virtual std::string_view getName() const = 0;
 
-  virtual ValidationResult validate(const std::string &subject, const 
std::shared_ptr<minifi::state::response::Value> &input) const = 0;
+  [[nodiscard]] virtual ValidationResult validate(const std::string &subject, 
const std::shared_ptr<minifi::state::response::Value> &input) const = 0;
 
-  virtual ValidationResult validate(const std::string &subject, const 
std::string &input) const = 0;
+  [[nodiscard]] virtual ValidationResult validate(const std::string &subject, 
const std::string &input) const = 0;
 
  protected:
   template<typename T>
-  ValidationResult _validate_internal(const std::string &subject, const 
std::shared_ptr<minifi::state::response::Value> &input) const {
+  [[nodiscard]] ValidationResult _validate_internal(const std::string 
&subject, const std::shared_ptr<minifi::state::response::Value> &input) const {
     if (std::dynamic_pointer_cast<T>(input) != nullptr) {
       return 
ValidationResult::Builder::createBuilder().withSubject(subject).withInput(input->getStringValue()).isValid(true).build();
     } else {
@@ -111,42 +102,55 @@ class PropertyValidator {
       return validate(subject, input->getStringValue());
     }
   }
-
-  std::string name_;
 };
 
-class AlwaysValid : public PropertyValidator {
-  bool always_valid_;
+class ConstantValidator : public PropertyValidator {
  public:
-  AlwaysValid(bool isalwaysvalid, const std::string &name)
-      : PropertyValidator(name),
-        always_valid_(isalwaysvalid) {
-  }
+  explicit constexpr ConstantValidator(bool value) : value_(value) {}
 
-  ~AlwaysValid() override = default;
+  constexpr ~ConstantValidator() override {}  // NOLINT see comment at parent
 
-  ValidationResult validate(const std::string &subject, const 
std::shared_ptr<minifi::state::response::Value> &input) const override {
-    return 
ValidationResult::Builder::createBuilder().withSubject(subject).withInput(input->getStringValue()).isValid(always_valid_).build();
+  [[nodiscard]] ValidationResult validate(const std::string &subject, const 
std::shared_ptr<minifi::state::response::Value> &input) const override {
+    return 
ValidationResult::Builder::createBuilder().withSubject(subject).withInput(input->getStringValue()).isValid(value_).build();
   }
 
-  ValidationResult validate(const std::string &subject, const std::string 
&input) const override {
-    return 
ValidationResult::Builder::createBuilder().withSubject(subject).withInput(input).isValid(always_valid_).build();
+  [[nodiscard]] ValidationResult validate(const std::string &subject, const 
std::string &input) const override {
+    return 
ValidationResult::Builder::createBuilder().withSubject(subject).withInput(input).isValid(value_).build();
   }
+
+ private:
+  bool value_;
+};
+
+class AlwaysValid : public ConstantValidator {
+ public:
+  constexpr AlwaysValid() : ConstantValidator{true} {}
+
+  constexpr ~AlwaysValid() override {}  // NOLINT see comment at parent
+
+  [[nodiscard]] std::string_view getName() const override { return "VALID"; }
+};
+
+class NeverValid : public ConstantValidator {
+ public:
+  constexpr NeverValid() : ConstantValidator{false} {}
+
+  constexpr ~NeverValid() override {}  // NOLINT see comment at parent
+
+  [[nodiscard]] std::string_view getName() const override { return "INVALID"; }
 };
 
 class BooleanValidator : public PropertyValidator {
  public:
-  BooleanValidator(const std::string &name) // NOLINT
-      : PropertyValidator(name) {
-  }
+  constexpr ~BooleanValidator() override {}  // NOLINT see comment at parent
 
-  ~BooleanValidator() override = default;
+  [[nodiscard]] std::string_view getName() const override { return 
"BOOLEAN_VALIDATOR"; }
 
-  ValidationResult validate(const std::string &subject, const 
std::shared_ptr<minifi::state::response::Value> &input) const override {
+  [[nodiscard]] ValidationResult validate(const std::string &subject, const 
std::shared_ptr<minifi::state::response::Value> &input) const override {
     return 
PropertyValidator::_validate_internal<minifi::state::response::BoolValue>(subject,
 input);
   }
 
-  ValidationResult validate(const std::string &subject, const std::string 
&input) const override {
+  [[nodiscard]] ValidationResult validate(const std::string &subject, const 
std::string &input) const override {
     if (utils::StringUtils::equalsIgnoreCase(input, "true") || 
utils::StringUtils::equalsIgnoreCase(input, "false"))
       return 
ValidationResult::Builder::createBuilder().withSubject(subject).withInput(input).isValid(true).build();
     else
@@ -156,16 +160,15 @@ class BooleanValidator : public PropertyValidator {
 
 class IntegerValidator : public PropertyValidator {
  public:
-  IntegerValidator(const std::string &name) // NOLINT
-      : PropertyValidator(name) {
-  }
-  ~IntegerValidator() override = default;
+  constexpr ~IntegerValidator() override {}  // NOLINT see comment at parent
+
+  [[nodiscard]] std::string_view getName() const override { return 
"INTEGER_VALIDATOR"; }
 
-  ValidationResult validate(const std::string &subject, const 
std::shared_ptr<minifi::state::response::Value> &input) const override {
+  [[nodiscard]] ValidationResult validate(const std::string &subject, const 
std::shared_ptr<minifi::state::response::Value> &input) const override {
     return 
PropertyValidator::_validate_internal<minifi::state::response::IntValue>(subject,
 input);
   }
 
-  ValidationResult validate(const std::string &subject, const std::string 
&input) const override {
+  [[nodiscard]] ValidationResult validate(const std::string &subject, const 
std::string &input) const override {
     try {
       std::stoi(input);
       return 
ValidationResult::Builder::createBuilder().withSubject(subject).withInput(input).isValid(true).build();
@@ -177,16 +180,15 @@ class IntegerValidator : public PropertyValidator {
 
 class UnsignedIntValidator : public PropertyValidator {
  public:
-  explicit UnsignedIntValidator(const std::string &name)
-      : PropertyValidator(name) {
-  }
-  ~UnsignedIntValidator() override = default;
+  constexpr ~UnsignedIntValidator() override {}  // NOLINT see comment at 
parent
 
-  ValidationResult validate(const std::string &subject, const 
std::shared_ptr<minifi::state::response::Value> &input) const override {
+  [[nodiscard]] std::string_view getName() const override { return 
"NON_NEGATIVE_INTEGER_VALIDATOR"; }
+
+  [[nodiscard]] ValidationResult validate(const std::string &subject, const 
std::shared_ptr<minifi::state::response::Value> &input) const override {
     return 
PropertyValidator::_validate_internal<minifi::state::response::UInt32Value>(subject,
 input);
   }
 
-  ValidationResult validate(const std::string &subject, const std::string 
&input) const override {
+  [[nodiscard]] ValidationResult validate(const std::string &subject, const 
std::string &input) const override {
     try {
       auto negative = input.find_first_of('-') != std::string::npos;
       if (negative) {
@@ -202,14 +204,16 @@ class UnsignedIntValidator : public PropertyValidator {
 
 class LongValidator : public PropertyValidator {
  public:
-  explicit LongValidator(const std::string &name, int64_t min = 
std::numeric_limits<int64_t>::min(), int64_t max = 
std::numeric_limits<int64_t>::max())
-      : PropertyValidator(name),
-        min_(min),
+  explicit constexpr LongValidator(int64_t min = 
std::numeric_limits<int64_t>::min(), int64_t max = 
std::numeric_limits<int64_t>::max())
+      : min_(min),
         max_(max) {
   }
-  ~LongValidator() override = default;
 
-  ValidationResult validate(const std::string &subject, const 
std::shared_ptr<minifi::state::response::Value> &input) const override {
+  constexpr ~LongValidator() override {}  // NOLINT see comment at parent
+
+  [[nodiscard]] std::string_view getName() const override { return 
"LONG_VALIDATOR"; }
+
+  [[nodiscard]] ValidationResult validate(const std::string &subject, const 
std::shared_ptr<minifi::state::response::Value> &input) const override {
     if (auto in64 = 
std::dynamic_pointer_cast<minifi::state::response::Int64Value>(input)) {
       return 
ValidationResult::Builder::createBuilder().withSubject(subject).withInput(in64->getStringValue()).isValid(in64->getValue()
 >= min_ && in64->getValue() <= max_).build();
     } else if (auto intb = 
std::dynamic_pointer_cast<minifi::state::response::IntValue>(input)) {
@@ -219,7 +223,7 @@ class LongValidator : public PropertyValidator {
     }
   }
 
-  ValidationResult validate(const std::string &subject, const std::string 
&input) const override {
+  [[nodiscard]] ValidationResult validate(const std::string &subject, const 
std::string &input) const override {
     try {
       auto res = std::stoll(input);
 
@@ -236,18 +240,20 @@ class LongValidator : public PropertyValidator {
 
 class UnsignedLongValidator : public PropertyValidator {
  public:
-  explicit UnsignedLongValidator(const std::string &name, uint64_t min = 
std::numeric_limits<uint64_t>::min(), uint64_t max = 
std::numeric_limits<uint64_t>::max())
-      : PropertyValidator(name),
-        min_(min),
+  explicit constexpr UnsignedLongValidator(uint64_t min = 
std::numeric_limits<uint64_t>::min(), uint64_t max = 
std::numeric_limits<uint64_t>::max())
+      : min_(min),
         max_(max) {
   }
-  ~UnsignedLongValidator() override = default;
 
-  ValidationResult validate(const std::string &subject, const 
std::shared_ptr<minifi::state::response::Value> &input) const override {
+  constexpr ~UnsignedLongValidator() override {}  // NOLINT see comment at 
parent
+
+  [[nodiscard]] std::string_view getName() const override { return 
"LONG_VALIDATOR"; }  // name is used by java nifi validators, so we should keep 
this as LONG instead of UNSIGNED_LONG
+
+  [[nodiscard]] ValidationResult validate(const std::string &subject, const 
std::shared_ptr<minifi::state::response::Value> &input) const override {
     return 
PropertyValidator::_validate_internal<minifi::state::response::UInt64Value>(subject,
 input);
   }
 
-  ValidationResult validate(const std::string &subject, const std::string 
&input) const override {
+  [[nodiscard]] ValidationResult validate(const std::string &subject, const 
std::string &input) const override {
     try {
       auto negative = input.find_first_of('-') != std::string::npos;
       if (negative) {
@@ -267,32 +273,30 @@ class UnsignedLongValidator : public PropertyValidator {
 
 class NonBlankValidator : public PropertyValidator {
  public:
-  explicit NonBlankValidator(const std::string& name)
-      : PropertyValidator(name) {
-  }
-  ~NonBlankValidator() override = default;
+  constexpr ~NonBlankValidator() override {}  // NOLINT see comment at parent
 
-  ValidationResult validate(const std::string& subject, const 
std::shared_ptr<minifi::state::response::Value>& input) const final {
+  [[nodiscard]] std::string_view getName() const override { return 
"NON_BLANK_VALIDATOR"; }
+
+  [[nodiscard]] ValidationResult validate(const std::string& subject, const 
std::shared_ptr<minifi::state::response::Value>& input) const final {
     return validate(subject, input->getStringValue());
   }
 
-  ValidationResult validate(const std::string& subject, const std::string& 
input) const final {
+  [[nodiscard]] ValidationResult validate(const std::string& subject, const 
std::string& input) const final {
     return 
ValidationResult::Builder::createBuilder().withSubject(subject).withInput(input).isValid(utils::StringUtils::trimLeft(input).size()).build();
   }
 };
 
 class DataSizeValidator : public PropertyValidator {
  public:
-  DataSizeValidator(const std::string &name) // NOLINT
-      : PropertyValidator(name) {
-  }
-  ~DataSizeValidator() override = default;
+  constexpr ~DataSizeValidator() override {}  // NOLINT see comment at parent
+
+  [[nodiscard]] std::string_view getName() const override { return 
"DATA_SIZE_VALIDATOR"; }
 
-  ValidationResult validate(const std::string &subject, const 
std::shared_ptr<minifi::state::response::Value> &input) const override {
+  [[nodiscard]] ValidationResult validate(const std::string &subject, const 
std::shared_ptr<minifi::state::response::Value> &input) const override {
     return PropertyValidator::_validate_internal<core::DataSizeValue>(subject, 
input);
   }
 
-  ValidationResult validate(const std::string &subject, const std::string 
&input) const override {
+  [[nodiscard]] ValidationResult validate(const std::string &subject, const 
std::string &input) const override {
     uint64_t out;
     return 
ValidationResult::Builder::createBuilder().withSubject(subject).withInput(input).isValid(core::DataSizeValue::StringToInt(input,
 out)).build();
   }
@@ -300,89 +304,76 @@ class DataSizeValidator : public PropertyValidator {
 
 class PortValidator : public LongValidator {
  public:
-  PortValidator(const std::string &name) // NOLINT
-      : LongValidator(name, 1, 65535) {
+  constexpr PortValidator()
+      : LongValidator(1, 65535) {
   }
-  ~PortValidator() override = default;
+
+  constexpr ~PortValidator() override {}  // NOLINT see comment at parent
+
+  [[nodiscard]] std::string_view getName() const override { return 
"PORT_VALIDATOR"; }
 };
 
 // Use only for specifying listen ports, where 0 means a randomly chosen one!
 class ListenPortValidator : public LongValidator {
  public:
-  ListenPortValidator(const std::string &name) // NOLINT
-    : LongValidator(name, 0, 65535) {
+  constexpr ListenPortValidator()
+    : LongValidator(0, 65535) {
   }
-  ~ListenPortValidator() override = default;
+
+  constexpr ~ListenPortValidator() override {}  // NOLINT see comment at parent
+
+  [[nodiscard]] std::string_view getName() const override { return 
"PORT_VALIDATOR"; }
 };
 
 class TimePeriodValidator : public PropertyValidator {
  public:
-  TimePeriodValidator(const std::string &name) // NOLINT
-      : PropertyValidator(name) {
-  }
-  ~TimePeriodValidator() override = default;
+  constexpr ~TimePeriodValidator() override {}  // NOLINT see comment at parent
+
+  [[nodiscard]] std::string_view getName() const override { return 
"TIME_PERIOD_VALIDATOR"; }
 
-  ValidationResult validate(const std::string &subject, const 
std::shared_ptr<minifi::state::response::Value> &input) const override {
+  [[nodiscard]] ValidationResult validate(const std::string &subject, const 
std::shared_ptr<minifi::state::response::Value> &input) const override {
     return 
PropertyValidator::_validate_internal<core::TimePeriodValue>(subject, input);
   }
 
-  ValidationResult validate(const std::string &subject, const std::string 
&input) const override {
+  [[nodiscard]] ValidationResult validate(const std::string &subject, const 
std::string &input) const override {
     auto parsed_time = 
utils::timeutils::StringToDuration<std::chrono::milliseconds>(input);
     return 
ValidationResult::Builder::createBuilder().withSubject(subject).withInput(input).isValid(parsed_time.has_value()).build();
   }
 };
 
-// STATIC DEFINITIONS
-
-class StandardValidators {
-  StandardValidators();
-
- public:
-  static const StandardValidators& get() {
-    static StandardValidators init;
-    return init;
-  }
-  static const gsl::not_null<std::shared_ptr<PropertyValidator>> 
&getValidator(const std::shared_ptr<minifi::state::response::Value> &input) {
-    const StandardValidators& init = get();
-    if (std::dynamic_pointer_cast<core::DataSizeValue>(input) != nullptr) {
-      return init.DATA_SIZE_VALIDATOR;
-    } else if (std::dynamic_pointer_cast<core::TimePeriodValue>(input) != 
nullptr) {
-      return init.TIME_PERIOD_VALIDATOR;
-    } else if 
(std::dynamic_pointer_cast<minifi::state::response::BoolValue>(input) != 
nullptr) {
-      return init.BOOLEAN_VALIDATOR;
-    } else if 
(std::dynamic_pointer_cast<minifi::state::response::IntValue>(input) != 
nullptr) {
-      return init.INTEGER_VALIDATOR;
-    } else if 
(std::dynamic_pointer_cast<minifi::state::response::UInt32Value>(input) != 
nullptr) {
-      return init.UNSIGNED_INT_VALIDATOR;;
-    } else if 
(std::dynamic_pointer_cast<minifi::state::response::Int64Value>(input) != 
nullptr) {
-      return init.LONG_VALIDATOR;
-    } else if 
(std::dynamic_pointer_cast<minifi::state::response::UInt64Value>(input) != 
nullptr) {
-      return init.UNSIGNED_LONG_VALIDATOR;
-    } else {
-      return init.VALID_VALIDATOR;
-    }
-  }
-
- public:
-  gsl::not_null<std::shared_ptr<PropertyValidator>> INVALID;
-  gsl::not_null<std::shared_ptr<PropertyValidator>> INTEGER_VALIDATOR;
-  gsl::not_null<std::shared_ptr<PropertyValidator>> UNSIGNED_INT_VALIDATOR;
-  gsl::not_null<std::shared_ptr<PropertyValidator>> LONG_VALIDATOR;
-  gsl::not_null<std::shared_ptr<PropertyValidator>> UNSIGNED_LONG_VALIDATOR;
-  gsl::not_null<std::shared_ptr<PropertyValidator>> BOOLEAN_VALIDATOR;
-  gsl::not_null<std::shared_ptr<PropertyValidator>> DATA_SIZE_VALIDATOR;
-  gsl::not_null<std::shared_ptr<PropertyValidator>> TIME_PERIOD_VALIDATOR;
-
-  gsl::not_null<std::shared_ptr<PropertyValidator>> NON_BLANK_VALIDATOR;
-  gsl::not_null<std::shared_ptr<PropertyValidator>> VALID_VALIDATOR;
-  gsl::not_null<std::shared_ptr<PropertyValidator>> PORT_VALIDATOR;
-  gsl::not_null<std::shared_ptr<PropertyValidator>> LISTEN_PORT_VALIDATOR;
-};
-
-}  // namespace core
-}  // namespace minifi
-}  // namespace nifi
-}  // namespace apache
-}  // namespace org
-
-#endif  // LIBMINIFI_INCLUDE_CORE_PROPERTYVALIDATION_H_
+namespace StandardValidators {
+inline constexpr auto INVALID = NeverValid{};
+inline constexpr auto INTEGER_VALIDATOR = IntegerValidator{};
+inline constexpr auto UNSIGNED_INT_VALIDATOR = UnsignedIntValidator{};
+inline constexpr auto LONG_VALIDATOR = LongValidator{};
+inline constexpr auto UNSIGNED_LONG_VALIDATOR = UnsignedLongValidator{};
+inline constexpr auto BOOLEAN_VALIDATOR = BooleanValidator{};
+inline constexpr auto DATA_SIZE_VALIDATOR = DataSizeValidator{};
+inline constexpr auto TIME_PERIOD_VALIDATOR = TimePeriodValidator{};
+inline constexpr auto NON_BLANK_VALIDATOR = NonBlankValidator{};
+inline constexpr auto VALID_VALIDATOR = AlwaysValid{};
+inline constexpr auto PORT_VALIDATOR = PortValidator{};
+inline constexpr auto LISTEN_PORT_VALIDATOR = ListenPortValidator{};
+
+inline gsl::not_null<const PropertyValidator*> getValidator(const 
std::shared_ptr<minifi::state::response::Value>& input) {
+  if (std::dynamic_pointer_cast<core::DataSizeValue>(input) != nullptr) {
+    return gsl::make_not_null(&DATA_SIZE_VALIDATOR);
+  } else if (std::dynamic_pointer_cast<core::TimePeriodValue>(input) != 
nullptr) {
+    return gsl::make_not_null(&TIME_PERIOD_VALIDATOR);
+  } else if 
(std::dynamic_pointer_cast<minifi::state::response::BoolValue>(input) != 
nullptr) {
+    return gsl::make_not_null(&BOOLEAN_VALIDATOR);
+  } else if 
(std::dynamic_pointer_cast<minifi::state::response::IntValue>(input) != 
nullptr) {
+    return gsl::make_not_null(&INTEGER_VALIDATOR);
+  } else if 
(std::dynamic_pointer_cast<minifi::state::response::UInt32Value>(input) != 
nullptr) {
+    return gsl::make_not_null(&UNSIGNED_INT_VALIDATOR);;
+  } else if 
(std::dynamic_pointer_cast<minifi::state::response::Int64Value>(input) != 
nullptr) {
+    return gsl::make_not_null(&LONG_VALIDATOR);
+  } else if 
(std::dynamic_pointer_cast<minifi::state::response::UInt64Value>(input) != 
nullptr) {
+    return gsl::make_not_null(&UNSIGNED_LONG_VALIDATOR);
+  } else {
+    return gsl::make_not_null(&VALID_VALIDATOR);
+  }
+}
+}  // namespace StandardValidators
+
+}  // namespace org::apache::nifi::minifi::core
diff --git a/libminifi/include/core/PropertyValue.h 
b/libminifi/include/core/PropertyValue.h
index e40d77b53..9b6c80b91 100644
--- a/libminifi/include/core/PropertyValue.h
+++ b/libminifi/include/core/PropertyValue.h
@@ -74,16 +74,12 @@ class PropertyValue : public state::response::ValueNode {
   PropertyValue(const PropertyValue &o) = default;
   PropertyValue(PropertyValue &&o) noexcept = default;
 
-  void setValidator(const gsl::not_null<std::shared_ptr<PropertyValidator>> 
&val) {
-    validator_ = val;
-  }
-
-  std::shared_ptr<PropertyValidator> getValidator() const {
-    return *validator_;
+  void setValidator(const PropertyValidator& validator) {
+    cached_value_validator_ = validator;
   }
 
   ValidationResult validate(const std::string &subject) const {
-    return validator_.validate(subject, getValue());
+    return cached_value_validator_.validate(subject, getValue());
   }
 
   operator uint64_t() const {
@@ -136,7 +132,7 @@ class PropertyValue : public state::response::ValueNode {
    */
   template<typename T>
   auto operator=(const T ref) -> typename std::enable_if<std::is_same<T, 
std::string>::value, PropertyValue&>::type {
-    validator_.invalidateCachedResult();
+    cached_value_validator_.invalidateCachedResult();
     return WithAssignmentGuard(ref, [&] () -> PropertyValue& {
       if (value_ == nullptr) {
         type_id = std::type_index(typeid(T));
@@ -166,7 +162,7 @@ class PropertyValue : public state::response::ValueNode {
   std::is_same<T, uint64_t >::value ||
   std::is_same<T, int64_t >::value ||
   std::is_same<T, bool >::value, PropertyValue&>::type {
-    validator_.invalidateCachedResult();
+    cached_value_validator_.invalidateCachedResult();
     if (value_ == nullptr) {
       type_id = std::type_index(typeid(T));
       value_ = minifi::state::response::createValue(ref);
@@ -200,7 +196,7 @@ class PropertyValue : public state::response::ValueNode {
   auto operator=(const std::string &ref) -> typename std::enable_if<
   std::is_same<T, DataSizeValue >::value ||
   std::is_same<T, TimePeriodValue >::value, PropertyValue&>::type {
-    validator_.invalidateCachedResult();
+    cached_value_validator_.invalidateCachedResult();
     return WithAssignmentGuard(ref, [&] () -> PropertyValue& {
       value_ = std::make_shared<T>(ref);
       type_id = value_->getTypeIndex();
@@ -241,7 +237,7 @@ class PropertyValue : public state::response::ValueNode {
 
  protected:
   std::type_index type_id;
-  CachedValueValidator validator_;
+  CachedValueValidator cached_value_validator_;
 };
 
 inline std::string conditional_conversion(const PropertyValue &v) {
diff --git a/libminifi/include/core/state/nodes/AgentInformation.h 
b/libminifi/include/core/state/nodes/AgentInformation.h
index 4579fff31..d38465295 100644
--- a/libminifi/include/core/state/nodes/AgentInformation.h
+++ b/libminifi/include/core/state/nodes/AgentInformation.h
@@ -122,11 +122,7 @@ class ComponentManifest : public DeviceInformation {
 
             SerializedResponseNode validatorName;
             validatorName.name = "validator";
-            if (prop.getValidator()) {
-              validatorName.value = prop.getValidator()->getName();
-            } else {
-              validatorName.value = "VALID";
-            }
+            validatorName.value = std::string{prop.getValidator().getName()};
 
             SerializedResponseNode supportsExpressionLanguageScope;
             supportsExpressionLanguageScope.name = "expressionLanguageScope";
diff --git a/libminifi/include/properties/Configuration.h 
b/libminifi/include/properties/Configuration.h
index dfc50e920..00e581a52 100644
--- a/libminifi/include/properties/Configuration.h
+++ b/libminifi/include/properties/Configuration.h
@@ -192,7 +192,7 @@ class Configuration : public Properties {
   static constexpr const char *controller_socket_port = 
"controller.socket.port";
   static constexpr const char *controller_ssl_context_service = 
"controller.ssl.context.service";
 
-  MINIFIAPI static const std::unordered_map<std::string_view, 
gsl::not_null<core::PropertyValidator*>> CONFIGURATION_PROPERTIES;
+  MINIFIAPI static const std::unordered_map<std::string_view, 
gsl::not_null<const core::PropertyValidator*>> CONFIGURATION_PROPERTIES;
   MINIFIAPI static const std::array<const char*, 2> 
DEFAULT_SENSITIVE_PROPERTIES;
 
   static std::vector<std::string> mergeProperties(std::vector<std::string> 
properties,
diff --git a/libminifi/src/Configuration.cpp b/libminifi/src/Configuration.cpp
index 893e967fb..34bbaac40 100644
--- a/libminifi/src/Configuration.cpp
+++ b/libminifi/src/Configuration.cpp
@@ -21,136 +21,136 @@
 
 namespace org::apache::nifi::minifi {
 
-const std::unordered_map<std::string_view, 
gsl::not_null<core::PropertyValidator*>> 
Configuration::CONFIGURATION_PROPERTIES{
-  {Configuration::nifi_default_directory, 
gsl::make_not_null(core::StandardValidators::get().VALID_VALIDATOR.get())},
-  {Configuration::nifi_flow_configuration_file, 
gsl::make_not_null(core::StandardValidators::get().VALID_VALIDATOR.get())},
-  {Configuration::nifi_flow_configuration_encrypt, 
gsl::make_not_null(core::StandardValidators::get().BOOLEAN_VALIDATOR.get())},
-  {Configuration::nifi_flow_configuration_file_backup_update, 
gsl::make_not_null(core::StandardValidators::get().BOOLEAN_VALIDATOR.get())},
-  {Configuration::nifi_flow_engine_threads, 
gsl::make_not_null(core::StandardValidators::get().UNSIGNED_INT_VALIDATOR.get())},
-  {Configuration::nifi_flow_engine_alert_period, 
gsl::make_not_null(core::StandardValidators::get().TIME_PERIOD_VALIDATOR.get())},
-  {Configuration::nifi_flow_engine_event_driven_time_slice, 
gsl::make_not_null(core::StandardValidators::get().TIME_PERIOD_VALIDATOR.get())},
-  {Configuration::nifi_administrative_yield_duration, 
gsl::make_not_null(core::StandardValidators::get().TIME_PERIOD_VALIDATOR.get())},
-  {Configuration::nifi_bored_yield_duration, 
gsl::make_not_null(core::StandardValidators::get().TIME_PERIOD_VALIDATOR.get())},
-  {Configuration::nifi_graceful_shutdown_seconds, 
gsl::make_not_null(core::StandardValidators::get().TIME_PERIOD_VALIDATOR.get())},
-  {Configuration::nifi_flowcontroller_drain_timeout, 
gsl::make_not_null(core::StandardValidators::get().TIME_PERIOD_VALIDATOR.get())},
-  {Configuration::nifi_server_name, 
gsl::make_not_null(core::StandardValidators::get().VALID_VALIDATOR.get())},
-  {Configuration::nifi_configuration_class_name, 
gsl::make_not_null(core::StandardValidators::get().VALID_VALIDATOR.get())},
-  {Configuration::nifi_flow_repository_class_name, 
gsl::make_not_null(core::StandardValidators::get().VALID_VALIDATOR.get())},
-  {Configuration::nifi_flow_repository_rocksdb_compression, 
gsl::make_not_null(core::StandardValidators::get().VALID_VALIDATOR.get())},
-  {Configuration::nifi_content_repository_class_name, 
gsl::make_not_null(core::StandardValidators::get().VALID_VALIDATOR.get())},
-  {Configuration::nifi_content_repository_rocksdb_compression, 
gsl::make_not_null(core::StandardValidators::get().VALID_VALIDATOR.get())},
-  {Configuration::nifi_provenance_repository_class_name, 
gsl::make_not_null(core::StandardValidators::get().VALID_VALIDATOR.get())},
-  {Configuration::nifi_volatile_repository_options_flowfile_max_count, 
gsl::make_not_null(core::StandardValidators::get().UNSIGNED_INT_VALIDATOR.get())},
-  {Configuration::nifi_volatile_repository_options_flowfile_max_bytes, 
gsl::make_not_null(core::StandardValidators::get().DATA_SIZE_VALIDATOR.get())},
-  {Configuration::nifi_volatile_repository_options_provenance_max_count, 
gsl::make_not_null(core::StandardValidators::get().UNSIGNED_INT_VALIDATOR.get())},
-  {Configuration::nifi_volatile_repository_options_provenance_max_bytes, 
gsl::make_not_null(core::StandardValidators::get().DATA_SIZE_VALIDATOR.get())},
-  {Configuration::nifi_volatile_repository_options_content_max_count, 
gsl::make_not_null(core::StandardValidators::get().UNSIGNED_INT_VALIDATOR.get())},
-  {Configuration::nifi_volatile_repository_options_content_max_bytes, 
gsl::make_not_null(core::StandardValidators::get().DATA_SIZE_VALIDATOR.get())},
-  {Configuration::nifi_volatile_repository_options_content_minimal_locking, 
gsl::make_not_null(core::StandardValidators::get().BOOLEAN_VALIDATOR.get())},
-  {Configuration::nifi_server_port, 
gsl::make_not_null(core::StandardValidators::get().PORT_VALIDATOR.get())},
-  {Configuration::nifi_server_report_interval, 
gsl::make_not_null(core::StandardValidators::get().TIME_PERIOD_VALIDATOR.get())},
-  {Configuration::nifi_provenance_repository_max_storage_size, 
gsl::make_not_null(core::StandardValidators::get().DATA_SIZE_VALIDATOR.get())},
-  {Configuration::nifi_provenance_repository_max_storage_time, 
gsl::make_not_null(core::StandardValidators::get().TIME_PERIOD_VALIDATOR.get())},
-  {Configuration::nifi_provenance_repository_directory_default, 
gsl::make_not_null(core::StandardValidators::get().VALID_VALIDATOR.get())},
-  {Configuration::nifi_flowfile_repository_directory_default, 
gsl::make_not_null(core::StandardValidators::get().VALID_VALIDATOR.get())},
-  {Configuration::nifi_dbcontent_repository_directory_default, 
gsl::make_not_null(core::StandardValidators::get().VALID_VALIDATOR.get())},
-  {Configuration::nifi_flowfile_repository_rocksdb_compaction_period, 
gsl::make_not_null(core::StandardValidators::get().TIME_PERIOD_VALIDATOR.get())},
-  {Configuration::nifi_dbcontent_repository_rocksdb_compaction_period, 
gsl::make_not_null(core::StandardValidators::get().TIME_PERIOD_VALIDATOR.get())},
-  {Configuration::nifi_remote_input_secure, 
gsl::make_not_null(core::StandardValidators::get().BOOLEAN_VALIDATOR.get())},
-  {Configuration::nifi_security_need_ClientAuth, 
gsl::make_not_null(core::StandardValidators::get().BOOLEAN_VALIDATOR.get())},
-  {Configuration::nifi_sensitive_props_additional_keys, 
gsl::make_not_null(core::StandardValidators::get().VALID_VALIDATOR.get())},
-  {Configuration::nifi_python_processor_dir, 
gsl::make_not_null(core::StandardValidators::get().VALID_VALIDATOR.get())},
-  {Configuration::nifi_extension_path, 
gsl::make_not_null(core::StandardValidators::get().VALID_VALIDATOR.get())},
-  {Configuration::nifi_security_client_certificate, 
gsl::make_not_null(core::StandardValidators::get().VALID_VALIDATOR.get())},
-  {Configuration::nifi_security_client_private_key, 
gsl::make_not_null(core::StandardValidators::get().VALID_VALIDATOR.get())},
-  {Configuration::nifi_security_client_pass_phrase, 
gsl::make_not_null(core::StandardValidators::get().VALID_VALIDATOR.get())},
-  {Configuration::nifi_security_client_ca_certificate, 
gsl::make_not_null(core::StandardValidators::get().VALID_VALIDATOR.get())},
-  {Configuration::nifi_security_use_system_cert_store, 
gsl::make_not_null(core::StandardValidators::get().VALID_VALIDATOR.get())},
-  {Configuration::nifi_security_windows_cert_store_location, 
gsl::make_not_null(core::StandardValidators::get().VALID_VALIDATOR.get())},
-  {Configuration::nifi_security_windows_server_cert_store, 
gsl::make_not_null(core::StandardValidators::get().VALID_VALIDATOR.get())},
-  {Configuration::nifi_security_windows_client_cert_store, 
gsl::make_not_null(core::StandardValidators::get().VALID_VALIDATOR.get())},
-  {Configuration::nifi_security_windows_client_cert_cn, 
gsl::make_not_null(core::StandardValidators::get().VALID_VALIDATOR.get())},
-  {Configuration::nifi_security_windows_client_cert_key_usage, 
gsl::make_not_null(core::StandardValidators::get().VALID_VALIDATOR.get())},
-  {Configuration::nifi_rest_api_user_name, 
gsl::make_not_null(core::StandardValidators::get().VALID_VALIDATOR.get())},
-  {Configuration::nifi_rest_api_password, 
gsl::make_not_null(core::StandardValidators::get().VALID_VALIDATOR.get())},
-  {Configuration::nifi_c2_enable, 
gsl::make_not_null(core::StandardValidators::get().BOOLEAN_VALIDATOR.get())},
-  {Configuration::nifi_c2_file_watch, 
gsl::make_not_null(core::StandardValidators::get().VALID_VALIDATOR.get())},
-  {Configuration::nifi_c2_flow_id, 
gsl::make_not_null(core::StandardValidators::get().VALID_VALIDATOR.get())},
-  {Configuration::nifi_c2_flow_url, 
gsl::make_not_null(core::StandardValidators::get().VALID_VALIDATOR.get())},
-  {Configuration::nifi_c2_flow_base_url, 
gsl::make_not_null(core::StandardValidators::get().VALID_VALIDATOR.get())},
-  {Configuration::nifi_c2_full_heartbeat, 
gsl::make_not_null(core::StandardValidators::get().BOOLEAN_VALIDATOR.get())},
-  {Configuration::nifi_c2_coap_connector_service, 
gsl::make_not_null(core::StandardValidators::get().VALID_VALIDATOR.get())},
-  {Configuration::nifi_c2_agent_heartbeat_period, 
gsl::make_not_null(core::StandardValidators::get().UNSIGNED_INT_VALIDATOR.get())},
-  {Configuration::nifi_c2_agent_heartbeat_reporter_classes, 
gsl::make_not_null(core::StandardValidators::get().VALID_VALIDATOR.get())},
-  {Configuration::nifi_c2_agent_class, 
gsl::make_not_null(core::StandardValidators::get().VALID_VALIDATOR.get())},
-  {Configuration::nifi_c2_agent_coap_host, 
gsl::make_not_null(core::StandardValidators::get().VALID_VALIDATOR.get())},
-  {Configuration::nifi_c2_agent_coap_port, 
gsl::make_not_null(core::StandardValidators::get().PORT_VALIDATOR.get())},
-  {Configuration::nifi_c2_agent_protocol_class, 
gsl::make_not_null(core::StandardValidators::get().VALID_VALIDATOR.get())},
-  {Configuration::nifi_c2_agent_identifier, 
gsl::make_not_null(core::StandardValidators::get().VALID_VALIDATOR.get())},
-  {Configuration::nifi_c2_agent_identifier_fallback, 
gsl::make_not_null(core::StandardValidators::get().VALID_VALIDATOR.get())},
-  {Configuration::nifi_c2_agent_trigger_classes, 
gsl::make_not_null(core::StandardValidators::get().VALID_VALIDATOR.get())},
-  {Configuration::nifi_c2_root_classes, 
gsl::make_not_null(core::StandardValidators::get().VALID_VALIDATOR.get())},
-  {Configuration::nifi_c2_root_class_definitions, 
gsl::make_not_null(core::StandardValidators::get().VALID_VALIDATOR.get())},
-  {Configuration::nifi_c2_rest_listener_port, 
gsl::make_not_null(core::StandardValidators::get().LISTEN_PORT_VALIDATOR.get())},
-  {Configuration::nifi_c2_rest_listener_cacert, 
gsl::make_not_null(core::StandardValidators::get().VALID_VALIDATOR.get())},
-  {Configuration::nifi_c2_rest_url, 
gsl::make_not_null(core::StandardValidators::get().VALID_VALIDATOR.get())},
-  {Configuration::nifi_c2_rest_url_ack, 
gsl::make_not_null(core::StandardValidators::get().VALID_VALIDATOR.get())},
-  {Configuration::nifi_c2_rest_ssl_context_service, 
gsl::make_not_null(core::StandardValidators::get().VALID_VALIDATOR.get())},
-  {Configuration::nifi_c2_rest_request_encoding, 
gsl::make_not_null(core::StandardValidators::get().VALID_VALIDATOR.get())},
-  {Configuration::nifi_c2_rest_heartbeat_minimize_updates, 
gsl::make_not_null(core::StandardValidators::get().BOOLEAN_VALIDATOR.get())},
-  {Configuration::nifi_c2_mqtt_connector_service, 
gsl::make_not_null(core::StandardValidators::get().VALID_VALIDATOR.get())},
-  {Configuration::nifi_c2_mqtt_heartbeat_topic, 
gsl::make_not_null(core::StandardValidators::get().VALID_VALIDATOR.get())},
-  {Configuration::nifi_c2_mqtt_update_topic, 
gsl::make_not_null(core::StandardValidators::get().VALID_VALIDATOR.get())},
-  {Configuration::nifi_state_storage_local, 
gsl::make_not_null(core::StandardValidators::get().VALID_VALIDATOR.get())},
-  {Configuration::nifi_state_storage_local_old, 
gsl::make_not_null(core::StandardValidators::get().VALID_VALIDATOR.get())},
-  {Configuration::nifi_state_storage_local_class_name, 
gsl::make_not_null(core::StandardValidators::get().VALID_VALIDATOR.get())},
-  {Configuration::nifi_state_storage_local_class_name_old, 
gsl::make_not_null(core::StandardValidators::get().VALID_VALIDATOR.get())},
-  {Configuration::nifi_state_storage_local_always_persist, 
gsl::make_not_null(core::StandardValidators::get().BOOLEAN_VALIDATOR.get())},
-  {Configuration::nifi_state_storage_local_always_persist_old, 
gsl::make_not_null(core::StandardValidators::get().BOOLEAN_VALIDATOR.get())},
-  {Configuration::nifi_state_storage_local_auto_persistence_interval, 
gsl::make_not_null(core::StandardValidators::get().TIME_PERIOD_VALIDATOR.get())},
-  {Configuration::nifi_state_storage_local_auto_persistence_interval_old, 
gsl::make_not_null(core::StandardValidators::get().TIME_PERIOD_VALIDATOR.get())},
-  {Configuration::nifi_state_storage_local_path, 
gsl::make_not_null(core::StandardValidators::get().VALID_VALIDATOR.get())},
-  {Configuration::nifi_state_storage_local_path_old, 
gsl::make_not_null(core::StandardValidators::get().VALID_VALIDATOR.get())},
-  {Configuration::minifi_disk_space_watchdog_enable, 
gsl::make_not_null(core::StandardValidators::get().BOOLEAN_VALIDATOR.get())},
-  {Configuration::minifi_disk_space_watchdog_interval, 
gsl::make_not_null(core::StandardValidators::get().TIME_PERIOD_VALIDATOR.get())},
-  {Configuration::minifi_disk_space_watchdog_stop_threshold, 
gsl::make_not_null(core::StandardValidators::get().UNSIGNED_LONG_VALIDATOR.get())},
-  {Configuration::minifi_disk_space_watchdog_restart_threshold, 
gsl::make_not_null(core::StandardValidators::get().UNSIGNED_LONG_VALIDATOR.get())},
-  {Configuration::nifi_framework_dir, 
gsl::make_not_null(core::StandardValidators::get().VALID_VALIDATOR.get())},
-  {Configuration::nifi_jvm_options, 
gsl::make_not_null(core::StandardValidators::get().VALID_VALIDATOR.get())},
-  {Configuration::nifi_nar_directory, 
gsl::make_not_null(core::StandardValidators::get().VALID_VALIDATOR.get())},
-  {Configuration::nifi_nar_deploy_directory, 
gsl::make_not_null(core::StandardValidators::get().VALID_VALIDATOR.get())},
-  {Configuration::nifi_log_spdlog_pattern, 
gsl::make_not_null(core::StandardValidators::get().VALID_VALIDATOR.get())},
-  {Configuration::nifi_log_spdlog_shorten_names, 
gsl::make_not_null(core::StandardValidators::get().BOOLEAN_VALIDATOR.get())},
-  {Configuration::nifi_log_appender_rolling, 
gsl::make_not_null(core::StandardValidators::get().VALID_VALIDATOR.get())},
-  {Configuration::nifi_log_appender_rolling_directory, 
gsl::make_not_null(core::StandardValidators::get().VALID_VALIDATOR.get())},
-  {Configuration::nifi_log_appender_rolling_file_name, 
gsl::make_not_null(core::StandardValidators::get().VALID_VALIDATOR.get())},
-  {Configuration::nifi_log_appender_rolling_max_files, 
gsl::make_not_null(core::StandardValidators::get().UNSIGNED_INT_VALIDATOR.get())},
-  {Configuration::nifi_log_appender_rolling_max_file_size, 
gsl::make_not_null(core::StandardValidators::get().DATA_SIZE_VALIDATOR.get())},
-  {Configuration::nifi_log_appender_stdout, 
gsl::make_not_null(core::StandardValidators::get().VALID_VALIDATOR.get())},
-  {Configuration::nifi_log_appender_stderr, 
gsl::make_not_null(core::StandardValidators::get().VALID_VALIDATOR.get())},
-  {Configuration::nifi_log_appender_null, 
gsl::make_not_null(core::StandardValidators::get().VALID_VALIDATOR.get())},
-  {Configuration::nifi_log_appender_syslog, 
gsl::make_not_null(core::StandardValidators::get().VALID_VALIDATOR.get())},
-  {Configuration::nifi_log_logger_root, 
gsl::make_not_null(core::StandardValidators::get().VALID_VALIDATOR.get())},
-  {Configuration::nifi_log_compression_cached_log_max_size, 
gsl::make_not_null(core::StandardValidators::get().DATA_SIZE_VALIDATOR.get())},
-  {Configuration::nifi_log_compression_compressed_log_max_size, 
gsl::make_not_null(core::StandardValidators::get().DATA_SIZE_VALIDATOR.get())},
-  {Configuration::nifi_log_alert_url, 
gsl::make_not_null(core::StandardValidators::get().VALID_VALIDATOR.get())},
-  {Configuration::nifi_log_alert_ssl_context_service, 
gsl::make_not_null(core::StandardValidators::get().VALID_VALIDATOR.get())},
-  {Configuration::nifi_log_alert_batch_size, 
gsl::make_not_null(core::StandardValidators::get().VALID_VALIDATOR.get())},
-  {Configuration::nifi_log_alert_flush_period, 
gsl::make_not_null(core::StandardValidators::get().TIME_PERIOD_VALIDATOR.get())},
-  {Configuration::nifi_log_alert_filter, 
gsl::make_not_null(core::StandardValidators::get().VALID_VALIDATOR.get())},
-  {Configuration::nifi_log_alert_rate_limit, 
gsl::make_not_null(core::StandardValidators::get().VALID_VALIDATOR.get())},
-  {Configuration::nifi_log_alert_buffer_limit, 
gsl::make_not_null(core::StandardValidators::get().VALID_VALIDATOR.get())},
-  {Configuration::nifi_log_alert_level, 
gsl::make_not_null(core::StandardValidators::get().VALID_VALIDATOR.get())},
-  {Configuration::nifi_asset_directory, 
gsl::make_not_null(core::StandardValidators::get().VALID_VALIDATOR.get())},
-  {Configuration::nifi_metrics_publisher_agent_identifier, 
gsl::make_not_null(core::StandardValidators::get().VALID_VALIDATOR.get())},
-  {Configuration::nifi_metrics_publisher_class, 
gsl::make_not_null(core::StandardValidators::get().VALID_VALIDATOR.get())},
-  {Configuration::nifi_metrics_publisher_prometheus_metrics_publisher_port, 
gsl::make_not_null(core::StandardValidators::get().PORT_VALIDATOR.get())},
-  {Configuration::nifi_metrics_publisher_metrics, 
gsl::make_not_null(core::StandardValidators::get().VALID_VALIDATOR.get())},
-  {Configuration::controller_socket_enable, 
gsl::make_not_null(core::StandardValidators::get().BOOLEAN_VALIDATOR.get())},
-  {Configuration::controller_socket_local_any_interface, 
gsl::make_not_null(core::StandardValidators::get().BOOLEAN_VALIDATOR.get())},
-  {Configuration::controller_socket_host, 
gsl::make_not_null(core::StandardValidators::get().VALID_VALIDATOR.get())},
-  {Configuration::controller_socket_port, 
gsl::make_not_null(core::StandardValidators::get().PORT_VALIDATOR.get())},
-  {Configuration::controller_ssl_context_service, 
gsl::make_not_null(core::StandardValidators::get().VALID_VALIDATOR.get())}
+const std::unordered_map<std::string_view, gsl::not_null<const 
core::PropertyValidator*>> Configuration::CONFIGURATION_PROPERTIES{
+  {Configuration::nifi_default_directory, 
gsl::make_not_null(&core::StandardValidators::VALID_VALIDATOR)},
+  {Configuration::nifi_flow_configuration_file, 
gsl::make_not_null(&core::StandardValidators::VALID_VALIDATOR)},
+  {Configuration::nifi_flow_configuration_encrypt, 
gsl::make_not_null(&core::StandardValidators::BOOLEAN_VALIDATOR)},
+  {Configuration::nifi_flow_configuration_file_backup_update, 
gsl::make_not_null(&core::StandardValidators::BOOLEAN_VALIDATOR)},
+  {Configuration::nifi_flow_engine_threads, 
gsl::make_not_null(&core::StandardValidators::UNSIGNED_INT_VALIDATOR)},
+  {Configuration::nifi_flow_engine_alert_period, 
gsl::make_not_null(&core::StandardValidators::TIME_PERIOD_VALIDATOR)},
+  {Configuration::nifi_flow_engine_event_driven_time_slice, 
gsl::make_not_null(&core::StandardValidators::TIME_PERIOD_VALIDATOR)},
+  {Configuration::nifi_administrative_yield_duration, 
gsl::make_not_null(&core::StandardValidators::TIME_PERIOD_VALIDATOR)},
+  {Configuration::nifi_bored_yield_duration, 
gsl::make_not_null(&core::StandardValidators::TIME_PERIOD_VALIDATOR)},
+  {Configuration::nifi_graceful_shutdown_seconds, 
gsl::make_not_null(&core::StandardValidators::TIME_PERIOD_VALIDATOR)},
+  {Configuration::nifi_flowcontroller_drain_timeout, 
gsl::make_not_null(&core::StandardValidators::TIME_PERIOD_VALIDATOR)},
+  {Configuration::nifi_server_name, 
gsl::make_not_null(&core::StandardValidators::VALID_VALIDATOR)},
+  {Configuration::nifi_configuration_class_name, 
gsl::make_not_null(&core::StandardValidators::VALID_VALIDATOR)},
+  {Configuration::nifi_flow_repository_class_name, 
gsl::make_not_null(&core::StandardValidators::VALID_VALIDATOR)},
+  {Configuration::nifi_flow_repository_rocksdb_compression, 
gsl::make_not_null(&core::StandardValidators::VALID_VALIDATOR)},
+  {Configuration::nifi_content_repository_class_name, 
gsl::make_not_null(&core::StandardValidators::VALID_VALIDATOR)},
+  {Configuration::nifi_content_repository_rocksdb_compression, 
gsl::make_not_null(&core::StandardValidators::VALID_VALIDATOR)},
+  {Configuration::nifi_provenance_repository_class_name, 
gsl::make_not_null(&core::StandardValidators::VALID_VALIDATOR)},
+  {Configuration::nifi_volatile_repository_options_flowfile_max_count, 
gsl::make_not_null(&core::StandardValidators::UNSIGNED_INT_VALIDATOR)},
+  {Configuration::nifi_volatile_repository_options_flowfile_max_bytes, 
gsl::make_not_null(&core::StandardValidators::DATA_SIZE_VALIDATOR)},
+  {Configuration::nifi_volatile_repository_options_provenance_max_count, 
gsl::make_not_null(&core::StandardValidators::UNSIGNED_INT_VALIDATOR)},
+  {Configuration::nifi_volatile_repository_options_provenance_max_bytes, 
gsl::make_not_null(&core::StandardValidators::DATA_SIZE_VALIDATOR)},
+  {Configuration::nifi_volatile_repository_options_content_max_count, 
gsl::make_not_null(&core::StandardValidators::UNSIGNED_INT_VALIDATOR)},
+  {Configuration::nifi_volatile_repository_options_content_max_bytes, 
gsl::make_not_null(&core::StandardValidators::DATA_SIZE_VALIDATOR)},
+  {Configuration::nifi_volatile_repository_options_content_minimal_locking, 
gsl::make_not_null(&core::StandardValidators::BOOLEAN_VALIDATOR)},
+  {Configuration::nifi_server_port, 
gsl::make_not_null(&core::StandardValidators::PORT_VALIDATOR)},
+  {Configuration::nifi_server_report_interval, 
gsl::make_not_null(&core::StandardValidators::TIME_PERIOD_VALIDATOR)},
+  {Configuration::nifi_provenance_repository_max_storage_size, 
gsl::make_not_null(&core::StandardValidators::DATA_SIZE_VALIDATOR)},
+  {Configuration::nifi_provenance_repository_max_storage_time, 
gsl::make_not_null(&core::StandardValidators::TIME_PERIOD_VALIDATOR)},
+  {Configuration::nifi_provenance_repository_directory_default, 
gsl::make_not_null(&core::StandardValidators::VALID_VALIDATOR)},
+  {Configuration::nifi_flowfile_repository_directory_default, 
gsl::make_not_null(&core::StandardValidators::VALID_VALIDATOR)},
+  {Configuration::nifi_dbcontent_repository_directory_default, 
gsl::make_not_null(&core::StandardValidators::VALID_VALIDATOR)},
+  {Configuration::nifi_flowfile_repository_rocksdb_compaction_period, 
gsl::make_not_null(&core::StandardValidators::TIME_PERIOD_VALIDATOR)},
+  {Configuration::nifi_dbcontent_repository_rocksdb_compaction_period, 
gsl::make_not_null(&core::StandardValidators::TIME_PERIOD_VALIDATOR)},
+  {Configuration::nifi_remote_input_secure, 
gsl::make_not_null(&core::StandardValidators::BOOLEAN_VALIDATOR)},
+  {Configuration::nifi_security_need_ClientAuth, 
gsl::make_not_null(&core::StandardValidators::BOOLEAN_VALIDATOR)},
+  {Configuration::nifi_sensitive_props_additional_keys, 
gsl::make_not_null(&core::StandardValidators::VALID_VALIDATOR)},
+  {Configuration::nifi_python_processor_dir, 
gsl::make_not_null(&core::StandardValidators::VALID_VALIDATOR)},
+  {Configuration::nifi_extension_path, 
gsl::make_not_null(&core::StandardValidators::VALID_VALIDATOR)},
+  {Configuration::nifi_security_client_certificate, 
gsl::make_not_null(&core::StandardValidators::VALID_VALIDATOR)},
+  {Configuration::nifi_security_client_private_key, 
gsl::make_not_null(&core::StandardValidators::VALID_VALIDATOR)},
+  {Configuration::nifi_security_client_pass_phrase, 
gsl::make_not_null(&core::StandardValidators::VALID_VALIDATOR)},
+  {Configuration::nifi_security_client_ca_certificate, 
gsl::make_not_null(&core::StandardValidators::VALID_VALIDATOR)},
+  {Configuration::nifi_security_use_system_cert_store, 
gsl::make_not_null(&core::StandardValidators::VALID_VALIDATOR)},
+  {Configuration::nifi_security_windows_cert_store_location, 
gsl::make_not_null(&core::StandardValidators::VALID_VALIDATOR)},
+  {Configuration::nifi_security_windows_server_cert_store, 
gsl::make_not_null(&core::StandardValidators::VALID_VALIDATOR)},
+  {Configuration::nifi_security_windows_client_cert_store, 
gsl::make_not_null(&core::StandardValidators::VALID_VALIDATOR)},
+  {Configuration::nifi_security_windows_client_cert_cn, 
gsl::make_not_null(&core::StandardValidators::VALID_VALIDATOR)},
+  {Configuration::nifi_security_windows_client_cert_key_usage, 
gsl::make_not_null(&core::StandardValidators::VALID_VALIDATOR)},
+  {Configuration::nifi_rest_api_user_name, 
gsl::make_not_null(&core::StandardValidators::VALID_VALIDATOR)},
+  {Configuration::nifi_rest_api_password, 
gsl::make_not_null(&core::StandardValidators::VALID_VALIDATOR)},
+  {Configuration::nifi_c2_enable, 
gsl::make_not_null(&core::StandardValidators::BOOLEAN_VALIDATOR)},
+  {Configuration::nifi_c2_file_watch, 
gsl::make_not_null(&core::StandardValidators::VALID_VALIDATOR)},
+  {Configuration::nifi_c2_flow_id, 
gsl::make_not_null(&core::StandardValidators::VALID_VALIDATOR)},
+  {Configuration::nifi_c2_flow_url, 
gsl::make_not_null(&core::StandardValidators::VALID_VALIDATOR)},
+  {Configuration::nifi_c2_flow_base_url, 
gsl::make_not_null(&core::StandardValidators::VALID_VALIDATOR)},
+  {Configuration::nifi_c2_full_heartbeat, 
gsl::make_not_null(&core::StandardValidators::BOOLEAN_VALIDATOR)},
+  {Configuration::nifi_c2_coap_connector_service, 
gsl::make_not_null(&core::StandardValidators::VALID_VALIDATOR)},
+  {Configuration::nifi_c2_agent_heartbeat_period, 
gsl::make_not_null(&core::StandardValidators::UNSIGNED_INT_VALIDATOR)},
+  {Configuration::nifi_c2_agent_heartbeat_reporter_classes, 
gsl::make_not_null(&core::StandardValidators::VALID_VALIDATOR)},
+  {Configuration::nifi_c2_agent_class, 
gsl::make_not_null(&core::StandardValidators::VALID_VALIDATOR)},
+  {Configuration::nifi_c2_agent_coap_host, 
gsl::make_not_null(&core::StandardValidators::VALID_VALIDATOR)},
+  {Configuration::nifi_c2_agent_coap_port, 
gsl::make_not_null(&core::StandardValidators::PORT_VALIDATOR)},
+  {Configuration::nifi_c2_agent_protocol_class, 
gsl::make_not_null(&core::StandardValidators::VALID_VALIDATOR)},
+  {Configuration::nifi_c2_agent_identifier, 
gsl::make_not_null(&core::StandardValidators::VALID_VALIDATOR)},
+  {Configuration::nifi_c2_agent_identifier_fallback, 
gsl::make_not_null(&core::StandardValidators::VALID_VALIDATOR)},
+  {Configuration::nifi_c2_agent_trigger_classes, 
gsl::make_not_null(&core::StandardValidators::VALID_VALIDATOR)},
+  {Configuration::nifi_c2_root_classes, 
gsl::make_not_null(&core::StandardValidators::VALID_VALIDATOR)},
+  {Configuration::nifi_c2_root_class_definitions, 
gsl::make_not_null(&core::StandardValidators::VALID_VALIDATOR)},
+  {Configuration::nifi_c2_rest_listener_port, 
gsl::make_not_null(&core::StandardValidators::LISTEN_PORT_VALIDATOR)},
+  {Configuration::nifi_c2_rest_listener_cacert, 
gsl::make_not_null(&core::StandardValidators::VALID_VALIDATOR)},
+  {Configuration::nifi_c2_rest_url, 
gsl::make_not_null(&core::StandardValidators::VALID_VALIDATOR)},
+  {Configuration::nifi_c2_rest_url_ack, 
gsl::make_not_null(&core::StandardValidators::VALID_VALIDATOR)},
+  {Configuration::nifi_c2_rest_ssl_context_service, 
gsl::make_not_null(&core::StandardValidators::VALID_VALIDATOR)},
+  {Configuration::nifi_c2_rest_request_encoding, 
gsl::make_not_null(&core::StandardValidators::VALID_VALIDATOR)},
+  {Configuration::nifi_c2_rest_heartbeat_minimize_updates, 
gsl::make_not_null(&core::StandardValidators::BOOLEAN_VALIDATOR)},
+  {Configuration::nifi_c2_mqtt_connector_service, 
gsl::make_not_null(&core::StandardValidators::VALID_VALIDATOR)},
+  {Configuration::nifi_c2_mqtt_heartbeat_topic, 
gsl::make_not_null(&core::StandardValidators::VALID_VALIDATOR)},
+  {Configuration::nifi_c2_mqtt_update_topic, 
gsl::make_not_null(&core::StandardValidators::VALID_VALIDATOR)},
+  {Configuration::nifi_state_storage_local, 
gsl::make_not_null(&core::StandardValidators::VALID_VALIDATOR)},
+  {Configuration::nifi_state_storage_local_old, 
gsl::make_not_null(&core::StandardValidators::VALID_VALIDATOR)},
+  {Configuration::nifi_state_storage_local_class_name, 
gsl::make_not_null(&core::StandardValidators::VALID_VALIDATOR)},
+  {Configuration::nifi_state_storage_local_class_name_old, 
gsl::make_not_null(&core::StandardValidators::VALID_VALIDATOR)},
+  {Configuration::nifi_state_storage_local_always_persist, 
gsl::make_not_null(&core::StandardValidators::BOOLEAN_VALIDATOR)},
+  {Configuration::nifi_state_storage_local_always_persist_old, 
gsl::make_not_null(&core::StandardValidators::BOOLEAN_VALIDATOR)},
+  {Configuration::nifi_state_storage_local_auto_persistence_interval, 
gsl::make_not_null(&core::StandardValidators::TIME_PERIOD_VALIDATOR)},
+  {Configuration::nifi_state_storage_local_auto_persistence_interval_old, 
gsl::make_not_null(&core::StandardValidators::TIME_PERIOD_VALIDATOR)},
+  {Configuration::nifi_state_storage_local_path, 
gsl::make_not_null(&core::StandardValidators::VALID_VALIDATOR)},
+  {Configuration::nifi_state_storage_local_path_old, 
gsl::make_not_null(&core::StandardValidators::VALID_VALIDATOR)},
+  {Configuration::minifi_disk_space_watchdog_enable, 
gsl::make_not_null(&core::StandardValidators::BOOLEAN_VALIDATOR)},
+  {Configuration::minifi_disk_space_watchdog_interval, 
gsl::make_not_null(&core::StandardValidators::TIME_PERIOD_VALIDATOR)},
+  {Configuration::minifi_disk_space_watchdog_stop_threshold, 
gsl::make_not_null(&core::StandardValidators::UNSIGNED_LONG_VALIDATOR)},
+  {Configuration::minifi_disk_space_watchdog_restart_threshold, 
gsl::make_not_null(&core::StandardValidators::UNSIGNED_LONG_VALIDATOR)},
+  {Configuration::nifi_framework_dir, 
gsl::make_not_null(&core::StandardValidators::VALID_VALIDATOR)},
+  {Configuration::nifi_jvm_options, 
gsl::make_not_null(&core::StandardValidators::VALID_VALIDATOR)},
+  {Configuration::nifi_nar_directory, 
gsl::make_not_null(&core::StandardValidators::VALID_VALIDATOR)},
+  {Configuration::nifi_nar_deploy_directory, 
gsl::make_not_null(&core::StandardValidators::VALID_VALIDATOR)},
+  {Configuration::nifi_log_spdlog_pattern, 
gsl::make_not_null(&core::StandardValidators::VALID_VALIDATOR)},
+  {Configuration::nifi_log_spdlog_shorten_names, 
gsl::make_not_null(&core::StandardValidators::BOOLEAN_VALIDATOR)},
+  {Configuration::nifi_log_appender_rolling, 
gsl::make_not_null(&core::StandardValidators::VALID_VALIDATOR)},
+  {Configuration::nifi_log_appender_rolling_directory, 
gsl::make_not_null(&core::StandardValidators::VALID_VALIDATOR)},
+  {Configuration::nifi_log_appender_rolling_file_name, 
gsl::make_not_null(&core::StandardValidators::VALID_VALIDATOR)},
+  {Configuration::nifi_log_appender_rolling_max_files, 
gsl::make_not_null(&core::StandardValidators::UNSIGNED_INT_VALIDATOR)},
+  {Configuration::nifi_log_appender_rolling_max_file_size, 
gsl::make_not_null(&core::StandardValidators::DATA_SIZE_VALIDATOR)},
+  {Configuration::nifi_log_appender_stdout, 
gsl::make_not_null(&core::StandardValidators::VALID_VALIDATOR)},
+  {Configuration::nifi_log_appender_stderr, 
gsl::make_not_null(&core::StandardValidators::VALID_VALIDATOR)},
+  {Configuration::nifi_log_appender_null, 
gsl::make_not_null(&core::StandardValidators::VALID_VALIDATOR)},
+  {Configuration::nifi_log_appender_syslog, 
gsl::make_not_null(&core::StandardValidators::VALID_VALIDATOR)},
+  {Configuration::nifi_log_logger_root, 
gsl::make_not_null(&core::StandardValidators::VALID_VALIDATOR)},
+  {Configuration::nifi_log_compression_cached_log_max_size, 
gsl::make_not_null(&core::StandardValidators::DATA_SIZE_VALIDATOR)},
+  {Configuration::nifi_log_compression_compressed_log_max_size, 
gsl::make_not_null(&core::StandardValidators::DATA_SIZE_VALIDATOR)},
+  {Configuration::nifi_log_alert_url, 
gsl::make_not_null(&core::StandardValidators::VALID_VALIDATOR)},
+  {Configuration::nifi_log_alert_ssl_context_service, 
gsl::make_not_null(&core::StandardValidators::VALID_VALIDATOR)},
+  {Configuration::nifi_log_alert_batch_size, 
gsl::make_not_null(&core::StandardValidators::VALID_VALIDATOR)},
+  {Configuration::nifi_log_alert_flush_period, 
gsl::make_not_null(&core::StandardValidators::TIME_PERIOD_VALIDATOR)},
+  {Configuration::nifi_log_alert_filter, 
gsl::make_not_null(&core::StandardValidators::VALID_VALIDATOR)},
+  {Configuration::nifi_log_alert_rate_limit, 
gsl::make_not_null(&core::StandardValidators::VALID_VALIDATOR)},
+  {Configuration::nifi_log_alert_buffer_limit, 
gsl::make_not_null(&core::StandardValidators::VALID_VALIDATOR)},
+  {Configuration::nifi_log_alert_level, 
gsl::make_not_null(&core::StandardValidators::VALID_VALIDATOR)},
+  {Configuration::nifi_asset_directory, 
gsl::make_not_null(&core::StandardValidators::VALID_VALIDATOR)},
+  {Configuration::nifi_metrics_publisher_agent_identifier, 
gsl::make_not_null(&core::StandardValidators::VALID_VALIDATOR)},
+  {Configuration::nifi_metrics_publisher_class, 
gsl::make_not_null(&core::StandardValidators::VALID_VALIDATOR)},
+  {Configuration::nifi_metrics_publisher_prometheus_metrics_publisher_port, 
gsl::make_not_null(&core::StandardValidators::PORT_VALIDATOR)},
+  {Configuration::nifi_metrics_publisher_metrics, 
gsl::make_not_null(&core::StandardValidators::VALID_VALIDATOR)},
+  {Configuration::controller_socket_enable, 
gsl::make_not_null(&core::StandardValidators::BOOLEAN_VALIDATOR)},
+  {Configuration::controller_socket_local_any_interface, 
gsl::make_not_null(&core::StandardValidators::BOOLEAN_VALIDATOR)},
+  {Configuration::controller_socket_host, 
gsl::make_not_null(&core::StandardValidators::VALID_VALIDATOR)},
+  {Configuration::controller_socket_port, 
gsl::make_not_null(&core::StandardValidators::PORT_VALIDATOR)},
+  {Configuration::controller_ssl_context_service, 
gsl::make_not_null(&core::StandardValidators::VALID_VALIDATOR)}
 };
 
 const std::array<const char*, 2> Configuration::DEFAULT_SENSITIVE_PROPERTIES = 
{Configuration::nifi_security_client_pass_phrase,
diff --git a/libminifi/src/core/Property.cpp b/libminifi/src/core/Property.cpp
index c2a0e92ae..2da633178 100644
--- a/libminifi/src/core/Property.cpp
+++ b/libminifi/src/core/Property.cpp
@@ -17,11 +17,8 @@
  */
 
 #include "core/Property.h"
-namespace org {
-namespace apache {
-namespace nifi {
-namespace minifi {
-namespace core {
+
+namespace org::apache::nifi::minifi::core {
 
 std::string Property::getName() const {
   return name_;
@@ -58,8 +55,8 @@ std::string Property::getValidRegex() const {
   return valid_regex_;
 }
 
-std::shared_ptr<PropertyValidator> Property::getValidator() const {
-  return validator_;
+const PropertyValidator& Property::getValidator() const {
+  return *validator_;
 }
 
 std::vector<std::string> Property::getValues() {
@@ -93,8 +90,4 @@ std::vector<std::pair<std::string, std::string>> 
Property::getExclusiveOfPropert
   return exclusive_of_properties_;
 }
 
-} /* namespace core */
-} /* namespace minifi */
-} /* namespace nifi */
-} /* namespace apache */
-} /* namespace org */
+}  // namespace org::apache::nifi::minifi::core
diff --git a/libminifi/src/core/PropertyValidation.cpp 
b/libminifi/src/core/PropertyValidation.cpp
deleted file mode 100644
index ff6da98ec..000000000
--- a/libminifi/src/core/PropertyValidation.cpp
+++ /dev/null
@@ -1,46 +0,0 @@
-/**
- *
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "core/PropertyValidation.h"
-namespace org {
-namespace apache {
-namespace nifi {
-namespace minifi {
-namespace core {
-
-StandardValidators::StandardValidators()
-  : INVALID(std::make_shared<AlwaysValid>(false, "INVALID")),
-    INTEGER_VALIDATOR(std::make_shared<IntegerValidator>("INTEGER_VALIDATOR")),
-    
UNSIGNED_INT_VALIDATOR(std::make_shared<UnsignedIntValidator>("NON_NEGATIVE_INTEGER_VALIDATOR")),
-    LONG_VALIDATOR(std::make_shared<LongValidator>("LONG_VALIDATOR")),
-    // name is used by java nifi validators, so we should keep this LONG and 
not change to reflect
-    // its internal use
-    
UNSIGNED_LONG_VALIDATOR(std::make_shared<UnsignedLongValidator>("LONG_VALIDATOR")),
-    BOOLEAN_VALIDATOR(std::make_shared<BooleanValidator>("BOOLEAN_VALIDATOR")),
-    
DATA_SIZE_VALIDATOR(std::make_shared<DataSizeValidator>("DATA_SIZE_VALIDATOR")),
-    
TIME_PERIOD_VALIDATOR(std::make_shared<TimePeriodValidator>("TIME_PERIOD_VALIDATOR")),
-    
NON_BLANK_VALIDATOR(std::make_shared<NonBlankValidator>("NON_BLANK_VALIDATOR")),
-    VALID_VALIDATOR(std::make_shared<AlwaysValid>(true, "VALID")),
-    PORT_VALIDATOR(std::make_shared<PortValidator>("PORT_VALIDATOR")),
-    
LISTEN_PORT_VALIDATOR(std::make_shared<ListenPortValidator>("PORT_VALIDATOR")) 
{}
-
-} /* namespace core */
-} /* namespace minifi */
-} /* namespace nifi */
-} /* namespace apache */
-} /* namespace org */
diff --git a/libminifi/src/properties/Properties.cpp 
b/libminifi/src/properties/Properties.cpp
index 9b694b3a0..e004c0d47 100644
--- a/libminifi/src/properties/Properties.cpp
+++ b/libminifi/src/properties/Properties.cpp
@@ -73,7 +73,7 @@ const core::PropertyValidator* getValidator(const 
std::string& lookup_value) {
 }
 
 std::optional<std::string> 
ensureTimePeriodValidatedPropertyHasExplicitUnit(const core::PropertyValidator* 
const validator, std::string& value) {
-  if (validator != core::StandardValidators::get().TIME_PERIOD_VALIDATOR.get())
+  if (validator != &core::StandardValidators::TIME_PERIOD_VALIDATOR)
     return std::nullopt;
   if (value.empty() || !std::all_of(value.begin(), value.end(), [](unsigned 
char c){ return ::isdigit(c); }))
     return std::nullopt;
@@ -82,7 +82,7 @@ std::optional<std::string> 
ensureTimePeriodValidatedPropertyHasExplicitUnit(cons
 }
 
 std::optional<std::string> 
ensureDataSizeValidatedPropertyHasExplicitUnit(const core::PropertyValidator* 
const validator, std::string& value) {
-  if (validator != core::StandardValidators::get().DATA_SIZE_VALIDATOR.get())
+  if (validator != &core::StandardValidators::DATA_SIZE_VALIDATOR)
     return std::nullopt;
   if (value.empty() || !std::all_of(value.begin(), value.end(), [](unsigned 
char c){ return ::isdigit(c); }))
     return std::nullopt;
@@ -91,10 +91,10 @@ std::optional<std::string> 
ensureDataSizeValidatedPropertyHasExplicitUnit(const
 }
 
 bool integerValidatedProperty(const core::PropertyValidator* const validator) {
-  return validator == core::StandardValidators::get().INTEGER_VALIDATOR.get()
-      || validator == 
core::StandardValidators::get().UNSIGNED_INT_VALIDATOR.get()
-      || validator == core::StandardValidators::get().LONG_VALIDATOR.get()
-      || validator == 
core::StandardValidators::get().UNSIGNED_LONG_VALIDATOR.get();
+  return validator == &core::StandardValidators::INTEGER_VALIDATOR
+      || validator == &core::StandardValidators::UNSIGNED_INT_VALIDATOR
+      || validator == &core::StandardValidators::LONG_VALIDATOR
+      || validator == &core::StandardValidators::UNSIGNED_LONG_VALIDATOR;
 }
 
 std::optional<int64_t> stringToDataSize(std::string_view input) {
diff --git a/libminifi/test/unit/PropertyValidationTests.cpp 
b/libminifi/test/unit/PropertyValidationTests.cpp
index e8803b15f..de95910dc 100644
--- a/libminifi/test/unit/PropertyValidationTests.cpp
+++ b/libminifi/test/unit/PropertyValidationTests.cpp
@@ -220,8 +220,9 @@ TEST_CASE("Property Change notification gets called even on 
erroneous assignment
 }
 
 TEST_CASE("Correctly Typed Property With Invalid Validation") {
+  LongValidator my_validator{0, 10};
   auto prop = PropertyBuilder::createProperty("prop")
-      ->withDefaultValue<int64_t>(5, 
std::make_shared<LongValidator>("myValidator", 0, 10))
+      ->withDefaultValue<int64_t>(5, my_validator)
       ->build();
   TestConfigurableComponent component;
   component.setSupportedProperties(std::array{prop});
@@ -262,7 +263,7 @@ TEST_CASE("TimePeriodValue Property without validator") {
 
 TEST_CASE("Validating listener port property") {
   auto prop = core::PropertyBuilder::createProperty("Port")
-        ->withType(core::StandardValidators::get().LISTEN_PORT_VALIDATOR)
+        ->withType(core::StandardValidators::LISTEN_PORT_VALIDATOR)
         ->build();
   REQUIRE_NOTHROW(prop.setValue("1234"));
   REQUIRE_THROWS_AS(prop.setValue("banana"), InvalidValueException);

[nifi-minifi-cpp] branch main updated: MINIFICPP-2094 Change validators from shared to raw pointers

Reply via email to