Code/Sandbox/Plugins/EditorCommon/AssetSystem/DependencyTracker.cpp

   1 // Copyright 2001-2018 Crytek GmbH / Crytek Group. All rights reserved.
   2
   3 #include "StdAfx.h"
   4 #include "DependencyTracker.h"
   5 #include "AssetManager.h"
   6
   7 namespace Private_DependencyTracker
   8 {
   9
  10 struct SLessKey
  11 {
  12         bool operator()(const std::pair<string, SAssetDependencyInfo>& a, const string& b)
  13         {
  14                 return stricmp(a.first.c_str(), b.c_str()) < 0;
  15         }
  16
  17         bool operator()(const string& a, const std::pair<string, SAssetDependencyInfo>& b)
  18         {
  19                 return stricmp(a.c_str(), b.first.c_str()) < 0;
  20         }
  21 };
  22
  23 struct SLessValue
  24 {
  25         bool operator()(const std::pair<string, SAssetDependencyInfo>& a, const string& b)
  26         {
  27                 return stricmp(a.second.path.c_str(), b.c_str()) < 0;
  28         }
  29
  30         bool operator()(const string& a, const std::pair<string, SAssetDependencyInfo>& b)
  31         {
  32                 return stricmp(a.c_str(), b.second.path.c_str()) < 0;
  33         }
  34 };
  35
  36 }
  37
  38
  39 CDependencyTracker::CDependencyTracker()
  40 {
  41         CAssetManager* pAssetManager = CAssetManager::GetInstance();
  42
  43         pAssetManager->signalAfterAssetsInserted.Connect([this](const std::vector<CAsset*>&)
  44         {
  45                 CreateIndex();
  46         }, (uintptr_t)this);
  47
  48         pAssetManager->signalAfterAssetsUpdated.Connect([this]()
  49         {
  50                 CreateIndex();
  51         }, (uintptr_t)this);
  52
  53         pAssetManager->signalAssetChanged.Connect([this](CAsset&)
  54         {
  55                 CreateIndex();
  56         }, (uintptr_t)this);
  57
  58         pAssetManager->signalAfterAssetsRemoved.Connect([this]()
  59         {
  60                 CreateIndex();
  61         }, (uintptr_t)this);
  62 }
  63
  64 CDependencyTracker::~CDependencyTracker()
  65 {
  66         CAssetManager* pAssetManager = CAssetManager::GetInstance();
  67         pAssetManager->signalAfterAssetsInserted.DisconnectById((uintptr_t)this);
  68         pAssetManager->signalAfterAssetsUpdated.DisconnectById((uintptr_t)this);
  69         pAssetManager->signalAssetChanged.DisconnectById((uintptr_t)this);
  70         pAssetManager->signalAfterAssetsRemoved.DisconnectById((uintptr_t)this);
  71 }
  72
  73 std::vector<SAssetDependencyInfo> CDependencyTracker::GetReverseDependencies(const char* szAssetPath) const
  74 {
  75         const auto range = GetRange(szAssetPath);
  76
  77         std::vector<SAssetDependencyInfo> dependencies;
  78         dependencies.reserve(3); // just an empirical expectation.
  79
  80         std::transform(range.first, range.second, std::back_inserter(dependencies), [](const auto& x)
  81         {
  82                 return x.second;
  83         });
  84
  85         return dependencies;
  86 }
  87
  88 std::pair<bool, int>  CDependencyTracker::IsAssetUsedBy(const char* szAssetPath, const char* szAnotherAssetPath) const
  89 {
  90         using namespace Private_DependencyTracker;
  91
  92         const auto range = GetRange(szAssetPath);
  93         if (range.first == range.second)
  94         {
  95                 return { false, 0 };
  96         }
  97
  98         const string value = PathUtil::ToUnixPath(szAnotherAssetPath);
  99         const auto lowerBound = std::lower_bound(range.first, range.second, value, SLessValue());
 100         if (lowerBound != range.second && (*lowerBound).second.path.CompareNoCase(value) == 0)
 101         {
 102                 return { true, (*lowerBound).second.usageCount };
 103         }
 104
 105         return { false, 0 };
 106 }
 107
 108 void CDependencyTracker::CreateIndex()
 109 {
 110         // Do nothing if the future has already referred to the deffered request.
 111         if (m_future.valid() && m_future.wait_for(std::chrono::seconds(0)) != std::future_status::ready)
 112         {
 113                 return;
 114         }
 115
 116         m_future = std::async(std::launch::deferred, [this]()
 117         {
 118                 m_index.clear();
 119                 CAssetManager* pAssetManager = CAssetManager::GetInstance();
 120                 pAssetManager->ForeachAsset([this](CAsset* pAsset)
 121                 {
 122                         MAKE_SURE(pAsset->GetFilesCount(), return);
 123
 124                         const std::vector<SAssetDependencyInfo>& dependencies = pAsset->GetDependencies();
 125                         for (const auto& item : dependencies)
 126                         {
 127                                 m_index.emplace_back(item.path, SAssetDependencyInfo( pAsset->GetFile(0), item.usageCount ));
 128                         }
 129                 });
 130
 131                 std::sort(m_index.begin(), m_index.end(), [](const auto& a, const auto& b)
 132                 {
 133                         const int first = stricmp(a.first.c_str(), b.first.c_str());
 134                         if (first != 0)
 135                         {
 136                                 return first < 0;
 137                         }
 138
 139                         return stricmp(a.second.path.c_str(), b.second.path.c_str()) < 0;
 140                 });
 141         });
 142 }
 143
 144 std::pair<CDependencyTracker::IndexIterator, CDependencyTracker::IndexIterator> CDependencyTracker::GetRange(const char* szAssetPath) const
 145 {
 146         using namespace Private_DependencyTracker;
 147
 148         if (m_future.valid())
 149         {
 150                 m_future.wait();
 151         }
 152
 153         const string key = PathUtil::ToUnixPath(szAssetPath);
 154         const auto lowerBound = std::lower_bound(m_index.cbegin(), m_index.cend(), key, SLessKey());
 155         const auto upperBound = std::upper_bound(lowerBound, m_index.cend(), key, SLessKey());
 156         return { lowerBound, upperBound };
 157 }