Skip to content

FrakLogLevel

enum FrakLogLevel

Conforms to Swift.Comparable, Swift.Equatable, Swift.Hashable, Swift.RawRepresentable, Swift.Sendable

Defined in: Sources/FrakSDK/Core/FrakConfig.swift:15

Cases

Section titled “Cases”

FrakLogLevel.debug

Section titled “FrakLogLevel.debug”
case debug

FrakLogLevel.error

Section titled “FrakLogLevel.error”
case error

FrakLogLevel.info

Section titled “FrakLogLevel.info”
case info

FrakLogLevel.none

Section titled “FrakLogLevel.none”
case none

FrakLogLevel.warn

Section titled “FrakLogLevel.warn”
case warn

Initializers

Section titled “Initializers”

init(rawValue:)

Section titled “init(rawValue:)”
init?(rawValue: Int)

Creates a new instance with the specified raw value.

If there is no value of the type that corresponds with the specified raw value, this initializer returns nil. For example:

enum PaperSize: String {
    case A4, A5, Letter, Legal
}


print(PaperSize(rawValue: "Legal"))
// Prints "Optional(PaperSize.Legal)"


print(PaperSize(rawValue: "Tabloid"))
// Prints "nil"
  • Parameter rawValue: The raw value to use for the new instance.

Properties

Section titled “Properties”

hashValue

Section titled “hashValue”
var hashValue: Int { get }

Methods

Section titled “Methods”

hash(into:)

Section titled “hash(into:)”
func hash(into hasher: inout Hasher)

Operators

Section titled “Operators”

!=(::)

static func != (lhs: Self, rhs: Self) -> Bool

Returns a Boolean value indicating whether two values are not equal.

Inequality is the inverse of equality. For any values a and b, a != b implies that a == b is false.

This is the default implementation of the not-equal-to operator (!=) for any type that conforms to Equatable.

  • Parameters:
    • lhs: A value to compare.
    • rhs: Another value to compare.

…(::)

Section titled “…(::)”
static func ... (minimum: Self, maximum: Self) -> ClosedRange<Self>

Returns a closed range that contains both of its bounds.

Use the closed range operator (...) to create a closed range of any type that conforms to the Comparable protocol. This example creates a ClosedRange<Character> from “a” up to, and including, “z”.

let lowercase = "a"..."z"
print(lowercase.contains("z"))
// Prints "true"

  • Parameters:

    • minimum: The lower bound for the range.
    • maximum: The upper bound for the range.

  • Precondition: minimum <= maximum.

…(_:)

Section titled “…(_:)”
static func ... (maximum: Self) -> PartialRangeThrough<Self>

Returns a partial range up to, and including, its upper bound.

Use the prefix closed range operator (prefix ...) to create a partial range of any type that conforms to the Comparable protocol. This example creates a PartialRangeThrough<Double> instance that includes any value less than or equal to 5.0.

let throughFive = ...5.0


throughFive.contains(4.0)     // true
throughFive.contains(5.0)     // true
throughFive.contains(6.0)     // false

You can use this type of partial range of a collection’s indices to represent the range from the start of the collection up to, and including, the partial range’s upper bound.

let numbers = [10, 20, 30, 40, 50, 60, 70]
print(numbers[...3])
// Prints "[10, 20, 30, 40]"

  • Parameter maximum: The upper bound for the range.

  • Precondition: maximum must compare equal to itself (i.e. cannot be NaN).

…(_:)

Section titled “…(_:)”
static func ... (minimum: Self) -> PartialRangeFrom<Self>

Returns a partial range extending upward from a lower bound.

Use the postfix range operator (postfix ...) to create a partial range of any type that conforms to the Comparable protocol. This example creates a PartialRangeFrom<Double> instance that includes any value greater than or equal to 5.0.

let atLeastFive = 5.0...


atLeastFive.contains(4.0)     // false
atLeastFive.contains(5.0)     // true
atLeastFive.contains(6.0)     // true

You can use this type of partial range of a collection’s indices to represent the range from the partial range’s lower bound up to the end of the collection.

let numbers = [10, 20, 30, 40, 50, 60, 70]
print(numbers[3...])
// Prints "[40, 50, 60, 70]"

  • Parameter minimum: The lower bound for the range.

  • Precondition: minimum must compare equal to itself (i.e. cannot be NaN).

..<(::)

Section titled “..<(::)”
static func ..< (minimum: Self, maximum: Self) -> Range<Self>

Returns a half-open range that contains its lower bound but not its upper bound.

Use the half-open range operator (..<) to create a range of any type that conforms to the Comparable protocol. This example creates a Range<Double> from zero up to, but not including, 5.0.

let lessThanFive = 0.0..<5.0
print(lessThanFive.contains(3.14))  // Prints "true"
print(lessThanFive.contains(5.0))   // Prints "false"

  • Parameters:

    • minimum: The lower bound for the range.
    • maximum: The upper bound for the range.

  • Precondition: minimum <= maximum.

..<(_:)

Section titled “..<(_:)”
static func ..< (maximum: Self) -> PartialRangeUpTo<Self>

Returns a partial range up to, but not including, its upper bound.

Use the prefix half-open range operator (prefix ..<) to create a partial range of any type that conforms to the Comparable protocol. This example creates a PartialRangeUpTo<Double> instance that includes any value less than 5.0.

let upToFive = ..<5.0


upToFive.contains(3.14)       // true
upToFive.contains(6.28)       // false
upToFive.contains(5.0)        // false

You can use this type of partial range of a collection’s indices to represent the range from the start of the collection up to, but not including, the partial range’s upper bound.

let numbers = [10, 20, 30, 40, 50, 60, 70]
print(numbers[..<3])
// Prints "[10, 20, 30]"

  • Parameter maximum: The upper bound for the range.

  • Precondition: maximum must compare equal to itself (i.e. cannot be NaN).

<(::)

Section titled “<(::)”
static func < (lhs: FrakLogLevel, rhs: FrakLogLevel) -> Bool

Returns a Boolean value indicating whether the value of the first argument is less than that of the second argument.

This function is the only requirement of the Comparable protocol. The remainder of the relational operator functions are implemented by the standard library for any type that conforms to Comparable.

  • Parameters:
    • lhs: A value to compare.
    • rhs: Another value to compare.

<=(::)

Section titled “<=(::)”
static func <= (lhs: Self, rhs: Self) -> Bool

Returns a Boolean value indicating whether the value of the first argument is less than or equal to that of the second argument.

This is the default implementation of the less-than-or-equal-to operator (<=) for any type that conforms to Comparable.

  • Parameters:
    • lhs: A value to compare.
    • rhs: Another value to compare.

>(::)

Section titled “>(::)”
static func > (lhs: Self, rhs: Self) -> Bool

Returns a Boolean value indicating whether the value of the first argument is greater than that of the second argument.

This is the default implementation of the greater-than operator (>) for any type that conforms to Comparable.

  • Parameters:
    • lhs: A value to compare.
    • rhs: Another value to compare.

>=(::)

Section titled “>=(::)”
static func >= (lhs: Self, rhs: Self) -> Bool

Returns a Boolean value indicating whether the value of the first argument is greater than or equal to that of the second argument.

This is the default implementation of the greater-than-or-equal-to operator (>=) for any type that conforms to Comparable.

  • Parameters:
    • lhs: A value to compare.
    • rhs: Another value to compare.
  • Returns: true if lhs is greater than or equal to rhs; otherwise, false.