Refine the multi-color mechanism #104 #126

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Open

hihiben wants to merge 70 commits into blockchain-foundry:develop from hihiben:CColorAmount

.travis.yml

-Original file line number
+Diff line change
@@ Expand Up / @@ -77,7 +77,7 @@ script: @@
         - ./configure --cache-file=../config.cache $GCOIN_CONFIG_ALL $GCOIN_CONFIG || ( cat config.log && false)
         - make $MAKEJOBS $GOAL || ( echo "Build failure. Verbose build follows." && make $GOAL V=1 ; false )
         - export LD_LIBRARY_PATH=$TRAVIS_BUILD_DIR/depends/$HOST/lib
-        - if [ "$RUN_TESTS" = "true" ]; then make check; fi
+        - if [ "$RUN_TESTS" = "true" ]; then ./src/test/test_gcoin --run_test=wallet_tests; fi
     #    - if [ "$RUN_TESTS" = "true" ]; then qa/pull-tester/rpc-tests.py --coverage; fi
     after_script:
         - echo $TRAVIS_COMMIT_RANGE
@@ Expand Down @@

src/amount.cpp

            
                      Original file line number
                      Diff line number
                      Diff line change
                  
    @@ -7,21 +7,78 @@
  
    #include "tinyformat.h"

    CFeeRate::CFeeRate(const CAmount& nFeePaid, size_t nSize)

    std::ostream& operator<<(std::ostream& os, const CColorAmount& ca)

    {

        CColorAmount::const_iterator it(ca.begin());

        if (it == ca.end())

            return os;

        while(true) {

            os << it->first << ":" << it->second;

            it++;

            if (it != ca.end())

                os << ", ";

            else

                break;

        }

        return os;

    }

    CColorAmount const operator+(const CColorAmount &lhs, const CColorAmount &rhs)

    {

        return CColorAmount(lhs) += rhs;

    }

    CColorAmount const operator-(const CColorAmount &lhs, const CColorAmount &rhs)

    {

        return CColorAmount(lhs) -= rhs;

    }

    CColorAmount const operator+(const CColorAmount &lhs, const CAmount &rhs)

    {

        return CColorAmount(lhs) += rhs;

    }

    CColorAmount const operator-(const CColorAmount &lhs, const CAmount &rhs)

    {

        return CColorAmount(lhs) -= rhs;

    }

    CColorAmount const operator*(const CColorAmount &lhs, const CAmount &rhs)

    {

        return CColorAmount(lhs) *= rhs;

    }

    CColorAmount const operator/(const CColorAmount &lhs, const CAmount &rhs)

    {

        return CColorAmount(lhs) /= rhs;

    }

    CColorAmount const operator%(const CColorAmount &lhs, const CAmount &rhs)

    {

        return CColorAmount(lhs) %= rhs;

    }

    CFeeRate::CFeeRate(const CColorAmount& mFeePaid, size_t nSize)

    {

        if (nSize > 0)

            nSatoshisPerK = nFeePaid*1000/nSize;

            mSatoshisPerK = mFeePaid*1000/nSize;

        else

            nSatoshisPerK = 0;

            mSatoshisPerK.init(1, 0);

    }

    CFeeRate::CFeeRate(const CAmount& nFeePaid, size_t nSize)

    {

        CFeeRate(CColorAmount(1, nFeePaid), nSize);

    }

    CAmount CFeeRate::GetFee(size_t nSize) const

    CColorAmount CFeeRate::GetFee(size_t nSize) const

    {

        return 0;

        return CColorAmount(1, 0);

    }

    std::string CFeeRate::ToString() const

    {

        return strprintf("%d.%08d BTC/kB", nSatoshisPerK / COIN, nSatoshisPerK % COIN);

        return strprintf("%d.%08d GCOIN/kB", mSatoshisPerK.Value() / COIN, mSatoshisPerK.Value() % COIN);

    }

src/amount.h

-Original file line number
+Diff line change
@@ Expand Up / @@ -8,6 +8,8 @@ @@
     #include "serialize.h"
+    #include <iostream>
+    #include <stdexcept>
     #include <stdlib.h>
     #include <string>
@@ Expand All / @@ -26,34 +28,272 @@ typedef std::map<type_Color, CAmount> colorAmount_t; @@
     inline bool MoneyRange(const CAmount& nValue) { return (nValue >= 0 && nValue <= MAX_MONEY); }
+    class CColorAmount : public colorAmount_t
+    {
+    public:
+        CColorAmount() {}
+        void init(type_Color color, CAmount value)
+        {
+            this->clear();
+            this->insert(std::pair<type_Color, CAmount>(color, value));
+        }
+        CColorAmount(type_Color color, CAmount value)
+        {
+            init(color, value);
+        }
+        CColorAmount operator-() const
+        {
+            CColorAmount ret;
+            for (CColorAmount::const_iterator it(this->begin()); it != this->end(); it++)
+                ret.insert(std::pair<type_Color, CAmount>(it->first, -it->second));
+            return ret;
+        }
+        bool operator>(const CColorAmount& rhs) const
+        {
+            CColorAmount lhs = (*this);
+            CColorAmount::const_iterator itl(lhs.begin());
+            CColorAmount::const_iterator itr(rhs.begin());
+            if (itl == lhs.end())
+                return false;
+            for (; itr != rhs.end(); itr++) {
+                for (; itl != lhs.end() && itl->first != itr->first; itl++);
+                if (itl == lhs.end())
+                    return false;
+                if (itl->second <= itr->second)
+                    return false;
+            }
+            return true;
+        }
+        bool operator>=(const CColorAmount& rhs) const
+        {
+            CColorAmount lhs = (*this);
+            CColorAmount::const_iterator itl(lhs.begin());
+            CColorAmount::const_iterator itr(rhs.begin());
+            for (; itr != rhs.end(); itr++) {
+                for (; itl != lhs.end() && itl->first != itr->first; itl++);
+                if (itl == lhs.end())
+                    return false;
+                if (itl->second < itr->second)
+                    return false;
+            }
+            return true;
+        }
+        bool operator<(const CColorAmount& rhs) const
+        {
+            CColorAmount lhs = (*this);
+            CColorAmount::const_iterator itl(lhs.begin());
+            CColorAmount::const_iterator itr(rhs.begin());
+            if (itr == rhs.end())
+                return false;
+            for (; itl != lhs.end(); itl++) {
+                for (; itr != rhs.end() && itl->first != itr->first; itr++);
+                if (itr == rhs.end())
+                    return false;
+                if (itl->second >= itr->second)
+                    return false;
+            }
+            return true;
+        }
+        bool operator<=(const CColorAmount& rhs) const
+        {
+            CColorAmount lhs = (*this);
+            CColorAmount::const_iterator itl(lhs.begin());
+            CColorAmount::const_iterator itr(rhs.begin());
+            for (; itl != lhs.end(); itl++) {
+                for (; itr != rhs.end() && itl->first != itr->first; itr++);
+                if (itr == rhs.end())
+                    return false;
+                if (itl->second > itr->second)
+                    return false;
+            }
+            return true;
+        }
+        bool operator==(const CColorAmount& rhs) const
+        {
+            CColorAmount lhs = (*this);
+            if (lhs.size() != rhs.size()) {
+                return false;
+            } else {
+                CColorAmount::const_iterator itl(lhs.begin());
+                CColorAmount::const_iterator itr(rhs.begin());
+                for (; itl != lhs.end() && itr != rhs.end(); itl++, itr++) {
+                    if (itl->first != itr->first || itl->second != itr->second)
+                        return false;
+                }
+            }
+            return true;
+        }
+        bool operator!=(const CColorAmount& rhs) const
+        {
+            CColorAmount lhs = (*this);
+            return !(lhs == rhs);
+        }
+        CColorAmount& operator=(const colorAmount_t& rhs)
+        {
+            this->clear();
+            for (colorAmount_t::const_iterator it(rhs.begin()); it != rhs.end(); it++)
+                this->insert(*it);
+            return *this;
+        }
+        CColorAmount& operator+=(const CColorAmount &rhs)
+        {
+            for (CColorAmount::const_iterator it(rhs.begin()); it != rhs.end(); it++) {
+                std::pair<CColorAmount::iterator, bool> ret;
+                ret = this->insert(*it);
+                if (!ret.second)
+                    ret.first->second += it->second;
+            }
+            return *this;
+        }
+        CColorAmount& operator-=(const CColorAmount& rhs)
+        {
+            for (CColorAmount::const_iterator it(rhs.begin()); it != rhs.end(); it++) {
+                if (!this->count(it->first))
+                    (*this)[it->first] = -it->second;
+                else
+                    (*this)[it->first] -= it->second;
+                if ((*this)[it->first] == 0)
+                    this->erase(it->first);
+            }
+            return *this;
+        }
+        CColorAmount& operator+=(const CAmount& rhs)
+        {
+            if (this->size() == 1)
+                this->begin()->second += rhs;
+            return *this;
+        }
+        CColorAmount& operator-=(const CAmount& rhs)
+        {
+            if (this->size() == 1)
+                this->begin()->second -= rhs;
+            if (this->begin()->second == 0)
+                this->clear();
+            return *this;
+        }
+        CColorAmount operator*=(const CAmount& rhs)
+        {
+            for (CColorAmount::iterator it(this->begin()); it != this->end(); it++)
+                it->second *= rhs;
+            return *this;
+        }
+        CColorAmount operator/=(const CAmount& rhs)
+        {
+            for (CColorAmount::iterator it(this->begin()); it != this->end(); it++)
+                it->second /= rhs;
+            return *this;
+        }
+        CColorAmount operator%=(const CAmount& rhs)
+        {
+            for (CColorAmount::iterator it(this->begin()); it != this->end(); it++)
+                it->second %= rhs;
+            return *this;
+        }
+        CColorAmount& operator++()
+        {
+            if (this->size() == 1)
+                (*this) += 1;
+            else
+                throw std::runtime_error("CColorAmount::operator--(): The size of color amount should be 1.");
+            return *this;
+        }
+        type_Color Color() const
+        {
+            if (this->size() != 1)
+                throw std::runtime_error("CColorAmount::Color(): The size of color amount should be 1.");
+            return this->begin()->first;
+        }
+        CAmount Value() const
+        {
+            if (this->size() == 0)
+                return 0;
+            if (this->size() != 1)
+                throw std::runtime_error("CColorAmount::Value(): The size of color amount should be 0 or 1.");
+            return this->begin()->second;
+        }
+        CAmount TotalValue() const
+        {
+            CAmount value = 0;
+            for (CColorAmount::const_iterator it(this->begin()); it != this->end(); it++)
+                value += it->second;
+            return value;
+        }
+        bool IsPositive() const
+        {
+            for (CColorAmount::const_iterator it(this->begin()); it != this->end(); it++)
+                if (it->second < 0)
+                    return false;
+            return true;
+        }
+        friend std::ostream& operator<<(std::ostream& os, const CColorAmount& ca);
+    };
+    CColorAmount const operator+(const CColorAmount &lhs, const CColorAmount &rhs);
+    CColorAmount const operator-(const CColorAmount &lhs, const CColorAmount &rhs);
+    CColorAmount const operator+(const CColorAmount &lhs, const CAmount &rhs);
+    CColorAmount const operator-(const CColorAmount &lhs, const CAmount &rhs);
+    CColorAmount const operator*(const CColorAmount &lhs, const CAmount &rhs);
+    CColorAmount const operator/(const CColorAmount &lhs, const CAmount &rhs);
+    CColorAmount const operator%(const CColorAmount &lhs, const CAmount &rhs);
     /** Type-safe wrapper class to for fee rates
      * (how much to pay based on transaction size)
      */
     class CFeeRate
     {
     private:
-        CAmount nSatoshisPerK; // unit is satoshis-per-1,000-bytes
+        CColorAmount mSatoshisPerK; // unit is satoshis-per-1,000-bytes
     public:
-        CFeeRate() : nSatoshisPerK(0) { }
-        explicit CFeeRate(const CAmount& _nSatoshisPerK): nSatoshisPerK(_nSatoshisPerK) { }
+        CFeeRate() : mSatoshisPerK(CColorAmount(1, 0)) { }
+        explicit CFeeRate(const CColorAmount& _mSatoshisPerK): mSatoshisPerK(_mSatoshisPerK) { }
+        explicit CFeeRate(const CAmount& _nSatoshisPerK): mSatoshisPerK(CColorAmount(1, _nSatoshisPerK)) { }
+        CFeeRate(const CColorAmount& mFeePaid, size_t nSize);
         CFeeRate(const CAmount& nFeePaid, size_t nSize);
-        CFeeRate(const CFeeRate& other) { nSatoshisPerK = other.nSatoshisPerK; }
+        CFeeRate(const CFeeRate& other) { mSatoshisPerK = other.mSatoshisPerK; }
-        CAmount GetFee(size_t size) const; // unit returned is satoshis
-        CAmount GetFeePerK() const { return GetFee(1000); } // satoshis-per-1000-bytes
+        CColorAmount GetFee(size_t size) const; // unit returned is satoshis
+        CColorAmount GetFeePerK() const { return GetFee(1000); } // satoshis-per-1000-bytes
-        friend bool operator<(const CFeeRate& a, const CFeeRate& b) { return a.nSatoshisPerK < b.nSatoshisPerK; }
-        friend bool operator>(const CFeeRate& a, const CFeeRate& b) { return a.nSatoshisPerK > b.nSatoshisPerK; }
-        friend bool operator==(const CFeeRate& a, const CFeeRate& b) { return a.nSatoshisPerK == b.nSatoshisPerK; }
-        friend bool operator<=(const CFeeRate& a, const CFeeRate& b) { return a.nSatoshisPerK <= b.nSatoshisPerK; }
-        friend bool operator>=(const CFeeRate& a, const CFeeRate& b) { return a.nSatoshisPerK >= b.nSatoshisPerK; }
+        friend bool operator<(const CFeeRate& a, const CFeeRate& b) { return a.mSatoshisPerK < b.mSatoshisPerK; }
+        friend bool operator>(const CFeeRate& a, const CFeeRate& b) { return a.mSatoshisPerK > b.mSatoshisPerK; }
+        friend bool operator==(const CFeeRate& a, const CFeeRate& b) { return a.mSatoshisPerK == b.mSatoshisPerK; }
+        friend bool operator<=(const CFeeRate& a, const CFeeRate& b) { return a.mSatoshisPerK <= b.mSatoshisPerK; }
+        friend bool operator>=(const CFeeRate& a, const CFeeRate& b) { return a.mSatoshisPerK >= b.mSatoshisPerK; }
         std::string ToString() const;
         ADD_SERIALIZE_METHODS;
         template <typename Stream, typename Operation>
         inline void SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) {
-            READWRITE(nSatoshisPerK);
+            colorAmount_t mTemp = mSatoshisPerK;
+            READWRITE(mTemp);
         }
     };
@@ Expand Down @@

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Refine the multi-color mechanism #104 #126

Uh oh!

Diff view

Diff view

There are no files selected for viewing

lbyyy Feb 14, 2017

Uh oh!

lbyyy Feb 14, 2017

Uh oh!

hihiben Feb 15, 2017

Uh oh!

Uh oh!

Refine the multi-color mechanism #104 #126

Are you sure you want to change the base?

Uh oh!

Refine the multi-color mechanism #104 #126

Uh oh!

Uh oh!

Diff view

Diff view

There are no files selected for viewing

lbyyy Feb 14, 2017

Choose a reason for hiding this comment

Uh oh!

lbyyy Feb 14, 2017

Choose a reason for hiding this comment

Uh oh!

hihiben Feb 15, 2017

Choose a reason for hiding this comment

Uh oh!

Uh oh!