Transform arrays with ObjectMapper to Realm's List type

ArrayTransform.swift

// Based on Swift 1.2, ObjectMapper 0.15, RealmSwift 0.94.1
// Author: Timo Wälisch <[email protected]>

import UIKit
import RealmSwift
import ObjectMapper
import SwiftyJSON

class ArrayTransform<T:RealmSwift.Object where T:Mappable> : TransformType {
    typealias Object = List<T>
    typealias JSON = Array<AnyObject>
    
    let mapper = Mapper<T>()
      
    func transformFromJSON(value: AnyObject?) -> List<T>? {
        var result = List<T>()
        if let tempArr = value as! Array<AnyObject>? {
            for entry in tempArr {
                let mapper = Mapper<T>()
                let model : T = mapper.map(entry)!
                result.append(model)
            }
        }
        return result
    }
    
    // transformToJson was replaced with a solution by @zendobk from https://gist.github.com/zendobk/80b16eb74524a1674871
    // to avoid confusing future visitors of this gist. Thanks to @marksbren for pointing this out (see comments of this gist)
    func transformToJSON(value: Object?) -> JSON? {
        var results = [AnyObject]()
        if let value = value {
            for obj in value {
                let json = mapper.toJSON(obj)
                results.append(json)
            }
        }
        return results
    }
}

SampleModel.swift

// SampleModel.swift
// Author: Timo Wälisch <[email protected]>

import UIKit
import ObjectMapper
import RealmSwift
import SwiftyJSON

class SampleModel: Object, Mappable {
    
    // MARK: Realm - stored properties
    
    dynamic var title: String = ""
    var products = List<ProductModel>()

    // MARK: ObjectMapper
    
    class func newInstance(map: Map) -> Mappable? {
        return SampleModel()
    }
    
    /// Mapping between ObjectMapper (JSON) and the model properties
    func mapping(map: Map) {
        title                   <- map["title"]
        products                <- (map["products"], ArrayTransform<ProductModel>())
    }
}

Thanks

I 'm use not optional forced unwrapping
This is my solution for Swift 4.2 & Xcode 10.1

import RealmSwift
import ObjectMapper

class ArrayTransform<T: RealmSwift.Object>: TransformType where T: Mappable {
    typealias Object = List<T>
    typealias JSON = Array<AnyObject>
    
    /**
     - Parameter value: JSON Value
     - Returns: if value is `nil` or not Array will be return empty List<T>
    */
    func transformFromJSON(_ value: Any?) -> Object? {
        let result = Object()
        guard let _value = value,
            let objectArray = _value as? Array<AnyObject> else { return result }

        let mapper = Mapper<T>()
        
        for object in objectArray {
            //if model is `nil` continue to next object
            guard let model = mapper.map(JSONObject: object) else {
                continue
            }
            
            result.append(model)
        }
        
        return result
    }
    
    /**
     - Parameter value: RealmSwift Object
     - Returns: if value is `nil` or empty will be return empty Array<AnyObject>
     */
    func transformToJSON(_ value: Object?) -> JSON? {
        var result = JSON()
        guard let _value = value, _value.count > 0 else { return  result }
        
        result = _value.map { $0 }
      
        
        return result
    }
}