Type.h

/* Copyright (C) 2020-2026 by Marc Boris Duerner
   SPDX-License-Identifier: LGPL-2.1-or-later WITH mif-exception
*/
 
#ifndef PT_MCP_TYPE_H
#define PT_MCP_TYPE_H
 
#include <Pt/Mcp/Api.h>
#include <Pt/NonCopyable.h>
#include <string>
#include <vector>
#include <iosfwd>
 
namespace Pt {
 
namespace Mcp {

class PT_MCP_API Type : private NonCopyable
{
  public:
    enum TypeId
    {
        Null = 0,     
        Integer = 1,  
        Number = 2,   
        String = 3,   
        Boolean = 4,  
        Object = 5,   
        Array = 6     
    };

    explicit Type(TypeId id)
    : _id(id)
    {}

    virtual ~Type();

    TypeId typeId() const
    { return _id; }

    virtual void toSchema(std::ostream& os,
                          const std::string& description = "") const;
 
  private:
    TypeId _id;
};
 

PT_MCP_API const Type& nullType();

PT_MCP_API const Type& integerType();

PT_MCP_API const Type& numberType();

PT_MCP_API const Type& stringType();

PT_MCP_API const Type& booleanType();
 

class PT_MCP_API Property
{
  public:
    Property(const std::string& name, const Type& type,
             const std::string& description = "");

    const std::string& name() const
    { return _name; }

    const Type& type() const
    { return *_type; }

    const std::string& description() const
    { return _description; }

    bool isRequired() const
    { return _required; }

    void setOptional()
    { _required = false; }
 
  private:
    std::string _name;
    const Type* _type;
    std::string _description;
    bool _required;
};
 

class PT_MCP_API ObjectType : public Type
{
  public:
    ObjectType();

    ~ObjectType();

    ObjectType& addProperty(const std::string& name, const Type& type,
                            const std::string& description = "");

    ObjectType& setOptional(const std::string& name);

    ObjectType& setStrict();

    const std::vector<Property>& properties() const
    { return _properties; }

    bool isStrict() const
    { return _strict; }

    void toSchema(std::ostream& os,
                  const std::string& description = "") const override;
 
  private:
    std::vector<Property> _properties;
    bool _strict;
};
 

class PT_MCP_API ArrayType : public Type
{
  public:
    explicit ArrayType(const Type& items);

    ~ArrayType();

    const Type& items() const
    { return *_items; }

    void toSchema(std::ostream& os,
                  const std::string& description = "") const override;
 
  private:
    const Type* _items;
};
 

class PT_MCP_API EnumType : public Type
{
  public:
    EnumType();

    ~EnumType();

    EnumType& addValue(const std::string& value);

    const std::vector<std::string>& values() const
    { return _values; }

    void toSchema(std::ostream& os,
                  const std::string& description = "") const override;
 
  private:
    std::vector<std::string> _values;
};
 

class PT_MCP_API NullableType : public Type
{
  public:
    explicit NullableType(const Type& inner);

    ~NullableType();

    const Type& inner() const
    { return *_inner; }

    void toSchema(std::ostream& os,
                  const std::string& description = "") const override;
 
  private:
    const Type* _inner;
};
 
} // namespace Mcp
 
} // namespace Pt
 
#endif // PT_MCP_TYPE_H