Sweep: Add CLinkAddress concept

[FreePhoenix888]

Sweep: Add CLinkAddress concept to cpp/Platform.Interfaces/. CLinkAddress must check that argument is integral and unsigned

Checklist

• cpp/Platform.Interfaces/CLinkAddress.h ✅ Commit 0e26908

• Include the `` and `` libraries at the beginning of the file. • Define the `Platform::Interfaces` namespace. • Inside the namespace, define the `CLinkAddress` concept that takes a single template argument `T`. • The concept should check if `T` is both integral and unsigned using `std::is_integral` and `std::is_unsigned` respectively.

[linksplatform-sweepai]

Here's the PR! #116.

💎 Sweep Pro: I used GPT-4 to create this ticket. You have unlimited GPT-4 tickets.

---

Actions (click)

• ↻ Restart Sweep

---

Step 1: 🔎 Searching

I found the following snippets in your repository. I will now analyze these snippets and come up with a plan.

Some code snippets I looked at (click to expand). If some file is missing from here, you can mention the path in the ticket description.

Interfaces/cpp/Platform.Interfaces/CSet.h

Lines 1 to 52 in 8259973

	#pragma once
	#include <concepts>
	#include <ranges>
	#include <tuple>
	#include <type_traits>
	#include "CEnumerable.h"
	namespace Platform::Interfaces {
	namespace Internal {
	template <typename TRawSelf, typename... TItems>
	consteval bool CSetHelpFunction() {
	using Self = std::remove_const_t<TRawSelf>;
	if constexpr (sizeof...(TItems) == 1) {
	return requires(Self self, std::tuple<TItems...> items, decltype(std::get<0>(items)) item) {
	{ self.find(item) } -> std::same_as<std::ranges::iterator_t<Self>>;
	{self.insert(item)};
	{self.erase(item)};
	{ self.contains(item) } -> std::same_as<bool>;
	{ self.empty() } -> std::same_as<bool>;
	{ self.size() } -> std::integral;
	{self.clear()};
	requires std::ranges::forward_range<Self>;
	};
	}
	if constexpr (sizeof...(TItems) == 0) {
	return requires(Self self, typename Enumerable<Self>::Item generic_item) {
	{ self.find(generic_item) } -> std::same_as<std::ranges::iterator_t<Self>>;
	{self.insert(generic_item)};
	{self.erase(generic_item)};
	{ self.contains(generic_item) } -> std::same_as<bool>;
	{ self.empty() } -> std::same_as<bool>;
	{ self.size() } -> std::integral;
	{self.clear()};
	requires std::ranges::forward_range<Self>;
	};
	}
	return false;
	}
	} // namespace Internal
	template <typename TSelf, typename... TItems>
	concept CSet = CEnumerable<TSelf> && Internal::CSetHelpFunction<TSelf, TItems...>();
	template <CSet TSelf>
	struct Set : Enumerable<TSelf> {};

Interfaces/cpp/Platform.Interfaces/CDictionary.h

Lines 1 to 77 in 8259973

	#pragma once
	#include <concepts>
	#include <iterator>
	#include <ranges>
	#include <tuple>
	#include <type_traits>
	#include <utility>
	#include "CEnumerable.h"
	namespace Platform::Interfaces {
	namespace Internal {
	template <typename TRawSelf, typename... TArgs>
	consteval bool CDictionaryHelpFunction() {
	using Self = std::remove_const_t<TRawSelf>;
	using GenericKey = std::remove_reference_t<decltype(std::get<0>(std::declval<typename Enumerable<Self>::Item>()))>;
	using GenericValue = std::remove_reference_t<decltype(std::get<1>(std::declval<typename Enumerable<Self>::Item>()))>;
	if constexpr (sizeof...(TArgs) == 0) {
	return requires(Self self, GenericKey generic_key, GenericValue generic_value) {
	{ self[generic_key] } -> std::same_as<GenericValue&>;
	{ self.find(generic_key) } -> std::forward_iterator;
	{ self.contains(generic_key) } -> std::same_as<bool>;
	{self.insert({generic_key, generic_value})};
	{ self.empty() } -> std::same_as<bool>;
	{ self.size() } -> std::integral;
	{self.clear()};
	requires std::ranges::forward_range<Self>;
	};
	}
	if constexpr (sizeof...(TArgs) == 1) {
	return requires(Self self, std::tuple<TArgs...> args,
	decltype(std::get<0>(args)) key, decltype(std::declval<Enumerable<Self>::Item>().second) generic_value) {
	{ self[key] } -> std::same_as<GenericValue&>;
	{ self.find(key) } -> std::forward_iterator;
	{ self.contains(key) } -> std::same_as<bool>;
	{self.insert({key, generic_value})};
	{ self.empty() } -> std::same_as<bool>;
	{ self.size() } -> std::integral;
	{self.clear()};
	requires std::ranges::forward_range<Self>;
	};
	}
	if constexpr (sizeof...(TArgs) == 2) {
	return requires(Self self, std::tuple<TArgs...> args,
	decltype(std::get<0>(args)) key, decltype(std::get<1>(args)) value) {
	{ self[key] } -> std::same_as<GenericValue&>;
	{ self.find(key) } -> std::forward_iterator;
	{ self.contains(key) } -> std::same_as<bool>;
	{self.insert({key, value})};
	{ self.empty() } -> std::same_as<bool>;
	{ self.size() } -> std::integral;
	{self.clear()};
	requires std::ranges::forward_range<Self>;
	};
	}
	return false;
	}
	} // namespace Internal
	template <typename TSelf, typename... TArgs>
	concept CDictionary = CEnumerable<TSelf> && Internal::CDictionaryHelpFunction<TSelf, TArgs...>();
	template <CDictionary TSelf>
	struct Dictionary : Enumerable<TSelf> {
	using base = Enumerable<TSelf>;
	using Key = decltype(std::get<0>(std::declval<base::Item>()));
	using Value = decltype(std::get<1>(std::declval<base::Item>()));
	};

https://github.com/linksplatform/Interfaces/blob/825997338e0852ecada7cfcfc58da7f7d918e80c/cpp/Platform.Interfaces/ICounter[TResult].h#L1-L12

Interfaces/cpp/Platform.Interfaces/IFactory.h

Lines 1 to 12 in 8259973

	#pragma once
	namespace Platform::Interfaces {
	template <typename...>
	struct IFactory;
	template <typename TProduct>
	struct IFactory<TProduct> {
	virtual TProduct Create() = 0;
	virtual ~IFactory() = default;
	};

Interfaces/cpp/Platform.Interfaces/ICriterionMatcher.h

Lines 1 to 12 in 8259973

	#pragma once
	namespace Platform::Interfaces {
	template <typename...>
	struct ICriterionMatcher;
	template <typename TArgument>
	struct ICriterionMatcher<TArgument> {
	virtual bool IsMatched(TArgument argument) = 0;
	virtual ~ICriterionMatcher() = default;
	};

---

Step 2: ⌨️ Coding

• cpp/Platform.Interfaces/CLinkAddress.h ✅ Commit 0e26908

• Include the `` and `` libraries at the beginning of the file. • Define the `Platform::Interfaces` namespace. • Inside the namespace, define the `CLinkAddress` concept that takes a single template argument `T`. • The concept should check if `T` is both integral and unsigned using `std::is_integral` and `std::is_unsigned` respectively.

---

Step 3: 🔁 Code Review

I have finished reviewing the code for completeness. I did not find errors for sweep/add-clinkaddress-concept.

.

---

🎉 Latest improvements to Sweep:

• Getting Sweep to run linters before committing! Check out Sweep Sandbox Configs to set it up.
• Added support for self-hosting! Check out Self-hosting Sweep to get started.
• [Self Hosting] Multiple options to compute vector embeddings, configure your .env file using VECTOR_EMBEDDING_SOURCE

---

💡 To recreate the pull request edit the issue title or description. To tweak the pull request, leave a comment on the pull request.
^{Join Our Discord}

[FreePhoenix888]

Sweep: you should write C++ concept, not struct!
Here is an example of C++ concept:

#pragma once

#include <concepts>

namespace Platform::Interfaces {
  template <typename TSelf, typename TValue, typename... TArgument>
  concept CSetter = sizeof...(TArgument) <= 1 && requires(TSelf self, TArgument... argument, TValue value) {
    { self.Set(argument..., value) } -> std::same_as<void>;
  };
}