HowardHinnant.github.io

That operator<< is inside the date namespace. Since neither of the operand types are from this namespace, argument-dependent lookup won't find it.

To use it you need either using namespace date or using date::operator<<.

Another issue in your code is that microseconds can only be constructed from an integer type, not floating point.

This is an unfortunate effect of the argument-dependent lookup: fmt::to_string calls format which ends up being resolved to date::format instead of fmt::format. The fix is to fully qualify the call to format in fmt::to_string since it depends on a user-defined type.

Update: this has been fixed in https://github.com/fmtlib/fmt/commit/2cac8a9d2e36cd920a9a60ec5b776c187e843fbb.

I would say yes, except for endian issues. I.e. if you save it on a big endian machine and read it with a little endian machine, you'll get the wrong answer.

Since sys_time is not a POD, you could also just extract its integral POD value and save that as binary:

What you are seeing is Short String Optimization (SSO). The standard allows for std::string to be built with a small internal buffer that the string can use to avoid doing any dynamic memory allocation. This is very advantageous since most strings are small so you can save a lot of allocations.

Unfortunately there is no restriction on the size of this buffer in the standard. MSVC uses 16 characters, libc++ uses 22.

This means that you'll either need to make sure you allocate a string that is big enough to use your allocator, or you'll just need to implement your own string class. A trick to allocate enough memory is to use

This would give the index of the day using date.h:

The heart of the issue is essentially a circular dependency.

Constructing the RTree causes the rtree<...> template instantiation which includes a typedef node_pointer = allocators_type::node_pointer, which triggers the instantiation of allocators_type, i.e. detail::rtree::allocators<...>, which has a base class of detail::rtree::node_alloc<...>, which in its definition rebinds the allocator to the node type. The node type is a variant of detail::rtree::variant_leaf<...> and detail::rtree::variant_internal_node<...>.

But stack_alloc needs the sizeof(T), so both templates included in the variant types get instantiated, and when instantiating variant_internal_node, it needs Allocators::node_pointer, so Allocators must be instantiated, but isn't that what we're in the middle of instantiating!

I suggest trying short_alloc and passing the allocator to the container. Because it separates the storage from the allocator type, it should not require completeness of the template type, breaking the circle.

Could this have something to do with your time zone? I know a lot of businesses are located on the east coast and "iso_week.h" could be based on that time, meaning it could be running at midnight and it just tells you that it is running at 3am. If this is not the case would it be wrong to just run the program at 9pm?

Numeric literal operator 'operator""_y' is declared inside of namespace 'date'.

You can use 'using namespace date' or 'using namespace date::literals'

More information: How to refer to user defined literal operator inside a namespace?

Use %T, it seems to work. Here is an example: