[rfile] Implement GetKeyInfo()

Author: silverweed

io/io/inc/ROOT/RFile.hxx

@@ -11,8 +11,9 @@
 #include <ROOT/RError.hxx>
 
 #include <deque>
-#include <memory>
+#include <functional>
 #include <iostream>
+#include <memory>
 #include <string_view>
 #include <typeinfo>
 
@@ -24,12 +25,15 @@ namespace ROOT {
 namespace Experimental {
 
 class RFile;
-struct RFileKeyInfo;
 
 namespace Internal {
 
 ROOT::RLogChannel &RFileLog();
 
+/// Returns an **owning** pointer to the object referenced by `key`. The caller must delete this pointer.
+/// This method is meant to only be used by the pythonization.
+[[nodiscard]] void *RFile_GetObjectFromKey(RFile &file, const RKeyInfo &key);
+
 } // namespace Internal
 
 namespace Detail {
@@ -59,6 +63,7 @@ Querying this information can be done via RFile::ListKeys(). Reading an object's
 doesn't deserialize the full object, so it's a relatively lightweight operation.
 */
 class RKeyInfo final {
+   friend class ROOT::Experimental::RFile;
    friend class ROOT::Experimental::RFileKeyIterable;
 
 public:
@@ -216,6 +221,8 @@ auto myObj = file->Get<TH1D>("h");
 ~~~
 */
 class RFile final {
+   friend void *Internal::RFile_GetObjectFromKey(RFile &file, const RKeyInfo &key);
+
    /// Flags used in PutInternal()
    enum PutFlags {
       /// When encountering an object at the specified path, overwrite it with the new one instead of erroring out.
@@ -357,6 +364,9 @@ public:
       return RFileKeyIterable(fFile.get(), basePath, flags);
    }
 
+   /// Retrieves information about the key of object at `path`, if one exists.
+   std::optional<RKeyInfo> GetKeyInfo(std::string_view path) const;
+
    /// Prints the internal structure of this RFile to the given stream.
    void Print(std::ostream &out = std::cout) const;
 };

io/io/src/RFile.cxx

@@ -178,6 +178,17 @@ static void EnsureFileOpenAndBinary(const TFile *tfile, std::string_view path)
       throw ROOT::RException(R__FAIL("Opened file " + std::string(path) + " is not a ROOT binary file"));
 }
 
+static std::string ReconstructFullKeyPath(const TKey &key)
+{
+   std::string path = key.GetName();
+   TDirectory *parent = key.GetMotherDir();
+   while (parent && parent->GetMotherDir()) {
+      path = std::string(parent->GetName()) + "/" + path;
+      parent = parent->GetMotherDir();
+   }
+   return path;
+}
+
 /////////////////////////////////////////////////////////////////////////////////////////////////
 std::pair<std::string_view, std::string_view> ROOT::Experimental::Detail::DecomposePath(std::string_view path)
 {
@@ -513,3 +524,24 @@ void RFile::Close()
    // NOTE: this also flushes the file internally
    fFile.reset();
 }
+
+std::optional<ROOT::Experimental::RKeyInfo> RFile::GetKeyInfo(std::string_view path) const
+{
+   const TKey *key = GetTKey(path);
+   if (!key)
+      return {};
+
+   RKeyInfo keyInfo;
+   keyInfo.fPath = ReconstructFullKeyPath(*key);
+   keyInfo.fClassName = key->GetClassName();
+   keyInfo.fCycle = key->GetCycle();
+   keyInfo.fTitle = key->GetTitle();
+
+   return keyInfo;
+}
+
+void *ROOT::Experimental::Internal::RFile_GetObjectFromKey(RFile &file, const RKeyInfo &key)
+{
+   void *obj = file.GetUntyped(key.GetPath(), key.GetClassName().c_str());
+   return obj;
+}

io/io/test/rfile.cxx

@@ -701,3 +701,26 @@ TEST(RFile, NormalizedPaths)
    EXPECT_NE(file->Get<TH1D>("//a////b/c"), nullptr);
    EXPECT_THROW(file->Get<TH1D>("a/b/c/"), ROOT::RException);
 }
+
+TEST(RFile, GetKeyInfo)
+{
+   FileRaii fileGuard("test_rfile_getkeyinfo.root");
+
+   auto file = RFile::Recreate(fileGuard.GetPath());
+   std::string obj = "obj";
+   file->Put("/s", obj);
+   file->Put("a/b/c", obj);
+   file->Put("b", obj);
+   file->Put("/a/d", obj);
+
+   EXPECT_EQ(file->GetKeyInfo("foo"), std::nullopt);
+
+   for (const std::string_view path : { "/s", "a/b/c", "b", "/a/d" }) {
+      auto key = file->GetKeyInfo(path);
+      ASSERT_NE(key, std::nullopt);
+      EXPECT_EQ(key->GetPath(), path[0] == '/' ? path.substr(1) : path);
+      EXPECT_EQ(key->GetClassName(), "string");
+      EXPECT_EQ(key->GetTitle(), "");
+      EXPECT_EQ(key->GetCycle(), 1);
+   }
+}