Added Codable conformance

Author: orchetect

README.md

@@ -44,6 +44,7 @@ A robust multiplatform Swift library for working with SMPTE timecode supporting
 - Common math operations between timecodes: add, subtract, multiply, divide
 - Form a `Range` or `Stride` between two timecodes
 - Exhaustive unit tests ensuring accuracy
+- Conforms to `Codable`
 
 ## Installation
 

Sources/TimecodeKit/FrameRate/FrameRate.swift

@@ -12,113 +12,113 @@ extension Timecode {
 
 	// MARK: - FrameRate
 
-	public enum FrameRate: Int {
+	public enum FrameRate: String, Codable {
 
 		/// 23.976 fps (aka 23.98)
 		///
 		/// Also known as 24p for HD video, sometimes rounded up to 23.98 fps. started out as the format for dealing with 24fps film in a NTSC post environment.
-		case _23_976
+		case _23_976 = "23.976"
 
 		/// 24 fps
 		///
 		/// (film, ATSC, 2k, 4k, 6k)
-		case _24
+		case _24 = "24"
 
 		/// 24.98 fps
 		///
 		/// This frame rate is commonly used to facilitate transfers between PAL and NTSC video and film sources. It is mostly used to compensate for some error.
-		case _24_98
+		case _24_98 = "24.98"
 
 		/// 25 fps
 		///
 		/// (PAL, used in Europe, Uruguay, Argentina, Australia), SECAM, DVB, ATSC)
-		case _25
+		case _25 = "25"
 
 		/// 29.97 fps (30p)
 		///
 		/// (NTSC American System (US, Canada, Mexico, Colombia, etc.), ATSC, PAL-M (Brazil))
 		/// (30 / 1.001) frame/sec
-		case _29_97
+		case _29_97 = "29.97"
 
 		/// 29.97 drop fps
-		case _29_97_drop
+		case _29_97_drop = "29.97d"
 
 		/// 30 fps
 		///
 		/// (ATSC) This is the frame count of NTSC broadcast video. However, the actual frame rate or speed of the video format runs at 29.97 fps.
 		///
 		/// This timecode clock does not run in realtime. It is slightly slower by 0.1%.
 		/// ie: 1:00:00:00:00 at 30 fps is approx 1:00:00:00;02 in 29.97df
-		case _30
+		case _30 = "30"
 
 		/// 30 drop fps:
 		///
 		/// The 30 fps drop-frame count is an adaptation that allows a timecode display running at 29.97 fps to actually show the clock-on-the-wall-time of the timeline by “dropping” or skipping specific frame numbers in order to “catch the clock up” to realtime.
-		case _30_drop
+		case _30_drop = "30d"
 
 		/// 47.952 (48p?)
 		///
 		/// Double 23.976 fps
-		case _47_952
+		case _47_952 = "47.952"
 
 		/// 48 fps
 		///
 		/// Double 24 fps
-		case _48
+		case _48 = "48"
 
 		/// 50 fps
 		///
 		/// Double 25 fps
-		case _50
+		case _50 = "50"
 
 		/// 59.94 fps
 		///
 		/// Double 29.97 fps
 		/// 
 		/// This video frame rate is supported by high definition cameras and is compatible with NTSC (29.97 fps).
-		case _59_94
+		case _59_94 = "59.94"
 
 		/// 59.94 drop fps
 		///
 		/// Double 29.97 drop fps
-		case _59_94_drop
+		case _59_94_drop = "59.94d"
 
 		/// 60 fps
 		///
 		/// Double 30 fps
 		///
 		/// This video frame rate is supported by many high definition cameras. However, the NTSC compatible 59.94 fps frame rate is much more common.
-		case _60
+		case _60 = "60"
 
 		/// 60 drop fps
 		///
 		/// Double 30 fps
-		case _60_drop
+		case _60_drop = "60d"
 
 		/// 100 fps
 		///
 		/// Double 50 fps / quadruple 25 fps
-		case _100
+		case _100 = "100"
 
 		/// 119.88 fps
 		///
 		/// Double 59.94 fps / quadruple 29.97 fps
-		case _119_88
+		case _119_88 = "119.88"
 
 		/// 119.88 drop fps
 		///
 		/// Double 59.94 drop fps / quadruple 29.97 drop fps
-		case _119_88_drop
+		case _119_88_drop = "119.88d"
 
 		/// 120 fps
 		///
 		/// Double 60 fps / quadruple 30 fps
-		case _120
+		case _120 = "120"
 
 		/// 120 drop fps
 		///
 		/// Double 60 fps drop / quadruple 30 fps drop
-		case _120_drop
+		case _120_drop = "120d"
 
 	}
 

Sources/TimecodeKit/TimeValue/TimeValue.swift

@@ -11,13 +11,13 @@ import Foundation
 /// Primitive struct to represent real time.
 ///
 /// In effort to retain precision, the value used when initializing will be stored unchanged, but can be accessed by either accessor. The backing value can be read as either `.seconds` or `.ms`. If the original format's property is get, the backing value will be returned unchanged. Otherwise it will be converted when needed when the properties are accessed.
-public struct TimeValue {
+public struct TimeValue: Codable {
 
 	// MARK: Data backing
 
-	private let msValue: Double?
+	internal let msValue: Double?
 
-	private let secondsValue: Double?
+	internal let secondsValue: Double?
 
 	// MARK: Public properties
 
@@ -101,10 +101,10 @@ extension TimeValue: Comparable {
 extension TimeValue {
 
 	/// Enum describing units of time, as stored by `TimeValue`
-	public enum UnitBacking {
+	public enum UnitBacking: String, Codable {
 
-		case ms
-		case seconds
+		case ms = "ms"
+		case seconds = "seconds"
 
 	}
 

Sources/TimecodeKit/Timecode.swift

@@ -10,7 +10,7 @@ import Foundation
 
 
 /// Object representing SMPTE timecode data with a variety of number- and string- based constructors, including helper functions to convert between them operators to perform math operations between them.
-public struct Timecode {
+public struct Timecode: Codable {
 
 	// MARK: - Immutable properties
 

Sources/TimecodeKit/UpperLimit/UpperLimit.swift

@@ -11,13 +11,13 @@ import Foundation
 extension Timecode {
 
 	/// Enum describing the maximum timecode ceiling.
-	public enum UpperLimit: Int {
+	public enum UpperLimit: String, Codable {
 
 		/// Pro Tools' upper limit is "23:59:59:FF" which is 1 day (24 hours) in duration.
-		case _24hours
+		case _24hours = "24 hours"
 
 		/// Cubase's upper limit is "99 23:59:59:FF" which is 100 days in duration.
-		case _100days
+		case _100days = "100 days"
 
 		/// Internal use.
 		internal var maxDays: Int {

Tests/TimecodeKit-Unit-Tests/Unit Tests/TimeValue/TimeValue Tests.swift

@@ -62,4 +62,41 @@ class TimeValue_UT_Tests: XCTestCase {
 
 	}
 
+	func testCodable() {
+		
+		// set up JSON coders with default settings
+		
+		let encoder = JSONEncoder()
+		let decoder = JSONDecoder()
+		
+		// set up a TimeValue object that has all non-defaults
+		
+		let time = 50505050.123456789123456789
+		
+		let ott1 = TimeValue(ms: time)
+		
+		// encode
+		
+		guard let encoded = try? encoder.encode(ott1)
+		else {
+			XCTFail("JSON encode failed.") ; return
+		}
+		
+		// decode
+		
+		guard let decoded = try? decoder.decode(TimeValue.self, from: encoded)
+		else {
+			XCTFail("JSON decode failed.") ; return
+		}
+		
+		// compare original to reconstructed
+		
+		XCTAssertEqual(ott1, decoded)
+		
+		XCTAssertEqual(ott1.msValue, decoded.msValue)
+		XCTAssertEqual(ott1.secondsValue, decoded.secondsValue)
+		XCTAssertEqual(ott1.backing, decoded.backing)
+		
+	}
+	
 }

Tests/TimecodeKit-Unit-Tests/Unit Tests/Timecode String Extensions Tests.swift

@@ -14,7 +14,6 @@ class Timecode_UT_Swift_Extensions_Tests: XCTestCase {
 	override func setUp() { }
 	override func tearDown() { }
 
-	
 	func testString_toTimeCode() {
 
 		XCTAssertEqual("01:05:20:14".toTimecode(at: ._23_976),

Tests/TimecodeKit-Unit-Tests/Unit Tests/Timecode Tests.swift

@@ -14,6 +14,54 @@ class Timecode_UT_Tests: XCTestCase {
 	override func setUp() { }
 	override func tearDown() { }
 
-	// no tests in this file
+	func testCodable() {
+		
+		// set up JSON coders with default settings
+		
+		let encoder = JSONEncoder()
+		let decoder = JSONDecoder()
+		
+		Timecode.FrameRate.allCases.forEach {
+			
+			// set up a timecode object that has all non-defaults
+			
+			var tc = "1 12:34:56:11.85"
+				.toTimecode(at: $0,
+							limit: ._100days,
+							subFramesDivisor: 100)!
+			
+			tc.displaySubFrames = true
+			
+			// encode
+			
+			guard let encoded = try? encoder.encode(tc)
+			else {
+				XCTFail("JSON encode failed.") ; return
+			}
+			
+			// decode
+			
+			guard let decoded = try? decoder.decode(Timecode.self, from: encoded)
+			else {
+				XCTFail("JSON decode failed.") ; return
+			}
+			
+			// compare original to reconstructed
+			
+			XCTAssertEqual(tc, decoded)
+			
+			XCTAssertEqual(tc.days, decoded.days)
+			XCTAssertEqual(tc.hours, decoded.hours)
+			XCTAssertEqual(tc.minutes, decoded.minutes)
+			XCTAssertEqual(tc.seconds, decoded.seconds)
+			XCTAssertEqual(tc.frames, decoded.frames)
+			XCTAssertEqual(tc.frameRate, decoded.frameRate)
+			XCTAssertEqual(tc.upperLimit, decoded.upperLimit)
+			XCTAssertEqual(tc.subFramesDivisor, decoded.subFramesDivisor)
+			XCTAssertEqual(tc.displaySubFrames, decoded.displaySubFrames)
+			
+		}
+		
+	}
 
 }