Return from initializer without initializing all stored properties error - swift

Question

import UIKit
enum DeviceType {
case Phone, Tablet, Watch
}
enum OperatingSystemType {
case iOS, Android, Windows
}
struct OperatingSystemVersion {
var Major: Int
var Minor: Int
var Patch: Int
}
struct OperatingSystem{
var type: OperatingSystemType
var version: OperatingSystemVersion
}
class Device {
var DeviceID: Int
var Type: DeviceType
var Operating_System: OperatingSystem
var UserID: Int
var Description: String
var InventoryNR: String
init () {
DeviceID = 1233
UserID = 2
Description = "took"
InventoryNR = "no17"
}
}
// I can't seem to get past this. I just want to create 2 enums, 2 structs and 2 classes
Device - Class
Device Id - Integer
Type - DeviceType
Operating System - OperatingSystem
User Id - Int
Description - String
Inventory Number - String

Answer 1

The error says you returned from init without initializing all stored properties. That's what the problem is. You need to initialize Type and OperatingSystem in init:
init () {
DeviceID = 1233
Type = .Phone
Operating_System = OperatingSystem(type: .iOS, version: OperatingSystemVersion(Major: 9, Minor: 0, Patch: 2))
UserID = 2
Description = "took"
InventoryNR = "no17"
}
In the future, please read the error messages before posting.

Answer 2

https://developer.apple.com/library/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Initialization.html
Initialization
Initialization is the process of preparing an instance
of a class, structure, or enumeration for use. This process involves
setting an initial value for each stored property on that instance and
performing any other setup or initialization that is required before
the new instance is ready for use.
You implement this initialization process by defining initializers,
which are like special methods that can be called to create a new
instance of a particular type. Unlike Objective-C initializers, Swift
initializers do not return a value. Their primary role is to ensure
that new instances of a type are correctly initialized before they are
used for the first time.
Instances of class types can also implement a deinitializer, which
performs any custom cleanup just before an instance of that class is
deallocated. For more information about deinitializers, see
Deinitialization.
Setting Initial Values for Stored Properties
Classes and structures must set all of their stored properties to an
appropriate initial value by the time an instance of that class or
structure is created. Stored properties cannot be left in an
indeterminate state.
You can set an initial value for a stored property within an
initializer, or by assigning a default property value as part of the
property’s definition. These actions are described in the following
sections.
NOTE
When you assign a default value to a stored property, or set its
initial value within an initializer, the value of that property is set
directly, without calling any property observers.
Initializers
Initializers are called to create a new instance of a particular type.
In its simplest form, an initializer is like an instance method with
no parameters, written using the init keyword:
init() {
// perform some initialization here
}
The example below defines a new structure called Fahrenheit to store temperatures expressed in the
Fahrenheit scale. The Fahrenheit structure has one stored property,
temperature, which is of type Double:
struct Fahrenheit {
var temperature: Double
init() {
temperature = 32.0
}
}
var f = Fahrenheit()
print("The default temperature is \(f.temperature)° Fahrenheit") // prints "The default temperature is 32.0° Fahrenheit"
The structure defines a single initializer, init, with no parameters, which initializes the stored temperature with a
value of 32.0 (the freezing point of water when expressed in the
Fahrenheit scale).
Default Property Values
You can set the initial value of a stored property from within an
initializer, as shown above. Alternatively, specify a default property
value as part of the property’s declaration. You specify a default
property value by assigning an initial value to the property when it
is defined.
NOTE
If a property always takes the same initial value, provide a default
value rather than setting a value within an initializer. The end
result is the same, but the default value ties the property’s
initialization more closely to its declaration. It makes for shorter,
clearer initializers and enables you to infer the type of the property
from its default value. The default value also makes it easier for you
to take advantage of default initializers and initializer inheritance,
as described later in this chapter.
You can write the Fahrenheit structure from above in a simpler form by
providing a default value for its temperature property at the point
that the property is declared:
struct Fahrenheit {
var temperature = 32.0
}