More transaction metadata work.

src/TransactionMeta.cpp

@@ -1,5 +1,8 @@
 #include "TransactionMeta.h"
 
+#include <boost/make_shared.hpp>
+#include <boost/bind.hpp>
+
 bool TransactionMetaNodeEntry::operator<(const TransactionMetaNodeEntry& e) const
 {
 	if (mType < e.mType) return true;
@@ -28,6 +31,23 @@ bool TransactionMetaNodeEntry::operator>=(const TransactionMetaNodeEntry& e) con
 	return compare(e) >= 0;
 }
 
+TMNEBalance::TMNEBalance(SerializerIterator& sit) : TransactionMetaNodeEntry(TMNChangedBalance)
+{
+	mFlags = sit.get32();
+	mFirstAmount = * dynamic_cast<STAmount*>(STAmount::deserialize(sit, "FirstAmount").get());
+	if ((mFlags & TMBTwoAmounts) != 0)
+		mSecondAmount = * dynamic_cast<STAmount*>(STAmount::deserialize(sit, "SecondAmount").get());
+}
+
+void TMNEBalance::addRaw(Serializer& sit) const
+{
+	sit.add8(mType);
+	sit.add32(mFlags);
+	mFirstAmount.add(sit);
+	if ((mFlags & TMBTwoAmounts) != 0)
+		mSecondAmount.add(sit);
+}
+
 void TMNEBalance::adjustFirstAmount(const STAmount& a)
 {
 	mFirstAmount += a;
@@ -68,3 +88,55 @@ Json::Value TMNEBalance::getJson(int p) const
 
 	return ret;
 }
+
+TransactionMetaNode::TransactionMetaNode(const uint256& node, SerializerIterator& sit) : mNode(node)
+{
+	mNode = sit.get256();
+	mPreviousTransaction = sit.get256();
+	mPreviousLedger = sit.get32();
+	int type;
+	do
+	{
+		type = sit.get8();
+		if (type == TransactionMetaNodeEntry::TMNChangedBalance)
+			mEntries.push_back(boost::shared_ptr<TransactionMetaNodeEntry>(new TMNEBalance(sit)));
+		else if (type != TransactionMetaNodeEntry::TMNEndOfMetadata)
+			throw std::runtime_error("Unparseable metadata");
+	} while (type != TransactionMetaNodeEntry::TMNEndOfMetadata);
+}
+
+void TransactionMetaNode::addRaw(Serializer& s) const
+{
+	s.add256(mNode);
+	s.add256(mPreviousTransaction);
+	s.add32(mPreviousLedger);
+	for (std::list<TransactionMetaNodeEntry::pointer>::const_iterator it = mEntries.begin(), end = mEntries.end();
+			it != end; ++it)
+		(*it)->addRaw(s);
+	s.add8(TransactionMetaNodeEntry::TMNEndOfMetadata);
+}
+
+TransactionMetaSet::TransactionMetaSet(uint32 ledger, const std::vector<unsigned char>& vec) : mLedger(ledger)
+{
+	Serializer s(vec);
+	SerializerIterator sit(s);
+
+	mTransactionID = sit.get256();
+
+	do
+	{
+		uint256 node = sit.get256();
+		if (node.isZero())
+			break;
+		mNodes.insert(TransactionMetaNode(node, sit));
+	} while(1);
+}
+
+void TransactionMetaSet::addRaw(Serializer& s) const
+{
+	s.add256(mTransactionID);
+	for (std::set<TransactionMetaNode>::const_iterator it = mNodes.begin(), end = mNodes.end();
+			it != end; ++it)
+		it->addRaw(s);
+	s.add256(uint256());
+}

src/TransactionMeta.h

@@ -10,6 +10,7 @@
 #include "../json/value.h"
 
 #include "uint256.h"
+#include "Serializer.h"
 #include "SerializedTypes.h"
 
 
@@ -27,6 +28,7 @@ public:
 
 	int getType() const { return mType; }
 	virtual Json::Value getJson(int) const = 0;
+	virtual void addRaw(Serializer&) const = 0;
 	virtual int compare(const TransactionMetaNodeEntry&) const = 0;
 
 	bool operator<(const TransactionMetaNodeEntry&) const;
@@ -52,6 +54,9 @@ protected:
 public:
 	TMNEBalance() : TransactionMetaNodeEntry(TMNChangedBalance), mFlags(0) { ; }
 
+	TMNEBalance(SerializerIterator&);
+	virtual void addRaw(Serializer&) const;
+
 	unsigned getFlags() const				{ return mFlags; }
 	const STAmount& getFirstAmount() const	{ return mFirstAmount; }
 	const STAmount& getSecondAmount() const	{ return mSecondAmount; }
@@ -66,6 +71,9 @@ public:
 
 class TransactionMetaNode
 { // a node that has been affected by a transaction
+public:
+	typedef boost::shared_ptr<TransactionMetaNode> pointer;
+
 protected:
 	uint256 mNode;
 	uint256 mPreviousTransaction;
@@ -80,10 +88,13 @@ public:
 	uint32 getPreviousLedger() const											{ return mPreviousLedger; }
 	const std::list<TransactionMetaNodeEntry::pointer>& peekEntries() const		{ return mEntries; }
 
-	bool operator<(const TransactionMetaNode& n) const { return mNode < n.mNode; }
-	bool operator<=(const TransactionMetaNode& n) const { return mNode <= n.mNode; }
-	bool operator>(const TransactionMetaNode& n) const { return mNode > n.mNode; }
-	bool operator>=(const TransactionMetaNode& n) const { return mNode >= n.mNode; }
+	bool operator<(const TransactionMetaNode& n) const	{ return mNode < n.mNode; }
+	bool operator<=(const TransactionMetaNode& n) const	{ return mNode <= n.mNode; }
+	bool operator>(const TransactionMetaNode& n) const	{ return mNode > n.mNode; }
+	bool operator>=(const TransactionMetaNode& n) const	{ return mNode >= n.mNode; }
+
+	TransactionMetaNode(const uint256&node, SerializerIterator&);
+	void addRaw(Serializer&) const;
 };
 
 class TransactionMetaSet
@@ -91,7 +102,7 @@ class TransactionMetaSet
 protected:
 	uint256 mTransactionID;
 	uint32 mLedger;
-	std::set<TransactionMetaNode> mEntries;
+	std::set<TransactionMetaNode> mNodes;
 
 public:
 	TransactionMetaSet(const uint256& txID, uint32 ledger) : mTransactionID(txID), mLedger(ledger)