Added calculation for afferent coupling of types

plugins/cpp_metrics/model/CMakeLists.txt

@@ -5,7 +5,8 @@ include_directories(
 set(ODB_SOURCES
   include/model/cppastnodemetrics.h
   include/model/cppcohesionmetrics.h
-  include/model/cppfilemetrics.h)
+  include/model/cppfilemetrics.h
+  include/model/cppafferentmetrics.h)
 
 generate_odb_files("${ODB_SOURCES}" "cpp")
 

plugins/cpp_metrics/model/include/model/cppafferentmetrics.h

@@ -0,0 +1,38 @@
+#ifndef CC_MODEL_AFFERENTMETRICS_H
+#define CC_MODEL_AFFERENTMETRICS_H
+
+#include <model/cppentity.h>
+#include <model/cpprecord.h>
+#include <model/cppastnode.h>
+
+namespace cc
+{
+namespace model
+{
+ #pragma db view \
+        object(CppRecord) \
+        object(CppAstNode : CppRecord::astNodeId == CppAstNode::id) \
+        object(File : CppAstNode::location.file) \
+        object(CppMemberType : CppMemberType::memberAstNode) 
+        struct AfferentRecordView
+        {
+            #pragma db column(CppEntity::entityHash)
+            std::size_t entityHash;
+
+            #pragma db column(CppMemberType::typeHash)
+            std::size_t typeHash;
+
+            #pragma db column(CppEntity::qualifiedName)
+            std::string qualifiedName;
+
+            #pragma db column(CppEntity::astNodeId)
+            CppAstNodeId astNodeId;
+
+            #pragma db column(File::path)
+            std::string filePath;
+        };
+
+} //model
+} //cc
+
+#endif //CC_MODEL_AFFERENTMETRICS_H

plugins/cpp_metrics/model/include/model/cppastnodemetrics.h

@@ -21,6 +21,7 @@ struct CppAstNodeMetrics
     BUMPY_ROAD = 4,
     LACK_OF_COHESION = 5,
     LACK_OF_COHESION_HS = 6,
+    AFFERENT_COUPLING = 7
   };
 
   #pragma db id auto

plugins/cpp_metrics/parser/include/cppmetricsparser/cppmetricsparser.h

@@ -76,7 +76,8 @@ class CppMetricsParser : public AbstractParser
   // Calculate the lack of cohesion between member variables
   // and member functions for every type.
   void lackOfCohesion();
-
+  // Calculate afferent coupling metric bewteen types
+  void afferentCouplingTypeLevel();
 
   /// @brief Constructs an ODB query that you can use to filter only
   /// the database records of the given parameter type whose path
@@ -197,6 +198,7 @@ class CppMetricsParser : public AbstractParser
   static const int functionMcCabePartitionMultiplier = 5;
   static const int functionBumpyRoadPartitionMultiplier = 5;
   static const int lackOfCohesionPartitionMultiplier = 25;
+  static const int afferentCouplingPartitionMultiplier = 25;
 };
 
 } // parser

plugins/cpp_metrics/parser/src/cppmetricsparser.cpp

@@ -6,6 +6,8 @@
 #include <model/cppcohesionmetrics-odb.hxx>
 #include <model/cppfilemetrics.h>
 #include <model/cppfilemetrics-odb.hxx>
+#include <model/cppafferentmetrics.h>
+#include <model/cppafferentmetrics-odb.hxx>
 
 #include <model/cppastnode.h>
 #include <model/cppastnode-odb.hxx>
@@ -98,6 +100,61 @@ bool CppMetricsParser::cleanupDatabase()
   return true;
 }
 
+
+void CppMetricsParser::afferentCouplingTypeLevel()
+{
+
+  // Calculate the cohesion metric for all types on parallel threads.
+  parallelCalcMetric<model::AfferentRecordView>(
+    "Afferent coupling",
+    _threadCount * afferentCouplingPartitionMultiplier, // number of jobs; adjust for granularity
+    getFilterPathsQuery<model::AfferentRecordView>(),
+    [&, this](const MetricsTasks<model::AfferentRecordView>& tasks)
+  {
+    util::OdbTransaction{_ctx.db}([&,this]
+    {
+      std::set<std::uint64_t> typesFound;
+      std::unordered_map<std::uint64_t, int> typeFoundCnt;
+      std::unordered_map<std::uint64_t,std::uint64_t> astNodeIdOfType;
+
+      for (const model::AfferentRecordView& type
+          : _ctx.db->query<model::AfferentRecordView>())
+      {
+        if (!cc::util::isRootedUnderAnyOf(_inputPaths, type.filePath))
+        {
+          continue;
+        }
+
+        typesFound.clear();
+        for (const model::CppMemberType& member : _ctx.db->query<model::CppMemberType>(
+          odb::query<cc::model::CppMemberType>::typeHash == type.entityHash &&
+          odb::query<cc::model::CppMemberType>::kind == model::CppMemberType::Kind::Field)) 
+        {
+          typesFound.insert(member.memberTypeHash);
+        }
+
+        astNodeIdOfType[type.typeHash] = type.astNodeId;
+
+        for (const auto& t : typesFound)
+        {
+          typeFoundCnt[t]++;
+        }
+      }
+
+      for (const auto& pair : typeFoundCnt)
+      {
+        model::CppAstNodeMetrics metric;
+        metric.astNodeId = astNodeIdOfType[pair.first];
+        metric.type = model::CppAstNodeMetrics::Type::AFFERENT_COUPLING;
+        metric.value = pair.second;
+        _ctx.db->persist(metric);
+      }
+
+
+    });
+  });
+}
+
 void CppMetricsParser::functionParameters()
 {
   parallelCalcMetric<model::CppFunctionParamCountWithId>(
@@ -376,6 +433,8 @@ bool CppMetricsParser::parse()
   typeMcCabe();
   LOG(info) << "[cppmetricsparser] Computing Lack of Cohesion metric for types.";
   lackOfCohesion();
+  LOG(info) << "[cppmetricsparser] Computing Afferent Coupling metric for types.";
+  afferentCouplingTypeLevel();
   return true;
 }