Slic3r::Utils Namespace Reference

Namespaces
namespace	__get_put_time_emulation
namespace	anonymous_namespace{Time.cpp}

Classes
struct	HexFile
class	Serial
struct	SerialPortInfo
class	TCPConsole

Enumerations
enum class	TimeZone { local , utc }
enum class	TimeFormat { gcode , iso8601Z }

Functions
static const char *	get_fmtstr (TimeFormat fmt)
time_t	get_current_time_utc ()
static std::string	tm2str (const std::tm *tms, const char *fmt)
std::string	time2str (const time_t &t, TimeZone zone, TimeFormat fmt)
static time_t	str2time (std::istream &stream, TimeZone zone, const char *fmt)
time_t	str2time (const std::string &str, TimeZone zone, TimeFormat fmt)
std::string	time2str (TimeZone zone, TimeFormat fmt)
std::string	utc_timestamp (time_t t)
std::string	utc_timestamp ()
std::string	iso_utc_timestamp (time_t t)
std::string	iso_utc_timestamp ()
time_t	parse_iso_utc_timestamp (const std::string &str)
static HexFile::DeviceKind	parse_device_kind (const std::string &str)
static size_t	hex_num_sections (fs::ifstream &file)
static bool	looks_like_printer (const std::string &friendly_name)
std::vector< SerialPortInfo >	scan_serial_ports_extended ()
std::vector< std::string >	scan_serial_ports ()
bool	operator== (const SerialPortInfo &sp1, const SerialPortInfo &sp2)

Variables
static const constexpr char *const	SLICER_UTC_TIME_FMT = "%Y-%m-%d at %T"
static const constexpr char *const	ISO8601Z_TIME_FMT = "%Y%m%dT%H%M%SZ"

Enumeration Type Documentation

TimeFormat

enum class Slic3r::Utils::TimeFormat

strong

Enumerator
gcode
iso8601Z

{ gcode, iso8601Z };

TimeZone

enum class Slic3r::Utils::TimeZone

strong

Enumerator
local
utc

{ local, utc };

Function Documentation

get_current_time_utc()

time_t Slic3r::Utils::get_current_time_utc

(

)

{
    using clk = std::chrono::system_clock;
    return clk::to_time_t(clk::now());
}

Referenced by Slic3r::_3MF_Exporter::_add_model_file_to_archive(), iso_utc_timestamp(), Slic3r::GUI::Config::SnapshotDB::take_snapshot(), time2str(), and utc_timestamp().

Here is the caller graph for this function:

get_fmtstr()

static const char * Slic3r::Utils::get_fmtstr ( TimeFormat  fmt )

static

{
    switch (fmt) {
    case TimeFormat::gcode: return SLICER_UTC_TIME_FMT;
    case TimeFormat::iso8601Z: return ISO8601Z_TIME_FMT;
    }
 
    return "";
}

References gcode, iso8601Z, ISO8601Z_TIME_FMT, and SLICER_UTC_TIME_FMT.

Referenced by str2time(), and time2str().

Here is the caller graph for this function:

hex_num_sections()

static size_t Slic3r::Utils::hex_num_sections ( fs::ifstream &  file )

static

{
  file.seekg(0);
  if (! file.good()) {
    return 0;
  }
 
  static const char *hex_terminator = ":00000001FF\r";
  size_t res = 0;
  std::string line;
  while (getline(file, line, '\n').good()) {
    // Account for LF vs CRLF
    if (!line.empty() && line.back() != '\r') {
      line.push_back('\r');
    }
 
    if (line == hex_terminator) {
      res++;
    }
  }
 
  return res;
}

iso_utc_timestamp() [1/2]

std::string Slic3r::Utils::iso_utc_timestamp ( )

inline

{
    return iso_utc_timestamp(get_current_time_utc());
}

References get_current_time_utc(), and iso_utc_timestamp().

Referenced by iso_utc_timestamp(), Slic3r::GUI::Config::Snapshot::save_ini(), and Slic3r::GUI::Config::SnapshotDB::take_snapshot().

Here is the call graph for this function:

Here is the caller graph for this function:

iso_utc_timestamp() [2/2]

std::string Slic3r::Utils::iso_utc_timestamp ( time_t  t )

inline

{
    return time2str(t, TimeZone::utc, TimeFormat::iso8601Z);
}

References iso8601Z, time2str(), and utc.

Here is the call graph for this function:

looks_like_printer()

static bool Slic3r::Utils::looks_like_printer ( const std::string &  friendly_name )

static

{
  return friendly_name.find("Original Prusa") != std::string::npos;
}

Referenced by scan_serial_ports_extended().

Here is the caller graph for this function:

operator==()

bool Slic3r::Utils::operator== ( const SerialPortInfo &  sp1, const SerialPortInfo &  sp2  )

inline

{
  return
    sp1.port       == sp2.port       &&
    sp1.id_vendor  == sp2.id_vendor  &&
    sp1.id_product == sp2.id_product &&
    sp1.is_printer == sp2.is_printer;
}

References Slic3r::Utils::SerialPortInfo::id_product, Slic3r::Utils::SerialPortInfo::id_vendor, Slic3r::Utils::SerialPortInfo::is_printer, and Slic3r::Utils::SerialPortInfo::port.

parse_device_kind()

static HexFile::DeviceKind Slic3r::Utils::parse_device_kind ( const std::string &  str )

static

{
       if (str == "mk2") { return HexFile::DEV_MK2; }
  else if (str == "mk3") { return HexFile::DEV_MK3; }
  else if (str == "mm-control") { return HexFile::DEV_MM_CONTROL; }
  else if (str == "cw1") { return HexFile::DEV_CW1; }
  else if (str == "cw1s") { return HexFile::DEV_CW1S; }
  else { return HexFile::DEV_GENERIC; }
}

References Slic3r::Utils::HexFile::DEV_CW1, Slic3r::Utils::HexFile::DEV_CW1S, Slic3r::Utils::HexFile::DEV_GENERIC, Slic3r::Utils::HexFile::DEV_MK2, Slic3r::Utils::HexFile::DEV_MK3, and Slic3r::Utils::HexFile::DEV_MM_CONTROL.

parse_iso_utc_timestamp()

time_t Slic3r::Utils::parse_iso_utc_timestamp ( const std::string &  str )

inline

{
    return str2time(str, TimeZone::utc, TimeFormat::iso8601Z);
}

References iso8601Z, str2time(), and utc.

Referenced by Slic3r::GUI::Config::Snapshot::load_ini().

Here is the call graph for this function:

Here is the caller graph for this function:

scan_serial_ports()

std::vector< std::string > Slic3r::Utils::scan_serial_ports

(

)

{
  std::vector<SerialPortInfo> ports = scan_serial_ports_extended();
  std::vector<std::string> output;
  output.reserve(ports.size());
  for (const SerialPortInfo &spi : ports)
    output.emplace_back(std::move(spi.port));
  return output;
}

References Slic3r::Utils::SerialPortInfo::port, and scan_serial_ports_extended().

Here is the call graph for this function:

scan_serial_ports_extended()

std::vector< SerialPortInfo > Slic3r::Utils::scan_serial_ports_extended

(

)

{
  std::vector<SerialPortInfo> output;
 
#ifdef _WIN32
  SP_DEVINFO_DATA devInfoData = { 0 };
  devInfoData.cbSize = sizeof(devInfoData);
  // Get the tree containing the info for the ports.
  HDEVINFO hDeviceInfo = SetupDiGetClassDevs(&GUID_DEVCLASS_PORTS, 0, nullptr, DIGCF_PRESENT);
  if (hDeviceInfo != INVALID_HANDLE_VALUE) {
    // Iterate over all the devices in the tree.
    for (int nDevice = 0; SetupDiEnumDeviceInfo(hDeviceInfo, nDevice, &devInfoData); ++ nDevice) {
      SerialPortInfo port_info;
      // Get the registry key which stores the ports settings.
      HKEY hDeviceKey = SetupDiOpenDevRegKey(hDeviceInfo, &devInfoData, DICS_FLAG_GLOBAL, 0, DIREG_DEV, KEY_QUERY_VALUE);
      if (hDeviceKey) {
        // Read in the name of the port.
        wchar_t pszPortName[4096];
        DWORD dwSize = sizeof(pszPortName);
        DWORD dwType = 0;
        if (RegQueryValueEx(hDeviceKey, L"PortName", NULL, &dwType, (LPBYTE)pszPortName, &dwSize) == ERROR_SUCCESS)
          port_info.port = boost::nowide::narrow(pszPortName);
        RegCloseKey(hDeviceKey);
        if (port_info.port.empty())
          continue;
      }
 
      // Find the size required to hold the device info.
      DWORD regDataType;
      DWORD reqSize = 0;
      SetupDiGetDeviceRegistryProperty(hDeviceInfo, &devInfoData, SPDRP_HARDWAREID, nullptr, nullptr, 0, &reqSize);
      std::vector<wchar_t> hardware_id(reqSize > 1 ? reqSize : 1);
      // Now store it in a buffer.
      if (! SetupDiGetDeviceRegistryProperty(hDeviceInfo, &devInfoData, SPDRP_HARDWAREID, &regDataType, (BYTE*)hardware_id.data(), reqSize, nullptr))
        continue;
      parse_hardware_id(boost::nowide::narrow(hardware_id.data()), port_info);
 
      // Find the size required to hold the friendly name.
      reqSize = 0;
      SetupDiGetDeviceRegistryProperty(hDeviceInfo, &devInfoData, SPDRP_FRIENDLYNAME, nullptr, nullptr, 0, &reqSize);
      std::vector<wchar_t> friendly_name;
      friendly_name.reserve(reqSize > 1 ? reqSize : 1);
      // Now store it in a buffer.
      if (! SetupDiGetDeviceRegistryProperty(hDeviceInfo, &devInfoData, SPDRP_FRIENDLYNAME, nullptr, (BYTE*)friendly_name.data(), reqSize, nullptr)) {
        port_info.friendly_name = port_info.port;
      } else {
        port_info.friendly_name = boost::nowide::narrow(friendly_name.data());
        port_info.is_printer = looks_like_printer(port_info.friendly_name);
      }
      output.emplace_back(std::move(port_info));
    }
  }
#elif __APPLE__
  // inspired by https://sigrok.org/wiki/Libserialport
  CFMutableDictionaryRef classes = IOServiceMatching(kIOSerialBSDServiceValue);
  if (classes != 0) {
    io_iterator_t iter;
    if (IOServiceGetMatchingServices(kIOMasterPortDefault, classes, &iter) == KERN_SUCCESS) {
      io_object_t port;
      while ((port = IOIteratorNext(iter)) != 0) {
        CFTypeRef cf_property = IORegistryEntryCreateCFProperty(port, CFSTR(kIOCalloutDeviceKey), kCFAllocatorDefault, 0);
        if (cf_property) {
          char path[PATH_MAX];
          Boolean result = CFStringGetCString((CFStringRef)cf_property, path, sizeof(path), kCFStringEncodingUTF8);
          CFRelease(cf_property);
          if (result) {
            SerialPortInfo port_info;
            port_info.port = path;
 
            // Attempt to read out the device friendly name
            if ((cf_property = IORegistryEntrySearchCFProperty(port, kIOServicePlane,
                     CFSTR("USB Interface Name"), kCFAllocatorDefault,
                     kIORegistryIterateRecursively | kIORegistryIterateParents)) ||
                (cf_property = IORegistryEntrySearchCFProperty(port, kIOServicePlane,
                     CFSTR("USB Product Name"), kCFAllocatorDefault,
                     kIORegistryIterateRecursively | kIORegistryIterateParents)) ||
                (cf_property = IORegistryEntrySearchCFProperty(port, kIOServicePlane,
                     CFSTR("Product Name"), kCFAllocatorDefault,
                     kIORegistryIterateRecursively | kIORegistryIterateParents)) ||
                (cf_property = IORegistryEntryCreateCFProperty(port, 
                     CFSTR(kIOTTYDeviceKey), kCFAllocatorDefault, 0))) {
              // Description limited to 127 char, anything longer would not be user friendly anyway.
              char description[128];
              if (CFStringGetCString((CFStringRef)cf_property, description, sizeof(description), kCFStringEncodingUTF8)) {
                port_info.friendly_name = std::string(description) + " (" + port_info.port + ")";
                port_info.is_printer = looks_like_printer(port_info.friendly_name);
              }
              CFRelease(cf_property);
            }
            if (port_info.friendly_name.empty())
              port_info.friendly_name = port_info.port;
 
            // Attempt to read out the VID & PID
            int vid, pid;
            auto cf_vendor = IORegistryEntrySearchCFProperty(port, kIOServicePlane, CFSTR("idVendor"),
              kCFAllocatorDefault, kIORegistryIterateRecursively | kIORegistryIterateParents);
            auto cf_product = IORegistryEntrySearchCFProperty(port, kIOServicePlane, CFSTR("idProduct"),
              kCFAllocatorDefault, kIORegistryIterateRecursively | kIORegistryIterateParents);
            if (cf_vendor && cf_product) {
              if (CFNumberGetValue((CFNumberRef)cf_vendor, kCFNumberIntType, &vid) &&
                CFNumberGetValue((CFNumberRef)cf_product, kCFNumberIntType, &pid)) {
                port_info.id_vendor = vid;
                port_info.id_product = pid;
              }
            }
            if (cf_vendor) { CFRelease(cf_vendor); }
            if (cf_product) { CFRelease(cf_product); }
 
            output.emplace_back(std::move(port_info));
          }
        }
        IOObjectRelease(port);
      }
    }
  }
#else
    // UNIX / Linux
    std::initializer_list<const char*> prefixes { "ttyUSB" , "ttyACM", "tty.", "cu.", "rfcomm" };
    for (auto &dir_entry : boost::filesystem::directory_iterator(boost::filesystem::path("/dev"))) {
        std::string name = dir_entry.path().filename().string();
        for (const char *prefix : prefixes) {
            if (boost::starts_with(name, prefix)) {
                const auto path = dir_entry.path().string();
                SerialPortInfo spi;
                spi.port = path;
#ifdef __linux__
        auto friendly_name = sysfs_tty_prop(name, "product");
        if (friendly_name) {
          spi.is_printer = looks_like_printer(*friendly_name);
          spi.friendly_name = (boost::format("%1% (%2%)") % *friendly_name % path).str();
        } else {
          spi.friendly_name = path;
        }
        auto vid = sysfs_tty_prop_hex(name, "idVendor");
        auto pid = sysfs_tty_prop_hex(name, "idProduct");
        if (vid && pid) {
          spi.id_vendor = *vid;
          spi.id_product = *pid;
        }
#else
                spi.friendly_name = path;
#endif
                output.emplace_back(std::move(spi));
                break;
            }
        }
    }
#endif
 
    output.erase(std::remove_if(output.begin(), output.end(), 
        [](const SerialPortInfo &info) {
            return boost::starts_with(info.port, "Bluetooth") || boost::starts_with(info.port, "FireFly"); 
        }),
        output.end());
    return output;
}

References Slic3r::Utils::SerialPortInfo::friendly_name, Slic3r::Utils::SerialPortInfo::id_product, Slic3r::Utils::SerialPortInfo::id_vendor, Slic3r::Utils::SerialPortInfo::is_printer, L, looks_like_printer(), boost::nowide::narrow(), PATH_MAX, and Slic3r::Utils::SerialPortInfo::port.

Referenced by Slic3r::FirmwareDialog::priv::avr109_lookup_port(), Slic3r::FirmwareDialog::priv::avr109_wait_for_bootloader(), Slic3r::FirmwareDialog::priv::find_serial_ports(), and scan_serial_ports().

Here is the call graph for this function:

Here is the caller graph for this function:

str2time() [1/2]

time_t Slic3r::Utils::str2time	(	const std::string &	str,
		TimeZone	zone,
		TimeFormat	fmt
	)

{
    std::string fmtstr = process_format(get_fmtstr(fmt), zone).c_str();
    std::stringstream ss(str);
 
    ss.imbue(std::locale("C"));
    return str2time(ss, zone, fmtstr.c_str());
}

References fmtstr(), get_fmtstr(), and str2time().

Here is the call graph for this function:

str2time() [2/2]

static time_t Slic3r::Utils::str2time ( std::istream &  stream, TimeZone  zone, const char *  fmt  )

static

{
    std::tm tms = {};
    tms.tm_isdst = -1;
 
    stream >> __get_put_time_emulation::get_time(&tms, fmt);
    time_t ret = time_t(-1);
 
    switch (zone) {
    case TimeZone::local: ret = _mktime(&tms); break;
    case TimeZone::utc:   ret = _timegm(&tms); break;
    }
 
    if (stream.fail() || ret < time_t(0)) ret = time_t(-1);
 
    return ret;
}

References Slic3r::Utils::__get_put_time_emulation::get_time(), local, and utc.

Referenced by parse_iso_utc_timestamp(), and str2time().

Here is the call graph for this function:

Here is the caller graph for this function:

time2str() [1/2]

std::string Slic3r::Utils::time2str	(	const time_t &	t,
		TimeZone	zone,
		TimeFormat	fmt
	)

{
    std::string ret;
    std::tm tms = {};
    tms.tm_isdst = -1;
    std::string fmtstr = process_format(get_fmtstr(fmt), zone);
 
    switch (zone) {
    case TimeZone::local:
        ret = tm2str(_localtime_r(&t, &tms), fmtstr.c_str()); break;
    case TimeZone::utc:
        ret = tm2str(_gmtime_r(&t, &tms), fmtstr.c_str()); break;
    }
 
    return ret;
}

References fmtstr(), get_fmtstr(), local, tm2str(), and utc.

Referenced by iso_utc_timestamp(), time2str(), and utc_timestamp().

Here is the call graph for this function:

Here is the caller graph for this function:

time2str() [2/2]

std::string Slic3r::Utils::time2str ( TimeZone  zone, TimeFormat  fmt  )

inline

{
    return time2str(get_current_time_utc(), zone, fmt);
}

References get_current_time_utc(), and time2str().

Here is the call graph for this function:

tm2str()

static std::string Slic3r::Utils::tm2str ( const std::tm *  tms, const char *  fmt  )

static

{
    std::stringstream ss;
    ss.imbue(std::locale("C"));
    ss << __get_put_time_emulation::put_time(tms, fmt);
    return ss.str();
}

References Slic3r::Utils::__get_put_time_emulation::put_time().

Referenced by time2str().

Here is the call graph for this function:

Here is the caller graph for this function:

utc_timestamp() [1/2]

std::string Slic3r::Utils::utc_timestamp ( )

inline

{
    return utc_timestamp(get_current_time_utc());
}

References get_current_time_utc(), and utc_timestamp().

Referenced by Slic3r::_3MF_Exporter::_add_model_file_to_archive(), Slic3r::anonymous_namespace{SL1.cpp}::fill_iniconf(), Slic3r::header_gcodeviewer_generated(), Slic3r::header_slic3r_generated(), and utc_timestamp().

Here is the call graph for this function:

Here is the caller graph for this function:

utc_timestamp() [2/2]

std::string Slic3r::Utils::utc_timestamp ( time_t  t )

inline

{
    return time2str(t, TimeZone::utc, TimeFormat::gcode);
}

References gcode, time2str(), and utc.

Here is the call graph for this function:

Variable Documentation

ISO8601Z_TIME_FMT

const constexpr char* const Slic3r::Utils::ISO8601Z_TIME_FMT = "%Y%m%dT%H%M%SZ"

staticconstexpr

Referenced by get_fmtstr().

SLICER_UTC_TIME_FMT

const constexpr char* const Slic3r::Utils::SLICER_UTC_TIME_FMT = "%Y-%m-%d at %T"

staticconstexpr

Referenced by get_fmtstr(), and Slic3r::Utils::anonymous_namespace{Time.cpp}::process_format().