method.h

Go to the documentation of this file.

// === method.h ========================================================================================================
//                                               Sen Infrastructure
//                   Released under the Apache License v2.0 (SPDX-License-Identifier Apache-2.0).
//                                    See the LICENSE.txt file for more information.
//                   © Airbus SAS, Airbus Helicopters, and Airbus Defence and Space SAU/GmbH/SAS.
// =====================================================================================================================
 
#ifndef SEN_CORE_META_METHOD_H
#define SEN_CORE_META_METHOD_H
 
// sen
#include "sen/core/base/class_helpers.h"
#include "sen/core/base/hash32.h"
#include "sen/core/meta/callable.h"
#include "sen/core/meta/type.h"
 
// std
#include <memory>
#include <utility>
#include <variant>
 
namespace sen
{

 
// forward declarations
class Property;

enum class Constness
{
  constant,
  nonConstant,
};

struct NonPropertyRelated
{
};

struct PropertyGetter
{
  const Property* property;
};

struct PropertySetter
{
  const Property* property;
};

using PropertyRelation = std::variant<NonPropertyRelated, PropertyGetter, PropertySetter>;

struct MethodSpec final
{
  MethodSpec(CallableSpec callableSpec,
             ConstTypeHandle<> returnType,
             Constness constness = Constness::nonConstant,
             PropertyRelation propertyRelation = NonPropertyRelated {},
             bool deferred = false,
             bool localOnly = false)
    : callableSpec(std::move(callableSpec))
    , constness(constness)
    , returnType(std::move(returnType))
    , propertyRelation(propertyRelation)
    , deferred(deferred)
    , localOnly(localOnly)
  {
  }
 
  // Comparison operators
  friend bool operator==(const MethodSpec& lhs, const MethodSpec& rhs) noexcept
  {
    return lhs.callableSpec == rhs.callableSpec && lhs.constness == rhs.constness && lhs.deferred == rhs.deferred &&
           lhs.returnType == rhs.returnType;
  }
 
  friend bool operator!=(const MethodSpec& lhs, const MethodSpec& rhs) noexcept { return !(lhs == rhs); }
 
public:
  CallableSpec callableSpec;                                  // NOLINT(misc-non-private-member-variables-in-classes)
  Constness constness = Constness::nonConstant;               // NOLINT(misc-non-private-member-variables-in-classes)
  ConstTypeHandle<> returnType;                               // NOLINT(misc-non-private-member-variables-in-classes)
  PropertyRelation propertyRelation = NonPropertyRelated {};  // NOLINT(misc-non-private-member-variables-in-classes)
  bool deferred = false;                                      // NOLINT(misc-non-private-member-variables-in-classes)
  bool localOnly = false;                                     // NOLINT(misc-non-private-member-variables-in-classes)
};

class Method final: public Callable
{
  SEN_NOCOPY_NOMOVE(Method)
  SEN_PRIVATE_TAG
 
public:
  Method(const MethodSpec& spec, Private notUsable);
 
public:
  [[nodiscard]] static std::shared_ptr<Method> make(MethodSpec spec);
 
public:  // special members
  ~Method() override = default;
 
public:
  [[nodiscard]] Constness getConstness() const noexcept;

  [[nodiscard]] bool getDeferred() const noexcept;

  [[nodiscard]] ConstTypeHandle<> getReturnType() const noexcept;

  [[nodiscard]] const PropertyRelation& getPropertyRelation() const noexcept;

  [[nodiscard]] bool getLocalOnly() const noexcept;

  [[nodiscard]] bool operator==(const Method& other) const noexcept;

  [[nodiscard]] bool operator!=(const Method& other) const noexcept;

  [[nodiscard]] MemberHash getHash() const noexcept;

  [[nodiscard]] MemberHash getId() const noexcept;
 
private:
  Constness constness_;
  bool deferred_;
  bool localOnly_;
  ConstTypeHandle<> returnType_;
  PropertyRelation propertyRelation_;
  MemberHash id_;
  MemberHash hash_;
};


template <>
struct impl::hash<MethodSpec>
{
  u32 operator()(const MethodSpec& spec) const noexcept
  {
    return hashCombine(hashSeed, spec.callableSpec, spec.constness, spec.returnType->getHash());
  }
};
 
}  // namespace sen
 
#endif  // SEN_CORE_META_METHOD_H