chore: rename to_seconds to to_epoch_seconds

Author: Bilb

include/session/util.hpp

@@ -203,7 +203,7 @@ inline std::string utf8_truncate(std::string val, size_t n) {
 
 // Helper function to transform a timestamp provided in seconds, milliseconds or microseconds to
 // seconds
-inline int64_t to_seconds(int64_t timestamp) {
+inline int64_t to_epoch_seconds(int64_t timestamp) {
     return timestamp > 9'000'000'000'000 ? timestamp / 1'000'000
          : timestamp > 9'000'000'000     ? timestamp / 1'000
                                          : timestamp;

src/config/contacts.cpp

@@ -97,7 +97,7 @@ void contact_info::load(const dict& info_dict) {
     } else {
         notifications = notify_mode::defaulted;
     }
-    mute_until = to_seconds(maybe_int(info_dict, "!").value_or(0));
+    mute_until = to_epoch_seconds(maybe_int(info_dict, "!").value_or(0));
 
     int exp_mode_ = maybe_int(info_dict, "e").value_or(0);
     if (exp_mode_ >= static_cast<int>(expiration_mode::none) &&
@@ -118,7 +118,7 @@ void contact_info::load(const dict& info_dict) {
         }
     }
 
-    created = to_seconds(maybe_int(info_dict, "j").value_or(0));
+    created = to_epoch_seconds(maybe_int(info_dict, "j").value_or(0));
 }
 
 void contact_info::into(contacts_contact& c) const {
@@ -136,12 +136,12 @@ void contact_info::into(contacts_contact& c) const {
     c.blocked = blocked;
     c.priority = priority;
     c.notifications = static_cast<CONVO_NOTIFY_MODE>(notifications);
-    c.mute_until = to_seconds(mute_until);
+    c.mute_until = to_epoch_seconds(mute_until);
     c.exp_mode = static_cast<CONVO_EXPIRATION_MODE>(exp_mode);
     c.exp_seconds = exp_timer.count();
     if (c.exp_seconds <= 0 && c.exp_mode != CONVO_EXPIRATION_NONE)
         c.exp_mode = CONVO_EXPIRATION_NONE;
-    c.created = to_seconds(created);
+    c.created = to_epoch_seconds(created);
 }
 
 contact_info::contact_info(const contacts_contact& c) : session_id{c.session_id, 66} {
@@ -159,12 +159,12 @@ contact_info::contact_info(const contacts_contact& c) : session_id{c.session_id,
     blocked = c.blocked;
     priority = c.priority;
     notifications = static_cast<notify_mode>(c.notifications);
-    mute_until = to_seconds(c.mute_until);
+    mute_until = to_epoch_seconds(c.mute_until);
     exp_mode = static_cast<expiration_mode>(c.exp_mode);
     exp_timer = exp_mode == expiration_mode::none ? 0s : std::chrono::seconds{c.exp_seconds};
     if (exp_timer <= 0s && exp_mode != expiration_mode::none)
         exp_mode = expiration_mode::none;
-    created = to_seconds(c.created);
+    created = to_epoch_seconds(c.created);
 }
 
 std::optional<contact_info> Contacts::get(std::string_view pubkey_hex) const {
@@ -240,7 +240,7 @@ void Contacts::set(const contact_info& contact) {
     if (notify == notify_mode::mentions_only)
         notify = notify_mode::all;
     set_positive_int(info["@"], static_cast<int>(notify));
-    set_positive_int(info["!"], to_seconds(contact.mute_until));
+    set_positive_int(info["!"], to_epoch_seconds(contact.mute_until));
 
     set_pair_if(
             contact.exp_mode != expiration_mode::none && contact.exp_timer > 0s,
@@ -249,7 +249,7 @@ void Contacts::set(const contact_info& contact) {
             info["E"],
             contact.exp_timer.count());
 
-    set_positive_int(info["j"], to_seconds(contact.created));
+    set_positive_int(info["j"], to_epoch_seconds(contact.created));
 }
 
 LIBSESSION_C_API void contacts_set(config_object* conf, const contacts_contact* contact) {
@@ -314,7 +314,7 @@ void Contacts::set_expiry(
 
 void Contacts::set_created(std::string_view session_id, int64_t timestamp) {
     auto c = get_or_construct(session_id);
-    c.created = to_seconds(timestamp);
+    c.created = to_epoch_seconds(timestamp);
     set(c);
 }
 

src/config/groups/info.cpp

@@ -83,32 +83,32 @@ void Info::set_expiry_timer(std::chrono::seconds expiration_timer) {
 }
 
 void Info::set_created(int64_t timestamp) {
-    set_positive_int(data["c"], to_seconds(timestamp));
+    set_positive_int(data["c"], to_epoch_seconds(timestamp));
 }
 
 std::optional<int64_t> Info::get_created() const {
     if (auto* ts = data["c"].integer())
-        return to_seconds(*ts);
+        return to_epoch_seconds(*ts);
     return std::nullopt;
 }
 
 void Info::set_delete_before(int64_t timestamp) {
-    set_positive_int(data["d"], to_seconds(timestamp));
+    set_positive_int(data["d"], to_epoch_seconds(timestamp));
 }
 
 std::optional<int64_t> Info::get_delete_before() const {
     if (auto* ts = data["d"].integer())
-        return to_seconds(*ts);
+        return to_epoch_seconds(*ts);
     return std::nullopt;
 }
 
 void Info::set_delete_attach_before(int64_t timestamp) {
-    set_positive_int(data["D"], to_seconds(timestamp));
+    set_positive_int(data["D"], to_epoch_seconds(timestamp));
 }
 
 std::optional<int64_t> Info::get_delete_attach_before() const {
     if (auto* ts = data["D"].integer())
-        return to_seconds(*ts);
+        return to_epoch_seconds(*ts);
     return std::nullopt;
 }
 

src/config/user_groups.cpp

@@ -36,18 +36,18 @@ namespace session::config {
 template <typename T>
 static void base_into(const base_group_info& self, T& c) {
     c.priority = self.priority;
-    c.joined_at = to_seconds(self.joined_at);
+    c.joined_at = to_epoch_seconds(self.joined_at);
     c.notifications = static_cast<CONVO_NOTIFY_MODE>(self.notifications);
-    c.mute_until = to_seconds(self.mute_until);
+    c.mute_until = to_epoch_seconds(self.mute_until);
     c.invited = self.invited;
 }
 
 template <typename T>
 static void base_from(base_group_info& self, const T& c) {
     self.priority = c.priority;
-    self.joined_at = to_seconds(c.joined_at);
+    self.joined_at = to_epoch_seconds(c.joined_at);
     self.notifications = static_cast<notify_mode>(c.notifications);
-    self.mute_until = to_seconds(c.mute_until);
+    self.mute_until = to_epoch_seconds(c.mute_until);
     self.invited = c.invited;
 }
 
@@ -129,15 +129,15 @@ void legacy_group_info::into(ugroups_legacy_group_info& c) && {
 
 void base_group_info::load(const dict& info_dict) {
     priority = maybe_int(info_dict, "+").value_or(0);
-    joined_at = to_seconds(std::max<int64_t>(0, maybe_int(info_dict, "j").value_or(0)));
+    joined_at = to_epoch_seconds(std::max<int64_t>(0, maybe_int(info_dict, "j").value_or(0)));
 
     int notify = maybe_int(info_dict, "@").value_or(0);
     if (notify >= 0 && notify <= 3)
         notifications = static_cast<notify_mode>(notify);
     else
         notifications = notify_mode::defaulted;
 
-    mute_until = to_seconds(maybe_int(info_dict, "!").value_or(0));
+    mute_until = to_epoch_seconds(maybe_int(info_dict, "!").value_or(0));
 
     invited = maybe_int(info_dict, "i").value_or(0);
 }
@@ -407,9 +407,9 @@ void UserGroups::set(const community_info& c) {
 
 void UserGroups::set_base(const base_group_info& bg, DictFieldProxy& info) const {
     set_nonzero_int(info["+"], bg.priority);
-    set_positive_int(info["j"], to_seconds(bg.joined_at));
+    set_positive_int(info["j"], to_epoch_seconds(bg.joined_at));
     set_positive_int(info["@"], static_cast<int>(bg.notifications));
-    set_positive_int(info["!"], to_seconds(bg.mute_until));
+    set_positive_int(info["!"], to_epoch_seconds(bg.mute_until));
     set_flag(info["i"], bg.invited);
     // We don't set n here because it's subtly different in the three group types
 }