Struct OSLogStore

Source

pub struct OSLogStore { /* private fields */ }

Expand description

A set of entries from the unified logging system. Instances represent a fixed range of entries and may be backed by a logarchive or the Mac’s local store.

Entries in OSLogStore objects are used by OSLogEnumerator instances; one store can support multiple OSLogEnumerator instances concurrently.

Implementations§

Source §

impl OSLogStore

Source

pub unsafe fn localStoreAndReturnError() -> Result<Retained<Self>, Retained<NSError>>

Create an OSLogStore representing the Mac’s local store.

Parameter error: If initialization is unsuccessful — for example, this process does not have access to local logs — return nil and set this parameter to a pointer to an error object describing the reason.

This enables processing of a sequence of logs as of the particular point in time when this object is created.

Gaining access to the local unified logging system requires permission from the system. The caller must be run by an admin account.

Source

pub unsafe fn storeWithScope_error( scope: OSLogStoreScope, ) -> Result<Retained<Self>, Retained<NSError>>

Create an OSLogStore for a subset of entries in the local store.

Parameter scope: The kind of subset the OSLogStore is for.

Parameter error: If initialization is unsuccessful, return nil and set this parameter to a pointer to an error object that describes the reason.

Source

pub unsafe fn storeWithURL_error( url: &NSURL, ) -> Result<Retained<Self>, Retained<NSError>>

Create an OSLogStore based on a logarchive.

Parameter url: The path identifying a logarchive to be read.

Parameter error: If initialization is unsuccessful — for example, the path is not to a valid logarchive or the logarchive is not compatible because it is from a newer version — return nil and set this parameter to a pointer to an error object that describes the reason.

Source

pub unsafe fn init(this: Allocated<Self>) -> Retained<Self>

👎Deprecated: Use one of the factory methods

Source

pub unsafe fn entriesEnumeratorWithOptions_position_predicate_error( &self, options: OSLogEnumeratorOptions, position: Option<&OSLogPosition>, predicate: Option<&NSPredicate>, ) -> Result<Retained<OSLogEnumerator>, Retained<NSError>>

Return an OSLogEnumerator object based on an underlying store. This object represents the sequence of entries for the store. OSLogStore. Additional parameters control which entries are yielded and their order.

Parameter options: Control the direction of iteration.

Parameter position: Where to start iteration. If nil, depend on the direction of the iteration: if forwards, start with the earliest entry; if reverse, start with the latest entry.

Parameter predicate: A predicate that filters which entries are in the sequence. If this is nil, yield all entries.

Parameter error: If the enumerator cannot be set up — for example, the predicate has an unrecognized key — return nil and set this to a pointer to an error object that describes the reason.

Source

pub unsafe fn entriesEnumeratorAndReturnError( &self, ) -> Result<Retained<OSLogEnumerator>, Retained<NSError>>

Return an OSLogEnumerator object with default options for viewing the entries; all are viewed, from earliest to latest.

Parameter error: If the enumerator cannot be set up, return nil and set this to a pointer to an error object that describes the reason.

Source

pub unsafe fn positionWithDate(&self, date: &NSDate) -> Retained<OSLogPosition>

Return a position representing the time specified.

Parameter date: The date to look for.

If there are multiple occurences of the same time — if, for example, there was a time change during the range of entries — the earliest occurrence is used.

Source

pub unsafe fn positionWithTimeIntervalSinceEnd( &self, seconds: NSTimeInterval, ) -> Retained<OSLogPosition>

Return a position representing an offset since the end of the time range that the entries span.

Parameter seconds: The seconds to add to the last time point in the range of entries.

Source

pub unsafe fn positionWithTimeIntervalSinceLatestBoot( &self, seconds: NSTimeInterval, ) -> Retained<OSLogPosition>

Return a position representing time since the last boot in the series of entries.

Parameter seconds: The seconds to add to the boot time point in the log time range.

Negative seconds would create an ambiguous or imprecise position; this function asserts that the interval is positive.

Source §

impl OSLogStore

Methods declared on superclass NSObject.

Source

pub unsafe fn new() -> Retained<Self>

Methods from Deref<Target = NSObject>§

Source

pub fn doesNotRecognizeSelector(&self, sel: Sel) -> !

Handle messages the object doesn’t recognize.

See Apple’s documentation for details.

Methods from Deref<Target = AnyObject>§

Source

pub fn class(&self) -> &'static AnyClass

Dynamically find the class of this object.

§Panics

May panic if the object is invalid (which may be the case for objects returned from unavailable init/new methods).

§Example

Check that an instance of NSObject has the precise class NSObject.

use objc2::ClassType;
use objc2::runtime::NSObject;

let obj = NSObject::new();
assert_eq!(obj.class(), NSObject::class());

Source

pub unsafe fn get_ivar<T>(&self, name: &str) -> &T
where T: Encode,

👎Deprecated: this is difficult to use correctly, use Ivar::load instead.

Use Ivar::load instead.

§Safety

The object must have an instance variable with the given name, and it must be of type T.

See Ivar::load_ptr for details surrounding this.

Source

pub fn downcast_ref<T>(&self) -> Option<&T>
where T: DowncastTarget,

Attempt to downcast the object to a class of type T.

This is the reference-variant. Use Retained::downcast if you want to convert a retained object to another type.

§Mutable classes

Some classes have immutable and mutable variants, such as NSString and NSMutableString.

When some Objective-C API signature says it gives you an immutable class, it generally expects you to not mutate that, even though it may technically be mutable “under the hood”.

So using this method to convert a NSString to a NSMutableString, while not unsound, is generally frowned upon unless you created the string yourself, or the API explicitly documents the string to be mutable.

See Apple’s documentation on mutability and on isKindOfClass: for more details.

§Generic classes

Objective-C generics are called “lightweight generics”, and that’s because they aren’t exposed in the runtime. This makes it impossible to safely downcast to generic collections, so this is disallowed by this method.

You can, however, safely downcast to generic collections where all the type-parameters are AnyObject.

§Panics

This works internally by calling isKindOfClass:. That means that the object must have the instance method of that name, and an exception will be thrown (if CoreFoundation is linked) or the process will abort if that is not the case. In the vast majority of cases, you don’t need to worry about this, since both root objects NSObject and NSProxy implement this method.

§Examples

Cast an NSString back and forth from NSObject.

use objc2::rc::Retained;
use objc2_foundation::{NSObject, NSString};

let obj: Retained<NSObject> = NSString::new().into_super();
let string = obj.downcast_ref::<NSString>().unwrap();
// Or with `downcast`, if we do not need the object afterwards
let string = obj.downcast::<NSString>().unwrap();

Try (and fail) to cast an NSObject to an NSString.

use objc2_foundation::{NSObject, NSString};

let obj = NSObject::new();
assert!(obj.downcast_ref::<NSString>().is_none());

Try to cast to an array of strings.

use objc2_foundation::{NSArray, NSObject, NSString};

let arr = NSArray::from_retained_slice(&[NSObject::new()]);
// This is invalid and doesn't type check.
let arr = arr.downcast_ref::<NSArray<NSString>>();

This fails to compile, since it would require enumerating over the array to ensure that each element is of the desired type, which is a performance pitfall.

Downcast when processing each element instead.

use objc2_foundation::{NSArray, NSObject, NSString};

let arr = NSArray::from_retained_slice(&[NSObject::new()]);

for elem in arr {
    if let Some(data) = elem.downcast_ref::<NSString>() {
        // handle `data`
    }
}