swift_generator 0.1.2

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "swift_generator"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/genswift

@@ -0,0 +1,34 @@
+#!/usr/bin/env ruby
+
+require 'commander/import'
+require 'swift_generator'
+
+# assistant = Objc2swiftAssistant::Assistant.new
+# assistant.runFromCommandLine
+
+program :name, 'genswift'
+program :version, '1.0.0'
+program :description, 'Basic CLI interface to the swift_generator gem'
+
+command :generate do |c|
+  c.syntax = 'genswift specfile'
+  c.description = 'Generate Swift files based upon a JSON specification file.'
+  c.option '--out STRING', String, 'The root of the generated Swift source. Overrides the setting in the spec file.'
+  c.action do |args, options|
+    options.default :out => nil
+
+    if args.size == 1
+      a = SwiftGenerator::Generator.new( Pathname.new(args[0]), options.out )
+      a.generate()
+    elsif args.size > 1
+      puts( "specfile must be specified" )
+    else
+      puts( "more than one argument provided to command" )
+    end
+  end
+end
+
+default_command :generate
+# end
+
+

data/bin/setup

@@ -0,0 +1,7 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/swift_generator.rb

@@ -0,0 +1,23 @@
+require "swift_generator/version"
+
+require "swift_generator/specfile_parser"
+
+module SwiftGenerator
+
+  class Generator
+
+    attr_accessor :spec_file_path
+    attr_accessor :out_dir_path
+
+    def initialize( spec_file_path, out_dir_str )
+      @spec_file_path = spec_file_path
+      @out_dir_path = out_dir_str         # may be nil
+    end
+
+    def generate
+      parser = SpecfileParser.new( @spec_file_path )
+      parser.process_specfile( )
+
+    end
+  end
+end

data/lib/swift_generator/code_generation/POSOTest.rb

@@ -0,0 +1,8 @@
+require_relative 'swift_class_generation'
+
+gen = SwiftDefinitionSet.new( 'output' )
+
+c1 = swift_class.new( gen, 'User', ['USIWireData'] )
+
+puts c1
+puts gen

data/lib/swift_generator/code_generation/SwiftFileTemplate.dna

@@ -0,0 +1,157 @@
+$definition_file = nil
+
+require 'fileutils'
+require "swift_generator/version"
+require "swift_generator/code_generation/swift_class_generation"
+
+
+module SwiftGenerator
+
+def write_files_for_definition_set( definition_set )
+    for _, f in definition_set.output_files
+        SwiftGenerator::writeGeneratedFile( f )
+    end
+end
+
+
+module_function :write_files_for_definition_set
+
+# files = YAML::load(File.open(ARGV[0]))
+
+# Templated Output Methods
+def write_element( element )
+  if( element.kind_of? SwiftClass )
+    SwiftGenerator::write_class( element )
+  elsif( element.kind_of? SwiftEnum )
+    SwiftGenerator::write_enum( element )
+  end
+end
+
+module_function :write_element
+
+def writeGeneratedFile( f )
+    return if ( f.is_user_file && File.exist?( f.file_path ))
+
+./!output( f.file_path )
+
+.//
+.//  @{f.file_name}
+.//  @{f.company_name}
+if $definition_file
+.//
+.//  Generated from @{$definition_file} on @{Time.now.strftime("%d/%m/%Y %H:%M")}
+end
+if f.include_editing_warnings
+    if !f.is_user_file
+.//
+.//  WARNING: This entire file is generated. DO NOT EDIT.
+    else
+.//
+.//  This is a user-editable generated file. Delete or rename this file to have a new empty file generated
+    end
+end
+.//
+.//  Copyright (c) @{Time.now.strftime("")} @{f.company_name}, Inc. All rights reserved.
+.//
+
+    for import_statement in f.import_statements.sort
+.&{import_statement}
+    end
+
+  for element in f.elements
+    SwiftGenerator::write_element(element)
+  end
+end
+
+module_function :writeGeneratedFile
+
+
+def write_enum( e )
+.
+.
+.&{e.access_control_modifier}enum @{e.type_name}
+    if e.inheritance_list.count > 0
+.    /+ : @{e.inheritance_list.join( ", " )}
+    end
+.    /+  {
+
+  e.enum_cases.each_with_index do |enum_case, _|
+    enum_case.declaration_lines().each do |declLine|
+.    &{declLine}
+    end
+  end
+
+  e.properties.each_with_index do |prop, i|
+.
+    prop.declaration_lines().each do |declLine|
+.    &{declLine}
+    end
+  end
+
+  SwiftGenerator::write_methods( e.methods )
+. }
+end
+
+module_function :write_enum
+
+
+def write_class( c )
+.
+.
+.&{c.access_control_modifier}class @{c.type_name}
+    if c.inheritance_list.count > 0
+.    /+ : @{c.inheritance_list.join( ", " )}
+    end
+.    /+  {
+
+  SwiftGenerator::write_property_declarations( c.transient_properties, "Transient" )
+  SwiftGenerator::write_property_declarations( c.persistent_properties, "Persistent" )
+
+  SwiftGenerator::write_methods( c.initializers )
+  SwiftGenerator::write_methods( c.methods )
+.}
+
+end
+
+module_function :write_class
+
+
+def write_property_declarations( properties, property_type_label )
+  properties.each_with_index do |prop, i|
+    if i == 0
+.
+.    // MARK: @{property_type_label} Properties
+    end
+    prop.declaration_lines().each do |declLine|
+.    &{declLine}
+    end
+  end
+
+end
+
+module_function :write_property_declarations
+
+
+def write_methods( methods )
+    methods.each_with_index do |m, i|
+        overrideString = m.override ? 'override ' : ''
+.
+    if ! m.comment.nil?
+.   &{m.comment}
+    end
+    args = m.argStr.nil? || m.argStr.empty? ? m.argStr : ' ' + m.argStr + ' '
+.   &{overrideString}&{m.access_control_modifier}&{m.func_fragment} @{m.name}(&{args})
+    if ! (m.returns.nil? || m.returns.length == 0 )
+.     /+ -> @{m.returns}
+    end
+.   /+ {
+    m.bodyLines.each do |line|
+.        &{line}
+    end
+.    }
+  end
+end
+
+module_function :write_methods
+
+end

data/lib/swift_generator/code_generation/ToRemove/generate.bash

@@ -0,0 +1,41 @@
+#!/bin/bash
+cd "$(dirname "$0")"
+pwd
+
+SOURCE_FILES=../Useful/Shared/Models/Generated/*.swift
+for f in $SOURCE_FILES
+do
+  rm $f
+done
+
+TEST_FILES=../UsefulTests/Shared/Models/Generated/*.swift
+for f in $TEST_FILES
+do
+  rm $f
+done
+
+./Tools/ribosome --rna PlainOldSwiftObjects.dna > PlainOldSwiftObjects.rna
+./PlainOldSwiftObjects.rna
+
+
+for f in $SOURCE_FILES
+do
+    echo " "
+    echo "--------------------------------------------------------------------------------"
+    echo " "
+    echo "Generated Source File: $f"
+    echo " "
+  # take action on each file. $f store current file name
+  cat $f
+done
+
+for f in $TEST_FILES
+do
+    echo " "
+    echo "--------------------------------------------------------------------------------"
+    echo " "
+    echo "Generated Test File: $f"
+    echo " "
+ # take action on each file. $f store current file name
+  cat $f
+done

data/lib/swift_generator/code_generation/code_generation_common.rb

@@ -0,0 +1,6 @@
+$SwiftIntegralTypes = [:Int, :UInt, :Int32, :UInt32, :Int64, :UInt64]
+$SwiftLegalEnumTypes = $SwiftIntegralTypes << :String
+
+$SwiftLegalEnumTypeNames = $SwiftLegalEnumTypes.map{ |typeSymbol| typeSymbol.to_s }
+
+$UNIMPLEMENTED = "SYSTEM ERROR: method missing"

data/lib/swift_generator/code_generation/swift_class_generation.rb

@@ -0,0 +1,1589 @@
+require 'rubygems'
+require 'json'
+require_relative 'swift_types'
+require_relative 'code_generation_common'
+require_relative 'swift_types'
+
+module SwiftGenerator
+
+# A Swift File to be generated. This file contains one or more elements
+# Elements can be classes (Future: Structs, Enums, Functions)
+class SwiftFile
+	attr_accessor :file_name
+	attr_accessor :file_path
+	attr_accessor :elements
+	attr_accessor :import_statements
+	attr_accessor :is_user_file
+	attr_accessor :company_name
+  attr_accessor :include_editing_warnings
+
+	def initialize (name, root_path, is_user_file:false, company_name:"<My Entity>")
+		name += '.swift' unless name.end_with?( '.swift' )
+		@file_name = name
+		@file_path = File.join(root_path, @file_name)
+
+    puts( "--- SwiftFile name = #{name} root_path = #{root_path} file_path = #{@file_path}" )
+
+    @is_user_file = is_user_file
+		@elements = []
+		@import_statements = []
+    @include_editing_warnings = false
+    @company_name = company_name
+	end
+
+	def add_element(swift_class)
+		@elements << swift_class
+	end
+
+	# Called before all other generation-time methods.
+	# Give user-defined elements ( classes, etc. ) the opportunity to construct other related or required elements
+	def prepare_supporting_elements
+		@elements.each do |element|
+			element.prepare_supporting_elements
+		end
+	end
+
+	def prepare_for_generation()
+		@elements.each do |element|
+			element.prepare_for_generation
+		end
+	end
+
+	# @param [String] module_name
+	def add_import(module_name)
+		import_statement = "import #{module_name}"
+		return if @import_statements.include?(import_statement)
+		@import_statements << import_statement
+	end
+end
+
+# Base class for Struct, Enum and Class
+class SwiftNonPrimitive
+	attr_accessor :definition_set
+	attr_accessor :type_name
+	attr_accessor :specified_type_name
+	attr_accessor :access_control_modifier
+	attr_accessor :inheritance_list		# Raw parent list
+
+	attr_accessor :file_name
+	attr_accessor :source_file
+
+	attr_accessor :properties
+	attr_accessor :initializers
+	attr_accessor :methods
+
+	attr_accessor :class_characteristics
+	attr_accessor :is_user_editable
+	attr_accessor :is_test_element
+
+	def initialize( definition_set, specified_type_name, inheritance_list=[], type_name:nil,
+					file_name: nil, characteristics:[], is_user_editable: false, is_test_element: false )
+		@definition_set = definition_set
+		@specified_type_name = specified_type_name
+		@inheritance_list = inheritance_list
+
+		@type_name = type_name.nil? ? specified_type_name : type_name
+		@file_name = file_name
+		#@access_control_modifier = 'public '
+		@access_control_modifier = ''
+
+		@class_characteristics = [* characteristics]
+		@is_user_editable = is_user_editable
+		@is_test_element = is_test_element
+
+		@methods = []
+		@initializers = []
+		@properties = []
+		@post_super_initializations = {}
+
+		# This class will now be added to the definition set and its source file
+		# The source file will be created if needed.
+		@definition_set.add_element(self)
+
+		# Source file is now set
+		@source_file.add_import('Foundation')
+	end
+
+	def transient_properties()
+		@properties.select { |prop| !prop.is_persistent }
+	end
+
+	def persistent_properties()
+		@properties.select { |prop| prop.is_persistent }
+	end
+
+	def comparable_properties()
+		persistent_properties
+	end
+
+	def resolve_property_types()
+		@properties.each do |property|
+			property.resolve_type
+		end
+	end
+
+	def swift_type_symbol
+		return @type_name.to_sym
+	end
+
+	def make_property_type; raise $UNIMPLEMENTED; end
+	def prepare_supporting_elements; raise $UNIMPLEMENTED; end
+	def prepare_for_generation; raise $UNIMPLEMENTED; end
+end
+
+$default_swift_enum_characteristics = [:indexed, :make_test_support]
+
+class SwiftEnum < SwiftNonPrimitive
+	attr_accessor :enum_flavor
+	attr_accessor :enum_raw_type
+	attr_accessor :is_integral_type
+
+	attr_accessor :enum_cases
+
+	def initialize( definition_set, type_name, inheritance_list=[], file_name: nil, characteristics:[]  )
+		determine_raw_type( inheritance_list )
+		super( definition_set, type_name, inheritance_list=inheritance_list, file_name: file_name, characteristics:characteristics )
+
+		@is_integral_type = $SwiftIntegralTypes.include? @enum_raw_type
+		@enum_cases = []
+	end
+
+
+	def add_case( enum_case )
+		@enum_cases << enum_case
+	end
+
+	def make_property_type()
+		# Make a type for this class so that references to this class can be resolved
+		# Includes code for hashing this enum
+
+		test_value_lambda = lambda{|num| make_test_value(num) }
+		property_type = StringEnumPropertyType.new( self, @enum_raw_type.to_sym, test_value:test_value_lambda )
+		property_type.hashable_value_lambda = lambda{|var_name, is_optional|
+			if is_optional
+				return "#{var_name}?.toIndex()"
+			else
+				return "#{var_name}.toIndex()"
+			end
+		}
+
+		#TODO Fix this Horror
+		property_type.custom_unmarshaling = lambda{|var_name, unwrapped_var|
+			"#{var_name} = #{unmarshal_expression(unwrapped_var)}"
+		}
+
+		return self.swift_type_symbol, property_type
+	end
+
+	def determine_raw_type(inheritace_list)
+		return if inheritace_list.empty?
+		possible_raw_type = inheritace_list[0]
+		@enum_raw_type = possible_raw_type if $SwiftLegalEnumTypeNames.include? possible_raw_type
+	end
+
+
+	def prepare_supporting_elements()
+	end
+
+
+	def prepare_for_generation()
+		make_enumeration_properties
+		make_indexing_methods
+		# make_test_support() if characteristics.include? :make_test_support
+	end
+
+
+	def make_enumeration_properties()
+		# The count of all cases for convenience
+		p_count = SwiftProperty.new(self, 'caseCount',  :Int, initialization_value:self.enum_cases.count )
+		p_count.property_qualifiers = 'static'
+
+		# An array of all cases in declaration order
+		case_list = @enum_cases.map{ |a_case| ".#{a_case.case_name}" }.join( ', ' )
+		p_all_cases = SwiftProperty.new(self, 'allCases', self.type_name.to_sym , collection_type: :array,  initialization_value:"[#{case_list}]" )
+		p_all_cases.property_qualifiers = 'static'
+	end
+
+	def make_indexing_methods
+		# .toIndex() -> Int
+		to_index_m = SwiftMethod.new(self, "toIndex", '', 'Int', comment: '/// USI standard enum method to get the case count')
+		to_index_m << '// Support for indexing for hashing, etc.'
+
+		to_index_m << "switch( self ) {"
+		i=0
+		for a_case in self.enum_cases
+			to_index_m._i "case #{a_case.case_name} : return #{i}"
+			to_index_m._o ""
+			i += 1
+		end
+		to_index_m.ii "default : return 0"
+		to_index_m << "}"
+
+		# Not Yet Required
+		# static fromIndex( Int ) -> Enum
+		# from_index_m = SwiftMethod.new(self, "fromIndex", 'index:Int', type_name, comment: '/// USI standard enum method to get the case count')
+		# from_index_m.func_qualifiers = 'static'
+		# from_index_m << "return #{@type_name}.allCases[ index ]"  #Note: this is not safe
+	end
+
+	# JSON marshaling support
+	def marshal_expression( name )
+		#Probably only works for String enums
+		return "#{name}.rawValue"
+	end
+
+	def unmarshal_expression( name )
+		#Probably only works for String enums
+		return "#{@type_name}( rawValue:#{name} )"
+	end
+
+	# Test Support
+	def make_test_value(index)
+		return "#{@type_name}.allCases[ #{index} % #{@type_name}.caseCount ]"
+	end
+end
+
+class SwiftEnumCase
+	attr_accessor :enum_def
+	attr_accessor :raw_value
+	attr_accessor :case_name
+
+	def initialize( enum_def, case_name, raw_value=nil )
+		@enum_def = enum_def
+		@raw_value = raw_value
+		@case_name = case_name
+
+		enum_def.add_case( self )
+	end
+
+	def declaration_lines()
+		raw_value_literal = @raw_value
+		case enum_def.enum_raw_type
+			when "String"
+				raw_value_literal = "\"#{@raw_value}\""
+		end
+
+		if raw_value.nil?
+			["case #{@case_name}"]
+		else
+			["case #{@case_name} = #{raw_value_literal}"]
+		end
+	end
+
+end
+
+
+
+
+# class SwiftNumericEnum
+# 	attr_accessor :enum_flavor
+# 	attr_accessor :enum_raw_type
+# 	attr_accessor :enum_cases
+#
+# 	def initialize( definition_set, type_name, file_name: nil, characteristics:[]  )
+# 		super( definition_set, type_name, file_name: file_name, characteristics:characteristics )
+# 	end
+#
+# 	def prepare_supporting_elements()
+# 		super()
+# 	end
+#
+# 	def prepare_for_generation()
+# 		super()
+# 	end
+# end
+#
+# class SwiftStringEnum
+# 	attr_accessor :enum_flavor
+# 	attr_accessor :enum_raw_type
+# 	attr_accessor :enum_cases
+#
+# 	def initialize( definition_set, type_name, file_name: nil, characteristics:[]  )
+# 		super( definition_set, type_name, file_name: file_name, characteristics:characteristics )
+# 	end
+#
+# 	def prepare_supporting_elements()
+# 		super()
+# 	end
+#
+# 	def prepare_for_generation()
+# 		super()
+# 	end
+# end
+
+
+#
+#
+#
+#
+# 		@do_generate = true
+#
+# 		@properties = []
+# 		@methods = []
+# 		#@access_control_modifier = 'public '
+# 		@access_control_modifier = ''
+#
+# 		# This class will now be added to the definition set and its source file
+# 		# The source file will be created if needed.
+#
+# 		# Source file is now set
+# 		@source_file.add_import('Foundation')
+# 		@supporting_elements_created = false
+# 	end
+# end
+
+
+# class SwiftStringEnum < SwiftEnum
+#
+# end
+
+
+#change
+	$default_swift_class_characteristics = []
+	# $default_swift_class_characteristics = [:json_serializable, :comparable, :make_test_class, :auto_describing]
+
+# A Swift Class to be generated.
+class SwiftClass < SwiftNonPrimitive
+	attr_accessor :parent_class			# The parent class.
+
+	# Initializations
+	attr_accessor :post_super_initializations
+
+	# Associated classes
+	attr_accessor :auto_test_class
+
+	# Convenience
+	attr_accessor :access_control_modifier
+	attr_accessor :do_generate
+	attr_accessor :supporting_elements_created
+	attr_accessor :test_object_method
+
+
+	# @param [SwiftDefinitionSet] definition_set
+	# @param [String] type_name
+	# @param [Array] inherited_from
+	# @param [Object] file_name
+	# @param [Object] characteristics
+	# @param [Object] is_test_class
+	def initialize (definition_set, specified_type_name, inheritance_list=[], file_name: nil,
+					characteristics:$default_swift_class_characteristics, is_test_element: false, is_user_editable: false)
+		# Generate the type name from the specified type name. Non-editable classes are prepended with "_"
+		prefix = characteristics.include?(:create_user_class) ? '_' : ''
+		type_name = prefix + specified_type_name
+
+		super( definition_set, specified_type_name, inheritance_list=inheritance_list, type_name:type_name, file_name:file_name, characteristics:characteristics, is_user_editable:is_user_editable, is_test_element: is_test_element )
+
+		@parent_class = nil
+
+		#change for known & legal combinations of characteristics
+		abort( "illegal class characteristics" ) if ! definition_set.characteristics_are_legal(@class_characteristics )
+
+		# prefix = @class_characteristics.include?(:create_user_class) ? '_' : ''
+		# @type_name = prefix + @specified_type_name
+
+		@do_generate = true
+
+		@supporting_elements_created = false
+	end
+
+	def post_super_init( values_for_properties )
+		@post_super_initializations.merge!( values_for_properties )
+	end
+
+	def add_simple_class_property( name, type, value:nil, mutability: :var, override:false)
+		# class variables not supported. Use class property instead.
+		p = SwiftProperty.new(self, name, type, mutability )
+		p.property_qualifiers = 'class'
+		p.property_qualifiers = "override #{p.property_qualifiers}" if override
+		p.getter_body = "return #{value}"
+	end
+
+	def make_property_type()
+		# Make a type for this class so that references to this class can be resolved
+		type_symbol = @type_name.to_sym
+
+		test_value_lambda = lambda{|num|
+			ensure_test_object_method
+			test_object_method_call(num)
+		}
+		property_type = SwiftObjectPropertyType.new( self, :NSDictionary, test_value:test_value_lambda )
+		property_type.hashable_value_lambda = lambda{|var_name, is_optional|
+			if is_optional
+				return "#{var_name}?.hashValue()"
+			else
+				return "#{var_name}.hashValue()"
+			end
+		}
+
+		#TODO Fix this Horror
+		property_type.custom_unmarshaling = lambda{|var_name, unwrapped_var| [
+			"#{var_name} = #{unmarshal_expression(unwrapped_var)}"
+		]}
+
+		return self.swift_type_symbol, property_type
+	end
+
+
+	# JSON marshaling support
+	def insert_marshal_expression( m, unwrapped_var, destination )
+		#Probably only works for String enums
+		m << "let objectDictionary = NSMutableDictionary()"
+		m << "#{unwrapped_var}.marshalToJSON( objectDictionary )"
+		m << "#{destination} = objectDictionary"
+	end
+
+	def insert_unmarshal_expression( m, unwrapped_value, destination )
+		#Probably only works for String enums
+		m << "let temp = #{self.type_name}()"
+		m << "temp.unmarshalFromJSON( #{unwrapped_value} )"
+		# TODO: validate?
+		m << "#{destination} = temp"
+	end
+
+	# TODO: Future? unwrapping and success variable.
+	# def insert_unmarshal_expression( m, jsonElement, destination, success_boolean )
+	# 	#Probably only works for String enums
+	# 	m << "if let objectDictionary = #{jsonElement} as? NSDictionary {"
+	# 	m._i "let temp = #{self.type_name}()"
+	# 	m << "temp.unmarshalFromJSON( objectDictionary )"
+	# 	m << "#{destination} = temp"
+	# 	m._o "#{success_boolean} = true"
+	# 	m << "} else {"
+	# 	m.ii "#{success_boolean} = false"
+	# 	m << "}"
+	# end
+
+	# Called before all other generation-time methods.
+	# Construct other related or required elements
+	# May be called more than once
+	def prepare_supporting_elements()
+		return if @supporting_elements_created
+
+		create_user_classes if @class_characteristics.include?(:create_user_class)
+		create_test_classes if ! @is_test_element && @class_characteristics.include?(:make_test_class)
+
+		@supporting_elements_created = true
+	end
+
+
+	def resolve_inheritance()
+		return if @inheritance_list.empty?
+		@parent_class = @definition_set.elements_by_name[ @inheritance_list[0] ]
+	end
+
+
+	def prepare_for_generation()
+		create_init_methods
+		create_equality_methods if @class_characteristics.include?(:comparable)
+		prepare_marshaling_code if @class_characteristics.include?(:json_serializable)
+		create_description_methods  if @class_characteristics.include?(:auto_describing)
+		create_copy_methods if @class_characteristics.include?(:json_serializable)
+	end
+
+
+	def create_init_methods()
+	# Only no-argument init methods & optional properties are currently supported
+
+	return if @post_super_initializations.empty?
+	init_m = SwiftInitializer.new(self, 'init', nil, override: true)
+	init_m << "super.init()"
+	keys = @post_super_initializations.keys.sort!
+	keys.each do |prop_name|
+			init_m << "#{prop_name} = #{@post_super_initializations[prop_name]}"
+		end
+	end
+
+
+	def create_equality_methods()
+		comparable_super = super_has_characteristics(:comparable)
+
+		#func isEqual(_ anObject: AnyObject!) -> Bool
+		is_equals_method = SwiftMethod.new(self, 'isEqual', 'other:AnyObject!', 'Bool', override: true)
+		is_equals_method << "if( other == nil ) { return false }"
+		other_typed_var = "other#{@type_name}"
+		if comparable_super
+			is_equals_method << "if( !super.isEqual( other )) { return false }"
+		end
+
+		is_equals_method << ""
+		is_equals_method << "if let #{other_typed_var} = other as? #{@type_name} {"
+
+		comparable_properties.each do |property|
+			other_name = "#{other_typed_var}.#{property.property_name}"
+
+			if property.property_type.nil?
+				puts( property.property_name )
+			end
+
+			if property.collection_type == :array
+				is_equals_method.ii "if( !optionalArraysEqual( #{property.property_name}, #{other_name} )) { return false }"
+			else
+				custom_test = property.property_type.custom_equality_test
+				if custom_test.nil?
+					is_equals_method.ii "if( self.#{property.property_name} != #{other_name} ) { return false }"
+				else
+					is_equals_method.ii "if( !#{custom_test.call(property.property_name, other_name)} ) { return false }"
+				end
+			end
+		end
+		is_equals_method << "" << "\treturn true"
+		is_equals_method << "} else {"
+		is_equals_method << "\treturn false"
+		is_equals_method << "}"
+
+		#- (NSUInteger)hash
+		hash_method = SwiftMethod.new(self, 'hashValue', '', 'Int', override: comparable_super)
+		hash_method << "var hasher = Hasher() // Hasher must be mutable" << ""
+
+		if comparable_super
+			hash_method << 'hasher.hashIn( super.hashValue() )'
+		end
+
+		comparable_properties.each do |property|
+			hash_element = lambda{ |var_name, is_optional| "hasher.hashIn( #{property.property_type.hashable_value(var_name, is_optional )} )"}
+
+			if( property.collection_type.nil?)
+				hash_method <<  hash_element.call(property.property_name, property.mutability_type.must_be_unwrapped)
+			elsif( property.collection_type == :array )
+				arrayName = "#{property.property_name}Array"
+				hash_method << "if let #{arrayName} = #{property.property_name} {"
+				hash_method._i "for element in #{arrayName} {"
+				hash_method.ii  hash_element.call("element", false)
+				hash_method._o "}"
+				hash_method << "}"
+			else
+				hash_method << "ERROR: hashing of #{property.collection_type.to_s} collections not supported."
+			end
+		end
+		hash_method << "" << "return hasher.hash"
+	end
+
+	def prepare_marshaling_code()
+		super_does_json = super_has_characteristics(:json_serializable)
+
+		# Reader & Writer
+		reader = SwiftMethod.new(self, 'unmarshalFromJSON', 'jsonObject:NSDictionary', nil, override: super_does_json )
+		writer = SwiftMethod.new(self, 'marshalToJSON', 'jsonObject:NSMutableDictionary', nil, override: super_does_json )
+
+		if super_does_json
+			reader << "super.unmarshalFromJSON( jsonObject )"
+			writer << "super.marshalToJSON( jsonObject )"
+		end
+
+		writer << "" << "jsonObject[\"objectType\"] = \"#{@type_name}\""
+
+		persistent_properties.each do |prop|
+			prop.unmarshal_code(reader)
+			prop.marshal_code(writer)
+		end
+
+		# Object Reader
+		object_reader = SwiftMethod.new(self, "objectFromJSON", 'newObjData:NSDictionary', @specified_type_name, override: super_does_json )
+		object_reader.func_qualifiers = 'class'
+
+		object_reader << "let newObj = #{@specified_type_name}()"
+		object_reader << "newObj.unmarshalFromJSON( newObjData )"
+		object_reader << 'return newObj'
+
+		# Array Reader & Writer
+
+		# Array Reader
+		array_reader = SwiftMethod.new(self, "arrayFromJSON", 'json:NSArray', '[USIBaseModel]', override: super_does_json )
+		array_reader.func_qualifiers = 'class'
+
+		array_reader << "var newObjects = [#{@specified_type_name}]()"
+		array_reader << "for objEntry in json {"
+		array_reader << "\tlet newObj = #{@specified_type_name}()"
+
+		array_reader << "\tif let newObjData = objEntry as? NSDictionary {"
+		array_reader << "\t\tnewObj.unmarshalFromJSON( newObjData )"
+		array_reader << "\t\tnewObjects.append( newObj )"
+
+		array_reader << "\t}"
+		array_reader << '}'
+		array_reader << 'return newObjects'
+
+		# Array Writer
+		array_writer = SwiftMethod.new(self, "arrayToJSON", "array:[USIBaseModel]", 'NSMutableArray', override: super_does_json )
+		array_writer.func_qualifiers = 'class'
+
+		array_writer << 'var dataArray = NSMutableArray()'
+
+		array_writer << "for obj in array {"
+		array_writer << "\tlet objData = NSMutableDictionary()"
+		array_writer << "\tobj.marshalToJSON( objData )"
+		array_writer << "\tdataArray.addObject( objData )"
+		array_writer << "}"
+		array_writer << "return dataArray"
+
+		end
+
+	# Copy methods
+	def create_copy_methods()
+		copy_to_method_name = "copyTo#{@type_name}"
+
+		# The copy method - calls copyTo so that we can avoid duplicating copy code
+		copy_m = SwiftMethod.new(self, 'copy', '', 'AnyObject', override: true)
+		copy_m << "let theCopy = #{@type_name}()"
+		copy_m << "#{copy_to_method_name}( theCopy )"
+		copy_m << "return theCopy"
+
+		copy_to_m = SwiftMethod.new(self, copy_to_method_name, "other: #{@type_name}", nil, override:false)
+
+		if !@parent_class.nil?
+			copy_to_m << "super.copyTo#{@parent_class.type_name}( other )"
+		end
+		self.persistent_properties.each do |prop|
+			copy_to_m << "\tother.#{prop.property_name} = #{prop.property_name}"
+		end
+	end
+
+	# Description methods
+	def create_description_methods()
+
+		# description
+		dm = SwiftMethod.new(self, 'description', 'indent:String="        ", diagnostic:Bool=false', "NSString", override:!@parent_class.nil? )
+		dm << "let d = NSMutableString()"
+
+		if @parent_class.nil?
+		else
+			dm << "d.appendString( super.description(indent:indent, diagnostic:diagnostic) )"
+		end
+
+		dm << "if( diagnostic ) {"
+		dm.ii	"d.appendString( \"    properties of class #{@type_name} :\\n\")"
+		dm.ii	"d.appendString( \"\\(indent)- none -\\n\")" if @properties.empty?
+		dm << "}"
+
+		self.persistent_properties.each do |prop|
+			if( prop.is_optional )
+				prop_value = prop.property_name
+				if prop.property_type.swift_kind == :enum
+					dm << "d.appendString( \"\\(indent)#{prop.property_name} = \\(prettyFormatEnum( #{prop_value} ))\\n\" )"
+				else
+					dm << "d.appendString( \"\\(indent)#{prop.property_name} = \\(prettyFormat( #{prop_value} ))\\n\" )"
+				end
+
+			else
+				dm << "d.appendString( \"\\(indent)#{prop.property_name} = \\(#{prop_value})\\n\" )"
+			end
+		end
+
+		dm << "return d"
+
+		# className
+		type_name_m = SwiftMethod.new(self, 'className', nil, 'String', override:!@parent_class.nil? )
+		type_name_m .func_qualifiers = 'class'
+		type_name_m << "return \"#{@type_name}\""
+	end
+
+	# User class generation
+	def create_user_classes
+		user_class_characteristics = @class_characteristics - [:make_test_class, :create_user_class]
+		@user_editable_class = SwiftClass.new(@definition_set, @specified_type_name, [@type_name], characteristics:user_class_characteristics, is_user_editable:true )
+		end
+
+	# Test class generation
+	def create_test_classes()
+		tc = @auto_test_class = SwiftUnitTestClass.new(@definition_set, self, 'AutoGenerated')
+	end
+
+	# Utility
+	def super_has_characteristics( *characteristics )
+		remaining_characteristics = characteristics
+		ancestor = @parent_class
+		until  ancestor.nil? || remaining_characteristics.empty?
+			remaining_characteristics = (remaining_characteristics - ancestor.class_characteristics)
+			ancestor = ancestor.parent_class
+		end
+
+		return remaining_characteristics.empty?
+	end
+
+	def set_test_values( set_method, variable_name, indexing_number )
+		if ! @parent_class.nil?
+			indexing_number = @parent_class.set_test_values( set_method, variable_name, indexing_number )
+		end
+
+		comparable_properties.each do |prop|
+			set_method << "#{variable_name}.#{prop.property_name} = #{prop.make_test_value(indexing_number)}"
+			indexing_number += 1
+		end
+
+		return indexing_number
+	end
+
+	# Test Support ( Here for embedded objects )
+	def ensure_test_object_method
+		#NOTE: this method is in the global test support class
+		return if !@test_object_method.nil?
+
+		comment = "/// Create a test #{@type_name} object with varying values"
+		# e.g. func makeTestUser() -> User
+		obj_name = "test#{@type_name}"
+		m = SwiftMethod.new(@definition_set.test_support_class, "makeTest#{@type_name}", '_ index:Int = 0', "#{@type_name}", comment: comment)
+		m.func_qualifiers = 'class'
+
+		m << "let #{obj_name} = #{@type_name}()" << ""
+		prop_index = 1
+
+		set_test_values( m, obj_name, 1 )
+
+		m << "" << "return #{obj_name}"
+		@test_object_method = m
+	end
+
+	def test_object_method_call(index=0)
+		argStr = index == 0 ? '' : "#{index}"
+		"#{@definition_set.test_support_class.type_name}.makeTest#{@type_name}(#{argStr})"
+	end
+end
+
+
+class SwiftUnitTestClass < SwiftClass
+	attr_accessor :tested_class
+	attr_accessor :tested_class_name
+
+	# @param [SwiftClass] tested_class
+	# @param [String] class_purpose
+	def initialize(definition_set, tested_class, class_purpose)
+		@tested_class = tested_class
+		@tested_class_name = tested_class.type_name
+		class_name = tested_class.specified_type_name + class_purpose + "Test"
+		super(definition_set, class_name, ['XCTestCase'], file_name: class_name, is_test_element: true, characteristics:[] )
+		@source_file.add_import('XCTest')
+	end
+
+
+	def prepare_for_generation()
+		super()
+
+		generate_copy_test
+		generate_marshal_test
+		generate_json_round_trip_test
+	end
+
+	def generate_copy_test
+		ensure_test_object_method
+
+		comment = "/// Test copy() implementation. Requires isEqual()"
+		m = SwiftMethod.new(self, "testCopying", '', '', comment: comment)
+		m << "let original = #{test_object_method_call()}"
+		m << "let theCopy = original.copy() as #{@tested_class_name}"
+
+		m << "if( theCopy != original ) {"
+		m << "    print(\"original\")"
+		m << "    print(original.description())"
+		m << "    print(\"theCopy\")"
+		m << "    print(theCopy.description())"
+		m << "}"
+
+		m << "XCTAssertEqual( theCopy, original, \"copy does not match original\" )"
+	end
+
+
+	def generate_marshal_test
+		ensure_test_object_method
+
+		comment = "/// Test Marshaling to JSON-compatible dictionaries"
+		m = SwiftMethod.new(self, 'testMarshaling', '', nil, comment: comment)
+		m << "let original = #{test_object_method_call()}"
+
+		m << "" << "let jsonObject = NSMutableDictionary()"
+		m << "original.marshalToJSON( jsonObject )" << ""
+
+		m << "let theCopy = #{@tested_class_name}()"
+		m << "theCopy.unmarshalFromJSON( jsonObject )" << ""
+
+		m << "if( theCopy != original ) {"
+		m._i 	"print(\"original\")"
+		m << 	"print(original.description())"
+		m << 	"print(\"theCopy\")"
+		m._o 	"print(theCopy.description())"
+		m << "}"
+
+		m << "XCTAssertEqual( theCopy, original, \"unmarshalled copy does not match original\" )"
+
+	end
+
+
+	def generate_json_round_trip_test
+		ensure_test_object_method
+		comment = "/// Test JSON round trip for a single object"
+		m = SwiftMethod.new(self, 'testJSONRoundTrip', '', nil, comment: comment)
+		m << "let original = #{test_object_method_call()}"
+
+		m << "" << "let jsonObject = NSMutableDictionary()"
+		m << "original.marshalToJSON( jsonObject )" << ""
+
+		m << "var error: NSError? = nil"
+		m << "let jsonData = NSJSONSerialization.dataWithJSONObject(jsonObject, options: nil, error:&error) as NSData?"
+		m << "XCTAssertNotNil( jsonData, \"Could not serialize to NSData\" )"
+
+		m << "var deserializedJSON:AnyObject? = NSJSONSerialization.JSONObjectWithData(jsonData!, options: nil, error:&error)"
+		m << "XCTAssertNotNil( deserializedJSON, \"Could not serialize to NSData\" )"
+
+		m << "if let newJSONObject = deserializedJSON as? NSDictionary {"
+		m._i 	"let theCopy = #{@tested_class_name}()"
+		m << 	"theCopy.unmarshalFromJSON( newJSONObject )"
+
+		m << 	"if( theCopy != original ) {"
+		m._i 		"print(\"original\")"
+		m << 		"print(original.description())"
+		m << 		"print(\"theCopy\")"
+		m._o 		"print(theCopy.description())"
+		m << 	"}"
+
+		m._o 	"XCTAssertEqual( theCopy, original, \"unmarshalled object should be == to original\" )"
+		m << "} else {"
+		m.ii 	"XCTAssert( false, \"JSON did not deserialize to an NSDictionary\" )"
+		m << "}"
+	end
+
+	# Utility
+	def ensure_test_object_method
+		@tested_class.ensure_test_object_method
+	end
+
+
+	def test_object_method_call(index=0)
+		@tested_class.test_object_method_call( index )
+	end
+end
+
+
+class SwiftProperty
+	attr_accessor :swift_class
+	attr_accessor :property_name
+	attr_accessor :property_type_symbol
+	attr_accessor :property_type
+	attr_accessor :mutability_type
+	attr_accessor :property_qualifiers
+	attr_accessor :is_persistent
+	attr_accessor :collection_type
+	attr_accessor :required
+
+	attr_accessor :initialization_value
+	attr_accessor :getter_body
+	attr_accessor :setter_body
+	attr_accessor :rest_omit
+
+
+	def initialize(swift_class, property_name, property_type_symbol, mutability= :let, initialization_value:nil, collection_type: nil, required: true, rest_omit:nil )
+		@swift_class = swift_class
+		@property_name = property_name
+		@property_type_symbol = property_type_symbol
+		@property_type = nil
+		# @property_type = swift_class.definition_set.property_type_for_symbol(property_type)
+		@mutability_type = SwiftDefinitionSet.mutability_types[mutability]
+		@is_persistent = false
+		@collection_type = collection_type
+		@required = required
+
+		#@access_control_modifier = 'public '
+		@access_control_modifier = ''
+		@property_qualifiers = nil
+
+		@initialization_value = initialization_value
+		@getter_body = nil
+		@setter_body = nil
+		@rest_omit = rest_omit
+
+		swift_class.properties << self
+	end
+
+	def declaration_lines
+
+		qualifiers = []
+		qualifiers += [*@property_qualifiers] if !@property_qualifiers.nil?
+		qualifiers << @mutability_type.mutability
+
+		declaration = "#{qualifiers.join(' ')} #{@property_name} : #{full_type_specifier()}"
+
+		# Initial Value
+		initial_value = @initialization_value
+		if !initial_value.nil?
+			if( collection_type == :array )
+				if( @mutability_type.mutability_id == :optional )
+					# Initialize variable arrays to empty by default
+					initial_value = "[]"
+				end
+
+			end
+		end
+
+		if (!initial_value.nil?)
+			declaration += " = #{initial_value}"
+		end
+
+		# Computed Properties
+		if !( @getter_body.nil? && @setter_body.nil? )
+			declaration = [declaration + " {"]
+
+			if !@getter_body.nil?
+				declaration << "\tget {"
+				declaration.concat([*@getter_body].map { |line| "\t\t" + line })
+				declaration << "\t}"
+			end
+
+			if !@setter_body.nil?
+				declaration << "" unless @getter_body.nil?
+				declaration << "\tset {"
+				declaration.concat([*@setter_body].map { |line| "\t\t" + line })
+				declaration << "\t}"
+			end
+
+			declaration << "}"
+		end
+
+		return [*declaration]
+	end
+
+	def full_type_specifier
+		# Apply Collection
+		full_type_name = @property_type.swift_type_name
+		if @collection_type == :array
+			full_type_name = "[#{full_type_name}]"
+		end
+
+		"#{full_type_name}#{@mutability_type.declaration_wrapping}"
+	end
+
+
+	def resolve_type()
+		@property_type = @swift_class.definition_set.property_type_for_symbol(@property_type_symbol)
+		abort( "No property type found for #{@property_type_symbol.to_s}") if @property_type.nil?
+	end
+
+
+	def make_test_value(index)
+		if @collection_type.nil?
+			return @property_type.make_test_value(index)
+		else
+			return '[]'
+		end
+	end
+
+	def property_declared_type
+		@property_type.swift_type_name + @mutability_type.declaration_wrapping
+	end
+
+	#Utility
+	def is_array_of_nsobject
+		(@collection_type == :array) && (@property_type.swift_kind == :class)
+	end
+
+	def is_optional
+		return @mutability_type.mutability_id == :optional
+	end
+end
+
+
+class SwiftPersistentProperty < SwiftProperty
+	attr_accessor :json_key
+
+	def initialize(swift_class, property_name, property_type, mutability=:let, initialization_value=nil, collection_type: nil, json_key: nil, rest_omit:nil  )
+		super(swift_class, property_name, property_type, mutability, initialization_value:initialization_value, collection_type: collection_type, rest_omit:rest_omit)
+		@is_persistent = true
+		@json_key = json_key.nil? ? property_name : json_key
+	end
+
+	def marshal_code(marshal_method)
+		if @collection_type.nil?
+			marshal_single_element(marshal_method)
+		else
+			case @collection_type
+
+				when :array
+					marshal_array(marshal_method)
+
+				when :dictionaryByString
+
+				else
+					puts "ERROR: Unknown collection_type: #{@collection_type.to_s}"
+			end
+		end
+	end
+
+	def marshal_single_element(marshal_method)
+		return if self.rest_omit == :omit
+		omit_null = self.rest_omit == :omit_if_null
+
+			case @property_type.swift_kind
+			when :primitive
+				case @mutability_type.mutability_id
+					when :optional
+						marshal_template(marshal_method, omit_null){ |m, unwrapped_var, destination|
+							m.<< "#{destination} = #{unwrapped_var}"
+						}
+					else
+						marshal_method << "ERROR Non-optional properties not yet supported"
+				end
+
+			when :enum
+				case @mutability_type.mutability_id
+					when :optional
+						marshal_template(marshal_method, omit_null){ |m, unwrapped_var, destination|
+							# TODO: Make this look like the class property method below
+							m << "#{destination} = #{@property_type.enum.marshal_expression( unwrapped_var)}"
+						}
+					else
+						marshal_method << "ERROR Non-optional properties not yet supported"
+				end
+
+			when :class
+				case @mutability_type.mutability_id
+					when :optional
+						marshal_template(marshal_method, omit_null){ |m, unwrapped_var, destination|
+							@property_type.swift_class.insert_marshal_expression( m, unwrapped_var, destination)
+						}
+					else
+						marshal_method << "ERROR Non-optional properties not yet supported"
+				end
+
+			when :struct
+				return 'Structs not yet supported'
+
+			else
+				puts "ERROR: Unknown swift_kind: #{@property_type.swift_kind.to_s}"
+		end
+	end
+
+
+	def marshal_array(marshal_method)
+		return if self.rest_omit == :omit
+		omit_null = self.rest_omit == :omit_if_null
+
+		case @property_type.swift_kind
+			when :primitive
+				if( @mutability_type.mutability_id != :optional )
+					marshal_method << "ERROR Non-optional properties not yet supported"
+				end
+
+				marshal_template(marshal_method, omit_null) { |m, unwrapped_var, destination|
+					m << "var newArray = NSMutableArray()"
+					m << "for element in #{unwrapped_var} {"
+					m.ii 	"newArray.addObject( element as #{@property_type.serialized_json_type.to_s} )"
+					m << "}"
+					m << "#{destination} = newArray"
+				}
+
+			when :class
+				if( @mutability_type.mutability_id != :optional )
+					marshal_method << "ERROR Non-optional properties not yet supported"
+				end
+
+				marshal_template(marshal_method, omit_null) { |m, unwrapped_var, destination|
+					m.ii "#{destination}  = #{@property_type.swift_type_name}.arrayToJSON(#{unwrapped_var})"
+				}
+
+			when :struct
+				return 'Arrays of structs not yet supported'
+
+			when :enum
+				if( @mutability_type.mutability_id != :optional )
+					marshal_method << "ERROR Non-optional properties not yet supported"
+				end
+
+				marshal_template(marshal_method, omit_null) { |m, unwrapped_var, destination|
+					m << "var newArray = NSMutableArray()"
+					m << "for element in #{unwrapped_var} {"
+					m.ii 	"newArray.addObject( #{@property_type.enum.marshal_expression( "element" )} )"
+					m << "}"
+					m << "#{destination} = newArray"
+				}
+
+			else
+				puts "ERROR: Unknown swift_kind: #{@property_type.swift_kind.to_s}"
+		end
+	end
+
+
+	def marshal_template(marshal_method, omit_null, &detail)
+		m = marshal_method
+		unwrapped_var = @property_name + "Val"
+		destination = "jsonObject[ \"#{@json_key}\" ]"
+		m << ""
+		m << "if let #{unwrapped_var} = #{@property_name} {"
+
+		if self.property_type.custom_marshaling.nil?
+			m.indent += 1
+			detail.call( m, unwrapped_var, destination)
+			m.indent -= 1
+		else
+			m.ii self.property_type.custom_marshaling.call( destination ,unwrapped_var)
+		end
+		m << "} else {"
+		if( ! omit_null )
+			m << "\t#{destination} = NSNull()"
+		else
+			m << "// Omit nil values"
+		end
+
+		m << "}"
+	end
+
+
+	def unmarshal_code(unmarshal_method)
+		if @collection_type.nil?
+			unmarshal_single_element(unmarshal_method)
+		else
+			case @collection_type
+				when :array
+					unmarshal_array(unmarshal_method)
+
+				when :dictionaryByString
+
+				else
+					puts "ERROR: Unknown collection_type: #{@collection_type.to_s}"
+			end
+		end
+	end
+
+	def unmarshal_single_element(unmarshal_method)
+		m = unmarshal_method
+		case @property_type.swift_kind
+			when :primitive, :enum
+				case @mutability_type.mutability_id
+					when :optional
+						unwrapped_var = @property_name + "Val"
+						m << ""
+						m << "if let #{unwrapped_var} = jsonObject[ \"#{@json_key}\" ] as? #{@property_type.serialized_json_type} {"
+
+						if self.property_type.custom_unmarshaling.nil?
+							m.ii "#{@property_name} = #{unwrapped_var} "
+						else
+							m.ii self.property_type.custom_unmarshaling.call( @property_name, unwrapped_var )
+						end
+
+						m << "} else {"
+						m.ii 	"#{@property_name} = nil"
+						m << "}"
+					else
+						m << "ERROR Non-optional properties not yet supported"
+				end
+
+				# if let aVal = jsonObject[ "a" ] as? Int {
+				# 	a = aVal
+				# } else {
+				# 	a = nil
+				# }
+
+				# if @property_type.auto_bridged
+				# 	return "#{@property_name} = jsonObject[ \"#{@json_key}\" ]"
+				# else
+				return "#{@property_name} = jsonObject[ \"#{@json_key}\" ] as #{property_declared_type}"
+			# end
+
+			when :class
+				case @mutability_type.mutability_id
+					when :optional
+						unwrapped_var = @property_name + "Val"
+						# TODO: check for success
+						# m << "var success = false"
+						m << "if let #{unwrapped_var} = jsonObject[ \"#{@json_key}\" ] as? #{@property_type.serialized_json_type} {"
+						self.property_type.swift_class.insert_unmarshal_expression( m, unwrapped_var, @property_name )
+						m << "} else {"
+						m.ii 	"#{@property_name} = nil"
+						m << "}"
+					else
+						m << "ERROR Non-optional properties not yet supported"
+				end
+
+			when :struct
+				return 'Structs not yet supported'
+
+			else
+				puts "ERROR: Unknown swift_kind: #{@property_type.swift_kind.to_s}"
+		end
+	end
+
+	def unmarshal_array(unmarshal_method)
+		m = unmarshal_method
+		case @property_type.swift_kind
+			when :primitive
+				if( @mutability_type.mutability_id == :optional )
+					unwrapped_var = @property_name + "Array"
+					prop_type = @property_type.swift_type_name
+					json_type = @property_type.serialized_json_type.to_s
+					m << ""
+					m << "if let #{unwrapped_var} = jsonObject[ \"#{@property_name}\" ] as? NSArray {"
+					m._i 	"var newArray = [#{prop_type}]()"
+					m << 	"for element in #{unwrapped_var} {"
+					m._i 		"if let typedElement = element as? #{json_type} {"
+					if @property_type.auto_bridged
+						m.ii 		"newArray.append( typedElement )"
+					else
+						m._i 		"if let unmarshalledValue = typedElement as #{prop_type} {"
+						m.ii 			"newArray.append( unmarshalledValue )"
+						m << 		"} else {"
+						m.ii			"println( \"Error in converting \\(typedElement) to #{prop_type}\")"
+						m._o 		"}"
+					end
+					m <<		"} else {"
+					m.ii			"println( \"Unexpected json value: \\(element) for #{prop_type}\")"
+					m._o 		"}"
+					m << 	"}"
+					m._o 	"#{@property_name} = newArray"
+					m << "} else {"
+					m.ii 	"#{@property_name} = nil"
+					m << "}"
+				else
+					m << "ERROR Non-optional properties not yet supported"
+				end
+			when :class
+				if( @mutability_type.mutability_id == :optional )
+					unwrapped_var = @property_name + "Array"
+					prop_type = @property_type.swift_type_name
+					m << ""
+					m << "if let #{unwrapped_var} = jsonObject[ \"#{@property_name}\" ] as? NSArray {"
+					m.ii 	"#{@property_name} = #{prop_type}.arrayFromJSON( #{unwrapped_var} ) as? [#{prop_type}]"
+					m << "} else {"
+					m.ii 	"#{@property_name} = nil"
+					m << "}"
+				else
+					m << "ERROR Non-optional properties not yet supported"
+				end
+
+			when :struct
+				m << 'ERROR Arrays of structs not yet supported'
+
+			when :enum
+				if( @mutability_type.mutability_id == :optional )
+					unwrapped_var = @property_name + "Array"
+					prop_type = @property_type.swift_type_name
+					m << ""
+					m << "if let #{unwrapped_var} = jsonObject[ \"#{@property_name}\" ] as? NSArray {"
+					m._i 	"var newArray = [#{prop_type}]()"
+					m << 	"for element in #{unwrapped_var} {"
+					m._i 		"if let typedElement = element as? NSString {"
+					m._i 			"if let enumValue = #{@property_type.enum.unmarshal_expression( "typedElement" )} {"
+					m.ii 				"newArray.append( enumValue )"
+					m << 			"} else {"
+					m.ii				"println( \"Error in converting \\(typedElement) to #{prop_type}\")"
+					m._o 			"}"
+					m <<		"} else {"
+					m.ii			"println( \"Unexpected json value: \\(element) for #{prop_type}\")"
+					m._o 		"}"
+					m << 	"}"
+					m._o 	"#{@property_name} = newArray"
+					m << "} else {"
+					m.ii 	"#{@property_name} = nil"
+					m << "}"
+				else
+					m << "ERROR Non-optional properties not yet supported"
+				end
+			else
+				puts "ERROR: Unknown swift_kind: #{@property_type.swift_kind.to_s}"
+		end
+	end
+
+
+	def all_collection_types
+		[
+			:array,
+			:dictionaryByString
+		]
+	end
+end
+
+class SwiftMethodBase
+	attr_accessor :name
+	attr_accessor :argStr
+	attr_accessor :override
+	attr_accessor :returns
+	attr_accessor :comment
+
+	attr_accessor :access_control_modifier
+	attr_accessor :func_qualifiers
+
+	attr_accessor :indent
+	attr_accessor :bodyLines
+
+
+	def initialize (swift_element, name, argStr, returns, override: false, comment: nil)
+		@name = name
+		@argStr = argStr
+		@returns = returns
+		@override = override
+		@comment = comment
+
+		@indent = 0
+		@bodyLines = []
+
+		@access_control_modifier = ''
+	end
+
+
+	def << (*line_or_lines)
+		line_or_lines = line_or_lines.flatten()
+		line_or_lines.each do |line|
+			new_line = ("\t" * @indent) + line
+			@bodyLines << new_line
+		end
+		@bodyLines = @bodyLines.flatten()
+	end
+
+	def _i (*line_or_lines)
+		@indent += 1
+		self << line_or_lines
+	end
+
+	def _o (*line_or_lines)
+		self << line_or_lines
+		@indent -= 1
+	end
+
+	def ii (*line_or_lines)
+		@indent += 1
+		self << line_or_lines
+		@indent -= 1
+	end
+
+	def func_fragment()
+		return 'func' if func_qualifiers.nil?
+		return [*func_qualifiers].join( ' ' ) + ' func'
+	end
+end
+
+class SwiftInitializer < SwiftMethodBase
+	def initialize (swift_element, name, argStr, override: false, comment: nil)
+		super(swift_element, name, argStr, nil, override:override, comment:comment)
+		swift_element.initializers << self
+	end
+
+	def func_fragment()
+		return [*func_qualifiers].join( ' ' )
+	end
+end
+
+
+class SwiftMethod < SwiftMethodBase
+
+	def initialize (swift_element, name, argStr, returns, override: false, comment: nil)
+		super(swift_element, name, argStr, returns, override:override, comment:comment)
+		swift_element.methods << self
+	end
+
+	def func_fragment()
+		return 'func' if func_qualifiers.nil?
+		return [*func_qualifiers].join( ' ' ) + ' func'
+	end
+end
+
+
+# Variable & Property Mutability
+class MutabilityType
+	attr_accessor :mutability_id
+	attr_accessor :mutability
+	attr_accessor :declaration_wrapping
+	attr_accessor :must_be_unwrapped
+
+	def initialize(mutability_id, mutability, declaration_wrapping, must_be_unwrapped: false)
+		@mutability_id = mutability_id
+		@mutability = mutability
+		@declaration_wrapping = declaration_wrapping
+		@must_be_unwrapped = must_be_unwrapped
+	end
+end
+
+
+# The single coordinator object for a set of swift file generations
+class SwiftDefinitionSet
+	attr_accessor :generated_root
+	attr_accessor :generated_test_root
+	attr_accessor :generated_user_root
+
+	attr_accessor :make_unknown_types
+
+	attr_accessor :all_class_characteristics
+	attr_accessor :output_files
+
+	attr_accessor :elements_by_name		# All non-primitives
+	# attr_accessor :classes_by_name		# Only classes
+	# attr_accessor :enums_by_name		# Only enums
+
+	attr_accessor :types_by_symbol
+	attr_accessor :make_more_supporting_elements
+
+	attr_accessor :test_support_class
+
+	attr_accessor :company_name
+
+	def self.mutability_types
+		{
+			let: MutabilityType.new(:let, 'let', ''),
+			var: MutabilityType.new(:var, 'var', ''),
+			optional: MutabilityType.new(:optional, 'var', '?', must_be_unwrapped: true),
+			unwrapped: MutabilityType.new(:unwrapped, 'var', '!')
+		}
+	end
+
+	def self.collection_types
+		{
+			list: "list",
+			idList: "idList"
+		}
+	end
+
+	def initialize( generated_root:nil, generated_user_root:nil, generated_test_root:nil)
+		@generated_root = File.expand_path(generated_root)
+		@generated_test_root = File.expand_path(generated_test_root) unless generated_test_root.nil?
+		@generated_user_root = File.expand_path(generated_user_root) unless generated_test_root.nil?
+
+		@make_unknown_types = false
+
+		@output_files = {}
+		@elements_by_name = {}
+		@make_more_supporting_elements = true
+
+		@all_class_characteristics = [
+			:json_serializable,
+			:comparable,
+			:make_test_class,
+			:create_user_class
+		]
+
+		@types_by_symbol = {}
+
+		initial_property_types.each do |propType|
+			@types_by_symbol[propType.swift_type_symbol] = propType
+    end
+
+    @company_name = "<defined in SwiftDefinitionSet.company_name>"
+	end
+
+	def run_generation_sequence
+		prepare_output_paths
+		prepare_supporting_elements
+		resolve_property_types
+		resolve_inheritance
+
+		prepare_for_generation
+		resolve_property_types
+	end
+
+	def prepare_output_paths
+		# Create / empty the generated output directories
+		paths = []
+		paths << @generated_root unless @generated_root.nil?
+		paths << @generated_test_root unless @generated_test_root.nil?
+		paths.each do |path|
+			FileUtils.mkdir_p(path)
+			Dir.foreach(path) do |entry|
+				file_path = File.join(path, entry)
+				if (File::ftype(file_path) == "file")
+					puts "deleting " + file_path
+					File.delete(file_path)
+				end
+			end
+		end
+	end
+
+	# Called first during code generation. Note that this method may lead to the creation of new files
+  def prepare_supporting_elements()
+    unless @generated_test_root.nil?
+      @test_support_class = SwiftClass.new(self, 'AutoGeneratedTestSupport', [], characteristics:[], is_test_element: true ) unless
+
+          while @make_more_supporting_elements do
+            @make_more_supporting_elements = false
+            original_output_files = @output_files.dup
+            original_output_files.each do |_, swiftFile|
+              swiftFile.prepare_supporting_elements
+            end
+          end
+    end
+
+	end
+
+	# Called during code generation.
+	def resolve_inheritance()
+		@elements_by_name.each do |_, element|
+			element.resolve_inheritance if element.respond_to? :resolve_inheritance
+		end
+	end
+
+	def resolve_property_types()
+		@elements_by_name.each do |_, element|
+			element.resolve_property_types if element.respond_to? :resolve_property_types
+		end
+	end
+
+	def prepare_for_generation
+		@output_files.each do |_, swiftFile|
+			swiftFile.prepare_for_generation
+		end
+	end
+
+	def add_element(swift_element)
+		file_name = swift_element.file_name || swift_element.type_name
+		the_file = file_for_name( file_name, swift_element.is_test_element, swift_element.is_user_editable )
+		the_file.add_element(swift_element)
+		swift_element.source_file = the_file
+
+		# if swift_element.is_a? SwiftEnum
+		# 	@enums_by_name[swift_element.type_name] = swift_element
+		# elsif swift_element.is_a? SwiftClass
+		# 	@elements_by_name[swift_element.type_name] = swift_element
+		# end
+
+		@elements_by_name[swift_element.type_name] = swift_element
+		@make_more_supporting_elements = true
+
+		# # Make a type for this class so that references to this class can be resolved
+		# type_symbol = swift_element.type_name.to_sym
+		# element_property_type = SwiftPropertyType.new( type_symbol, :NSDictionary, swift_kind: :class, test_value:nil )
+		# @types_by_symbol[type_symbol] = element_property_type
+
+		(type_symbol, property_type) = swift_element.make_property_type
+		@types_by_symbol[type_symbol] = property_type
+	end
+
+	# def add_json_serializable_class(serializable_class)
+	# 	@json_serializable_classes << serializable_class
+	# end
+
+	def file_for_name(name, is_test_element, is_user_editable)
+		if( is_test_element )
+			abort( "User-modifiable test classes are not generated" ) if is_user_editable
+			file_dir = @generated_test_root
+		else
+			if( is_user_editable )
+				file_dir = @generated_user_root
+			else
+				file_dir = @generated_root
+			end
+		end
+
+		@output_files[name] ||= SwiftFile.new(name, file_dir, is_user_file:is_user_editable, company_name:@company_name)
+		return @output_files[name]
+	end
+
+	def property_type_for_symbol(symbol)
+		resolved = @types_by_symbol[symbol]
+		if resolved.nil?
+			if @make_unknown_types
+				resolved = make_unknown_type( symbol  )
+			else
+				puts( "ERROR: Unknown symbol: #{symbol.to_s}")
+			end
+		end
+
+		resolved
+	end
+
+	def make_unknown_type( symbol )
+		property_type = SwiftPropertyType.new( symbol, :NSDictionary )		#TODO: NSDictionary? for unknown type?
+		@types_by_symbol[ symbol ] = property_type
+		property_type
+	end
+
+	# General purpose
+	def characteristics_are_legal( characteristics )
+		unknown_characteristics = (characteristics - @all_class_characteristics)
+		unknown_characteristics.empty?
+	end
+end
+
+end
+