#40: Added .initializeNow() to LazyContainer

Implemented it everywhere in this package, added tests.

Also moved tests to the proper folder.

Author: KyNorthstar

CHANGELOG.md

@@ -42,3 +42,6 @@ Initial movement from 4.x.
 
 - Transitioned to Swift Testing
     - Removed `LinuxMain.swift` & `XCTestManifests.swift` from tests since they're no longer needed
+
+- Introduced `.initializeNow()`
+    - https://github.com/RougeWare/Swift-Lazy-Containers/issues/40

Sources/LazyContainers/FunctionalLazy.swift renamed to Sources/Lazy/FunctionalLazy.swift

@@ -73,6 +73,11 @@ public struct FunctionalLazy<Value>: LazyContainer {
     public var isInitialized: Bool { _guts.isInitialized }
 
 
+    public mutating func initializeNow() {
+        _guts.initializeNow()
+    }
+    
+    
 
     /// The actual functionality of `FunctionalLazy`, separated so that the semantics work out better
     @propertyWrapper
@@ -114,6 +119,11 @@ public struct FunctionalLazy<Value>: LazyContainer {
             set { initializer = { newValue } }
         }
 
+        
+        func initializeNow() {
+            _ = initializer()
+        }
+        
 
         /// Indicates whether the value has indeed been initialized
         public var isInitialized: Bool { nil == semaphore }

Sources/LazyContainers/Lazy.swift renamed to Sources/Lazy/Lazy.swift

@@ -19,11 +19,11 @@ public struct Lazy<Value>: LazyContainer {
 
     /// Privatizes the inner-workings of this functional lazy container
     @ValueReference
-    private var guts: ValueHolder<Value>
+    private var guts: ValueHolder
 
 
     /// Allows other initializers to have a shared point of initialization
-    private init(_guts: ValueReference<ValueHolder<Value>>) {
+    private init(_guts: ValueReference<ValueHolder>) {
         self._guts = _guts
     }
 
@@ -73,6 +73,11 @@ public struct Lazy<Value>: LazyContainer {
 
     /// Indicates whether the value has indeed been initialized
     public var isInitialized: Bool { _guts.wrappedValue.hasValue }
+    
+    
+    public mutating func initializeNow() {
+        guts.initializeNow()
+    }
 }
 
 
@@ -120,6 +125,18 @@ public enum LazyContainerValueHolder<Value> {
         case .unset(initializer: _): return false
         }
     }
+    
+    
+    /// Immediately initializes the value held inside this value holder
+    ///
+    /// If this holder already contains a value, this does nothing
+    mutating func initializeNow()  {
+        switch self {
+        case .hasValue(_): return
+        case .unset(let initializer):
+            self = .hasValue(value: initializer())
+        }
+    }
 }
 
 
@@ -128,7 +145,5 @@ public enum LazyContainerValueHolder<Value> {
 public extension LazyContainer {
 
     /// Takes care of keeping track of the state, value, and initializer as needed
-    ///
-    /// - Attention: This will change in version 5, to be an alias to `LazyContainerValueHolder<Value>`
-    typealias ValueHolder = LazyContainerValueHolder
+    typealias ValueHolder = LazyContainerValueHolder<Value>
 }

Sources/LazyContainers/LazyContainer + Codable.swift renamed to Sources/Lazy/LazyContainer + Codable.swift

@@ -34,6 +34,13 @@ public protocol LazyContainer {
     var isInitialized: Bool { get }
 
 
+    /// Immediately initializes the value held inside this lazy container
+    ///
+    /// If this holder already contains a value, this does nothing
+    // https://github.com/RougeWare/Swift-Lazy-Containers/issues/40
+    mutating func initializeNow()
+    
+    
     /// Creates a lazy container that already contains an initialized value.
     ///
     /// This is useful when you need a uniform API (for instance, when implementing a protocol that requires a `Lazy`),
@@ -68,7 +75,5 @@ public final class LazyContainerValueReference<Value> {
 public extension LazyContainer {
 
     /// Allows you to use reference semantics to hold a value inside a lazy container.
-    ///
-    /// - Attention: This will change in version 5, to be an alias to `LazyContainerValueReference<Value>`
     typealias ValueReference = LazyContainerValueReference
 }

Sources/LazyContainers/LazyContainer + Equatable.swift renamed to Sources/Lazy/LazyContainer + Equatable.swift

@@ -20,11 +20,11 @@ public struct ResettableLazy<Value>: LazyContainer {
 
     /// Privatizes the inner-workings of this functional lazy container
     @ValueReference
-    private var guts: ResettableValueHolder<Value>
+    private var guts: ResettableValueHolder
 
 
     /// Allows other initializers to have a shared point of initialization
-    private init(_guts: ValueReference<ResettableValueHolder<Value>>) {
+    private init(_guts: ValueReference<ResettableValueHolder>) {
         self._guts = _guts
     }
 
@@ -80,6 +80,11 @@ public struct ResettableLazy<Value>: LazyContainer {
     public var isInitialized: Bool { _guts.wrappedValue.hasValue }
 
 
+    public mutating func initializeNow() {
+        guts.initializeNow()
+    }
+    
+    
     /// Resets this lazy structure back to its unset state. Next time a value is needed, it will be regenerated using
     /// the initializer given by the constructor
     public func clear() {
@@ -147,6 +152,18 @@ public enum LazyContainerResettableValueHolder<Value> {
         case .unset(initializer: _): return false
         }
     }
+    
+    
+    /// Immediately initializes the value in this holder.
+    ///
+    /// If this holder already contains a value, this does nothing
+    public mutating func initializeNow() {
+        switch self {
+        case .hasValue(value: _, initializer: _): return
+        case .unset(let initializer):
+            self = .hasValue(value: initializer(), initializer: initializer)
+        }
+    }
 }
 
 
@@ -156,7 +173,5 @@ public enum LazyContainerResettableValueHolder<Value> {
 public extension LazyContainer {
 
     /// Takes care of keeping track of the state, value, and initializer as needed
-    ///
-    /// - Attention: This will change in version 5, to be an alias to `LazyContainerResettableValueHolder<Value>`
-    typealias ResettableValueHolder = LazyContainerResettableValueHolder
+    typealias ResettableValueHolder = LazyContainerResettableValueHolder<Value>
 }