cbor | CBOR support for serde | Serialization library

I'd like to serialize a std::chrono::local_time by sending it's time_since_epoch().count() value. My question is how is a non-C++ receiver supposed to interpret that value? Is it the actual number of ticks since the epoch at local midnight (1970-01-01T00:00:00)? What about daylight saving time changes? Is the time_since_epoch() bijective with the wall clock time? That is, can there be two values of std::chrono::local_time::time_since_spoch() that represent the same wall clock/calendar time?

I cannot find detailed information about the interpretation of std::chrono::local_time::time_since_spoch() at the usual places: cppreference, the latest C++ standard draft, or Howard Hinnant's date library documentation.

'Why even serialize a std::chrono::local_time?', you may ask. Well, a use case would be a building automation system that must perform a certain task at a given local time on a special day, regardless of timezones or daylight saving time. For example, "turn off the lights at 20:00 local time on Earth Day, 2021 (April 22).

EDIT: 'Why not serialize it as an ISO8601 date/time (without any offset), you may ask?'. I want to serialize it as a compact number using a binary protocol, such as CBOR.

I have an byte[] encodedKeyBytes and I want to create the associated Public Key.

If you look at how this go-cardano-client is making it's handshake request payload:

https://github.com/gocardano/go-cardano-client/blob/master/shelley/handshake.go#L64

Is it possible to send data with a different content type using the index method from the Python elasticsearch library? The documentation for the ingest-attachment plugin mentions that you can use the CBOR encoding to avoid encoding and decoding the attached files to and from BASE64. However, as of writing this question, even their usage example performs the request with the requests library rather than the ElasticSearch client:

This is what my pom.xml looks like

C++11 introduced std::begin(std::valarray&) as well as std::end(std::valarray&).

C++17 introduced std::data() which works with std::vector, std::array, C-style arrays, etc. But why wasn't an overloaded std::data() introduced for std::valarray?

std::valarray is specified to have contiguous storage, which can be accessed by taking the address of a[0] (see Notes).

std::data(std::valarray& a) could have simply been defined to return &(a[0]). Why hasn't this been done? Is it an oversight?

My motivation is that I'm working on a general-purpose serialization library. When it receives contiguous binary number arrays from a source (such as CBOR), it detects if the destination container has an overloaded data(container) function, a container.resize(n) member function, as well as an appropriate value_type (matching primitive number type). The existence of all three makes it possible to efficiently memcpy() the source data directly into the destination container. It would make my life simpler if there was a std::data(std::valarray&) overload. The lack of it isn't a showstopper, but it does make the code more messy.

ADDENDUM: The reason why I want to detect a data function is that it tells me that the destination container is contiguous. If it's contiguous, then I can do an efficient byte copy (via std::memcpy or std::copy doesn't really matter). If it's not contiguous, then I have to unpack each unaligned source array number one at a time and append it to the destination container using push_back, emplace, etc depending on the container type.

ADDENDUM 2: I've decided to use an adaptor and traits approach instead of detecting the presence of a data function. This will make it easier to support non-standard or user-defined container types. My question about why there is no std::data(std::valarray& a) still stands.

ADDENDUM 3: I should have clarified that I need to do this hackery for CBOR typed arrays, which can only be numbers. Furthermore, the numbers in the source buffer are not aligned to element boundaries. I'm aware that the binary data may need endian swapping, and that copying bytes to a floating point type may trigger weird NaN behavior if not treated carefully.

I now regret mentioning my motivation, and should have let the std::data(std::valarray& a) question stand on its own. What a trainwreck this question has become, haha. :-)

I'd like to be able to copy big endian float arrays directly from an unaligned network buffer into a std::vector and perform the byte swapping back to host order "in place", without involving an intermediate std::vector. Is this even safe? I'm worried that the big endian float data may accidentally be interpreted as NaNs and trigger unexpected behavior. Is this a valid concern?

For the purposes of this question, assume that the host machine receiving the data is little endian.

Here's some code that demonstrates what I'm trying to do:

I am trying to use aws Transcribe to convert a wav file to text. I have uploaded a wav file to S3, which is located here and it has public read/write permissions: https://s3.us-east-1.amazonaws.com/csld8xmsdksdf8s9sk3mmdjsdifkjksdijsldk/Transcribe2.wav. The wav file is valid. I can download it in my browser and replay it (and it sounds like the origin recording), so I think we can rule out an invalid input file, file permissions, etc.

I am using java version: 1.8.0_275 for mac.

I expect my program to give me back the transcribed text: "Hello amazon Subscribe, what is this?"

Here is the actual program output, including exception:

I am new at using Sonarqube and I have an issue that maybe you can help with.

I am working in a development project now that uses Jdk 8 update 261, so I have my environment variable JAVA_HOME pointing to it and I can not change it as suggested in other posts.

So I installed jdk 11 as you can see in this image:

installed jdks

And I edited my wrapper.conf to this:

wrapper.conf file

But still my sonarqube does not start. This is the log I get in my C:\sonarqube-7.9.5\logs\sonar file: