statusbar_log Namespace Reference

Functions
void	FlushOutput ()
void	SaveCursorPosition ()
void	RestoreCursorPosition ()
void	ClearToEndOfLine ()
void	ClearFromStartOfLine ()
void	ClearLine ()
void	ClearCurrentLine ()
int	Log (const LogLevel log_level, const std::string &filename, const char *fmt,...)
int	CreateStatusbarHandle (StatusbarHandle &statusbar_handle, const std::vector< unsigned int > _positions, const std::vector< unsigned int > _bar_sizes, const std::vector< std::string > _prefixes, const std::vector< std::string > _postfixes)
int	DestroyStatusbarHandle (StatusbarHandle &statusbar_handle)
int	UpdateStatusbar (StatusbarHandle &statusbar_handle, const std::size_t idx, const double percent)

Function Documentation

ClearCurrentLine()

void statusbar_log::ClearCurrentLine

(

)

Definition at line 409 of file statusbarlog.cpp.

                        {
  std::cout << "\r"        // Return to line start
            << "\033[2K";  // Clear entire line
  _ConditionalFlush();
}

Here is the caller graph for this function:

ClearFromStartOfLine()

void statusbar_log::ClearFromStartOfLine

(

)

Definition at line 399 of file statusbarlog.cpp.

                            {
  std::cout << "\033[1K";  // ANSI escape code to clear to end of line
  _ConditionalFlush();
}

ClearLine()

void statusbar_log::ClearLine

(

)

Definition at line 404 of file statusbarlog.cpp.

                 {
  std::cout << "\033[2K";
  _ConditionalFlush();
}

ClearToEndOfLine()

void statusbar_log::ClearToEndOfLine

(

)

Definition at line 394 of file statusbarlog.cpp.

                        {
  std::cout << "\033[0K";  // ANSI escape code to clear to end of line
  _ConditionalFlush();
}

CreateStatusbarHandle()

int statusbar_log::CreateStatusbarHandle	(	StatusbarHandle &	statusbar_handle,
		const std::vector< unsigned int >	_positions,
		const std::vector< unsigned int >	_bar_sizes,
		const std::vector< std::string >	_prefixes,
		const std::vector< std::string >	_postfixes
	)

Definition at line 488 of file statusbarlog.cpp.

                                                                 {
  statusbar_handle.valid = false;
  statusbar_handle.id = 0;
  if (_positions.size() != _bar_sizes.size() ||
      _bar_sizes.size() != _prefixes.size() ||
      _prefixes.size() != _postfixes.size()) {
    LogErr(kFilename,
            "Failed to create statusbar_handle The vecotors '_positions', "
            "'_bar_sizes', '_prefixes' and "
            "'_postfixes' must have the same size! Got: '_positions': %d, "
            "'_bar_sizes': %d, '_prefixes': %d, '_postfixes': %d.",
            _positions.size(), _bar_sizes.size(), _prefixes.size(),
            _postfixes.size());
    return -1;
  }
 
  if (_statusbar_registry.size() - _statusbar_free_handles.size() >=
      kMaxHandles) {
    LogErr(
        kFilename,
        "Failed to create statusbar handle. Maximum status bars (%zu) reached",
        statusbar_log::kMaxHandles);
    return -2;
  }
 
  std::unique_lock<std::mutex> console_lock(_console_mutex, std::defer_lock);
  std::unique_lock<std::mutex> registry_lock(_registry_mutex, std::defer_lock);
  std::unique_lock<std::mutex> ID_count_lock(_id_count_mutex, std::defer_lock);
  std::lock(console_lock, registry_lock, ID_count_lock);
 
  _handle_id_count++;
  if (_handle_id_count == 0) {
    console_lock.unlock();
    registry_lock.unlock();
    LogWrn(kFilename,
            "Max number of possible statusbar handle.ids reached, looping back "
            "to 1");
    std::lock(console_lock, registry_lock);
    _handle_id_count++;
  }
 
  const std::size_t num_bars = _positions.size();
  const std::vector<double> percentages(num_bars, 0.0);
  const std::vector<std::size_t> spin_idxs(num_bars, 0);
 
  std::vector<std::string> sanitized_prefixes;
  sanitized_prefixes.reserve(_prefixes.size());
  std::vector<std::string> sanitized_postfixes;
  sanitized_prefixes.reserve(_postfixes.size());
  std::vector<unsigned int> sanitized_bar_sizes;
  sanitized_bar_sizes.reserve(_bar_sizes.size());
  for (std::size_t i = 0; i < _prefixes.size(); ++i) {
    std::string _prefix = _prefixes[i];
    if (_prefix.length() > kMaxPrefixLength) {
      _prefix.resize(kMaxPrefixLength - 3);
      _prefix += "...";
    }
    sanitized_prefixes.push_back(_SanitizeString(_prefix));
 
    std::string _postfix = _postfixes[i];
    if (_postfix.length() > kMaxPostfixLength) {
      _postfix.resize(kMaxPostfixLength - 3);
      _postfix += "...";
    }
    sanitized_postfixes.push_back(_SanitizeString(_postfix));
 
    sanitized_bar_sizes.push_back(
        std::min<unsigned int>(_bar_sizes[i], kMaxBarWidth));
  }
 
  if (!_statusbar_free_handles.empty()) {
    StatusbarHandle free_handle = _statusbar_free_handles.back();
    _statusbar_free_handles.pop_back();
    statusbar_handle.idx = free_handle.idx;
    _statusbar_registry[statusbar_handle.idx] = {
        percentages,         _positions,
        sanitized_bar_sizes, sanitized_prefixes,
        sanitized_postfixes, spin_idxs,
        _handle_id_count,    false};
  } else {
    statusbar_handle.idx = _statusbar_registry.size();
    _statusbar_registry.emplace_back(Statusbar{
        percentages, _positions, sanitized_bar_sizes, sanitized_prefixes,
        sanitized_postfixes, spin_idxs, _handle_id_count, false});
  }
  statusbar_handle.id = _handle_id_count;
  statusbar_handle.valid = true;
  for (std::size_t idx = 0; idx < num_bars; idx++) {
    _DrawStatusbarComponent(
        0.0, _statusbar_registry[statusbar_handle.idx].bar_sizes[idx],
        _statusbar_registry[statusbar_handle.idx].prefixes[idx],
        _statusbar_registry[statusbar_handle.idx].postfixes[idx],
        _statusbar_registry[statusbar_handle.idx].spin_idxs[idx],
        _statusbar_registry[statusbar_handle.idx].positions[idx]);
  }
  return kStatusbarLogSuccess;
}

DestroyStatusbarHandle()

int statusbar_log::DestroyStatusbarHandle

(

StatusbarHandle &

statusbar_handle

)

Definition at line 590 of file statusbarlog.cpp.

                                                              {
  std::unique_lock<std::mutex> console_lock(_console_mutex, std::defer_lock);
  std::unique_lock<std::mutex> registry_lock(_registry_mutex, std::defer_lock);
  std::lock(console_lock, registry_lock);
 
  const int err = _IsValidHandle(statusbar_handle);
  if (err != kStatusbarLogSuccess) {
    console_lock.unlock();
    registry_lock.unlock();
    _IsValidHandleVerbose(statusbar_handle);
    LogErr(kFilename, "Failed to destory statusbar_handle!");
    return err;
  }
  Statusbar& target = _statusbar_registry[statusbar_handle.idx];
 
  for (std::size_t i = 0; i < target.positions.size(); i++) {
    _MoveCursorUp(target.positions[i]);
    ClearCurrentLine();
    _MoveCursorUp(-target.positions[i]);
  }
  std::cout.flush();
 
  target.percentages.clear();
  target.positions.clear();
  target.bar_sizes.clear();
 
  for (std::string& str : target.prefixes) {
    std::fill(str.begin(), str.end(), '\0');
  }
  for (std::string& str : target.postfixes) {
    std::fill(str.begin(), str.end(), '\0');
  }
  target.prefixes.clear();
  target.postfixes.clear();
 
  target.id = 0;
  target.spin_idxs.clear();
 
  _statusbar_free_handles.push_back(statusbar_handle);
 
  statusbar_handle.valid = false;
  statusbar_handle.id = 0;
 
  return kStatusbarLogSuccess;
}

Here is the call graph for this function:

FlushOutput()

void statusbar_log::FlushOutput

(

)

Definition at line 382 of file statusbarlog.cpp.

{ std::cout << std::flush; }

Log()

int statusbar_log::Log	(	const LogLevel	log_level,
		const std::string &	filename,
		const char *	fmt,
			...
	)

Definition at line 415 of file statusbarlog.cpp.

             {
  if (log_level > kLogLevel) return kStatusbarLogSuccess;
  std::unique_lock<std::mutex> console_lock(_console_mutex, std::defer_lock);
  std::unique_lock<std::mutex> registry_lock(_registry_mutex, std::defer_lock);
  std::lock(console_lock, registry_lock);
  // std::lock_guard<std::mutex> ID_count_lock(_id_count_mutex);
 
  const bool statusbars_active = !_statusbar_registry.empty();
 
  const char* prefix = "";
  // clang-format off
  switch(log_level){
    case kLogLevelErr: prefix = "ERROR"; break;
    case kLogLevelWrn: prefix = "WARNING"; break;
    case kLogLevelInf: prefix = "INFO"; break;
    case kLogLevelDbg: prefix = "DEBUG"; break;
    default: break;
  }
  // clang-format on
 
  int move = 0;
  if (statusbars_active) {
    for (std::size_t i = 0; i < _statusbar_registry.size(); ++i) {
      for (std::size_t j = 0; j < _statusbar_registry[i].positions.size();
           ++j) {
        int current_pos = _statusbar_registry[i].positions[j];
        if (current_pos > move) {
          move = current_pos;
        }
      }
    }
  }
 
  va_list args;
  va_list args_copy;
  _MoveCursorUp(move);
  if (statusbars_active) printf("\r\033[2K\r");
  va_start(args, fmt);
  va_copy(args_copy, args);
  unsigned int size = std::vsnprintf(nullptr, 0, fmt, args_copy);
  size = std::min(size, kMaxLogLength);
  std::vector<char> buffer(size + 1);
  std::vsnprintf(buffer.data(), buffer.size(), fmt, args);
  std::string message = _SanitizeStringWithNewline(buffer.data());
  va_end(args);
 
  std::string sanitized_filename = _SanitizeStringWithNewline(filename);
  if (sanitized_filename.length() > kMaxFilenameLength) {
    sanitized_filename.resize(kMaxFilenameLength - 3);
    sanitized_filename += "...";
  }
 
  printf("%s [%s]: %s\n", prefix, sanitized_filename.c_str(), message.c_str());
  _ConditionalFlush();
  _MoveCursorUp(-move);
 
  if (statusbars_active) {
    for (std::size_t i = 0; i < _statusbar_registry.size(); ++i) {
      for (std::size_t j = 0; j < _statusbar_registry[i].positions.size();
           ++j) {
        _DrawStatusbarComponent(_statusbar_registry[i].percentages[j],
                                _statusbar_registry[i].bar_sizes[j],
                                _statusbar_registry[i].prefixes[j],
                                _statusbar_registry[i].postfixes[j],
                                _statusbar_registry[i].spin_idxs[j],
                                _statusbar_registry[i].positions[j]);
      }
    }
  }
  return kStatusbarLogSuccess;
}

RestoreCursorPosition()

void statusbar_log::RestoreCursorPosition

(

)

Definition at line 389 of file statusbarlog.cpp.

                             {
  std::cout << "\033[u";  // ANSI escape code to restore cursor position
  _ConditionalFlush();
}

SaveCursorPosition()

void statusbar_log::SaveCursorPosition

(

)

Definition at line 384 of file statusbarlog.cpp.

                          {
  std::cout << "\033[s";  // ANSI escape code to save cursor position
  _ConditionalFlush();
}

UpdateStatusbar()

int statusbar_log::UpdateStatusbar	(	StatusbarHandle &	statusbar_handle,
		const std::size_t	idx,
		const double	percent
	)

Definition at line 636 of file statusbarlog.cpp.

                                          {
  std::unique_lock<std::mutex> console_lock(_console_mutex, std::defer_lock);
  std::unique_lock<std::mutex> registry_lock(_registry_mutex, std::defer_lock);
  std::lock(console_lock, registry_lock);
 
  // std::lock_guard<std::mutex> ID_count_lock(_id_count_mutex);
 
  const int err = _IsValidHandle(statusbar_handle);
  if (err != kStatusbarLogSuccess) {
    console_lock.unlock();
    registry_lock.unlock();
    _IsValidHandleVerbose(statusbar_handle);
    LogErr(kFilename, "Failed to update statusbar: Invalid handle.");
    return err;
  }
 
  if (percent > 100.0 || percent < 0.0) {
    console_lock.unlock();
    registry_lock.unlock();
    LogErr(kFilename, "Failed to update statusbar: Invalid percentage.");
    return -5;
  }
 
  Statusbar& statusbar = _statusbar_registry[statusbar_handle.idx];
 
  if (idx >= statusbar.percentages.size()) {
    console_lock.unlock();
    registry_lock.unlock();
    LogErr(kFilename, "Failed to update statusbar: Invalid bar index.");
    return -6;
  }
 
  statusbar.percentages[idx] = percent;
  statusbar.spin_idxs[idx] = statusbar.spin_idxs[idx] + 1;
  int bar_error_code = _DrawStatusbarComponent(
      percent, statusbar.bar_sizes[idx], statusbar.prefixes[idx],
      statusbar.postfixes[idx], statusbar.spin_idxs[idx],
      statusbar.positions[idx]);
 
  if (bar_error_code != kStatusbarLogSuccess && !statusbar.error_reported) {
    statusbar.error_reported = true;
    const char* why;
    switch (bar_error_code) {
      case -1:
        why = "Terminal width detection failed (Windows)";
        break;
      case -2:
        why = "Terminal width detection failed (Linux)";
        break;
      case -3:
        why = "Truncating was needed";
        break;
      case -4:
        why =
            "Terminal width detection failed (Windows) and truncation was "
            "needed";
        break;
      case -5:
        why =
            "Terminal width detection failed (Linux) and truncation was "
            "needed";
        break;
    }
    LogErr(kFilename, "%s on statusbar with ID %u at bar idx %zu!", why,
            statusbar.id, idx);
  }
 
  return kStatusbarLogSuccess;
}