utils.cc

Go to the documentation of this file.

 // This Source Code Form is licensed MPL-2.0: http://mozilla.org/MPL/2.0
#include "utils.hh"
#include "platform.hh"
#include "strings.hh"
#include "memory.hh"
#include "unicode.hh"
#include "internal.hh"
#include <signal.h>
#include <sys/time.h>
#include <poll.h>
#include <fcntl.h>
#include <cmath>
#include <atomic>
#include <unistd.h>
 
namespace Ase {
 
// == i18n & gettext ==
const char*
ase_gettext (const String &untranslated)
{
  CString translated = untranslated;
  return translated.c_str(); // relies on global CString storage
}
 
// == Date & Time ==
String
now_strftime (const String &format)
{
  std::time_t t = std::time (nullptr);
  char buffer[4096] = { 0, };
  if (std::strftime (buffer, sizeof (buffer), format.c_str(), std::localtime (&t)))
    return buffer;
  return "";
}
 
// == MakeIcon ==
namespace MakeIcon {
 
IconString
KwIcon (const String &keywords)
{
  static const String keyword_charset = string_set_ascii_alnum() + "_-";
  String s = keywords;
  return_unless (!s.empty(), {});
  StringS words = string_split_any (keywords, " ,");
  Aux::erase_all (words, [] (const String &word) {
    if (word.empty()) return true;
    if (!string_is_canonified (word, keyword_charset))
      {
        warning ("%s: invalid icon keyword: '%s'", __func__, word);
        return true;
      }
    return false;
  });
  IconString is;
  is.assign (string_join (", ", words));
  if (!is.empty() && is.find (',') == is.npos)
    is += ",";  // ensure comma in keyword list
  return is;
}
 
IconString
operator""_icon (const char *key, size_t)
{
  return KwIcon (key);
}
 
IconString
UcIcon (const String &unicode)
{
  std::vector<uint32_t> codepoints;
  if (utf8_to_unicode (unicode, codepoints) > 3 ||
      (codepoints.size() >= 1 && !unicode_is_character (codepoints[0])) ||
      (codepoints.size() >= 2 && !unicode_is_character (codepoints[1])) ||
      (codepoints.size() >= 3 && !unicode_is_character (codepoints[2])))
    warning ("%s: invalid icon unicode: '%s'", __func__, unicode);
  IconString is;
  is.assign (unicode);
  return is;
}
 
IconString
operator""_uc (const char *key, size_t)
{
  return UcIcon (key);
}
 
IconString
SvgIcon (const String &svgdata)
{
  return_unless (!svgdata.empty(), {});
  if (!string_startswith (svgdata, "<svg") || !string_startswith (svgdata, "<SVG"))
    warning ("%s: invalid svg icon: %s…", __func__, svgdata.substr (0, 40));
  IconString is;
  is.assign (svgdata);
  return is;
}
 
} // MakeIcon
 
// == EventFd ==
EventFd::EventFd () :
  fds { -1, -1 }
{}
 
int
EventFd::open ()
{
  if (opened())
    return 0;
  ASE_UNUSED long nflags;
#ifdef HAVE_SYS_EVENTFD_H
  do
    fds[0] = eventfd (0 /*initval*/, EFD_CLOEXEC | EFD_NONBLOCK);
  while (fds[0] < 0 && (errno == EAGAIN || errno == EINTR));
#else
  int err;
  do
    err = pipe2 (fds, O_CLOEXEC | O_NONBLOCK);
  while (err < 0 && (errno == EAGAIN || errno == EINTR));
  if (fds[1] >= 0)
    {
      nflags = fcntl (fds[1], F_GETFL, 0);
      assert_return (nflags & O_NONBLOCK, -1);
      nflags = fcntl (fds[1], F_GETFD, 0);
      assert_return (nflags & FD_CLOEXEC, -1);
    }
#endif
  if (fds[0] >= 0)
    {
      nflags = fcntl (fds[0], F_GETFL, 0);
      assert_return (nflags & O_NONBLOCK, -1);
      nflags = fcntl (fds[0], F_GETFD, 0);
      assert_return (nflags & FD_CLOEXEC, -1);
      return 0;
    }
  return -errno;
}
 
int
EventFd::inputfd () // fd for POLLIN
{
  return fds[0];
}
 
bool
EventFd::opened ()
{
  return inputfd() >= 0;
}
 
bool
EventFd::pollin ()
{
  struct pollfd pfd = { inputfd(), POLLIN, 0 };
  int presult;
  do
    presult = poll (&pfd, 1, -1);
  while (presult < 0 && (errno == EAGAIN || errno == EINTR));
  return pfd.revents != 0;
}
 
void
EventFd::wakeup()
{
  int err;
#ifdef HAVE_SYS_EVENTFD_H
  do
    err = eventfd_write (fds[0], 1);
  while (err < 0 && errno == EINTR);
#else
  char w = 'w';
  do
    err = write (fds[1], &w, 1);
  while (err < 0 && errno == EINTR);
#endif
  // EAGAIN occours if too many wakeups are pending
}
 
void
EventFd::flush()
{
  int err;
#ifdef HAVE_SYS_EVENTFD_H
  eventfd_t bytes8;
  do
    err = eventfd_read (fds[0], &bytes8);
  while (err < 0 && errno == EINTR);
#else
  char buffer[512]; // 512 is POSIX pipe atomic read/write size
  do
    err = read (fds[0], buffer, sizeof (buffer));
  while (err == 512 || (err < 0 && errno == EINTR));
#endif
  // EAGAIN occours if no wakeups are pending
}
 
EventFd::~EventFd ()
{
#ifdef HAVE_SYS_EVENTFD_H
  close (fds[0]);
#else
  close (fds[0]);
  close (fds[1]);
#endif
  fds[0] = -1;
  fds[1] = -1;
}
 
// == CustomDataContainer ==
CustomDataContainer::CustomDataEntry&
CustomDataContainer::custom_data_entry (VirtualBase *key)
{
  if (!custom_data_)
    custom_data_ = std::make_unique<CustomDataS> (1);
  assert_return (key != nullptr, *custom_data_->end());
  for (auto &e : *custom_data_)
    if (e.key == key)
      return e;
  custom_data_->push_back ({ .key = key, });
  return custom_data_->back();
}
 
std::any&
CustomDataContainer::custom_data_get (VirtualBase *key) const
{
  if (custom_data_)
    for (auto &e : *custom_data_)
      if (e.key == key)
        return e;
  static std::any dummy;
  return dummy;
}
 
bool
CustomDataContainer::custom_data_del (VirtualBase *key)
{
  if (custom_data_)
    return Aux::erase_first (*custom_data_, [key] (auto &e) { return key == e.key; });
  return 0;
  static_assert (sizeof (CustomDataContainer) == sizeof (void*));
}
 
void
CustomDataContainer::custom_data_destroy()
{
  return_unless (custom_data_);
  while (!custom_data_->empty())
    {
      std::any old;
      std::swap (old, custom_data_->back());
      custom_data_->pop_back();
      // destroy old *after* removal from vector
    }
}
 
CustomDataContainer::~CustomDataContainer()
{
  custom_data_destroy();
}
 
} // Ase
 
#include "testing.hh"
 
namespace { // Anon
 
TEST_INTEGRITY (utils_tests);
static void
utils_tests()
{
  using namespace Ase;
  TASSERT (uint16_swap_le_be (0x1234) == 0x3412);
  TASSERT (uint32_swap_le_be (0xe23456f8) == 0xf85634e2);
  TASSERT (uint64_swap_le_be (0xf2345678a1b2c3d4) == 0xd4c3b2a1785634f2);
  std::vector<float> fv { 1, -2, 0, -0.5, 2, -1 };
  bool b;
  b = Aux::contains (fv, [] (auto v) { return v == 9; }); TASSERT (b == false);
  b = Aux::contains (fv, [] (auto v) { return v == 2; }); TASSERT (b == true);
  size_t j;
  j = Aux::erase_all (fv, [] (auto v) { return fabs (v) == 2; });
  TASSERT (j == 2 && fv == (std::vector<float> { 1, 0, -0.5, -1 }));
  j = Aux::erase_first (fv, [] (auto v) { return fabs (v) == 1; });
  TASSERT (j == 1 && fv == (std::vector<float> { 0, -0.5, -1 }));
}
 
} // Anon