registry.hpp

Go to the documentation of this file.

// Copyright (c) 2025 [caomengxuan666]
 
#pragma once
 
#include <mutex>
#include <optional>
#include <string>
#include <string_view>
#include <unordered_map>
#include <vector>
 
#include "cxxmcp/core/result.hpp"
#include "cxxmcp/protocol/prompt.hpp"
#include "cxxmcp/protocol/resource.hpp"
#include "cxxmcp/protocol/tool.hpp"
#include "cxxmcp/server/handler_types.hpp"
#include "cxxmcp/server/schema_validator.hpp"
#include "cxxmcp/server/transport.hpp"
 
 
namespace mcp::server {
 
class ToolRegistry {
 public:
  ToolRegistry() = default;
  ToolRegistry(const ToolRegistry& other);
  ToolRegistry& operator=(const ToolRegistry& other);
  ToolRegistry(ToolRegistry&& other) noexcept;
  ToolRegistry& operator=(ToolRegistry&& other) noexcept;
 
  core::Result<core::Unit> add(protocol::ToolDefinition definition,
                               ToolHandler handler);
 
  core::Result<protocol::ToolDefinition> get(std::string_view name) const;
 
  core::Result<protocol::ToolResult> call(std::string_view name,
                                          protocol::Json arguments) const;
 
  core::Result<protocol::ToolResult> call(protocol::ToolCall call) const;
 
  core::Result<core::Unit> validate(const protocol::ToolCall& call) const;
 
  core::Result<protocol::ToolResult> call(
      std::string_view name, protocol::Json arguments,
      const SessionContext& session_context) const;
 
  core::Result<protocol::ToolResult> call(
      protocol::ToolCall call, const SessionContext& session_context) const;
 
  core::Result<protocol::ToolResult> call(protocol::ToolCall call,
                                          const SessionContext& session_context,
                                          CancellationToken cancellation) const;
  core::Result<protocol::ToolResult> call(
      protocol::ToolCall call, const SessionContext& session_context,
      CancellationToken cancellation,
      const JsonSchemaValidator* schema_validator) const;
 
  core::Result<protocol::ToolResult> call(std::string_view name,
                                          protocol::Json arguments,
                                          const std::string& session_id) const;
 
  std::vector<protocol::ToolDefinition> list() const;
 
 private:
  struct Entry {
    protocol::ToolDefinition definition;
    ToolHandler handler;
  };
 
  mutable std::mutex mutex_;
  std::unordered_map<std::string, Entry> tools_;
  mutable std::vector<protocol::ToolDefinition> sorted_tools_cache_;
  mutable bool sorted_tools_cache_dirty_ = true;
};
 
class PromptRegistry {
 public:
  PromptRegistry() = default;
  PromptRegistry(const PromptRegistry& other);
  PromptRegistry& operator=(const PromptRegistry& other);
  PromptRegistry(PromptRegistry&& other) noexcept;
  PromptRegistry& operator=(PromptRegistry&& other) noexcept;
 
  core::Result<core::Unit> add(protocol::Prompt prompt, PromptHandler handler);
 
  core::Result<protocol::PromptsGetResult> get(
      std::string_view name, protocol::Json arguments,
      const std::string& session_id) const;
 
  core::Result<protocol::PromptsGetResult> get(
      std::string_view name, protocol::Json arguments,
      const SessionContext& session_context) const;
  core::Result<protocol::PromptsGetResult> get(
      std::string_view name, protocol::Json arguments,
      const SessionContext& session_context,
      CancellationToken cancellation) const;
 
  std::vector<protocol::Prompt> list() const;
 
 private:
  struct Entry {
    protocol::Prompt prompt;
    PromptHandler handler;
  };
 
  mutable std::mutex mutex_;
  std::unordered_map<std::string, Entry> prompts_;
  mutable std::vector<protocol::Prompt> sorted_prompts_cache_;
  mutable bool sorted_prompts_cache_dirty_ = true;
};
 
class ResourceRegistry {
 public:
  ResourceRegistry() = default;
  ResourceRegistry(const ResourceRegistry& other);
  ResourceRegistry& operator=(const ResourceRegistry& other);
  ResourceRegistry(ResourceRegistry&& other) noexcept;
  ResourceRegistry& operator=(ResourceRegistry&& other) noexcept;
 
  core::Result<core::Unit> add(protocol::Resource resource,
                               ResourceReadHandler handler);
 
  core::Result<protocol::ResourcesReadResult> read(
      std::string_view uri, protocol::Json params,
      const std::string& session_id) const;
 
  core::Result<protocol::ResourcesReadResult> read(
      std::string_view uri, protocol::Json params,
      const SessionContext& session_context) const;
  core::Result<protocol::ResourcesReadResult> read(
      std::string_view uri, protocol::Json params,
      const SessionContext& session_context,
      CancellationToken cancellation) const;
 
  std::vector<protocol::Resource> list() const;
 
 private:
  struct Entry {
    protocol::Resource resource;
    ResourceReadHandler handler;
  };
 
  mutable std::mutex mutex_;
  std::unordered_map<std::string, Entry> resources_;
  mutable std::vector<protocol::Resource> sorted_resources_cache_;
  mutable bool sorted_resources_cache_dirty_ = true;
};
 
class ResourceTemplateRegistry {
 public:
  ResourceTemplateRegistry() = default;
  ResourceTemplateRegistry(const ResourceTemplateRegistry& other);
  ResourceTemplateRegistry& operator=(const ResourceTemplateRegistry& other);
  ResourceTemplateRegistry(ResourceTemplateRegistry&& other) noexcept;
  ResourceTemplateRegistry& operator=(
      ResourceTemplateRegistry&& other) noexcept;
 
  core::Result<core::Unit> add(protocol::ResourceTemplate resource_template);
 
  std::vector<protocol::ResourceTemplate> list() const;
 
 private:
  mutable std::mutex mutex_;
  std::unordered_map<std::string, protocol::ResourceTemplate>
      resource_templates_;
  mutable std::vector<protocol::ResourceTemplate> sorted_templates_cache_;
  mutable bool sorted_templates_cache_dirty_ = true;
};
 
}  // namespace mcp::server