Switch DataAccess to hold unique_ptr to remove includes

citp · Apr 24, 2018 · 213ae90 · 213ae90
1 parent 7146b76
commit 213ae90
Show file tree

Hide file tree

Showing 37 changed files with 202 additions and 155 deletions.
diff --git a/example/example.cpp b/example/example.cpp
@@ -13,12 +13,9 @@
 #include <blocksci/chain/transaction.hpp>
 #include <blocksci/chain/block.hpp>
 #include <blocksci/script.hpp>
-#include <blocksci/index/hash_index.hpp>
 #include <blocksci/address/address.hpp>
 #include <blocksci/chain/transaction_range.hpp>
 
-//#include <hsql/SQLParser.h>
-
 #include <google/sparse_hash_map>
 #include <google/dense_hash_map>
 
@@ -90,8 +87,6 @@ int main(int argc, const char * argv[]) {
 //        std::cout << out << std::endl;
 //    }
 
-    std::cout << chain.getAccess().hashIndex.countTxes() << std::endl;
-
     RANGES_FOR(auto block, chain) {
         RANGES_FOR(auto tx, block) {
             std::cout << tx << std::endl;
@@ -122,29 +117,6 @@ int main(int argc, const char * argv[]) {
 //    
 //    std::cout << count << "\n";
 
-//    const std::string query = "Select index FROM txes WHERE locktime > 0";
-//    hsql::SQLParserResult result;
-//    hsql::SQLParser::parse(query, &result);
-//    
-//    if (result.isValid() && result.size() > 0) {
-//        const hsql::SQLStatement* statement = result.getStatement(0);
-//        
-//        if (statement->isType(hsql::kStmtSelect)) {
-//            const hsql::SelectStatement* select = (const hsql::SelectStatement*) statement;
-//            /* ... */
-//        }
-//    }
-//    
-//    HashIndex hashIndex{chain.access.config};
-//    RANGES_FOR(auto block, chain) {
-//        RANGES_FOR(auto tx, block) {
-//            assert(hashIndex.getTxIndex(tx.getHash()) == tx.txNum);
-//        }
-//        
-//    }
-
-    return 0;
-
 //    auto block = chain[100000];
 //    auto tx = block[0];
 //    std::cout << tx.getHash().GetHex() << "\n";

diff --git a/include/blocksci/address/equiv_address.hpp b/include/blocksci/address/equiv_address.hpp
@@ -60,7 +60,7 @@ namespace blocksci {
             return scriptEquivalent;
         }
 
-        ranges::any_view<OutputPointer> getOutputPointers() const;
+        ranges::any_view<OutputPointer> getOutputPointers();
         int64_t calculateBalance(BlockHeight height);
         ranges::any_view<Output> getOutputs();
         std::vector<Input> getInputs();

diff --git a/include/blocksci/chain/block.hpp b/include/blocksci/chain/block.hpp
@@ -39,8 +39,8 @@ namespace blocksci {
         public:
             cursor() = default;
             cursor(const Block &block_, uint32_t txNum) : block(&block_), currentTxIndex(txNum) {
-                if (currentTxIndex < block->access->chain.txCount()) {
-                    currentTxPos = reinterpret_cast<const char *>(block->access->chain.getTx(currentTxIndex));
+                if (currentTxIndex < block->access->getChain().txCount()) {
+                    currentTxPos = reinterpret_cast<const char *>(block->access->getChain().getTx(currentTxIndex));
                 } else {
                     currentTxPos = nullptr;
                 }
@@ -77,13 +77,13 @@ namespace blocksci {
 
             void prev() {
                 currentTxIndex--;
-                currentTxPos = reinterpret_cast<const char *>(block->access->chain.getTx(currentTxIndex));
+                currentTxPos = reinterpret_cast<const char *>(block->access->getChain().getTx(currentTxIndex));
             }
 
             void advance(int amount) {
                 currentTxIndex += static_cast<uint32_t>(amount);
-                if (currentTxIndex < block->access->chain.txCount()) {
-                    currentTxPos = reinterpret_cast<const char *>(block->access->chain.getTx(currentTxIndex));
+                if (currentTxIndex < block->access->getChain().txCount()) {
+                    currentTxPos = reinterpret_cast<const char *>(block->access->getChain().getTx(currentTxIndex));
                 } else {
                     currentTxPos = nullptr;
                 }
@@ -100,7 +100,7 @@ namespace blocksci {
 
     public:
         Block() = default;
-        Block(BlockHeight blockNum_, DataAccess &access_) : access(&access_), rawBlock(access->chain.getBlock(blockNum_)), blockNum(blockNum_) {
+        Block(BlockHeight blockNum_, DataAccess &access_) : access(&access_), rawBlock(access->getChain().getBlock(blockNum_)), blockNum(blockNum_) {
         }
 
         DataAccess &getAccess() const {
@@ -148,7 +148,7 @@ namespace blocksci {
         }
 
         ranges::optional<std::chrono::system_clock::time_point> getTimeSeen() const {
-            return access->mempoolIndex.getBlockTimestamp(blockNum);
+            return access->getMempoolIndex().getBlockTimestamp(blockNum);
         }
 
         uint32_t bits() const {
@@ -207,7 +207,7 @@ namespace blocksci {
         }
 
         std::vector<unsigned char> getCoinbase() const {
-            return access->chain.getCoinbase(rawBlock->coinbaseOffset);
+            return access->getChain().getCoinbase(rawBlock->coinbaseOffset);
         }
 
         Transaction coinbaseTx() const {

diff --git a/include/blocksci/chain/blockchain.hpp b/include/blocksci/chain/blockchain.hpp
@@ -164,13 +164,13 @@ namespace blocksci {
     public:
         Blockchain() = default;
         explicit Blockchain(const DataConfiguration &config) : access(config) {
-            lastBlockHeight = access.chain.blockCount();
+            lastBlockHeight = access.getChain().blockCount();
         }
         explicit Blockchain(const std::string &dataDirectory) : Blockchain(DataConfiguration{dataDirectory, true, BlockHeight{0}}) {}
 
         void reload() {
             access.reload();
-            lastBlockHeight = access.chain.blockCount();
+            lastBlockHeight = access.getChain().blockCount();
         }
 
         DataAccess &getAccess() { return access; }
@@ -183,12 +183,12 @@ namespace blocksci {
         }
 
         uint32_t addressCount(AddressType::Enum type) const {
-            return access.scripts.scriptCount(dedupType(type));
+            return access.getScripts().scriptCount(dedupType(type));
         }
 
         template <AddressType::Enum type>
         auto scripts() {
-            return ranges::view::ints(uint32_t{1}, access.scripts.scriptCount(dedupType(type)) + 1) | ranges::view::transform([&](uint32_t scriptNum) {
+            return ranges::view::ints(uint32_t{1}, access.getScripts().scriptCount(dedupType(type)) + 1) | ranges::view::transform([&](uint32_t scriptNum) {
                 return ScriptAddress<type>(scriptNum, access);
             });
         }

diff --git a/include/blocksci/core/chain_access.hpp → include/blocksci/chain/chain_access.hpp b/include/blocksci/core/chain_access.hpp → include/blocksci/chain/chain_access.hpp
@@ -9,10 +9,10 @@
 #ifndef chain_access_hpp
 #define chain_access_hpp
 
-#include "bitcoin_uint256.hpp"
-#include "core_fwd.hpp"
-#include "file_mapper.hpp"
-#include "raw_block.hpp"
+#include <blocksci/core/bitcoin_uint256.hpp>
+#include <blocksci/core/core_fwd.hpp>
+#include <blocksci/core/file_mapper.hpp>
+#include <blocksci/core/raw_block.hpp>
 
 #include <blocksci/blocksci_export.h>
 #include <blocksci/exception.hpp>

diff --git a/include/blocksci/chain/chain_fwd.hpp b/include/blocksci/chain/chain_fwd.hpp
@@ -9,6 +9,7 @@
 #define chain_fwd_h
 
 namespace blocksci {
+    class ChainAccess;
     class Blockchain;
     class Block;
     class Transaction;

diff --git a/include/blocksci/chain/input.hpp b/include/blocksci/chain/input.hpp
@@ -9,6 +9,7 @@
 #ifndef raw_input_hpp
 #define raw_input_hpp
 
+#include "chain_access.hpp"
 #include "inout_pointer.hpp"
 
 #include <blocksci/blocksci_export.h>
@@ -41,10 +42,10 @@ namespace blocksci {
 
         Input(const InputPointer &pointer_, BlockHeight blockHeight_, const Inout &inout_, const uint32_t *sequenceNum_, DataAccess &access_) :
         access(&access_), inout(&inout_), sequenceNum(sequenceNum_), pointer(pointer_), blockHeight(blockHeight_) {
-            assert(pointer.isValid(access_.chain));
+            assert(pointer.isValid(access_.getChain()));
         }
         Input(const InputPointer &pointer_, DataAccess &access_) :
-        Input(pointer_, access_.chain.getBlockHeight(pointer_.txNum), access_.chain.getTx(pointer_.txNum)->getInput(pointer_.inoutNum), &access_.chain.getSequenceNumbers(pointer_.txNum)[pointer_.inoutNum], access_) {}
+        Input(pointer_, access_.getChain().getBlockHeight(pointer_.txNum), access_.getChain().getTx(pointer_.txNum)->getInput(pointer_.inoutNum), &access_.getChain().getSequenceNumbers(pointer_.txNum)[pointer_.inoutNum], access_) {}
 
         DataAccess &getAccess() const {
             return *access;
@@ -66,7 +67,7 @@ namespace blocksci {
         Block block() const;
 
         BlockHeight age() const {
-            return blockHeight - access->chain.getBlockHeight(inout->getLinkedTxNum());
+            return blockHeight - access->getChain().getBlockHeight(inout->getLinkedTxNum());
         }
 
         bool operator==(const Inout &other) const {

diff --git a/include/blocksci/chain/output.hpp b/include/blocksci/chain/output.hpp
@@ -9,6 +9,7 @@
 #ifndef output_hpp
 #define output_hpp
 
+#include "chain_access.hpp"
 #include "inout_pointer.hpp"
 
 #include <blocksci/blocksci_export.h>
@@ -38,24 +39,24 @@ namespace blocksci {
 
         Output(const OutputPointer &pointer_, BlockHeight blockHeight_, const Inout &inout_, DataAccess &access_) :
         access(&access_), inout(&inout_), blockHeight(blockHeight_), pointer(pointer_) {
-            assert(pointer.isValid(access_.chain));
-            if (inout->getLinkedTxNum() < access->chain.maxLoadedTx()) {
+            assert(pointer.isValid(access_.getChain()));
+            if (inout->getLinkedTxNum() < access->getChain().maxLoadedTx()) {
                 spendingTxIndex = inout->getLinkedTxNum();
             } else {
                 spendingTxIndex = 0;
             }
         }
 
         Output(const OutputPointer &pointer_, DataAccess &access_) :
-        Output(pointer_, -1, access_.chain.getTx(pointer_.txNum)->getOutput(pointer_.inoutNum), access_) {}
+        Output(pointer_, -1, access_.getChain().getTx(pointer_.txNum)->getOutput(pointer_.inoutNum), access_) {}
 
         DataAccess &getAccess() const {
             return *access;
         }
 
         BlockHeight getBlockHeight() const {
             if (blockHeight == -1) {
-                blockHeight = access->chain.getBlockHeight(pointer.txNum);
+                blockHeight = access->getChain().getBlockHeight(pointer.txNum);
             }
             return blockHeight;
         }

diff --git a/include/blocksci/chain/transaction.hpp b/include/blocksci/chain/transaction.hpp
@@ -14,6 +14,7 @@
 
 #include <blocksci/blocksci_export.h>
 #include <blocksci/core/raw_transaction.hpp>
+#include <blocksci/index/mempool_index.hpp>
 
 #include <range/v3/view/iota.hpp>
 #include <range/v3/view/zip_with.hpp>
@@ -26,16 +27,6 @@ namespace blocksci {
         InvalidHashException() : std::runtime_error("No Match for hash") {}
     };
 
-    namespace internal {
-        inline uint32_t getTxIndex(const uint256 &hash, HashIndex &index) {
-            auto txIndex = index.getTxIndex(hash);
-            if (txIndex == 0) {
-                throw InvalidHashException();
-            }
-            return txIndex;
-        }
-    }
-
     class BLOCKSCI_EXPORT Transaction {
     private:
         DataAccess *access;
@@ -48,29 +39,29 @@ namespace blocksci {
 
         Transaction() = default;
 
-        Transaction(const RawTransaction *data_, uint32_t txNum_, BlockHeight blockHeight_, DataAccess &access_) : access(&access_), data(data_), sequenceNumbers(access_.chain.getSequenceNumbers(txNum_)), txNum(txNum_), blockHeight(blockHeight_) {}
+        Transaction(const RawTransaction *data_, uint32_t txNum_, BlockHeight blockHeight_, DataAccess &access_) : access(&access_), data(data_), sequenceNumbers(access_.getChain().getSequenceNumbers(txNum_)), txNum(txNum_), blockHeight(blockHeight_) {}
 
-        Transaction(uint32_t index, DataAccess &access_) : Transaction(index, access_.chain.getBlockHeight(index), access_) {}
+        Transaction(uint32_t index, DataAccess &access_) : Transaction(index, access_.getChain().getBlockHeight(index), access_) {}
 
-        Transaction(uint32_t index, BlockHeight height, DataAccess &access_) : Transaction(access_.chain.getTx(index), index, height, access_) {}
+        Transaction(uint32_t index, BlockHeight height, DataAccess &access_) : Transaction(access_.getChain().getTx(index), index, height, access_) {}
 
-        Transaction(const uint256 &hash, DataAccess &access) : Transaction(internal::getTxIndex(hash, access.hashIndex), access) {}
+        Transaction(const uint256 &hash, DataAccess &access);
         Transaction(const std::string &hash, DataAccess &access) : Transaction(uint256S(hash), access) {}
 
         DataAccess &getAccess() const {
             return *access;
         }
 
         uint256 getHash() const {
-            return *access->chain.getTxHash(txNum);
+            return *access->getChain().getTxHash(txNum);
         }
 
         ranges::optional<std::chrono::system_clock::time_point> getTimeSeen() const {
-            return access->mempoolIndex.getTxTimestamp(txNum);
+            return access->getMempoolIndex().getTxTimestamp(txNum);
         }
 
         bool observedInMempool() const {
-            return access->mempoolIndex.observed(txNum);
+            return access->getMempoolIndex().observed(txNum);
         }
 
         std::string toString() const {

diff --git a/include/blocksci/cluster/cluster.hpp b/include/blocksci/cluster/cluster.hpp
@@ -76,12 +76,7 @@ namespace blocksci {
 
         Cluster(uint32_t clusterNum_, const ClusterAccess &access_) : clusterAccess(access_), clusterNum(clusterNum_) {}
 
-        auto getAddresses() const {
-            auto &addressIndex = clusterAccess.access.addressIndex;
-            return getPossibleAddresses() | ranges::view::filter([&addressIndex](const Address &address) {
-                return addressIndex.checkIfTopLevel(address);
-            });
-        }
+        ranges::any_view<Address> getAddresses() const;
 
         auto taggedAddresses(const std::unordered_map<blocksci::Address, std::string> &tags) const {
             return getAddresses() | ranges::view::transform([tags](Address && address) -> ranges::optional<TaggedAddress> {

diff --git a/include/blocksci/core.hpp b/include/blocksci/core.hpp
@@ -10,8 +10,6 @@
 #define core_group_header_h
 
 #include <blocksci/core/bitcoin_uint256.hpp>
-#include <blocksci/core/chain_access.hpp>
-#include <blocksci/core/script_access.hpp>
 #include <blocksci/core/script_data.hpp>
 #include <blocksci/core/script_info.hpp>
 #include <blocksci/core/dedup_address_type.hpp>

diff --git a/include/blocksci/core/core_fwd.hpp b/include/blocksci/core/core_fwd.hpp
@@ -41,9 +41,6 @@ namespace blocksci {
 
     class uint256;
     class uint160;
-
-    class ChainAccess;
-    class ScriptAccess;
 } // namespace blocksci
 
 #endif /* blocksci_core_fwd_hpp */
diff --git a/include/blocksci/core/raw_address.hpp b/include/blocksci/core/raw_address.hpp
@@ -16,6 +16,8 @@
 #include <functional>
 
 namespace blocksci {
+	class ScriptAccess;
+
     struct BLOCKSCI_EXPORT RawAddress {
         uint32_t scriptNum;
         AddressType::Enum type;

diff --git a/include/blocksci/scripts/multisig_pubkey_script.hpp b/include/blocksci/scripts/multisig_pubkey_script.hpp
@@ -9,6 +9,7 @@
 #define multisig_pubkey_script_hpp
 
 #include "pubkey_base_script.hpp"
+#include "script_access.hpp"
 
 #include <blocksci/blocksci_export.h>
 #include <blocksci/core/address_info.hpp>
@@ -22,7 +23,7 @@ namespace blocksci {
     public:
         constexpr static AddressType::Enum addressType = AddressType::MULTISIG_PUBKEY;
 
-        ScriptAddress(uint32_t addressNum_, DataAccess &access_) : PubkeyAddressBase(addressNum_, addressType, access_.scripts.getScriptData<dedupType(addressType)>(addressNum_), access_) {}
+        ScriptAddress(uint32_t addressNum_, DataAccess &access_) : PubkeyAddressBase(addressNum_, addressType, access_.getScripts().getScriptData<dedupType(addressType)>(addressNum_), access_) {}
 
         std::string addressString() const;
 

diff --git a/include/blocksci/scripts/multisig_script.hpp b/include/blocksci/scripts/multisig_script.hpp
@@ -10,6 +10,7 @@
 #define multisig_script_hpp
 
 #include "script.hpp"
+#include "script_access.hpp"
 
 #include <blocksci/blocksci_export.h>
 #include <blocksci/core/address_info.hpp>
@@ -26,7 +27,7 @@ namespace blocksci {
         }
     public:
         constexpr static AddressType::Enum addressType = AddressType::MULTISIG;
-        ScriptAddress(uint32_t addressNum_, DataAccess &access_) : ScriptBase(addressNum_, addressType, access_, access_.scripts.getScriptData<dedupType(addressType)>(addressNum_)) {}
+        ScriptAddress(uint32_t addressNum_, DataAccess &access_) : ScriptBase(addressNum_, addressType, access_, access_.getScripts().getScriptData<dedupType(addressType)>(addressNum_)) {}
 
         std::string toString() const {
             std::stringstream ss;

diff --git a/include/blocksci/scripts/nonstandard_script.hpp b/include/blocksci/scripts/nonstandard_script.hpp
@@ -10,9 +10,11 @@
 #define nonstandard_script_hpp
 
 #include "script.hpp"
+#include "script_access.hpp"
 #include "script_view.hpp"
 
 #include <blocksci/blocksci_export.h>
+#include <blocksci/core/address_info.hpp>
 #include <blocksci/util/data_access.hpp>
 
 #include <range/v3/utility/optional.hpp>
@@ -47,7 +49,7 @@ namespace blocksci {
         constexpr static AddressType::Enum addressType = AddressType::NONSTANDARD;
 
         ScriptAddress() = default;
-        ScriptAddress(uint32_t addressNum_, DataAccess &access_) : ScriptAddress(addressNum_, access_.scripts.getScriptData<dedupType(addressType)>(addressNum_), access_) {}
+        ScriptAddress(uint32_t addressNum_, DataAccess &access_) : ScriptAddress(addressNum_, access_.getScripts().getScriptData<dedupType(addressType)>(addressNum_), access_) {}
 
         std::string inputString() const {
             auto inputScript = getInputScript();