Merge pull request #2740 from jamescowens/improve_allocation_class

util: Improve allocation class
gridcoin-community · Feb 18, 2024 · 871aad2 · 871aad2
2 parents baa544b + 4c14a71
commit 871aad2
Show file tree

Hide file tree

Showing 6 changed files with 272 additions and 78 deletions.
diff --git a/src/gridcoin/sidestake.cpp b/src/gridcoin/sidestake.cpp
@@ -48,6 +48,14 @@ Allocation::Allocation(const Fraction& f)
     : Fraction(f)
 {}
 
+Allocation::Allocation(const int64_t& numerator, const int64_t& denominator)
+    : Fraction(numerator, denominator)
+{}
+
+Allocation::Allocation(const int64_t& numerator, const int64_t& denominator, const bool& simplify)
+    : Fraction(numerator, denominator, simplify)
+{}
+
 CAmount Allocation::ToCAmount() const
 {
     return GetNumerator() / GetDenominator();
@@ -58,6 +66,146 @@ double Allocation::ToPercent() const
     return ToDouble() * 100.0;
 }
 
+Allocation Allocation::operator+(const Allocation& rhs) const
+{
+    return static_cast<Allocation>(Fraction::operator+(rhs));
+}
+
+Allocation Allocation::operator+(const int64_t& rhs) const
+{
+    return static_cast<Allocation>(Fraction::operator+(rhs));
+}
+
+Allocation Allocation::operator-(const Allocation& rhs) const
+{
+    return static_cast<Allocation>(Fraction::operator-(rhs));
+}
+
+Allocation Allocation::operator-(const int64_t& rhs) const
+{
+    return static_cast<Allocation>(Fraction::operator-(rhs));
+}
+
+Allocation Allocation::operator*(const Allocation& rhs) const
+{
+    return static_cast<Allocation>(Fraction::operator*(rhs));
+}
+
+Allocation Allocation::operator*(const int64_t& rhs) const
+{
+    return static_cast<Allocation>(Fraction::operator*(rhs));
+}
+
+Allocation Allocation::operator/(const Allocation& rhs) const
+{
+    return static_cast<Allocation>(Fraction::operator/(rhs));
+}
+
+Allocation Allocation::operator/(const int64_t& rhs) const
+{
+    return static_cast<Allocation>(Fraction::operator/(rhs));
+}
+
+Allocation Allocation::operator+=(const Allocation& rhs)
+{
+    return static_cast<Allocation>(Fraction::operator+=(rhs));
+}
+
+Allocation Allocation::operator+=(const int64_t& rhs)
+{
+    return static_cast<Allocation>(Fraction::operator+=(rhs));
+}
+
+Allocation Allocation::operator-=(const Allocation& rhs)
+{
+    return static_cast<Allocation>(Fraction::operator-=(rhs));
+}
+
+Allocation Allocation::operator-=(const int64_t& rhs)
+{
+    return static_cast<Allocation>(Fraction::operator-=(rhs));
+}
+
+Allocation Allocation::operator*=(const Allocation& rhs)
+{
+    return static_cast<Allocation>(Fraction::operator*=(rhs));
+}
+
+Allocation Allocation::operator*=(const int64_t& rhs)
+{
+    return static_cast<Allocation>(Fraction::operator*=(rhs));
+}
+
+Allocation Allocation::operator/=(const Allocation& rhs)
+{
+    return static_cast<Allocation>(Fraction::operator/=(rhs));
+}
+
+Allocation Allocation::operator/=(const int64_t& rhs)
+{
+    return static_cast<Allocation>(Fraction::operator/=(rhs));
+}
+
+bool Allocation::operator==(const Allocation& rhs) const
+{
+    return Fraction::operator==(rhs);
+}
+
+bool Allocation::operator!=(const Allocation& rhs) const
+{
+    return Fraction::operator!=(rhs);
+}
+
+bool Allocation::operator<=(const Allocation& rhs) const
+{
+    return Fraction::operator<=(rhs);
+}
+
+bool Allocation::operator>=(const Allocation& rhs) const
+{
+    return Fraction::operator>=(rhs);
+}
+
+bool Allocation::operator<(const Allocation& rhs) const
+{
+    return Fraction::operator<(rhs);
+}
+
+bool Allocation::operator>(const Allocation& rhs) const
+{
+    return Fraction::operator>(rhs);
+}
+
+bool Allocation::operator==(const int64_t& rhs) const
+{
+    return Fraction::operator==(rhs);
+}
+
+bool Allocation::operator!=(const int64_t& rhs) const
+{
+    return Fraction::operator!=(rhs);
+}
+
+bool Allocation::operator<=(const int64_t& rhs) const
+{
+    return Fraction::operator<=(rhs);
+}
+
+bool Allocation::operator>=(const int64_t& rhs) const
+{
+    return Fraction::operator>=(rhs);
+}
+
+bool Allocation::operator<(const int64_t& rhs) const
+{
+    return Fraction::operator<(rhs);
+}
+
+bool Allocation::operator>(const int64_t& rhs) const
+{
+    return Fraction::operator>(rhs);
+}
+
 // -----------------------------------------------------------------------------
 // Class: LocalSideStake
 // -----------------------------------------------------------------------------

diff --git a/src/gridcoin/sidestake.h b/src/gridcoin/sidestake.h
@@ -43,6 +43,23 @@ class Allocation : public Fraction
     //!
     Allocation(const Fraction& f);
 
+    //!
+    //! \brief Initialize an allocation directly from specifying a numerator and denominator
+    //! \param numerator
+    //! \param denominator
+    //!
+    Allocation(const int64_t& numerator, const int64_t& denominator);
+
+    //!
+    //! \brief Initialize an allocation directly from specifying a numerator and denominator, specifying the simplification
+    //! directive.
+    //!
+    //! \param numerator
+    //! \param denominator
+    //! \param simplify
+    //!
+    Allocation(const int64_t& numerator, const int64_t& denominator, const bool& simplify);
+
     //!
     //! \brief Allocations extend the Fraction class and can also represent the result of the allocation constructed fraction
     //! and the result of the multiplication of that fraction times the reward, which is in CAmount (i.e. int64_t).
@@ -57,6 +74,35 @@ class Allocation : public Fraction
     //! \return double percent representation of the allocation fraction.
     //!
     double ToPercent() const;
+
+    Allocation operator+(const Allocation& rhs) const;
+    Allocation operator+(const int64_t& rhs) const;
+    Allocation operator-(const Allocation& rhs) const;
+    Allocation operator-(const int64_t& rhs) const;
+    Allocation operator*(const Allocation& rhs) const;
+    Allocation operator*(const int64_t& rhs) const;
+    Allocation operator/(const Allocation& rhs) const;
+    Allocation operator/(const int64_t& rhs) const;
+    Allocation operator+=(const Allocation& rhs);
+    Allocation operator+=(const int64_t& rhs);
+    Allocation operator-=(const Allocation& rhs);
+    Allocation operator-=(const int64_t& rhs);
+    Allocation operator*=(const Allocation& rhs);
+    Allocation operator*=(const int64_t& rhs);
+    Allocation operator/=(const Allocation& rhs);
+    Allocation operator/=(const int64_t& rhs);
+    bool operator==(const Allocation& rhs) const;
+    bool operator!=(const Allocation& rhs) const;
+    bool operator<=(const Allocation& rhs) const;
+    bool operator>=(const Allocation& rhs) const;
+    bool operator<(const Allocation& rhs) const;
+    bool operator>(const Allocation& rhs) const;
+    bool operator==(const int64_t& rhs) const;
+    bool operator!=(const int64_t& rhs) const;
+    bool operator<=(const int64_t& rhs) const;
+    bool operator>=(const int64_t& rhs) const;
+    bool operator<(const int64_t& rhs) const;
+    bool operator>(const int64_t& rhs) const;
 };
 
 //!

diff --git a/src/miner.cpp b/src/miner.cpp
@@ -968,7 +968,7 @@ void SplitCoinStakeOutput(CBlock &blocknew, int64_t &nReward, bool &fEnableStake
             if (allocation * nReward < CENT)
             {
                 LogPrintf("WARN: SplitCoinStakeOutput: distribution %f too small to address %s.",
-                          CoinToDouble(static_cast<GRC::Allocation>(allocation * nReward).ToCAmount()),
+                          CoinToDouble((allocation * nReward).ToCAmount()),
                           address.ToString()
                           );
                 continue;
@@ -998,7 +998,7 @@ void SplitCoinStakeOutput(CBlock &blocknew, int64_t &nReward, bool &fEnableStake
 
             // For allocations ending less than 100% assign using sidestake allocation.
             if (SumAllocation + allocation < 1)
-                nSideStake = static_cast<GRC::Allocation>(allocation * nReward).ToCAmount();
+                nSideStake = (allocation * nReward).ToCAmount();
             // We need to handle the final sidestake differently in the case it brings the total allocation up to 100%,
             // because testing showed in corner cases the output return to the staking address could be off by one Halford.
             else if (SumAllocation + allocation == 1)
@@ -1010,7 +1010,7 @@ void SplitCoinStakeOutput(CBlock &blocknew, int64_t &nReward, bool &fEnableStake
 
             LogPrintf("SplitCoinStakeOutput: create sidestake UTXO %i value %f to address %s",
                       nOutputsUsed,
-                      CoinToDouble(static_cast<GRC::Allocation>(allocation * nReward).ToCAmount()),
+                      CoinToDouble((allocation * nReward).ToCAmount()),
                       address.ToString()
                       );
             SumAllocation += allocation;

diff --git a/src/test/gridcoin/sidestake_tests.cpp b/src/test/gridcoin/sidestake_tests.cpp
@@ -140,7 +140,7 @@ BOOST_AUTO_TEST_CASE(sidestake_Allocation_multiplication_and_derivation_of_alloc
 
     CAmount max_accrual = 16384 * COIN;
 
-    CAmount actual_output = static_cast<GRC::Allocation>(allocation * max_accrual).ToCAmount();
+    CAmount actual_output = (allocation * max_accrual).ToCAmount();
     BOOST_CHECK_EQUAL(actual_output, int64_t {1638236160000});
 }