Improve the readability of STBase-derived types

* Increase the visibility of each type's API.
* No functional changes.

src/ripple/protocol/STValidation.h

@@ -43,6 +43,21 @@ constexpr std::uint32_t vfFullyCanonicalSig = 0x80000000;
 
 class STValidation final : public STObject, public CountedObject<STValidation>
 {
+    bool mTrusted = false;
+
+    // Determines the validity of the signature in this validation; unseated
+    // optional if we haven't yet checked it, a boolean otherwise.
+    mutable std::optional<bool> valid_;
+
+    // The public key associated with the key used to sign this validation
+    PublicKey const signingPubKey_;
+
+    // The ID of the validator that issued this validation. For validators
+    // that use manifests this will be derived from the master public key.
+    NodeID const nodeID_;
+
+    NetClock::time_point seenTime_ = {};
+
 public:
     /** Construct a STValidation from a peer from serialized data.
 
@@ -61,27 +76,7 @@ public:
     STValidation(
         SerialIter& sit,
         LookupNodeID&& lookupNodeID,
-        bool checkSignature)
-        : STObject(validationFormat(), sit, sfValidation)
-        , signingPubKey_([this]() {
-            auto const spk = getFieldVL(sfSigningPubKey);
-
-            if (publicKeyType(makeSlice(spk)) != KeyType::secp256k1)
-                Throw<std::runtime_error>("Invalid public key in validation");
-
-            return PublicKey{makeSlice(spk)};
-        }())
-        , nodeID_(lookupNodeID(signingPubKey_))
-    {
-        if (checkSignature && !isValid())
-        {
-            JLOG(debugLog().error()) << "Invalid signature in validation: "
-                                     << getJson(JsonOptions::none);
-            Throw<std::runtime_error>("Invalid signature in validation");
-        }
-
-        assert(nodeID_.isNonZero());
-    }
+        bool checkSignature);
 
     /** Construct, sign and trust a new STValidation issued by this node.
 
@@ -97,54 +92,13 @@ public:
         PublicKey const& pk,
         SecretKey const& sk,
         NodeID const& nodeID,
-        F&& f)
-        : STObject(validationFormat(), sfValidation)
-        , signingPubKey_(pk)
-        , nodeID_(nodeID)
-        , seenTime_(signTime)
-    {
-        assert(nodeID_.isNonZero());
-
-        // First, set our own public key:
-        if (publicKeyType(pk) != KeyType::secp256k1)
-            LogicError(
-                "We can only use secp256k1 keys for signing validations");
-
-        setFieldVL(sfSigningPubKey, pk.slice());
-        setFieldU32(sfSigningTime, signTime.time_since_epoch().count());
-
-        // Perform additional initialization
-        f(*this);
-
-        // Finally, sign the validation and mark it as trusted:
-        setFlag(vfFullyCanonicalSig);
-        setFieldVL(sfSignature, signDigest(pk, sk, getSigningHash()));
-        setTrusted();
-
-        // Check to ensure that all required fields are present.
-        for (auto const& e : validationFormat())
-        {
-            if (e.style() == soeREQUIRED && !isFieldPresent(e.sField()))
-                LogicError(
-                    "Required field '" + e.sField().getName() +
-                    "' missing from validation.");
-        }
-
-        // We just signed this, so it should be valid.
-        valid_ = true;
-    }
+        F&& f);
 
     STBase*
-    copy(std::size_t n, void* buf) const override
-    {
-        return emplace(n, buf, *this);
-    }
+    copy(std::size_t n, void* buf) const override;
 
     STBase*
-    move(std::size_t n, void* buf) override
-    {
-        return emplace(n, buf, std::move(*this));
-    }
+    move(std::size_t n, void* buf) override;
 
     // Hash of the validated ledger
     uint256
@@ -161,16 +115,10 @@ public:
     getSeenTime() const noexcept;
 
     PublicKey const&
-    getSignerPublic() const noexcept
-    {
-        return signingPubKey_;
-    }
+    getSignerPublic() const noexcept;
 
     NodeID const&
-    getNodeID() const noexcept
-    {
-        return nodeID_;
-    }
+    getNodeID() const noexcept;
 
     bool
     isValid() const noexcept;
@@ -179,31 +127,19 @@ public:
     isFull() const noexcept;
 
     bool
-    isTrusted() const noexcept
-    {
-        return mTrusted;
-    }
+    isTrusted() const noexcept;
 
     uint256
     getSigningHash() const;
 
     void
-    setTrusted()
-    {
-        mTrusted = true;
-    }
+    setTrusted();
 
     void
-    setUntrusted()
-    {
-        mTrusted = false;
-    }
+    setUntrusted();
 
     void
-    setSeen(NetClock::time_point s)
-    {
-        seenTime_ = s;
-    }
+    setSeen(NetClock::time_point s);
 
     Blob
     getSerialized() const;
@@ -214,23 +150,120 @@ public:
 private:
     static SOTemplate const&
     validationFormat();
-
-    bool mTrusted = false;
-
-    // Determines the validity of the signature in this validation; unseated
-    // optional if we haven't yet checked it, a boolean otherwise.
-    mutable std::optional<bool> valid_;
-
-    // The public key associated with the key used to sign this validation
-    PublicKey const signingPubKey_;
-
-    // The ID of the validator that issued this validation. For validators
-    // that use manifests this will be derived from the master public key.
-    NodeID const nodeID_;
-
-    NetClock::time_point seenTime_ = {};
 };
 
+template <class LookupNodeID>
+STValidation::STValidation(
+    SerialIter& sit,
+    LookupNodeID&& lookupNodeID,
+    bool checkSignature)
+    : STObject(validationFormat(), sit, sfValidation)
+    , signingPubKey_([this]() {
+        auto const spk = getFieldVL(sfSigningPubKey);
+
+        if (publicKeyType(makeSlice(spk)) != KeyType::secp256k1)
+            Throw<std::runtime_error>("Invalid public key in validation");
+
+        return PublicKey{makeSlice(spk)};
+    }())
+    , nodeID_(lookupNodeID(signingPubKey_))
+{
+    if (checkSignature && !isValid())
+    {
+        JLOG(debugLog().error()) << "Invalid signature in validation: "
+                                 << getJson(JsonOptions::none);
+        Throw<std::runtime_error>("Invalid signature in validation");
+    }
+
+    assert(nodeID_.isNonZero());
+}
+
+/** Construct, sign and trust a new STValidation issued by this node.
+
+    @param signTime When the validation is signed
+    @param publicKey The current signing public key
+    @param secretKey The current signing secret key
+    @param nodeID ID corresponding to node's public master key
+    @param f callback function to "fill" the validation with necessary data
+*/
+template <typename F>
+STValidation::STValidation(
+    NetClock::time_point signTime,
+    PublicKey const& pk,
+    SecretKey const& sk,
+    NodeID const& nodeID,
+    F&& f)
+    : STObject(validationFormat(), sfValidation)
+    , signingPubKey_(pk)
+    , nodeID_(nodeID)
+    , seenTime_(signTime)
+{
+    assert(nodeID_.isNonZero());
+
+    // First, set our own public key:
+    if (publicKeyType(pk) != KeyType::secp256k1)
+        LogicError("We can only use secp256k1 keys for signing validations");
+
+    setFieldVL(sfSigningPubKey, pk.slice());
+    setFieldU32(sfSigningTime, signTime.time_since_epoch().count());
+
+    // Perform additional initialization
+    f(*this);
+
+    // Finally, sign the validation and mark it as trusted:
+    setFlag(vfFullyCanonicalSig);
+    setFieldVL(sfSignature, signDigest(pk, sk, getSigningHash()));
+    setTrusted();
+
+    // Check to ensure that all required fields are present.
+    for (auto const& e : validationFormat())
+    {
+        if (e.style() == soeREQUIRED && !isFieldPresent(e.sField()))
+            LogicError(
+                "Required field '" + e.sField().getName() +
+                "' missing from validation.");
+    }
+
+    // We just signed this, so it should be valid.
+    valid_ = true;
+}
+
+inline PublicKey const&
+STValidation::getSignerPublic() const noexcept
+{
+    return signingPubKey_;
+}
+
+inline NodeID const&
+STValidation::getNodeID() const noexcept
+{
+    return nodeID_;
+}
+
+inline bool
+STValidation::isTrusted() const noexcept
+{
+    return mTrusted;
+}
+
+inline void
+STValidation::setTrusted()
+{
+    mTrusted = true;
+}
+
+inline void
+STValidation::setUntrusted()
+{
+    mTrusted = false;
+}
+
+inline void
+STValidation::setSeen(NetClock::time_point s)
+{
+    seenTime_ = s;
+}
+
 }  // namespace ripple
 
 #endif