struct some_class {
  std::chrono::base_clock *clock_ = &std::chrono::system_clock;

  std::string do_something() {
    return make_iso_timestamp(*clock_);
  }
};

// In tests
some_class t;
t.clock = fixed_clock(2020, 12, 23, 11, 22);
ASSERT_EQ("2020-12-23T11:22", t.do_something());

V>То есть, в Go та же самая сетка времени что и в плюсном chrono::nanoseconds с 64-битным счетчиком. Выписываем ему ненависть?

package main
import "time"
func main() {
  tm := time.Now()
  println(tm.Format("2006-01-02T15:04:05.999999999Z07:00"))
  // Или:
  println(tm.Format(time.RFC3339Nano))
}

#include <iostream>
#include <sstream>
#include <chrono>
#include <iomanip>

int main()
{
  auto now = std::chrono::system_clock::now();
  auto epoch_seconds = std::chrono::system_clock::to_time_t(now); 

  std::stringstream stream;
  stream << std::put_time(gmtime(&epoch_seconds), "%FT%T");
  auto truncated = std::chrono::system_clock::from_time_t(epoch_seconds);
  auto delta_ns = std::chrono::duration_cast<std::chrono::nanoseconds>(now - truncated).count();
  // And append this to the output stream as fractional seconds
  // e.g. 2016-08-30T08:18:51.867479
  stream << "." << std::fixed << std::setw(9) << std::setfill('0') << delta_ns;
 
  std::cout << stream.str() << std::endl;
}

#include <chrono>

#include <fmt/core.h>
#include <fmt/chrono.h>

int main()
{
    using namespace std::literals::chrono_literals;

    using deciseconds = std::chrono::duration<int64_t, std::ratio<1, 10>>;
    using tertia = std::chrono::duration<int64_t, std::ratio<1, 60>>;

    fmt::print("Custom duration: {}\n", std::chrono::seconds{1} + deciseconds{1} + tertia{3});
    fmt::print("Standard durations: {} {} {} {}\n", 1h, 5min, 6s, 10ns );
}

Program returned: 0
Program stdout
Custom duration: 69[1/60]s
Standard durations: 1h 5m 6s 10ns

    struct timestamp_t {
        int64_t epoch_seconds;
        uint32_t nanos;
    };

    class clock_t
    {
    public:
        virtual ~clock_t() = default;
        virtual timestamp_t now() const;
    };

template<class Timespace> struct timestamp_t {
  int64_t epoch_seconds;
  uint32_t nanos;
};

template<class Timespace> class clock_t    {
  public:
    virtual ~clock_t() = default;
    virtual timestamp_t<Timespace> now() const;
};

V>И в Java похоже тоже нету наносекундной точности для 200 миллиардов лет.. По крайней мере я такого не нашел, но может плохо искал . Покажи?

    The maximum supported Instant, '1000000000-12-31T23:59:59.999999999Z'.
    The minimum supported Instant, '-1000000000-01-01T00:00Z'.

L>А мне, к примеру, нужно представление времени с показателем качества часов (тут в соседней теме про IEC61850 спрашивали, там такое есть)

struct time_with_quality_t {
   timestamp_t time_;
   quality_t quality_;
};

#include <iostream>
#include <string>

using namespace std;

template <class Precision>
string getISOCurrentTimestamp()
{
    auto now = chrono::system_clock::now();
    return date::format("%FT%TZ", date::floor<Precision>(now));
}

int main() {

 cout << getISOCurrentTimestamp<chrono::nanoseconds>();   
}

2020-12-29T20:45:46.149347442Z

   namespace co = std::chrono

   const auto                     diff_time         = time1 - time2;
   const decltype(diff_time)      zero{};
   const co::seconds              diff_seconds      = co::duration_cast<co::seconds>( zero < diff_time ? diff_time + co::microseconds(500)
                                                                                                       : diff_time - co::microseconds(500)
                                                                                    );

std::chrono::duration<Rep,Period>::zero()

const auto diff_time = time1 - time2;
if ( diff_time.zero() < diff_time )
{
}

if ( decltype(diff_time)::zero() < diff_time )
{
}

if ( std::chrono::duration<std::chrono::seconds::rep>::zero() < diff_time )
{
}

if ( std::chrono::seconds::zero() < diff_time )
{
}

	TLDR

#include <chrono>

int main()
{
    using namespace std::literals::chrono_literals;

    const auto d = 3s;
    const bool b1 = (d > 0s);
    const bool b2 = (d == 0ns);
}

BFE>

BFE>std::chrono::duration<Rep,Period>::zero()
BFE>

BFE>const auto diff_time = time1 - time2;
BFE>if ( diff_time.zero() < diff_time )
BFE>{
BFE>}
BFE>

BFE>if ( decltype(diff_time)::zero() < diff_time )
BFE>{
BFE>}
BFE>

BFE>if ( std::chrono::duration<std::chrono::seconds::rep>::zero() < diff_time )
BFE>{
BFE>}
BFE>

BFE>if ( std::chrono::seconds::zero() < diff_time )
BFE>{
BFE>}
BFE>

namespace my {

const std::chrono::duration<int> zero_duration{};

}