@@ -12,58 +12,70 @@
class CTxMemPool ;
// Dumb helper to handle CTransaction compression at serialize-time
-struct TransactionCompressor {
+template <typename T>
+struct TransactionCompressWrapper {
private:
- CTransactionRef & tx;
+ T & tx;
public:
- TransactionCompressor (CTransactionRef & txIn) : tx(txIn) {}
-
- ADD_SERIALIZE_METHODS ;
+ TransactionCompressWrapper (T & txIn) : tx(txIn) {}
+ SERIALIZE_METHODS (obj) { READWRITE (obj. tx ); }
+} ;
- template <typename Stream, typename Operation>
- inline void SerializationOp (Stream& s, Operation ser_action) {
- READWRITE (tx); // TODO: Compress tx encoding
+template <typename I>
+struct Uint48Wrapper {
+private:
+ I& m_int;
+public:
+ Uint48Wrapper (I& i) : m_int(i) {}
+ template <typename Stream> void Serialize (Stream& s) const
+ {
+ uint32_t lsb = m_int & 0xffffffff ;
+ uint16_t msb = (m_int >> 32 ) & 0xffff ;
+ s << lsb << msb;
+ }
+ template <typename Stream> void Unserialize (Stream& s)
+ {
+ uint32_t lsb;
+ uint16_t msb;
+ s >> lsb >> msb;
+ m_int = (uint64_t (msb) << 32 ) | uint64_t (lsb);
}
};
+template <typename T>
+static inline TransactionCompressWrapper<T> TransactionCompressor (T& tx) { return TransactionCompressWrapper<T>(tx); }
+
class BlockTransactionsRequest {
public:
// A BlockTransactionsRequest message
uint256 blockhash;
std::vector<uint16_t > indexes;
- ADD_SERIALIZE_METHODS;
-
- template <typename Stream, typename Operation>
- inline void SerializationOp (Stream& s, Operation ser_action) {
- READWRITE (blockhash);
+ template <typename Stream>
+ void Serialize (Stream& s) const
+ {
+ s << blockhash;
uint64_t indexes_size = (uint64_t )indexes.size ();
- READWRITE (COMPACTSIZE (indexes_size));
- if (ser_action.ForRead ()) {
- size_t i = 0 ;
- while (indexes.size () < indexes_size) {
- indexes.resize (std::min ((uint64_t )(1000 + indexes.size ()), indexes_size));
- for (; i < indexes.size (); i++) {
- uint64_t index = 0 ;
- READWRITE (COMPACTSIZE (index ));
- if (index > std::numeric_limits<uint16_t >::max ())
- throw std::ios_base::failure (" index overflowed 16 bits"
- indexes[i] = index ;
- }
- }
-
- uint16_t offset = 0 ;
- for (size_t j = 0 ; j < indexes.size (); j++) {
- if (uint64_t (indexes[j]) + uint64_t (offset) > std::numeric_limits<uint16_t >::max ())
- throw std::ios_base::failure (" indexes overflowed 16 bits"
- indexes[j] = indexes[j] + offset;
- offset = indexes[j] + 1 ;
- }
- } else {
- for (size_t i = 0 ; i < indexes.size (); i++) {
- uint64_t index = indexes[i] - (i == 0 ? 0 : (indexes[i - 1 ] + 1 ));
- READWRITE (COMPACTSIZE (index ));
- }
+ s << COMPACTSIZE (indexes_size);
+ for (size_t i = 0 ; i < indexes.size (); i++) {
+ const uint64_t index = indexes[i] - (i == 0 ? 0 : (indexes[i - 1 ] + 1 ));
+ s << COMPACTSIZE (index );
+ }
+ }
+
+ template <typename Stream>
+ void Unserialize (Stream& s)
+ {
+ std::vector<uint64_t > tmp;
+ s >> blockhash >> VectorApply<CompactSizeWrapper>(tmp);
+
+ indexes.resize (tmp.size ());
+ uint16_t offset = 0 ;
+ for (size_t j = 0 ; j < tmp.size (); j++) {
+ if (tmp[j] + uint64_t (offset) > std::numeric_limits<uint16_t >::max ())
+ throw std::ios_base::failure (" indexes overflowed 16 bits"
+ indexes[j] = tmp[j] + offset;
+ offset = indexes[j] + 1 ;
}
}
};
@@ -78,24 +90,9 @@ class BlockTransactions {
BlockTransactions (const BlockTransactionsRequest& req) :
blockhash (req.blockhash), txn(req.indexes.size()) {}
- ADD_SERIALIZE_METHODS;
-
- template <typename Stream, typename Operation>
- inline void SerializationOp (Stream& s, Operation ser_action) {
- READWRITE (blockhash);
- uint64_t txn_size = (uint64_t )txn.size ();
- READWRITE (COMPACTSIZE (txn_size));
- if (ser_action.ForRead ()) {
- size_t i = 0 ;
- while (txn.size () < txn_size) {
- txn.resize (std::min ((uint64_t )(1000 + txn.size ()), txn_size));
- for (; i < txn.size (); i++)
- READWRITE (REF (TransactionCompressor (txn[i])));
- }
- } else {
- for (size_t i = 0 ; i < txn.size (); i++)
- READWRITE (REF (TransactionCompressor (txn[i])));
- }
+ SERIALIZE_METHODS (obj)
+ {
+ READWRITE (obj.blockhash , VectorApply<TransactionCompressWrapper>(obj.txn ));
}
};
@@ -106,16 +103,21 @@ struct PrefilledTransaction {
uint16_t index;
CTransactionRef tx;
- ADD_SERIALIZE_METHODS;
+ template <typename Stream>
+ void Serialize (Stream& s) const
+ {
+ s << COMPACTSIZE (index ) << TransactionCompressor (tx);
+ }
- template <typename Stream, typename Operation>
- inline void SerializationOp (Stream& s, Operation ser_action) {
- uint64_t idx = index ;
- READWRITE (COMPACTSIZE (idx));
+ template <typename Stream>
+ void Unserialize (Stream& s)
+ {
+ uint64_t idx;
+ s >> COMPACTSIZE (idx);
if (idx > std::numeric_limits<uint16_t >::max ())
throw std::ios_base::failure (" index overflowed 16-bits"
index = idx;
- READWRITE ( REF ( TransactionCompressor (tx)) );
+ s >> TransactionCompressor (tx);
}
};
@@ -154,40 +156,18 @@ class CBlockHeaderAndShortTxIDs {
size_t BlockTxCount () const { return shorttxids.size () + prefilledtxn.size (); }
- ADD_SERIALIZE_METHODS;
-
- template <typename Stream, typename Operation>
- inline void SerializationOp (Stream& s, Operation ser_action) {
- READWRITE (header);
- READWRITE (nonce);
-
- uint64_t shorttxids_size = (uint64_t )shorttxids.size ();
- READWRITE (COMPACTSIZE (shorttxids_size));
- if (ser_action.ForRead ()) {
- size_t i = 0 ;
- while (shorttxids.size () < shorttxids_size) {
- shorttxids.resize (std::min ((uint64_t )(1000 + shorttxids.size ()), shorttxids_size));
- for (; i < shorttxids.size (); i++) {
- uint32_t lsb = 0 ; uint16_t msb = 0 ;
- READWRITE (lsb);
- READWRITE (msb);
- shorttxids[i] = (uint64_t (msb) << 32 ) | uint64_t (lsb);
- static_assert (SHORTTXIDS_LENGTH == 6 , " shorttxids serialization assumes 6-byte shorttxids"
- }
- }
- } else {
- for (size_t i = 0 ; i < shorttxids.size (); i++) {
- uint32_t lsb = shorttxids[i] & 0xffffffff ;
- uint16_t msb = (shorttxids[i] >> 32 ) & 0xffff ;
- READWRITE (lsb);
- READWRITE (msb);
- }
- }
-
- READWRITE (prefilledtxn);
+ template <typename Stream>
+ void Serialize (Stream& s) const
+ {
+ s << header << nonce << VectorApply<Uint48Wrapper>(shorttxids) << prefilledtxn;
+ }
- if (ser_action.ForRead ())
- FillShortTxIDSelector ();
+ template <typename Stream>
+ inline void Unserialize (Stream& s)
+ {
+ static_assert (SHORTTXIDS_LENGTH == 6 , " shorttxids serialization assumes 6-byte shorttxids"
+ s >> header >> nonce >> VectorApply<Uint48Wrapper>(shorttxids) >> prefilledtxn;
+ FillShortTxIDSelector ();
}
};
For ease of implementation, deserialization first happens into a
std::vector<uint64_t>, and is then converted. This means a temporary is created and allocated, which is an overhead that the old implementation didn't have.