ScriptedInstanceRegistry.h

Go to the documentation of this file.

//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
 
#ifndef LLDB_INTERPRETER_SCRIPTEDINSTANCEREGISTRY_H
#define LLDB_INTERPRETER_SCRIPTEDINSTANCEREGISTRY_H
 
#include "lldb/Utility/FileSpec.h"
#include "lldb/Utility/StructuredData.h"
#include "lldb/Utility/UUID.h"
#include "lldb/lldb-defines.h"
#include "lldb/lldb-enumerations.h"
#include "lldb/lldb-forward.h"
#include "lldb/lldb-types.h"
#include "llvm/ADT/ArrayRef.h"
#include "llvm/ADT/DenseMap.h"
#include "llvm/ADT/StringRef.h"
 
#include <cstdint>
#include <mutex>
#include <string>
#include <vector>
 
namespace lldb_private {
 
struct ScriptedInstanceInfo {
  uint64_t id = 0;
  UUID uuid;
  lldb::addr_t object_address = LLDB_INVALID_ADDRESS;
  /// The interface's PluginManager name, from the string literal its
  /// GetPluginNameStatic() returns, so this never dangles.
  llvm::StringRef plugin_name;
  std::string class_name;
  FileSpec source_path;
  StructuredData::DictionarySP args_sp;
};
 
/// The live instances of one extension class. Instances belong to the same
/// group when they share a class name, source path and extension kind, so a
/// class reused for several kinds of extension gets one group per kind.
struct ScriptedInstanceGroup {
  std::string class_name;
  lldb::ScriptedExtension extension = lldb::eScriptedExtensionInvalid;
  FileSpec source_path;
  std::vector<ScriptedInstanceInfo> instances;
 
  bool operator<(const ScriptedInstanceGroup &other) const;
 
  StructuredData::DictionarySP ToStructuredData() const;
 
  void Dump(Stream &s, const Debugger &debugger, bool use_color) const;
};
 
/// Entries are snapshots taken when the object is created, so listing them
/// never calls back into an interface that might be mid-destruction on
/// another thread.
class ScriptedInstanceRegistry {
public:
  uint64_t Add(ScriptedInstanceInfo info);
 
  void Remove(uint64_t id);
 
  std::vector<ScriptedInstanceInfo> GetInstances() const;
 
  std::vector<ScriptedInstanceGroup> GetInstanceGroups(
      llvm::ArrayRef<lldb::ScriptedExtension> extensions = {}) const;
 
private:
  std::vector<ScriptedInstanceInfo> CopyInstances() const;
 
  mutable std::mutex m_mutex;
  uint64_t m_next_id = 1;
  llvm::DenseMap<uint64_t, ScriptedInstanceInfo> m_instances;
};
 
} // namespace lldb_private
 
#endif // LLDB_INTERPRETER_SCRIPTEDINSTANCEREGISTRY_H