Programming Log: 10/1/16

Wednesday, October 26, 2016

Playground and Testing Subquery by NSExpression (2)

My next test is to use Subquery expression to test a one-to-many case. A person may have some friends. My search is to find a person whose friends at least one's birth year is greater than 2011. For this case, the operator any can be used. I have defined an aggregation enumerate type for using operators:


public enum AggregateType: String {
  case any = "any"
  case all = "all"
  case none = "none"
}

By the way, I found in my test that in Subquery, the operator NONE is actually NOT ALL.

One-to-many Relationship Test

Here is my test in Playground:


TestSubquery.TestSubquery(aggregate: .any, birthYearLowLimit: 2011, friendsLevel: 1)

One of Bob's friend Lisa was born in the year of 2012. Therefore, the expected result Bob is found:


Creating Person object and friends...
Person - name: Bob, birthYear: 1997
    Friend - name: Tony, birthYear: 2010, friends: (none)
    Friend - name: Lisa, birthYear: 2012, friends: (none)
Collection expression: {<MyPlayground_Sources.Person: 0x600000262040>}
Collection expression result value: (
    "<MyPlayground_Sources.Person: 0x600000262040>"
)
Person - name: Bob, birthYear: 1997
Predicate: ANY $x.friends.birthYear > 2011
Subquery Expression: SUBQUERY({<MyPlayground_Sources.Person: 0x600000262040>}, $x, ANY $x.friends.birthYear > 2011)
  collection: {<MyPlayground_Sources.Person: 0x600000262040>}
  variable: x
  predicate: ANY $x.friends.birthYear > 2011
Subquery expression result value: Optional(<__NSArrayM 0x600000055240>(
<MyPlayground_Sources.Person: 0x600000262040>
)
)
Subquery expression value as [Person]: [<MyPlayground_Sources.Person: 0x600000262040>] as follows
Person - name: Bob, birthYear: 1997
    Friend - name: Tony, birthYear: 2010, friends: (none)
    Friend - name: Lisa, birthYear: 2012, friends: (none)

I tested other two operators(all and none). The results are all empty array(of Person). That's expected.

Need to Check `Friends` Collection?

What happens if Bob has no friends? I thought. I immediately did the following test with friendsLevel to 0:


TestSubquery.TestSubquery(aggregate: .any, birthYearLowLimit: 2011, friendsLevel: 0)

The result is as expected, empty array. However, to my surprise, I got Bob in an array of [Person] for both ALL and NONE operators:


Creating Person object and friends...
Person - name: Bob, birthYear: 1997
Collection expression: {<MyPlayground_Sources.Person: 0x60000006aec0>}
Collection expression result value: (
    "<MyPlayground_Sources.Person: 0x60000006aec0>"
)
Person - name: Bob, birthYear: 1997
Predicate: ALL $x.friends.birthYear > 2011
Subquery Expression: SUBQUERY({<MyPlayground_Sources.Person: 0x60000006aec0>}, $x, ALL $x.friends.birthYear > 2011)
  collection: {<MyPlayground_Sources.Person: 0x60000006aec0>}
  variable: x
  predicate: ALL $x.friends.birthYear > 2011
Subquery expression result value: Optional(<__NSArrayM 0x60000005e960>(
<MyPlayground_Sources.Person: 0x60000006aec0>
)
)
Subquery expression value as [Person]: [<MyPlayground_Sources.Person: 0x60000006aec0>] as follows
Person - name: Bob, birthYear: 1997

I am not sure if this is a bug in Subquery. Still I don't know how the implementation is done within the predicate. To guarantee the result is correct, I think that further checking if friends being nil is needed. My tests are updated with additional parameter to check friends so that the predicate contains checking if friends being nil.


TestSubquery.TestSubquery(aggregate: .all, birthYearLowLimit: 2011, checkFriendsNull: true, friendsLevel: 0)

The test result is prefect, as-expected if checkFriendsNull parameter is set to true. All tests for other two operators are also correct.


Creating Person object and friends...
Person - name: Bob, birthYear: 1997
Collection expression: {<MyPlayground_Sources.Person: 0x618000069200>}
Collection expression result value: (
    "<MyPlayground_Sources.Person: 0x618000069200>"
)
Person - name: Bob, birthYear: 1997
Predicate: $x.friends != nil AND ALL $x.friends.birthYear > 2011
Subquery Expression: SUBQUERY({<MyPlayground_Sources.Person: 0x618000069200>}, $x, $x.friends != nil AND ALL $x.friends.birthYear > 2011)
  collection: {<MyPlayground_Sources.Person: 0x618000069200>}
  variable: x
  predicate: $x.friends != nil AND ALL $x.friends.birthYear > 2011
Subquery expression result value: Optional(<__NSArrayM 0x608000056b30>(

)
)
Subquery expression value as [Person]: [] as follows

More on One-to-many Relationship Test

The above test has only one condition on friends' birthYear property. How about to add one more condition on property name containing something?

Here is a test with two conditions:


TestSubquery.TestSubquery(aggregate: .any, nameContains: "T", birthYearLowLimit: 2011, checkFriendsNull: true, friendsLevel: 1)

The result of the test is as follows:


Creating Person object and friends...
Person - name: Bob, birthYear: 1997
    Friend - name: Tony, birthYear: 2010, friends: (none)
    Friend - name: Lisa, birthYear: 2012, friends: (none)
Collection expression: {<MyPlayground_Sources.Person: 0x60800007f5c0>}
Collection expression result value: (
    "<MyPlayground_Sources.Person: 0x60800007f5c0>"
)
Person - name: Bob, birthYear: 1997
Predicate: $x.friends != nil AND ANY $x.friends.name CONTAINS "T" AND ANY $x.friends.birthYear > 2011
Subquery Expression: SUBQUERY({<MyPlayground_Sources.Person: 0x60800007f5c0>}, $x, $x.friends != nil AND ANY $x.friends.name CONTAINS "T" AND ANY $x.friends.birthYear > 2011)
  collection: {<MyPlayground_Sources.Person: 0x60800007f5c0>}
  variable: x
  predicate: $x.friends != nil AND ANY $x.friends.name CONTAINS "T" AND ANY $x.friends.birthYear > 2011
Subquery expression result value: Optional(<__NSArrayM 0x618000051af0>(
<MyPlayground_Sources.Person: 0x60800007f5c0>
)
)
Subquery expression value as [Person]: [<MyPlayground_Sources.Person: 0x60800007f5c0>] as follows
Person - name: Bob, birthYear: 1997
    Friend - name: Tony, birthYear: 2010, friends: (none)
    Friend - name: Lisa, birthYear: 2012, friends: (none)

The result seems correct, however, Bob's friend Tony was born in 2010, and another friend Lisa was born in 2012. If you look carefully at the logic of Subquery's predicate, the fetch conditions are done by ANY operator on friends subset separately, i.e., checking only on name on friends, and then only birth year on friends. It does not mean one of friends whose both name and birth year meet fetch conditions.

In my next blog, I'll continue to talk about how to find out that at least one of friend's both properties meed fetch requirement.

Resources

Previous blog: Playground and Testing Subquery by NSExpression (1)
Next blog: Playground and Testing Subquery by NSExpression (3)

Monday, October 24, 2016

Playground and Testing Subquery by NSExpression (1)

I am not sure when Playground was introduced to Xcode, may version 2? I started to use Playground when I moved to Xcode 3. As I mentioned in my previous blog, I would like to find out a better way to test Subquery.

It is very easy to add a Playground in iOS project in Xcode. However, it is hard to test CoreData in Playground. First, CoreData model is not easy to add to Playground, even though I eventually found a way to add CoreData context to Playground. Next difficulty is that I still cannot fig out how to add CoreData managed data classes to Playground. It seems that namespace between my project and Playground are different. I could change all my managed classes to public, but they are not visible nor accessible through CoreData fetch mechanism.

My purpose is to test Subquery. When I found out that Subquery can be built in NSExpression, I immediately think about Playground as a place to do my test.

Playground in Xcode

To add a Playground to Xcode project is very simple: just add a new file to Xcode project and then select Playground. By default, it is called as MyPlayground. There are two folders within the Playground: Sources for all swift source codes, and Resources for resource files.

The following is MyPlayground in Xcode left panel Project navigator view.

On the right panel, the left area on the top is an editable area for swift codes. The right side on the top is an area for immediate result view and the bottom is debug result view.

It is better to organize all the classes, extensions, enumerations and types in swift files under Sources folder. In order to access them from Playground, all the accessible elements have to be public.

During your start test stage, you may need to place all your classes and variables, types, and functions in Playground. In this way, any run-time errors would be highlighted during your test. When all those elements are OK, you can move them to a swift file under Sources folder.

Test Class

As I mentioned in my previous blog, the first parameter in Subquery is a collection of objects, defined by a class. What I found that there are some requirement for the class. First, the class has to inherit from NSObject which has hash code for equality. Secondly, if you need to use operator ALL, ANY, or NONE on collection properties defined in the class, the collection has to be NSSet type.

For my test, I defined the following Person class.


public class Person : NSObject {
    public var name: String
    public let birthYear: Int
    public var friends: NSSet?

    init(name pName: String, birthYear year : Int) {
        name = pName
        birthYear = year
        super.init()
    }
}

I created a swift file TestSubquery.swift in Sources folder. The Person class is defined there. This class is perfect data for Subquery's first parameter: collection. The class has two simple properties name and birthYear, and one collection property friends. In my test, only one person object is created and placed in an array as collection, which is used as the first parameter in Subquery.

friends property is optional NSSet type collection, where actually Person objects are hold or null if no objects. Each person in friends could have friends. In this way, nested friends could be used as many levels of one-to-many relationship for testing. The following is my help function(in TestSubquery.swift file as a module function) to create base data for my tests. The function takes one parameter to control levels of nested friends. I'll explain how to use this parameter to do some interesting tests later.


func getPerson(friendsLevel: Int) -> [Person] {
    print("Creating Person object and friends...")
    let p = Person(name: "Bob", birthYear: 1997)
    if friendsLevel > 0 {
        let p1 = Person(name: "Tony", birthYear: 2010)
        if friendsLevel > 1 {
            let p1_1 = Person(name: "Tony1", birthYear: 2012)
            if friendsLevel > 2 {
                 let p1_1_1 = Person(name: "Tony1_1", birthYear: 2011)
                 let p1_1_2 = Person(name: "Tony1_2", birthYear: 2012)
                 p1_1.friends = NSSet(objects: p1_1_1, p1_1_2)
            }
            let p1_2 = Person(name: "Lisa1", birthYear: 2011)
            p1.friends = NSSet(objects: p1_1, p1_2)
        }
        let p2 = Person(name: "Lisa", birthYear: 2012)
        p.friends = NSSet(objects: p1, p2)
    }
    printPerson(personCollection: [p], printFriends: true)
    return [p]
}

Here is the complete debug information of person data structure (up to 2 levels of nested friends):


Creating Person object and friends...
Person - name: Bob, birthYear: 1997
    Friend - name: Tony, birthYear: 2010
      Friend - name: Tony1, birthYear: 2012
        Friend - name: Tony1_2, birthYear: 2012, friends: (none)
        Friend - name: Tony1_1, birthYear: 2011, friends: (none)
      Friend - name: Lisa1, birthYear: 2011, friends: (none)
    Friend - name: Lisa, birthYear: 2012, friends: (none)

In addition to that, I have added some other types and help functions, as well as a test class TestSubquery. Here I don't need to list all the codes for them. Only test codes will be provided and explained in the following sections.

The complete source code can be downloaded from a link in Resources section.

Test Structure

Subquery NSExpression will be used as an expression object for my tests. To build a Subquery expression, two things have to be prepared: a collection data or expression and a predicate. Therefore, all my tests are defined in the following structure or steps:

get an expression of Person collection,
create a predicate, and
build a Subquery expression, finally evaluate the Subquery expression to get result.

Step 1 is very simple. The collection of Person is obtained from the function getPerson(...) as explained above. In step 2, a predicate is created by one of a list of help functions, which define interested fetch query conditions against to the collection of Person. Finally, it is time ready to build a Subquery expression and then to evaluate its result in step 3.

Let's look at a simple test func defined in TestSubquery class.


public class TestSubquery {
...
  public static func TestSubquery(nameContains: String, birthYearLowLimit: Int, friendsLevel: Int = 2) {
    let e = getColletionExpression(friendsLevel: friendsLevel)
    let predicate = getPredicate(nameContains: nameContains, birthYearLowLimit: birthYearLowLimit)
    let expValue = getSubqueryExpressionResult(collection: e, predicate: predicate)
    printSubqueryExpressionWith(result: expValue)
  }
...
}

At line 4, only one person with a name, birth year and a collection of friends (or null if no friends) is created as collection expression by the help func of getCollectionExpression. At line 5, a predicate with CONTAINS(string) function for name and low limit for birth year is obtained from the help func of getPredicate. With the data collection and predicate ready, at line 6, the help func of getSubqueryExpressionResult builds a Subquery expression and evaluates the result.

Test and Result

To better understand my test, extensive information are printed out in debug window. Here is one example of using above test func in Playground:


TestSubquery.TestSubquery(nameContains: "L", birthYearLowLimit: 2010, friendsLevel: 0)

and the debug information is as follows:


Creating Person object and friends...
Person - name: Bob, birthYear: 1997
Collection expression: {<MyPlayground_Sources.Person: 0x60800007e940>}
Collection expression result value: (
    "<MyPlayground_Sources.Person: 0x60800007e940>"
)
Person - name: Bob, birthYear: 1997
Predicate: $x.name CONTAINS "L" AND $x.birthYear > 2010
Subquery Expression: SUBQUERY({<MyPlayground_Sources.Person: 0x60800007e940>}, $x, $x.name CONTAINS "L" AND $x.birthYear > 2010)
  collection: {<MyPlayground_Sources.Person: 0x60800007e940>}
  variable: x
  predicate: $x.name CONTAINS "L" AND $x.birthYear > 2010
Subquery expression result value: Optional(<__NSArrayM 0x610000046030>(

)
)
Subquery expression value as [Person]: [] as follows

In this test result, line 1-7 explain that only one person "Bob" who is born in 1997 created as in a collection expression. The debug information at line 8 is the print-out during a predicate was obtained. From line 9-12 are information about building Subquery expression, and its three parameters: collection, variable and predicate. The information at remaining lines shows the Subquery expression evaluation result, and detail information as an array of Person or empty if no result.

If test is changed to name containing "B" and birth year greater than 1990, the person Bob will be in the result array:


Creating Person object and friends...
Person - name: Bob, birthYear: 1997
Collection expression: {<MyPlayground_Sources.Person: 0x608000077fc0>}
Collection expression result value: (
    "<MyPlayground_Sources.Person: 0x608000077fc0>"
)
Person - name: Bob, birthYear: 1997
Predicate: $x.name CONTAINS "B" AND $x.birthYear > 1990
Subquery Expression: SUBQUERY({<MyPlayground_Sources.Person: 0x608000077fc0>}, $x, $x.name CONTAINS "B" AND $x.birthYear > 1990)
  collection: {<MyPlayground_Sources.Person: 0x608000077fc0>}
  variable: x
  predicate: $x.name CONTAINS "B" AND $x.birthYear > 1990
Subquery expression result value: Optional(<__NSArrayM 0x60800005cc50>(
<MyPlayground_Sources.Person: 0x608000077fc0>
)
)
Subquery expression value as [Person]: [<MyPlayground_Sources.Person: 0x608000077fc0>] as follows
Person - name: Bob, birthYear: 1997

It is really fun to test Subquery expression in Playground.

Stay tuned for the power of Subquery expression and more interesting findings in my other tests.

Resources

Article by Andrew Bancroft: Using a Core Data Model in Swift Playground
StackOverflow QA: NSExpression Subquery usage
Apple's Developer API Reference: NSExpression
Apple's Developer API Reference: Creating Subquery NSExpression init(...)
Previous blog: One-to-Many Relationship and Subquery
Next blog: Playground and Testing Subquery by NSExpression (2)
Source Code: TestSubquery.swift

Friday, October 21, 2016

One-to-Many Relationship and Subquery

Recently I have to deal with a case in my app. In a one-to-many relationship, I need to define a predicate for many's element to be checked. Here taking Person as a simple class for example, as in following swift class:


class Person {
  var name: String?
  var birthYear: Int?
  var friends: NSSet?
}

the Person class has three properties, name, birthYear, and friends. I use CoreData model to define Person entity. What I need to find a person whose has friends(at least one) and those friends has to meet certain criteria.

For example, find all person who has friends and at least one of friends' birth year is greater than 2000.

Soon I found a solution: I need to build a predicate with function Subquery. For above example, my fetch request can be built in following codes:


let request = NSFetchRequest<Person> = NSFetchRequest(entityName: "Person")
let predicate = NSPredicate(format: "SUBQUERY(friends, $x, $x.name CONTAINS 'David' && $x.birthYear > 2000).@count > 0")
request.predicate = predicate

Subquery Function

The Subquery function is rarely mentioned, however, it is a very powerful to resolve some complicated one-to-many relationship.

The function takes three parameters:

A collection
a variable, and
a predicate

Basically, the function will loop through the collection to verify each element if the predicate condition is true, and all the matched elements will be returned back as a collection or empty if none met. For above example case, the Subquery will enumerate each person in friends collection, return a collection of persons whose name contains "David" and whose (David's) birth year is greater than 2000.

For this kind or more complicated relationships, this function is very concise and powerful. For example, relationship may go one more level deeper: friends' friends whose name contains "Lisa" and whose (Lisa's) birth year is greater than 2005. For this case, nested Subquery can be used. That is, a Subquery contains another Subquery to verify one more deep relationship:


let request = NSFetchRequest<Person> = NSFetchRequest(entityName: "Person")
let predicate = NSPredicate(format: "SUBQUERY(friends, $x, 
  SUBQUERY($x.friends, $y, $y.name CONTAINS 'Lisa' && $y.birthYear > 2005).@count > 0).@count > 0")
request.predicate = predicate

The Subquery function can further use ALL, ANY or NONE operator in the third predicate parameter on collection property for more complicated predicate conditions.


SUBQUERY(friends, $x, $x.friends != nil && ALL $x.friends.birthYear > 2000)
SUBQUERY(friends, $x, $x.friends != nil && ANY $x.friends.birthYear > 2000)
SUBQUERY(friends, $x, $x.friends != nil && NONE $x.friends.birthYear > 2000)

Operator ALL, ANY or NONE applies to the left collection for all of, at least one, or none of element in the collection. In this way, frinds.friends's property(birthYear) can be added to complete the predicate condition.

As you can see, in all above codes, Subquery is used in NSPredicate, which is attached to NSFetchRequest to fetch entity objects in CoreData context. To test Subquery in various cases, I have to find some way to add objects to CoreData database. In most cases I had to run my app to do my tests. That's very time consuming and painful process.

Further investigating into Subquery, I found that Subquery used in NSPredicate is actually based on NSExpression. Actually, Subquery can be tested by using NSExpression with various samples of collections. My next blog will discuss this very interesting topic.

References

Apple Developer's Documentation: Predicate Programming Guide
Article: Fun with Objective-C
StackOverflow QA: How to create predicate for object count several relationships deep? Core Data iOS Swift
Apple's Developer API Reference: NSExpression
Apple's Developer API Reference: Creating Subquery NSExpression init(...)

Thursday, October 13, 2016

Localize Plurals in iOS

Apple emphasizes internationalization and localization since its start of iPhone development. This is actually a very wide and difficult topic in some areas. Plurals in various languages make it really hard to code. In iOS, a solution is provided to get localized plural string and it is very nice and handy.

You can find the solution in many articles if you google it. Basically, the solution is based on a Plist resource file and couple of functions.

By default, the resource file is named as Localizable.stringsdict. Another file should be created as well: Localizable.strings along side even empty.

In the current Xcode 8, there is no stringsdict file type when you add from New File... What you can do is to use Plist file type, and then remove plist extension from the file name. In this way, the XML file can be viewed in ASCII Property List or a hierarchical format.

Plist File Structure

The property list is based on dictionary or dict node to define hierarchical structure. Each dict contains a list of key-value property. Each value can be a string or dict (children set of key-value list). The reason to use dict is that each key within a dictionary has to be unique.

This resource file contains three levels of dict. The top dict contains a list of resource keys. Each key can be used by function NSLocalizedString to retrieve a format string for the resource file.


<plist version="1.0">
    <dict>
        <key>number_of_files</key>
        <dict>
            ...
        </dict>
        <key>working hours</key>
        <dict>
            ...
        </dict>
        <key># of entities</key>
        <dict>
            ...
        </dict>
    </dict>
</plist>

The second dict level contains a list of key-value pairs. The first pair is used to a format for a plural string: by key NSStringLocalizedFormatKey, and its value as the format string. For example:


           <key>NSStringLocalizedFormatKey</key>
           <string>Total: %#@files@, %#@subs@</string>

The string value normally contains one or more variables. Each variable is marked by %#@ as preceding, and @ as ending. The variable should contain a numeric value, therefore, the result of the variable would be a localized plural string.

The remaining key-value pairs define plural rule for each variable. Each variable is a key, and the paired value defines plural rule by the third level of dict. For example, the following is English plural rule for the variable files.


           <key>files</key>
           <dict>
               <key>NSStringFormatSpecTypeKey</key>
               <string>NSStringPluralRulType</string>
               <key>NSStringFormatValueTypeKey</key>
               <string>d</string>
               <key>zero<key>
               <string>%d file</string>
               <key>one</key>
               <string>%d file</string>
               <key>other</key>
               <string>%d files</string>
           </dict>
           <key>subs</key>
           <dict>
               ...
           </dict>

The first two key-value pairs in the third dict level are as-they-are standard, no change. The remaining key-value pairs are for language specific plural rules. For English, the plural rule has three categories: zero, one and other.

Refer to the resources for language plural categories.

Functions for Plural Strings

With above Plist file defined, the localized plural strings can be retrieved by following codes:


let numFiles = 3
let numSubs = 1
let format = NSLocalizedString(" ", comment: "")
let text = String.localizedStringWithFormat(format, numFiles, numSubs)

The first function NSLocalizedString gets a localized format string from Plist, and the second function localizedStringWithFormat retrieves corresponding plural string based on numeric values.

I have written a simple function to get localized plural string by extension to String.


extension NSString {
  static func localizedStringForPlurals(formatKey key: String, comment: String = "", args: CVarArg... ) -> String
    {
        let format = NSLocalizedString(key, comment: comment)
        let result = withVaList(args){
            (NSString(format: format, locale: NSLocale.current, arguments: $0) as String)
        }
        return result
    }
}

It is much simple to use the extension function in my project:


let text = String.localizedStringForPlurals(formatKey: "number_of_files", comment: "Total: # of file, # of sub", args: numFiles, numSubs)
// or
let text1 = String.localizedStringForPlurals(formatKey: "number_of_files", args: numFiles, numSubs)

Resources

Blog article: Localizing Plurals in iOS Development
Apple Guilds and Sample Code: Internationalization and Localization Guide: Stringdict File Format
CLDR: Language Plural Rules
Stack Overflow: iOS Swift and localizedStringWithFormat
Stack Overflow: Swift function with args… pass to another function with args

Tuesday, October 11, 2016

Swift 3 and Generics

Soon after Apple offically released Swift 3 and Xcode 8 after WWDC 2016 on September 13, 2016, I started a process to convert my iOS application to this new version. This time, Xcode provides an auto-conversion tool to convert most of my codes to Swift 3. However, I still had manually to make some changes to handle compiling errors and warnings.

For the errors, I had no choice to fix my codes. One interesting feature in Xcode 3 is that any function call which returns a type, a warning message is generated even the result is assigned to a variable. For example, MyLoger class uses chaining method a lot, that is, method call returning back to class itself.


self.logger.debug() {
   return "[\(#function)] is called." }.indent(true)

even the above method call does not return its result to a variable, Xcode still shows a warning message: result of call to 'indent' is unused. Since MyLogger is used in many places, a long list warning appears very annoying. What my fix is to add a no result call method endChain() to the log class.


self.logger.debug() {
   return "[\(#function)] is called." }.indent(true).endChain()

Those changes are OK, except one I still cannot find a solution, as explained in the following section.

Subclass Based on Generic Class not Available in Storyboard

I have a base class based on UITableViewController and NSFetchedResultsControllerDelegate. This base class contains most of basic codes for table view and table view's data source. I need to utilize Swift generic feature to define this base class as generic class, holding common codes. Then my subclass based on the generic base class would have specialized codes for various data entities.

The problem is that all my subclasses based on this generic base class are not showing up in Storyboard (Showing the identity inspector tab, Custom class dropdown list). By narrowing down to a simple generic class and a subclass from the base class, I found this problem persistence.

I think this most likely being a bug in the current version of Xcode.

Eventually I got an alternative solution: removing generic from the base class, and duplicating the base class into several classes based on my entity data types(fortunately, only a limited number of data types in my project). I tried to make as less changes as possible in all those base classes. First, I changed generic type to a entity data type. Then each class is divided into two parts, common codes which takes majority, and entity data type specific part only a small portion of codes.

I also tried to closure block as method parameter or local data members so that my subclass will plug or assign block of codes for the closure. The example:


typealias FetchRequestBlock_t = () -> NSFetchRequest<MyEntity1>

class MyEntity1TableViewController : UITableViewController, NSFetchedResultsControllerDelegate
{
    // MARK: Properties, methods special for MyEntity1
    // Block perperty to be initialized by subclass
    var fetchRequestBlock : FetchRequestBlock_t?
    var fetchedResultsController : NSFetchedResultsController<MyEntity1>?

    // Block as parameter: plug in codes by subclass call
    func setupFetchResultController(fetchRequestBlock: FetchRequestBlock_t) {
      let fetchRequest = fetchRequestBlock()
      ...
    }

    fileprivate func methodSave(entity: MyEntity1) {
      // Use block var in local usages
      MyEntity1.save(entity, self.fetchRequestBlock!)
      self.tableView.reloadData()
    }

    ...

    // MARK: -
    // Common codes
    // MARK: Propeties and methods 
    ...
}

Here is an example of subclass to initialize block use base class method:


class MyEntity1ListViewController : MyEntity1TableViewController
{
    ...
    override open func viewDidLoad()
    {
        super.viewDidLoad()
        let block: FetchRequestBlock_t = {
          let fetchRequest: FetchRequest<MyEntity1> = NSFetchRequest(entityName: "MyEntity1")
          ...
          return fetchRequest
        }
        self.fetchRequestBlock = fetchRequest
        self.setupFetchResultController(fetchRequestBlock: fetchRequest)
        ...
    }
    ...
}

With this not-perfect-solution, all my subclasses are visible in Storyboard. I hope the next version of Xcode would fix this bug.

References

StackOverFlow QA: Xcode 8: custom class based on generic class not available in storyboard
Apple Developer Forums: Xcode 8 - Problem with View Controllers initialized in storyboard

Swift 3 and Generics


self.logger.debug() {
   return "[\(#function)] is called." }.indent(true)


self.logger.debug() {
   return "[\(#function)] is called." }.indent(true).endChain()

Those changes are OK, except one I still cannot find a solution, as explained in the following section.

Subclass Based on Generic Class not Available in Storyboard


typealias FetchRequestBlock_t = () -> NSFetchRequest<MyEntity1>

class MyEntity1TableViewController : UITableViewController, NSFetchedResultsControllerDelegate
{
    // MARK: Properties, methods special for MyEntity1
    // Block perperty to be initialized by subclass
    var fetchRequestBlock : FetchRequestBlock_t?
    var fetchedResultsController : NSFetchedResultsController<MyEntity1>?

    // Block as parameter: plug in codes by subclass call
    func setupFetchResultController(fetchRequestBlock: FetchRequestBlock_t) {
      let fetchRequest = fetchRequestBlock()
      ...
    }

    fileprivate func methodSave(entity: MyEntity1) {
      // Use block var in local usages
      MyEntity1.save(entity, self.fetchRequestBlock!)
      self.tableView.reloadData()
    }

    ...

    // MARK: -
    // Common codes
    // MARK: Propeties and methods 
    ...
}

Here is an example of subclass to initialize block use base class method:


class MyEntity1ListViewController : MyEntity1TableViewController
{
    ...
    override open func viewDidLoad()
    {
        super.viewDidLoad()
        let block: FetchRequestBlock_t = {
          let fetchRequest: FetchRequest<MyEntity1> = NSFetchRequest(entityName: "MyEntity1")
          ...
          return fetchRequest
        }
        self.fetchRequestBlock = fetchRequest
        self.setupFetchResultController(fetchRequestBlock: fetchRequest)
        ...
    }
    ...
}

With this not-perfect-solution, all my subclasses are visible in Storyboard. I hope the next version of Xcode would fix this bug.

References

StackOverFlow QA: Xcode 8: custom class based on generic class not available in storyboard
Apple Developer ForumsXcode 8 - Problem with View Controllers initialized in storyboard

Swift 3 and Generics


self.logger.debug() {
   return "[\(#function)] is called." }.indent(true)


self.logger.debug() {
   return "[\(#function)] is called." }.indent(true).endChain()

Those changes are OK, except one I still cannot find a solution, as explained in the following section.

Subclass Based on Generic Class not Available in Storyboard


typealias FetchRequestBlock_t = () -> NSFetchRequest<MyEntity1>

class MyEntity1TableViewController : UITableViewController, NSFetchedResultsControllerDelegate
{
    // MARK: Properties, methods special for MyEntity1
    // Block perperty to be initialized by subclass
    var fetchRequestBlock : FetchRequestBlock_t?
    var fetchedResultsController : NSFetchedResultsController<MyEntity1>?

    // Block as parameter: plug in codes by subclass call
    func setupFetchResultController(fetchRequestBlock: FetchRequestBlock_t) {
      let fetchRequest = fetchRequestBlock()
      ...
    }

    fileprivate func methodSave(entity: MyEntity1) {
      // Use block var in local usages
      MyEntity1.save(entity, self.fetchRequestBlock!)
      self.tableView.reloadData()
    }

    ...

    // MARK: -
    // Common codes
    // MARK: Propeties and methods 
    ...
}

Here is an example of subclass to initialize block use base class method:


class MyEntity1ListViewController : MyEntity1TableViewController
{
    ...
    override open func viewDidLoad()
    {
        super.viewDidLoad()
        let block: FetchRequestBlock_t = {
          let fetchRequest: FetchRequest<MyEntity1> = NSFetchRequest(entityName: "MyEntity1")
          ...
          return fetchRequest
        }
        self.fetchRequestBlock = fetchRequest
        self.setupFetchResultController(fetchRequestBlock: fetchRequest)
        ...
    }
    ...
}

With this not-perfect-solution, all my subclasses are visible in Storyboard. I hope the next version of Xcode would fix this bug.

References

StackOverFlow QA: Xcode 8: custom class based on generic class not available in storyboard
StackOverFlow QA: Xcode 8 - Problem with View Controllers initialized in storyboard

Programming Log

Wednesday, October 26, 2016

Playground and Testing Subquery by NSExpression (2)

One-to-many Relationship Test

Need to Check `Friends` Collection?

More on One-to-many Relationship Test

Resources

Monday, October 24, 2016

Playground and Testing Subquery by NSExpression (1)

Playground in Xcode

Test Class

Test Structure

Test and Result

Resources

Friday, October 21, 2016

One-to-Many Relationship and Subquery

Subquery Function

References

Thursday, October 13, 2016

Localize Plurals in iOS

Plist File Structure

Functions for Plural Strings

Resources

Tuesday, October 11, 2016

Swift 3 and Generics

Subclass Based on Generic Class not Available in Storyboard

References

Swift 3 and Generics

Subclass Based on Generic Class not Available in Storyboard

References

Swift 3 and Generics

Subclass Based on Generic Class not Available in Storyboard

References

Blog Archive

Categories by Labels

About Me

Wednesday, October 26, 2016

One-to-many Relationship Test

Need to Check Friends Collection?

More on One-to-many Relationship Test

Resources

Monday, October 24, 2016

Playground in Xcode

Test Class

Test Structure

Test and Result

Resources

Friday, October 21, 2016

Subquery Function

References

Thursday, October 13, 2016

Plist File Structure

Functions for Plural Strings

Resources

Tuesday, October 11, 2016

Subclass Based on Generic Class not Available in Storyboard

References

Subclass Based on Generic Class not Available in Storyboard

References

Subclass Based on Generic Class not Available in Storyboard

References

Blog Archive

Categories by Labels

Subscribe To

About Me

Need to Check `Friends` Collection?