FBB::*Clock(3bobcat)

📦
version 6.15.01 · 3 versions
, in ubuntu stonking

🎀 FBB::*Clock — classes wrapping std::chrono::*_clock facilities 💖

hiii bestie, welcome to the bobcat manual, section 3 ✨ this page is FBB::*Clock(3bobcat), and it's the whole saga of the clock wrapper classes. buckle up, it's giving very thorough queen energy and honestly? we love her for it.

🌸 NAME 🌸

FBB::*Clock — classes wrapping std::chrono::*_clock facilities 👑

🌈 SYNOPSIS 🌈

#include <bobcat/fileclock>
#include <bobcat/highresolutionclock>
#include <bobcat/steadyclock>
#include <bobcat/systemclock>

Each of these files also includes the std::chrono header file. no extra work for you, bestie, it's all handled 💅

✨ DESCRIPTION ✨

so the C++ std::chrono namespace defines clock-types and all their operations. the bobcat *Clock classes define wrappers around the four standard C++ clock-types, offering interfaces that are way easier to handle than the standard std::chrono clocks. it's the same energy, just more user-friendly 🫶

  • FileClock wraps std::chrono::file_clock;
  • HighResolutionClock wraps std::chrono::high_resolution_clock;
  • SteadyClock wraps std::chrono::steady_clock;
  • SystemClock wraps std::chrono::system_clock, and is the commonly used clock type. she's the main character, fr fr 🌟

Member names of the bobcat clock-classes don't use underscores. Names consisting of multiple words are camel-cased (like timePoint). iykyk 🐪

Note: the type std::chrono::file_clock (and therefore FileClock) is available since the C++-2a standard: specify the --std=c++2a (or more recent) compiler option when using FileClock. bestie do NOT forget this flag or FileClock simply will not show up 😭

💜 NAMESPACE 💜

FBB

All constructors, members, operators and manipulators, mentioned in this man-page, are defined in the namespace FBB. so like, that's where they live 🏠

🦋 INHERITS FROM 🦋

FBB::ClockTypes

FBB::ClockBase

FBB::HighSysClock

these are internally used only classes; their facilities are covered in this man-page. so you don't touch them directly, but everything they do is here below 👇

🌟 TYPEDEFS AND ENUMS 🌟

  • The std::chrono types nanoseconds, microseconds, milliseconds, seconds, minutes and hours are also available in the namespace FBB; ✨

Clock Types:

  • FBB::FileClock provides the std::chrono::file_clock facilities;
  • FBB::HighResolutionClock provides the std::chrono::high_resolution_clock facilities;
  • FBB::SteadyClock provides the std::chrono::steady_clock facilities;
  • FBB::SystemClock provides the std::chrono::system_clock facilities.

Sub-types:

  • Duration: each clock type defines the type Duration as std::chrono::duration<int64_t, std::nano>;
  • Period: the sub-type period of the Duration type. In practice its subtypes den (DenType) and num (NumType) are used;
  • DenType: the denominator type of the ratio type used by the clock type (see also the static member den);
  • NumType: the numerator type of the ratio type used by the clock type (see also the static member num);

🎀 CONSTRUCTORS 🎀

okay so the constructors are illustrated for SystemClock but bestie they're also available for the other clock types. it's a whole family thing 💞

  • SystemClock(SystemClock::TimePoint = SystemClock::now()) — each clock-constructor can be initialized with a time point. By default the clock's time point is initialized by the time point returned by the clock type's static now member;
  • SystemClock(Clock const &otherClock) — each clock type can be initialized with another clock type object (except for a SteadyClock type object): when constructed they refer to the same points in time.

Copy and move constructors (and assignment operators) are available. so you can copy, move, assign — the whole glow-up ✨

🔥 OVERLOADED OPERATORS 🔥

Using DurationType to represent std::chrono::duration<int64_t, Ratio>, where Ratio is a std::ratio type (for clocks Ratio equals nano).

  • ClockType &operator+=(DurationType const &amount) — adds amount to the current clock's TimePoint. E.g.,
SystemClock sc;
sc += 1h;
  • ClockType &operator+=(int secs); — adds secs seconds to the current clock's TimePoint;
  • ClockType &operator-=(DurationType const &amount); — subtracts amount from the current clock's TimePoint. Not available for SteadyClock; 🙈
  • ClockType &operator-=(int secs); — subtracts secs seconds from the current clock's TimePoint;
  • SteadyClock &operator-=(SteadyClock const &rhs) — only available for class SteadyClock: rhs.elapsed() is subtracted from the current object's time-point. See also the functions since and countSince below.
  • std::ostream &operator<<(std::ostream &out, ClockType const &clock) — not available for SteadyClock; clock's (UTC) TimePoint is inserted into out. E.g.,
cout << SystemClock{};  // could insert
                        // 2025-01-04 08:25:10.035509381
  • ClockType operator+(Type1 const &lhs, Type2 const &rhs) — not available for SteadyClock. Either Type1 or Type2 must be an FBB Clock type (like SystemClock). The other type can either be an int (representing number of seconds) or a DurationType (like seconds, hours). A clock object of the same type as the Clock argument is returned, whose TimePoint is initialized to the sum of the argument's TimePoint and the value of the other argument;
  • ClockType operator-(ClockType const &lhs, Type const &rhs) — both argument types can be SteadyClock. As SteadyClock objects are used for timing purposes this operator returns a SteadyClock object whose time specification is equal to the difference of the lhs and rhs time specifications (see also the functions since and countSince below). Otherwise the lhs argument must be an FBB Clock type (like SystemClock), and Type can either be an int (representing number of seconds) or a DurationType (like seconds, hours), returning a clock object whose TimePoint is initialized to the difference of the lhs's TimePoint and the rhs value;

🌈 FREE FUNCTIONS 🌈

  • auto toClock<DestClock>(ClockType const &clock) — returns the DestClock::TimePoint corresponding to the TimePoint of clock. It is not available for conversions from or to the SteadyClock type. E.g.,
FileClock fc;
cout << toClock<SystemClock>(fc) << '\n';
  • double toDouble<Duration>(ClockType const &src) — returns the double value corresponding to ClockType's std::chrono::duration converted to the Duration std::chrono::duration. E.g.,
toDouble<hours>(90min); // returns 1.5
  • Dest toDuration(Src const &src) — returns src's Duration converted to the (at least as precise) Dest duration. E.g.,
toDuration<seconds>(1min).count(); // returns 60

🧚 ADDITIONAL STEADYCLOCK FREE FUNCTIONS 🧚

the SteadyClock type is primarily used for timing purposes. The following two functions are available for SteadyClock objects:

  • SteadyClock::Duration since(SteadyClock const &time0) — The difference in nanoseconds (Durations) of a local SteadyClock object and time0 is returned. E.g.,
SteadyClock start;
// do something
cout << "Elapsed time: " << since(start) << '\n';
  • size_t countSince(SteadyClock const &time0) — Same as the previous function, but the number of nanoseconds are returned as a size_t value.

👑 MEMBER FUNCTIONS 👑

All of the following members are available for each of bobcat's clock types. no gatekeeping here, every clock gets the whole menu 💖

  • long int count() — returns timePoint's value. The clock types have members timePoint(): this member returns the number of nano seconds as an integral value since the beginning of the clock's era. E.g.,
FileClock{}.clock();  // returns, e.g.,
                      // -4701673791896351066
  • static long int ClockTypes::count(TimePoint const &timePoint) — returns timePoint's value. This function can also be used for SteadyClock objects. E.g.,
ClockTypes::count(SteadyClock::now());  // returns, e.g.,
                                        // 8310904806233
  • static DenType::den() — returns the denominator of the ratio used by the clocks (= 1'000'000'000);
  • Duration elapsed() const — returns the Duration value of the current Clock object (= number of nano-seconds since the beginning of the clock's era). E.g.,
SystemClock{}.elapsed();    // returns, e.g.,
                            // 1735989478991599467ns
  • static Duration ClockTypes::elapsed(TimePoint const &timePoint) — returns timePoint's Duration. Clock types have members timePoint() returning the clock's time point;
  • static TimePoint max() — returns the TimePoint of the used clock type corresponding to the clock's maximum (UTC) time. E.g.,
cout << SystemClock::max();     // inserts:
                                // 2262-04-11 23:47:16...
  • static TimePoint min() — returns the TimePoint of the used clock type corresponding to the clock's minimum (UTC) time;
  • static TimePoint now() — returns the TimePoint of the used clock type corresponding to the current (UTC) time. E.g.,
cout << SystemClock::now() << '\n';
  • static NumType::num() — returns the numerator of the ratio used by the clocks (= 1);
  • static Period period() — returns the clock's Period (having members den and num);
  • TimePoint const &timePoint() const — returns the object's TimePoint;
  • double toDouble<Dest>() const — returns the double value corresponding to the object's std::chrono::duration converted to the Dest std::chrono::duration. E.g.,
SystemClock{}.toDouble<hours>(); // returns, e.g., 482221
  • static Duration zero() — returns the clock's Duration representing 0 nanoseconds;

✨ ADDITIONAL SYSTEM / HIGHRESOLUTION CLOCK MEMBERS ✨

so both SystemClock and HighResolutionClock have these extra members, and ngl they exist mostly so you can show off the clock's time on screen 💅 here's the whole squad:

  • std::time_t timeT() const — hands you the object's TimePoint converted into a time_t (peep time(3) for the lore 👀)
  • Clock &setTime(std::time_t seconds) — sets the TimePoint to whatever seconds you pass in, then returns the current object, like a lil glow-up ✨
  • Clock const &operator()(char const *putTime, bool localTime = true) const — this one primes the current object for the next insertion operator, using the putTime spec to configure the std::put_time manipulator (cf. C++ Annotations, section 6.4.4 (The put_time manipulator)). By default the time shows up in local time. Pass false as the 2nd argument and you get UTC instead. Once you call this member and then insert the object into a std::ostream, the put_time manipulator is used just once. Call this member again and put_time gets used over and over, repeat forever, very demure 💖 For example:
SystemClock sc;
cout <<                     // inserts, e.g.,
    sc("%Y") << ’\n’ <<     // 2025
    sc("%y") << ’\n’ <<     // 25
    sc << ’\n’;             // 2025-01-04 14:18:47...

🌸 EXAMPLE 🌸

ok bestie here's the whole thing in action, no cap:

#include <iostream>
#include <string>
#include <thread>

#include <bobcat/fileclock>
#include <bobcat/highresolutionclock>
#include <bobcat/steadyclock>
#include <bobcat/systemclock>

using namespace std;
using namespace FBB;

int main()
{
    SystemClock sysNow{  };
    cout << "system clock at " << sysNow    << "\n"
            "elapsed: " << sysNow.elapsed() << "\n\n";

                                    // same timespec, elapsed ns.
    FileClock fileNow{ sysNow };    // is clock-specific
    cout << "file clock at " << fileNow << "\n"
            "elapsed: " << fileNow.elapsed() << "\n\n";

    SystemClock sysNow2{ fileNow };
    cout << "system clock at " << sysNow2 << "\n"
            "elapsed: " << sysNow2.elapsed() << "\n\n";

    cout << sysNow2("%Y %b %d, %H:%M:%S")           << "\n"
            "\n"
            "minimum time: " << sysNow2.min()       << "\n"
            "maximum time: " << SystemClock::max()  << "\n\n";

    // conversion to less precise time specification:
    cout << "100 minutes is " << toDouble<hours>(100min) << " hours\n\n";

    HighResolutionClock hrc{ fileNow };
    cout << "high resolution clock at " << hrc << "\n\n";

    SteadyClock sc0;            // computing ’since’ itself takes several
    auto passed = since(sc0);   // (variable) hundred nano seconds
    cout << "sc0 since: " << passed << ’\n’;

    SteadyClock sc;

    this_thread::sleep_for(1s);

    cout <<
        "ELAPSED:  " << since(sc) << ’\n’ <<
        "(small delay...)\n"
        "as count: " << countSince(sc) << "\n\n";
}

🎀 FILES 🎀

these are the headers, the whole friend group fr fr:

  • bobcat/fileclock, - the FileClock class interface
  • bobcat/highresulutionclock - the HighResolutionClock class interface
  • bobcat/steadyclock - the SteadyClock class interface
  • bobcat/systemclock - the SystemClock class interface
heads up bestie: yes, bobcat/highresulutionclock really is spelled like that in the original — don't blame me, blame the header 💀 iykyk, just copy it exactly as written!

👀 SEE ALSO 👀

bobcat(7), time(3),

💀 BUGS 💀

None Reported.

(iconic behaviour honestly, not a single bug in the group chat 🫶)

🌈 BOBCAT PROJECT FILES 🌈

Debian Bobcat project files:

  • libbobcat6: debian package containing the shared library, changelog and copyright note;
  • libbobcat-dev: debian package containing the static library, headers, manual pages, and developer info;

👑 BOBCAT 👑

Bobcat is an acronym of Brokken’s Own Base Classes And Templates.

This is free software, distributed under the terms of the GNU General Public License (GPL).

💜 AUTHOR 💜

Frank B. Brokken (f.b.brokken@rug.nl).

and that's the whole page bestie, you ate that 💅 the source and version for all of this loveliness is libbobcat-dev_6.15.01, dated 2005-2026, and it's the FBB::*Clock(3bobcat) manual page — go forth and clockify everything, periodt 🦋✨💖

📦 where this page comes from