fix: remove Long64_t from common header-only

[ianna]

• fixes issue C++ for JIT-compilation (RDataFrame and cppyy) shouldn't be in awkward/header-only. #2032
• enable boolean type test

[codecov]

Codecov Report

Merging #2084 (6b99430) into main (54ab9f3) will not change coverage.
The diff coverage is n/a.

Additional details and impacted files

[ianna]

@jpivarski - I think, using a fundamental type here is ok for either ROOT users or those who don't have it installed. The Long64_t is a type alias for a long type (that is also an int64_t) on Mac, but it's a long long on Ubuntu.

[jpivarski]

Looks good! I'd accept it as it is, but I made a suggestion to consider before merging it. Whether you decide to accept the suggestion or not, you can merge this PR.

If you merge it today (i.e. in the next few hours), then it will be included in the next awkward-cpp release. Otherwise, we'll do another awkward-cpp release later.

[ianna]

@jpivarski - please, check. I'm done with this PR for today. Thanks!

[jpivarski]

See below. I'll try committing this change and auto-merging.

[jpivarski]

E               TypeError: while calling
E               
E                   ak.from_rdataframe(
E                       rdf = RInterface<ROOT::Detail::RDF::RLoopManager,void>-instance
E                       columns = 'x'
E                   )
E               
E               Error details: unrecognized primitive: 'unsupported_primitive_type'. Must be one of
E               
E                   bool, int8, uint8, int16, uint16, int32, uint32, int64, uint64, float32, float64, complex64, complex128, datetime64, timedelta64, float16, float128, complex256
E               
E               or a datetime64/timedelta64 with units (e.g. 'datetime64[15us]')

out        = None
primitive  = 'unsupported_primitive_type'

Okay, I'm going to check it out locally and see what's happening.

[jpivarski]

And since std::is_same_v<T, bool> checks compatibility/equivalence, rather than exact alias names...

std::is_same_v<T, bool> does not check for compatibility/equivalence. It checks for exact equality in some sense (possibly depends on how stdint.h was written):

root [0] std::is_same_v<Long64_t, int64_t>
(const bool) false

But this should do it:

root [1] std::is_integral_v<Long64_t> && std::is_signed_v<Long64_t> && sizeof(Long64_t) == 8
(bool) true

I'm updating the code.

[jpivarski]

This is working for me, locally:

awkward/header-only/awkward/utils.h

Lines 19 to 77 in 7929f0b

	/// @brief Returns the name of a primitive type as a string.
	template <typename T>
	const std::string
	type_to_name() {
	if (std::is_integral_v<T>) {
	if (std::is_signed_v<T>) {
	if (sizeof(T) == 1) {
	return "int8";
	}
	else if (sizeof(T) == 2) {
	return "int16";
	}
	else if (sizeof(T) == 4) {
	return "int32";
	}
	else if (sizeof(T) == 8) {
	return "int64";
	}
	}
	else {
	if (sizeof(T) == 1) {
	return "uint8";
	}
	else if (sizeof(T) == 2) {
	return "uint16";
	}
	else if (sizeof(T) == 4) {
	return "uint32";
	}
	else if (sizeof(T) == 8) {
	return "uint64";
	}
	}
	}
	else if (std::is_same_v<T, float>) {
	return "float32";
	}
	else if (std::is_same_v<T, double>) {
	return "float64";
	}
	else if (std::is_same_v<T, std::complex<float>>) {
	return "complex64";
	}
	else if (std::is_same_v<T, std::complex<double>>) {
	return "complex128";
	}
	// std::is_integral_v<T> and sizeof(T) not in (1, 2, 4, 8) can get here.
	// Don't connect this line with the above as an 'else' clause.
	return std::string("unsupported primitive type: ") + typeid(T).name();
	}
	template <>
	const std::string
	type_to_name<bool>() {
	// This takes precedence over the unspecialized template, and therefore any
	// 8-bit data that is not named bool will be mapped to "int8" or "uint8".
	return "bool";
	}

[ianna]

@jpivarski - thanks! It looks great. I will try to run more extensive tests to check the containers of strings/chars.

[ianna]

And since std::is_same_v<T, bool> checks compatibility/equivalence, rather than exact alias names...

std::is_same_v<T, bool> does not check for compatibility/equivalence. It checks for exact equality in some sense (possibly depends on how stdint.h was written):

root [0] std::is_same_v<Long64_t, int64_t>
(const bool) false

yes, because in this case:

root [0] std::is_same_v<Long64_t, int64_t>
(const bool) false
root [1] std::is_same_v<Long64_t, long long>
(const bool) true
root [2] std::is_same_v<int64_t, long>
(const bool) true

But this should do it:

root [1] std::is_integral_v<Long64_t> && std::is_signed_v<Long64_t> && sizeof(Long64_t) == 8
(bool) true

I'm updating the code.