How to use rawType method of RawTypeRepository class

...24  let isOverridable: Bool25  let hasSelfConstraint: Bool26  let isMockable: Bool27  28  private let rawType: RawType29  30  init?(from dictionary: StructureDictionary,31        rootKind: SwiftDeclarationKind,32        rawType: RawType,33        moduleNames: [String],34        rawTypeRepository: RawTypeRepository,35        typealiasRepository: TypealiasRepository) {36    guard let kind = SwiftDeclarationKind(from: dictionary), kind.isMethod,37      // Can't override static method declarations in classes.38      kind.typeScope == .instance39      || kind.typeScope == .class40      || (kind.typeScope == .static && rootKind == .protocol)41      else { return nil }42    43    guard let name = dictionary[SwiftDocKey.name.rawValue] as? String, name != "deinit"44      else { return nil }45    self.name = name46    let isInitializer = name.hasPrefix("init(")47    self.isInitializer = isInitializer48    49    let accessLevel = AccessLevel(from: dictionary) ?? .defaultLevel50    self.isMockable =51      accessLevel.isMockableMember(in: rootKind, withinSameModule: rawType.parsedFile.shouldMock)52      || (isInitializer && accessLevel.isMockable) // Initializers cannot be `open`.53    self.accessLevel = accessLevel54    55    let source = rawType.parsedFile.data56    let attributes = Attributes(from: dictionary, source: source)57    guard !attributes.contains(.final) else { return nil }58    self.isDesignatedInitializer = isInitializer && !attributes.contains(.convenience)59    60    let substructure = dictionary[SwiftDocKey.substructure.rawValue] as? [StructureDictionary] ?? []61    self.kind = kind62    self.isOverridable = rootKind == .class63    self.rawType = rawType64    65    // Parse declared attributes and parameters.66    let rawParametersDeclaration: Substring?67    (self.attributes,68     rawParametersDeclaration) = Method.parseDeclaration(from: dictionary,69                                                         source: source,70                                                         isInitializer: isInitializer,71                                                         attributes: attributes)72    73    // Parse return type.74    let (returnType, returnTypeName) = Method.parseReturnType(75      from: dictionary,76      rawType: rawType,77      moduleNames: moduleNames,78      rawTypeRepository: rawTypeRepository,79      typealiasRepository: typealiasRepository)80    self.returnType = returnType81    self.returnTypeName = returnTypeName82    83    // Parse generic type constraints and where clauses.84    self.whereClauses = Method.parseWhereClauses(from: dictionary,85                                                 source: source,86                                                 rawType: rawType,87                                                 moduleNames: moduleNames,88                                                 rawTypeRepository: rawTypeRepository)89    self.genericTypes = substructure90      .compactMap({ structure -> GenericType? in91        guard let genericType = GenericType(from: structure,92                                            rawType: rawType,93                                            moduleNames: moduleNames,94                                            rawTypeRepository: rawTypeRepository)95          else { return nil }96        return genericType97      })98    99    // Parse parameters.100    let (shortName, labels) = Method.parseArgumentLabels(name: name,101                                                         parameters: rawParametersDeclaration)102    self.shortName = shortName103    let parameters = Method.parseParameters(labels: labels,104                                            substructure: substructure,105                                            rawParametersDeclaration: rawParametersDeclaration,106                                            rawType: rawType,107                                            moduleNames: moduleNames,108                                            rawTypeRepository: rawTypeRepository,109                                            typealiasRepository: typealiasRepository)110    self.parameters = parameters111    112    // Parse any containing preprocessor macros.113    if let offset = dictionary[SwiftDocKey.offset.rawValue] as? Int64 {114      self.compilationDirectives = rawType.parsedFile.compilationDirectives.filter({115        $0.range.contains(offset)116      })117    } else {118      self.compilationDirectives = []119    }120    121    // Check whether this method has any `Self` type constraints.122    self.hasSelfConstraint =123      returnTypeName.contains(SerializationRequest.Constants.selfTokenIndicator)124      || parameters.contains(where: { $0.hasSelfConstraints })125  }126  127  private static func parseDeclaration(from dictionary: StructureDictionary,128                                       source: Data?,129                                       isInitializer: Bool,130                                       attributes: Attributes) -> (Attributes, Substring?) {131    guard let declaration = SourceSubstring.key.extract(from: dictionary, contents: source)132      else { return (attributes, nil) }133    134    var fullAttributes = attributes135    var rawParametersDeclaration: Substring?136    137    // Parse parameter attributes.138    let startIndex = declaration.firstIndex(of: "(")139    let parametersEndIndex =140      declaration[declaration.index(after: (startIndex ?? declaration.startIndex))...]141        .firstIndex(of: ")", excluding: .allGroups)142    if let startIndex = startIndex, let endIndex = parametersEndIndex {143      rawParametersDeclaration = declaration[declaration.index(after: startIndex)..<endIndex]144      145      if isInitializer { // Parse failable initializers.146        let genericsStart = declaration[..<startIndex].firstIndex(of: "<") ?? startIndex147        let failable = declaration[declaration.index(before: genericsStart)..<genericsStart]148        if failable == "?" {149          fullAttributes.insert(.failable)150        } else if failable == "!" {151          fullAttributes.insert(.unwrappedFailable)152        }153      }154    }155    156    // Parse return type attributes.157    let returnAttributesStartIndex = parametersEndIndex ?? declaration.startIndex158    let returnAttributesEndIndex = declaration.firstIndex(of: "-", excluding: .allGroups)159      ?? declaration.endIndex160    let returnAttributes = declaration[returnAttributesStartIndex..<returnAttributesEndIndex]161    if returnAttributes.range(of: #"\bthrows\b"#, options: .regularExpression) != nil {162      fullAttributes.insert(.throws)163    }164    165    return (fullAttributes, rawParametersDeclaration)166  }167  168  private static func parseArgumentLabels(name: String, parameters: Substring?)169  -> (shortName: String, labels: [String?]) {170    let (shortName, labels) = name.extractArgumentLabels()171    guard parameters?.isEmpty == false else {172      return (shortName, labels)173    }174    let declarationLabels = parameters?.components(separatedBy: ",", excluding: .allGroups)175      .map({ $0.components(separatedBy: ":", excluding: .allGroups)[0]176            .trimmingCharacters(in: .whitespacesAndNewlines) })177      .map({ $0.components(separatedBy: " ", excluding: .allGroups)[0]178            .trimmingCharacters(in: .whitespacesAndNewlines) })179      .map({ $0 != "_" ? $0 : nil })180    return (shortName, declarationLabels ?? labels)181  }182  183  private static func parseWhereClauses(from dictionary: StructureDictionary,184                                        source: Data?,185                                        rawType: RawType,186                                        moduleNames: [String],187                                        rawTypeRepository: RawTypeRepository) -> [WhereClause] {188    guard let nameSuffix = SourceSubstring.nameSuffixUpToBody.extract(from: dictionary,189                                                                      contents: source),190      let whereRange = nameSuffix.range(of: #"\bwhere\b"#, options: .regularExpression)191      else { return [] }192    return nameSuffix[whereRange.upperBound..<nameSuffix.endIndex]193      .components(separatedBy: ",", excluding: .allGroups)194      .compactMap({ WhereClause(from: String($0)) })195      .map({ GenericType.qualifyWhereClause($0,196                                            containingType: rawType,197                                            moduleNames: moduleNames,198                                            rawTypeRepository: rawTypeRepository) })199  }200  201  private static func parseReturnType(202    from dictionary: StructureDictionary,203    rawType: RawType,204    moduleNames: [String],205    rawTypeRepository: RawTypeRepository,206    typealiasRepository: TypealiasRepository207  ) -> (DeclaredType, String) {208    guard let rawReturnTypeName = dictionary[SwiftDocKey.typeName.rawValue] as? String else {209      return (DeclaredType(from: "Void"), "Void")210    }211    let declaredType = DeclaredType(from: rawReturnTypeName)212    let serializationContext = SerializationRequest213      .Context(moduleNames: moduleNames,214               rawType: rawType,215               rawTypeRepository: rawTypeRepository,216               typealiasRepository: typealiasRepository)217    let qualifiedTypeNameRequest = SerializationRequest(method: .moduleQualified,218                                                        context: serializationContext,219                                                        options: .standard)220    return (declaredType, declaredType.serialize(with: qualifiedTypeNameRequest))221  }222  223  private static func parseParameters(labels: [String?],224                                      substructure: [StructureDictionary],225                                      rawParametersDeclaration: Substring?,226                                      rawType: RawType,227                                      moduleNames: [String],228                                      rawTypeRepository: RawTypeRepository,229                                      typealiasRepository: TypealiasRepository) -> [MethodParameter] {230    guard !labels.isEmpty else { return [] }231    var parameterIndex = 0232    let rawDeclarations = rawParametersDeclaration?233      .components(separatedBy: ",", excluding: .allGroups)234      .map({ $0.trimmingCharacters(in: .whitespacesAndNewlines) })235    return substructure.compactMap({236      let rawDeclaration = rawDeclarations?.get(parameterIndex)237      guard let parameter = MethodParameter(from: $0,238                                            argumentLabel: labels.get(parameterIndex) ?? nil,239                                            parameterIndex: parameterIndex,240                                            rawDeclaration: rawDeclaration,241                                            rawType: rawType,242                                            moduleNames: moduleNames,243                                            rawTypeRepository: rawTypeRepository,244                                            typealiasRepository: typealiasRepository)245        else { return nil }246      parameterIndex += 1247      return parameter248    })249  }250}251extension Method: Hashable {252  /// A hashable version of Method that's unique according to Swift generics when subclassing.253  /// https://forums.swift.org/t/cannot-override-more-than-one-superclass-declaration/22213254  struct Reduced: Hashable {255    let name: String256    let returnTypeName: String257    let parameters: [MethodParameter]258    let attributes: Attributes259    init(from method: Method) {260      self.name = method.name261      self.returnTypeName = method.returnTypeName262      self.parameters = method.parameters263      264      var reducedAttributes = Attributes()265      if method.attributes.contains(.unwrappedFailable) {266        reducedAttributes.insert(.unwrappedFailable)267      }268      self.attributes = reducedAttributes269    }270  }271  272  func hash(into hasher: inout Hasher) {273    hasher.combine(name)274    hasher.combine(returnTypeName)275    hasher.combine(kind.typeScope == .instance)276    hasher.combine(genericTypes)277    hasher.combine(whereClauses)278    hasher.combine(parameters)279  }280  281  static func == (lhs: Method, rhs: Method) -> Bool {282    return lhs.hashValue == rhs.hashValue283  }284}285extension Method: Comparable {286  static func < (lhs: Method, rhs: Method) -> Bool {287    return (288      lhs.whereClauses,289      lhs.returnTypeName,290      lhs.kind.typeScope,291      lhs.parameters,292      lhs.genericTypes,293      lhs.name294    ) < (295      rhs.whereClauses,296      rhs.returnTypeName,297      rhs.kind.typeScope,298      rhs.parameters,299      rhs.genericTypes,300      rhs.name301    )302  }303}304extension Method: Specializable {305  private init(from method: Method, returnTypeName: String, parameters: [MethodParameter]) {306    self.name = method.name307    self.shortName = method.shortName308    self.returnType = DeclaredType(from: returnTypeName)309    self.returnTypeName = returnTypeName310    self.isInitializer = method.isInitializer311    self.isDesignatedInitializer = method.isDesignatedInitializer312    self.accessLevel = method.accessLevel313    self.kind = method.kind314    self.genericTypes = method.genericTypes315    self.whereClauses = method.whereClauses316    self.parameters = parameters317    self.attributes = method.attributes318    self.compilationDirectives = method.compilationDirectives319    self.isOverridable = method.isOverridable320    self.hasSelfConstraint = method.hasSelfConstraint321    self.isMockable = method.isMockable322    self.rawType = method.rawType323  }324  325  func specialize(using context: SpecializationContext,326                  moduleNames: [String],327                  genericTypeContext: [[String]],328                  excludedGenericTypeNames: Set<String>,329                  rawTypeRepository: RawTypeRepository,330                  typealiasRepository: TypealiasRepository) -> Method {331    guard !context.specializations.isEmpty else { return self }332    333    // Function-level generic types can shadow class-level generics and shouldn't be specialized.334    let excludedGenericTypeNames = excludedGenericTypeNames.union(genericTypes.map({ $0.name }))335    336    // Specialize return type.337    let declaredType = DeclaredType(from: returnTypeName)338    let serializationContext = SerializationRequest339      .Context(moduleNames: moduleNames,340               rawType: rawType,341               rawTypeRepository: rawTypeRepository,342               typealiasRepository: typealiasRepository)343    let attributedSerializationContext = SerializationRequest344      .Context(from: serializationContext,345               genericTypeContext: genericTypeContext + serializationContext.genericTypeContext,346               excludedGenericTypeNames: excludedGenericTypeNames,347               specializationContext: context)348    let options: SerializationRequest.Options = [.standard, .shouldSpecializeTypes]349    let qualifiedTypeNameRequest = SerializationRequest(method: .moduleQualified,350                                                        context: attributedSerializationContext,351                                                        options: options)352    let specializedReturnTypeName = declaredType.serialize(with: qualifiedTypeNameRequest)353    354    // Specialize parameters.355    let specializedParameters = parameters.map({356      $0.specialize(using: context,357                    moduleNames: moduleNames,358                    genericTypeContext: genericTypeContext,359                    excludedGenericTypeNames: excludedGenericTypeNames,360                    rawTypeRepository: rawTypeRepository,361                    typealiasRepository: typealiasRepository)362    })363    364    return Method(from: self,365                  returnTypeName: specializedReturnTypeName,366                  parameters: specializedParameters)367  }368}369private extension String {370  func extractArgumentLabels() -> (shortName: String, labels: [String?]) {371    guard let startIndex = firstIndex(of: "("),372      let stopIndex = firstIndex(of: ")") else { return (self, []) }373    let shortName = self[..<startIndex].trimmingCharacters(in: .whitespacesAndNewlines)374    let arguments = self[index(after: startIndex)..<stopIndex]...

...79  let whereClauses: [WhereClause]80  let hasSelfConstraint: Bool81  82  init?(from dictionary: StructureDictionary,83        rawType: RawType,84        moduleNames: [String],85        rawTypeRepository: RawTypeRepository) {86    guard let kind = SwiftDeclarationKind(from: dictionary),87      kind == .genericTypeParam || kind == .associatedtype,88      let name = dictionary[SwiftDocKey.name.rawValue] as? String89      else { return nil }90    91    self.name = name92    93    var constraints: Set<String>94    if let rawInheritedTypes = dictionary[SwiftDocKey.inheritedtypes.rawValue] as? [StructureDictionary] {95      constraints = GenericType.parseInheritedTypes(rawInheritedTypes: rawInheritedTypes,96                                                    moduleNames: moduleNames,97                                                    rawType: rawType,98                                                    rawTypeRepository: rawTypeRepository)99    } else {100      constraints = []101    }102    103    let whereClauses: [WhereClause]104    if kind == .associatedtype {105      whereClauses = GenericType.parseAssociatedTypes(constraints: &constraints,106                                                      rawType: rawType,107                                                      dictionary: dictionary,108                                                      moduleNames: moduleNames,109                                                      rawTypeRepository: rawTypeRepository)110      self.hasSelfConstraint = whereClauses.contains(where: { $0.hasSelfConstraint })111    } else {112      whereClauses = []113      self.hasSelfConstraint = false114    }115    self.whereClauses = whereClauses116    self.constraints = constraints117  }118  119  /// Qualify any generic type constraints, which SourceKit gives us as inherited types.120  private static func parseInheritedTypes(rawInheritedTypes: [StructureDictionary],121                                          moduleNames: [String],122                                          rawType: RawType,123                                          rawTypeRepository: RawTypeRepository) -> Set<String> {124    var constraints = Set<String>()125    for rawInheritedType in rawInheritedTypes {126      guard let name = rawInheritedType[SwiftDocKey.name.rawValue] as? String else { continue }127      let declaredType = DeclaredType(from: name)128      let serializationContext = SerializationRequest129        .Context(moduleNames: moduleNames,130                 rawType: rawType,131                 rawTypeRepository: rawTypeRepository)132      let qualifiedTypeNameRequest = SerializationRequest(method: .moduleQualified,133                                                          context: serializationContext,134                                                          options: .standard)135      constraints.insert(declaredType.serialize(with: qualifiedTypeNameRequest))136    }137    return constraints138  }139  140  /// Manually parse any constraints defined by associated types in protocols.141  private static func parseAssociatedTypes(constraints: inout Set<String>,142                                           rawType: RawType,143                                           dictionary: StructureDictionary,144                                           moduleNames: [String],145                                           rawTypeRepository: RawTypeRepository) -> [WhereClause] {146    var whereClauses = [WhereClause]()147    let source = rawType.parsedFile.data148    guard let declaration = SourceSubstring.key.extract(from: dictionary, contents: source),149      let inferredTypeLowerBound = declaration.firstIndex(of: ":")150      else { return whereClauses }151    152    let inferredTypeStartIndex = declaration.index(after: inferredTypeLowerBound)153    let typeDeclaration = declaration[inferredTypeStartIndex...]154    155    // Associated types can also have generic type constraints using a generic `where` clause.156    let allInferredTypes: String157    if let whereRange = typeDeclaration.range(of: #"\bwhere\b"#, options: .regularExpression) {158      let rawInferredType = typeDeclaration[..<whereRange.lowerBound]159      allInferredTypes = rawInferredType.trimmingCharacters(in: .whitespacesAndNewlines)160      161      whereClauses = typeDeclaration[whereRange.upperBound...]162        .components(separatedBy: ",", excluding: .allGroups)163        .compactMap({ WhereClause(from: String($0)) })164        .map({ GenericType.qualifyWhereClause($0,165                                              containingType: rawType,166                                              moduleNames: moduleNames,167                                              rawTypeRepository: rawTypeRepository) })168    } else { // No `where` generic type constraints.169      allInferredTypes = typeDeclaration.trimmingCharacters(in: .whitespacesAndNewlines)170    }171    let inferredTypes = allInferredTypes172      .substringComponents(separatedBy: ",")173      .map({ $0.trimmingCharacters(in: .whitespacesAndNewlines) })174    175    // Qualify all generic constraint types.176    for inferredType in inferredTypes {177      let declaredType = DeclaredType(from: inferredType)178      let serializationContext = SerializationRequest179        .Context(moduleNames: moduleNames,180                 rawType: rawType,181                 rawTypeRepository: rawTypeRepository)182      let qualifiedTypeNameRequest = SerializationRequest(method: .moduleQualified,183                                                          context: serializationContext,184                                                          options: .standard)185      constraints.insert(declaredType.serialize(with: qualifiedTypeNameRequest))186    }187    188    return whereClauses189  }190  191  /// Type constraints for associated types can contain `Self` references which need to be resolved.192  static func qualifyWhereClause(_ whereClause: WhereClause,193                                 containingType: RawType,194                                 moduleNames: [String],195                                 rawTypeRepository: RawTypeRepository) -> WhereClause {196    let serializationContext = SerializationRequest197      .Context(moduleNames: moduleNames,198               rawType: containingType,199               rawTypeRepository: rawTypeRepository)200    let qualifiedTypeNameRequest = SerializationRequest(method: .moduleQualified,201                                                        context: serializationContext,202                                                        options: .standard)203    204    let declaredConstrainedType = DeclaredType(from: whereClause.constrainedTypeName)205    var qualifiedConstrainedTypeName = declaredConstrainedType206      .serialize(with: qualifiedTypeNameRequest)207    208    let declaredConstraintType = DeclaredType(from: whereClause.genericConstraint)209    var qualifiedConstraintTypeName = declaredConstraintType210      .serialize(with: qualifiedTypeNameRequest)211    212    // De-qualify `Self` constraints.213    let selfPrefix = "\(SerializationRequest.Constants.selfToken)."...

...8import SourceKittenFramework9struct Typealias {10  let name: String11  let typeNames: [String] // Possible that this references another typealias or multiple types.12  let rawType: RawType13  14  init?(from rawType: RawType) {15    guard let kind = SwiftDeclarationKind(from: rawType.dictionary), kind == .typealias,16      let name = rawType.dictionary[SwiftDocKey.name.rawValue] as? String17      else { return nil }18    self.name = name19    self.rawType = rawType20    21    guard let typeNames = Typealias.parseTypeNames(from: rawType.dictionary,22                                                   parsedFile: rawType.parsedFile)23      else { return nil }24    self.typeNames = typeNames25  }26  27  static func parseTypeNames(from dictionary: StructureDictionary,28                             parsedFile: ParsedFile) -> [String]? {29    let source = parsedFile.data30    guard let rawDeclaration = SourceSubstring.nameSuffix.extract(from: dictionary,31                                                                  contents: source),32      let declarationIndex = rawDeclaration.firstIndex(of: "=") else { return nil }33    let declaration = rawDeclaration[rawDeclaration.index(after: declarationIndex)...]34    return declaration.substringComponents(separatedBy: "&").map({35      $0.trimmingCharacters(in: .whitespacesAndNewlines)36    })37  }38}39class TypealiasRepository {40  /// Fully qualified (module) typealias name => `Typealias`41  private(set) var typealiases = [String: Typealias]()42  /// Fully qualified (module) typealias name => actual fully qualified (module) type name43  private var unwrappedTypealiases = Synchronized<[String: [String]]>([:])44  45  /// Start tracking a typealias.46  func addTypealias(_ typeAlias: Typealias) {47    typealiases[typeAlias.rawType.fullyQualifiedModuleName] = typeAlias48  }49  50  /// Returns the actual fully qualified type name for a given fully qualified (module) type name.51  func actualTypeNames(for typeName: String,52                       rawTypeRepository: RawTypeRepository,53                       moduleNames: [String],54                       referencingModuleName: String,55                       containingTypeNames: ArraySlice<String>) -> [String] {56    guard let typeAlias = typealiases[typeName] else { return [typeName] }57    return actualTypeNames(for: typeAlias,58                           rawTypeRepository: rawTypeRepository,59                           moduleNames: moduleNames,60                           referencingModuleName: referencingModuleName,61                           containingTypeNames: containingTypeNames)62  }63  64  /// Returns the actual type name for a given `Typealias`, if one exists.65  func actualTypeNames(for typeAlias: Typealias,66                       rawTypeRepository: RawTypeRepository,67                       moduleNames: [String],68                       referencingModuleName: String,69                       containingTypeNames: ArraySlice<String>) -> [String] {70    // This typealias is already resolved.71    if let actualTypeNames = unwrappedTypealiases.read({72      $0[typeAlias.rawType.fullyQualifiedModuleName]73    }) {74      return actualTypeNames75    }76    77    // Get the fully qualified name of the referenced type.78    let aliasedRawTypeNames = typeAlias.typeNames.map({ typeName -> String in79      guard let qualifiedTypeName = rawTypeRepository80        .nearestInheritedType(named: typeName,81                              moduleNames: moduleNames,82                              referencingModuleName: referencingModuleName,83                              containingTypeNames: containingTypeNames)?84        .findBaseRawType()?.fullyQualifiedModuleName85        else { return typeName }86      return qualifiedTypeName87    })88    89    // Check if the typealias references another typealias.90    let unwrappedNames = aliasedRawTypeNames.flatMap({ aliasedRawTypeName -> [String] in91      guard let aliasedTypealias = typealiases[aliasedRawTypeName] else {92        return [aliasedRawTypeName]93      }94      return actualTypeNames(for: aliasedTypealias,95                             rawTypeRepository: rawTypeRepository,96                             moduleNames: moduleNames,97                             referencingModuleName: aliasedTypealias.rawType.parsedFile.moduleName,98                             containingTypeNames: aliasedTypealias.rawType.containingTypeNames[...])99    })100    unwrappedTypealiases.update {101      $0[typeAlias.rawType.fullyQualifiedModuleName] = unwrappedNames102    }103    return unwrappedNames104  }105}...

1import UIKit2class ViewController: UIViewController {3    override func viewDidLoad() {4        super.viewDidLoad()5        let rawType = RawTypeRepository()6        rawType.rawType()7    }8    override func didReceiveMemoryWarning() {9        super.didReceiveMemoryWarning()10    }

1let rawType = RawTypeRepository()2print(rawType.rawType())3let rawType = RawTypeRepository()4print(rawType.rawType())5let rawType = RawTypeRepository()6print(rawType.rawType())7let rawType = RawTypeRepository()8print(rawType.rawType())9let rawType = RawTypeRepository()10print(rawType.rawType())11let rawType = RawTypeRepository()12print(rawType.rawType())13let rawType = RawTypeRepository()14print(rawType.rawType())15let rawType = RawTypeRepository()16print(rawType.rawType())17let rawType = RawTypeRepository()18print(rawType.rawType())19let rawType = RawTypeRepository()20print(rawType.rawType())21let rawType = RawTypeRepository()22print(rawType.rawType())23let rawType = RawTypeRepository()24print(rawType.rawType())25let rawType = RawTypeRepository()26print(rawType.rawType())27let rawType = RawTypeRepository()28print(rawType.rawType())29let rawType = RawTypeRepository()30print(rawType.rawType())

1let rawType = RawTypeRepository().rawType()2print(rawType)3let rawType = RawTypeRepository().rawType()4print(rawType)5let rawType = RawTypeRepository().rawType()6print(rawType)7let rawType = RawTypeRepository().rawType()8print(rawType)9let rawType = RawTypeRepository().rawType()10print(rawType)11let rawType = RawTypeRepository().rawType()12print(rawType)13let rawType = RawTypeRepository().rawType()14print(rawType)15let rawType = RawTypeRepository().rawType()16print(rawType)17let rawType = RawTypeRepository().rawType()18print(rawType)19let rawType = RawTypeRepository().rawType()20print(rawType)21let rawType = RawTypeRepository().rawType()22print(rawType)23let rawType = RawTypeRepository().rawType()24print(rawType)25let rawType = RawTypeRepository().rawType()26print(rawType)27let rawType = RawTypeRepository().rawType()28print(rawType)

1let rawType = RawTypeRepository.rawType(from: 1)2print(rawType)3let rawType = RawTypeRepository.rawType(from: 2)4print(rawType)5let rawType = RawTypeRepository.rawType(from: 3)6print(rawType)7let rawType = RawTypeRepository.rawType(from: 4)8print(rawType)9let rawType = RawTypeRepository.rawType(from: 5)10print(rawType)11let rawType = RawTypeRepository.rawType(from: 6)12print(rawType)13let rawType = RawTypeRepository.rawType(from: 7)14print(rawType)15let rawType = RawTypeRepository.rawType(from: 8)16print(rawType)17let rawType = RawTypeRepository.rawType(from: 9)18print(rawType)19let rawType = RawTypeRepository.rawType(from: 10)20print(rawType)21let rawType = RawTypeRepository.rawType(from: 11)22print(rawType)23let rawType = RawTypeRepository.rawType(from: 12)24print(rawType)25let rawType = RawTypeRepository.rawType(from: 13)26print(rawType)

1import Foundation2import RawTypeRepository3let rawType = RawTypeRepository()4rawType.rawType()5import Foundation6import RawTypeRepository7let rawType = RawTypeRepository()8rawType.rawType()9import Foundation10import RawTypeRepository11let rawType = RawTypeRepository()12rawType.rawType()13import Foundation14import RawTypeRepository15let rawType = RawTypeRepository()16rawType.rawType()17import Foundation18import RawTypeRepository19let rawType = RawTypeRepository()20rawType.rawType()21import Foundation22import RawTypeRepository23let rawType = RawTypeRepository()24rawType.rawType()25import Foundation26import RawTypeRepository27let rawType = RawTypeRepository()28rawType.rawType()29import Foundation30import RawTypeRepository31let rawType = RawTypeRepository()32rawType.rawType()33import Foundation34import RawTypeRepository35let rawType = RawTypeRepository()36rawType.rawType()37import Foundation38import RawTypeRepository39let rawType = RawTypeRepository()40rawType.rawType()41import Foundation42import RawTypeRepository43let rawType = RawTypeRepository()44rawType.rawType()45import Foundation46import RawTypeRepository47let rawType = RawTypeRepository()48rawType.rawType()49import Foundation50import RawType

1import Foundation2class RawTypeRepository {3func rawType() {4print("Raw Type")5}6}7import Foundation8class RawTypeRepository {9func rawType() {10print("Raw Type")11}12}13import Foundation14class RawTypeRepository {15func rawType() {16print("Raw Type")17}18}19import Foundation20class RawTypeRepository {21func rawType() {22print("Raw Type")23}24}25import Foundation26class RawTypeRepository {27func rawType() {28print("Raw Type")29}30}31import Foundation32class RawTypeRepository {33func rawType() {34print("Raw Type")35}36}37import Foundation38class RawTypeRepository {39func rawType() {40print("Raw Type")41}42}43import Foundation44class RawTypeRepository {45func rawType() {46print("Raw Type")47}48}49import Foundation50class RawTypeRepository {51func rawType() {52print("Raw Type")53}54}55import Foundation56class RawTypeRepository {57func rawType() {58print("Raw Type")59}60}61import Foundation62class RawTypeRepository {63func rawType() {64print("Raw Type")65}66}67import Foundation68class RawTypeRepository {69func rawType() {70print("Raw Type")71}72}73import Foundation74class RawTypeRepository {75func rawType() {76print("Raw Type")

1let rawTypeRepo = RawTypeRepository()2let rawType = RawType()3rawTypeRepo.getRawType(id: 1) { (response, error) in4if error != nil {5print(error!)6}7print(rawType.id)8print(rawType.name)9print(rawType.description)10print(rawType.created_at)11print(rawType.updated_at)12}13let rawTypeRepo = RawTypeRepository()14let rawType = RawType()15rawTypeRepo.updateRawType(id: 1, rawType: rawType) { (response, error) in16if error != nil {17print(error!)18}19print(rawType.id)20print(rawType.name)21print(rawType.description)22print(rawType.created_at)23print(rawType.updated_at)24}25let rawTypeRepo = RawTypeRepository()26rawTypeRepo.deleteRawType(id: 1) { (response, error) in27if error != nil {28print(error!)29}30print("RawType deleted successfully")31}32let rawTypeRepo = RawTypeRepository()33rawTypeRepo.getAllRawTypes { (response, error) in34if error != nil {35print(error!)

1var repo = RawTypeRepository()2var rawType = repo.rawType("String")3println(rawType)4class RawTypeRepository {5    func rawType(name: String) -> String {6        return "RawType for \(name)"7    }8}9var repo = RawTypeRepository()10var rawType = repo.rawType("String")11println(rawType)