Reminds me of some exploration I did with Moveable.

I vaguely recalled that when I tested a few years back, the way Moveable was designed were causing a compile time error with Windows/VSBuild. I would also welcome a redesign of Moveable using more recent language facilities.

Hi all,
U++ does not have a container with std::array functionality. Is there any simple way to mark std::array<T, N> moveable if only T is moveable?
I didn't come with anything better than implementing my own version of std::array derived from Moveable<MyArray<T, N>>. By using macro NTL_MOVEABLE one can only mark moveable a specific type not a template. Even if I want to mark specific template type, macro does not work with template types having two or more parameters and I have to expand macro myself:

template<> inline void AssertMoveable<std::array<double, 2>>(std::array<double, 2>*) {}

Correct me if I miss something. Shouldn't the mechanism of marking type moveable be done through partial class instantiation? Or concepts with C++20?

Same semantics does not cover U++ moveable. Now I agree it is unlikely, but so I thought about std::string until I met implementation that is not U++ moveable...

Story of std::basic_string (GLIBCXX implementation)

It's surprising that a basic_string<ch> would cause trouble (core dump etc) when treated as raw bytes. Digging into its implementation (in <bits/basic_string.h>), we have the data members
...

last time I tested, AssertMoveable was preventing U++ be compiled with std=c++20. Eventually that might be a move we have to make.

Well it all starts with testing Upp code for C++20 compliance. let's try theide first. The ide compiles fine on both GCC and CLANG with -std=c++20 option, except some complaints on capturing this by default is deprecated in C++20, which are easy to fix or safe to ignore for now. But it's a total different story with MSC. with standard set to C++17, MSC rejects a bunch of stuff like

return somecondition? "a literal string" : AString;

These are also easy to fix if you don't mind your local version is slightly different from the main stream.

When standard is set to C++20 or c++latest, Upp::Moveable AssertMoveable0() is start to causing compilation failure, this one seems to be quite difficult to fix.

I was thinking it's just a mechanism to communicate to the compiler that it can treat object of this class as raw bytes, maybe we can do it differently with so much more facilities available in more recent c++ library.

So I start to do some experiment.

Lance wrote on Wed, 03 July 2024 03:39

Reminds me of some exploration I did with Moveable.

I vaguely recalled that when I tested a few years back, the way Moveable was designed were causing a compile time error with Windows/VSBuild. I would also welcome a redesign of Moveable using more recent language facilities.

Suggestions? (But it needs to be backward compatible).

#include <Core/Core.h>
#include <type_traits>

namespace Upp {
// First way of marking class moveable is to be an ancestor of NtlMoveableBase
template <class T> class NtlMoveableBase {};

// Second way is to specialize NtlMoveableClass
template <class T>
struct NtlMoveableClass
: std::integral_constant<bool,
	   std::is_trivial_v<T>
	|| std::is_base_of_v<Upp::NtlMoveableBase<T>, T>
	// below is not needed if we make them derived from NtlMoveableBase
	|| std::is_base_of_v<Upp::Moveable_<T>, T>
	|| std::is_base_of_v<Upp::Moveable<T>, T>
	|| std::is_base_of_v<Upp::MoveableAndDeepCopyOption<T>, T>> {};

// For instance mark std::array<T, N> moveable if only T is moveable
template <class T, size_t N>
struct NtlMoveableClass<std::array<T, N>>
: std::integral_constant<bool, NtlMoveableClass<T>::value> {};

// Helper for checking whether class is moveable
template <class T>
inline constexpr bool IsNtlMoveable = NtlMoveableClass<T>::value;

// Optional concept for c++20
template <class T>
concept NtlMoveable = IsNtlMoveable<T>;

}

using namespace Upp;

// use of concept
template <NtlMoveable T>
struct MyVector
{
	T *ptr;
	// Or use static_assert
	~MyVector() { static_assert(IsNtlMoveable<T>); }
};

CONSOLE_APP_MAIN
{
	// Checking if given type is moveable
	static_assert(IsNtlMoveable<int>);
	static_assert(IsNtlMoveable<const void *>);
	static_assert(IsNtlMoveable<Vector<int>>);
	static_assert(IsNtlMoveable<std::array<int, 5>>);
	static_assert(IsNtlMoveable<std::array<Vector<int>, 5>>);
	static_assert(!IsNtlMoveable<Thread>);
}

mirek wrote on Thu, 18 July 2024 08:41

Lance wrote on Wed, 03 July 2024 03:39

Reminds me of some exploration I did with Moveable.

I vaguely recalled that when I tested a few years back, the way Moveable was designed were causing a compile time error with Windows/VSBuild. I would also welcome a redesign of Moveable using more recent language facilities.

Suggestions? (But it needs to be backward compatible).

I was thinking about something like that:

#include <Core/Core.h>
#include <type_traits>

namespace Upp {
// First way of marking class moveable is to be an ancestor of NtlMoveableBase
template <class T> class NtlMoveableBase {};

// Second way is to specialize NtlMoveableClass
template <class T>
struct NtlMoveableClass
: std::integral_constant<bool,
	   std::is_trivial_v<T>
	|| std::is_base_of_v<Upp::NtlMoveableBase<T>, T>
	// below is not needed if we make them derived from NtlMoveableBase
	|| std::is_base_of_v<Upp::Moveable_<T>, T>
	|| std::is_base_of_v<Upp::Moveable<T>, T>
	|| std::is_base_of_v<Upp::MoveableAndDeepCopyOption<T>, T>> {};

// For instance mark std::array<T, N> moveable if only T is moveable
template <class T, size_t N>
struct NtlMoveableClass<std::array<T, N>>
: std::integral_constant<bool, NtlMoveableClass<T>::value> {};

// Helper for checking whether class is moveable
template <class T>
inline constexpr bool IsNtlMoveable = NtlMoveableClass<T>::value;

// Optional concept for c++20
template <class T>
concept NtlMoveable = IsNtlMoveable<T>;

}

using namespace Upp;

// use of concept
template <NtlMoveable T>
struct MyVector
{
	T *ptr;
	// Or use static_assert
	~MyVector() { static_assert(IsNtlMoveable<T>); }
};

CONSOLE_APP_MAIN
{
	// Checking if given type is moveable
	static_assert(IsNtlMoveable<int>);
	static_assert(IsNtlMoveable<const void *>);
	static_assert(IsNtlMoveable<Vector<int>>);
	static_assert(IsNtlMoveable<std::array<int, 5>>);
	static_assert(IsNtlMoveable<std::array<Vector<int>, 5>>);
	static_assert(!IsNtlMoveable<Thread>);
}

You could redefine NTL_MOVEABLE macro as a specialization of NtlMoveableClass.
But you need to change an assertion AssertMoveable((T*)0) to static_assert(IsNtlMoveable<T>).
Are those ideas usable?

template <class T> struct Moveable {};

template <class T>
inline constexpr bool is_Moveable = std::is_trivially_copyable<T>::value ||
                                    std::is_base_of<moveable<T>, T>::value;

The capability to manually mark a class might still be an asset. Suppose we receive a third party class whose objects are trivially relocatable but not trivially copyable, the simplest way to make Upp::Vector accept it is to mark it. Wrongfully marked class will usually result in immediate runtime error, hence should not be a big concern.

Another thing to consider: Tuple is moveable if all its components are moveable. Are we able to express that somehow? (If not, no big deal, I can make Tuple moveable and request that elements are).

struct not_moveable {};

template <class A, class B>
class Two : std::conditional<is_moveable<A> && is_moveable<B>, moveable<Two<A, B>>, not_moveable>::type {
	A a;
	B b;
};

mirek wrote on Thu, 25 July 2024 09:19

Another thing to consider: Tuple is moveable if all its components are moveable. Are we able to express that somehow? (If not, no big deal, I can make Tuple moveable and request that elements are).

Figured it out:

struct not_moveable {};

template <class A, class B>
class Two : std::conditional<is_moveable<A> && is_moveable<B>, moveable<Two<A, B>>, not_moveable>::type {
	A a;
	B b;
};

auto [a, b] = some std::tuple

// For instance mark std::array<T, N> moveable if only T is moveable
template <class T, size_t N>
struct NtlMoveableClass<std::array<T, N>>
: std::integral_constant<bool, NtlMoveableClass<T>::value> {};

BTW, easiest and really nice way how to add optional trait:

template <> inline constexpr bool is_moveable<std::string> = true;

(do not want this, but could be useful to know)

#include <iostream>
#include <type_traits>
#include <array>


template <class T> struct Moveable {};

template <class T>
inline constexpr bool is_moveable_v = std::is_trivially_copyable<T>::value ||
                                    std::is_base_of<Moveable<T>, T>::value;

class C: public Moveable<C>{
	C(const C& c){}
	C(C&& c){}
};

// uncomment to communicate the moveability of array<T,n> to the compiler
//template <class T, int n>
//inline constexpr bool is_moveable_v<std::array<T,n>> = is_moveable_v<T>;

int main()
{
	std::cout<<is_moveable_v<std::array<C,5>><<std::endl;
}

mirek wrote on Thu, 25 July 2024 09:19

Another thing to consider: Tuple is moveable if all its components are moveable. Are we able to express that somehow? (If not, no big deal, I can make Tuple moveable and request that elements are).

Figured it out:

struct not_moveable {};

template <class A, class B>
class Two : std::conditional<is_moveable<A> && is_moveable<B>, moveable<Two<A, B>>, not_moveable>::type {
	A a;
	B b;
};

template <class A, class B> inline constexpr bool is_moveable<Two<A, B>> = is_moveable<A> && is_moveable<B>;