Cppcheck report - [project name]: kooling/datamodel/timestamp.h

#pragma once

#include <chrono>
#include <iomanip>
#include <iostream>
#include <sstream>
#include <time.h>

namespace kooling::datamodel {

struct timestamp : std::chrono::system_clock::time_point
{
    using base = std::chrono::system_clock::time_point;
    using base::base;

    timestamp(base&& b) : base{ std::forward<base>(b) } {}
<--- Struct 'timestamp' has a constructor with 1 argument that is not explicit. [+]
Struct 'timestamp' has a constructor with 1 argument that is not explicit. Such, so called "Converting constructors", should in general be explicit for type safety reasons as that prevents unintended implicit conversions.

    static timestamp now()
    {
        return base::clock::now();
    }

    long long milliseconds() const
    {
        return std::chrono::time_point_cast<std::chrono::milliseconds>(*this).time_since_epoch().count();
    }

    time_t to_time_t() const
    {
        return timestamp::clock::to_time_t(*this);
    }

    operator std::string() const
    {
        const auto t{ to_time_t() };
        struct std::tm tm{};
        gmtime_r(&t, &tm);
        std::stringstream ss;
        ss << std::put_time(&tm, "%Y-%m-%dT%H:%M:%SZ");
        return ss.str();
    }
};

struct duration : timestamp::duration
{
    using base = timestamp::duration;
    using base::base;

    duration(base&& b) : base{ std::forward<base>(b) } {}
<--- Struct 'duration' has a constructor with 1 argument that is not explicit. [+]
Struct 'duration' has a constructor with 1 argument that is not explicit. Such, so called "Converting constructors", should in general be explicit for type safety reasons as that prevents unintended implicit conversions.

    static duration from_h(double h)
    {
        return std::chrono::duration_cast<base>(std::chrono::minutes{ static_cast<int>(h * 60) });
    }

    operator std::string() const
    {
        std::stringstream os;
        auto s{ seconds() };
        const auto h{ s / 3600 };
        s -= h * 3600;
        const auto m{ s / 60 };
        s -= m * 60;
        os << std::setfill('0') << std::setw(2) << h << ':'
                                << std::setw(2) << m << ':'
                                << std::setw(2) << s;
        return os.str();
    }

    long long seconds() const
    {
        return std::chrono::duration_cast<std::chrono::seconds>(*this).count();
    }
};

inline std::ostream& operator<<(std::ostream& os, const timestamp& timestamp)
{
    return os << std::string{ timestamp };
}

inline std::ostream& operator<<(std::ostream& os, const duration& duration)
{
    return os << std::string{ duration };
}

} // namespace kooling::datamodel