Struct libpt_log::Logger

pub struct Logger {}

Logger for pt

This struct exists mainly for the python module, so that we can use the same logger with both python and rust.

Implementations

impl Logger

Main implementation

pub fn new() -> Self

create a Logger

Creates a new uninitialized Logger object.

pub fn init(log_dir: Option<PathBuf>, max_level: Option<Level>) -> Result<()>

initializes the logger

Will enable the logger to be used.

Assumes some defaults, use init_customized for more control

pub fn init_customized( log_to_file: bool, log_dir: PathBuf, ansi: bool, display_filename: bool, display_level: bool, display_target: bool, max_level: Level, display_thread_ids: bool, display_thread_names: bool, display_line_number: bool ) -> Result<()>

initializes the logger

Will enable the logger to be used.

pub fn error<T>(&self, printable: T)where T: Display,

logging at Level::ERROR

pub fn warn<T>(&self, printable: T)where T: Display,

logging at Level::WARN

pub fn info<T>(&self, printable: T)where T: Display,

logging at Level::INFO

pub fn debug<T>(&self, printable: T)where T: Display,

logging at Level::DEBUG

pub fn trace<T>(&self, printable: T)where T: Display,

logging at Level::TRACE

impl Logger

Implementation of the python interface

pub fn py_new() -> PyResult<Self>

Python version of new()

pub fn py_init( log_dir: Option<PathBuf>, max_level: Option<String> ) -> Result<()>

Python version of init()

pub fn py_error(&self, printable: String)

Python version of error()

pub fn py_warn(&self, printable: String)

Python version of warn()

pub fn py_info(&self, printable: String)

Python version of info()

pub fn py_debug(&self, printable: String)

Python version of debug()

pub fn py_trace(&self, printable: String)

Python version of trace()

Trait Implementations

impl Debug for Logger

fn fmt(&self, f: &mut Formatter<'_>) -> Result

DEBUG representation for Logger

impl IntoPy<Py<PyAny>> for Logger

fn into_py(self, py: Python<'_>) -> PyObject

Performs the conversion.

impl PyClass for Logger

type Frozen = False

Whether the pyclass is frozen.

impl PyClassImpl for Logger

const IS_BASETYPE: bool = false

#[pyclass(subclass)]

const IS_SUBCLASS: bool = false

#[pyclass(extends=…)]

const IS_MAPPING: bool = false

#[pyclass(mapping)]

const IS_SEQUENCE: bool = false

#[pyclass(sequence)]

type Layout = PyCell<Logger>

Layout

type BaseType = PyAny

Base class

type ThreadChecker = ThreadCheckerStub<Logger>

This handles following two situations:

type PyClassMutability = <<PyAny as PyClassBaseType>::PyClassMutability as PyClassMutability>::MutableChild

Immutable or mutable

type Dict = PyClassDummySlot

Specify this class has #[pyclass(dict)] or not.

type WeakRef = PyClassDummySlot

Specify this class has #[pyclass(weakref)] or not.

type BaseNativeType = PyAny

The closest native ancestor. This is PyAny by default, and when you declare #[pyclass(extends=PyDict)], it’s PyDict.

fn items_iter() -> PyClassItemsIter

fn doc(py: Python<'_>) -> PyResult<&'static CStr>

Rendered class doc

fn lazy_type_object() -> &'static LazyTypeObject<Self>

fn dict_offset() -> Option<isize>

fn weaklist_offset() -> Option<isize>

impl PyClassNewTextSignature<Logger> for PyClassImplCollector<Logger>

fn new_text_signature(self) -> Option<&'static str>

impl<'a, 'py> PyFunctionArgument<'a, 'py> for &'a Logger

type Holder = Option<PyRef<'py, Logger>>

fn extract(obj: &'py PyAny, holder: &'a mut Self::Holder) -> PyResult<Self>

impl<'a, 'py> PyFunctionArgument<'a, 'py> for &'a mut Logger

type Holder = Option<PyRefMut<'py, Logger>>

fn extract(obj: &'py PyAny, holder: &'a mut Self::Holder) -> PyResult<Self>

impl PyMethods<Logger> for PyClassImplCollector<Logger>

fn py_methods(self) -> &'static PyClassItems

impl PyTypeInfo for Logger

type AsRefTarget = PyCell<Logger>

Utility type to make Py::as_ref work.

const NAME: &'static str = "Logger"

Class name.

const MODULE: Option<&'static str> = ::core::option::Option::None

Module name, if any.

fn type_object_raw(py: Python<'_>) -> *mut PyTypeObject

Returns the PyTypeObject instance for this type.

fn type_object(py: Python<'_>) -> &PyType

Returns the safe abstraction over the type object.

fn is_type_of(object: &PyAny) -> bool

Checks if object is an instance of this type or a subclass of this type.

fn is_exact_type_of(object: &PyAny) -> bool

Checks if object is an instance of this type.