         /*
         stringToSearch is greater than the originalString return false
         */
-        if originalString.characters.count < stringToSearch.characters.count
+        if count(originalString) < count(stringToSearch)
         {
             return [String]()
         }

    approximately matches that String object
    
    :param originalString
            The original contents that is going to be searched
    :param stringToSearch
            The specific contents to search for
    :param isCaseSensitive
            A Boolean value to indicate whether to use case sensitive or case
            insensitive search parameters
    :return
           The Array of String(s) if any are found otherwise an empty Array of String(s)
    */

    public class func search(var originalString originalString: String, var stringToSearch: String, isCaseSensitive: Bool) -> [String]
    {
        /*
        Either String is empty return false
        */
        if originalString.characters.count == 0 || stringToSearch.characters.count == 0
        {
            return [String]()
        }

    }
    
    /*
    The score method that provides fast fuzzy string matching and scoring based
    on the technique of finding strings that match a pattern approximately
    (rather than exactly). The problem of approximate string matching is typically
    dived intotwo sub-problems: finding approximate substring matches inside
    a given string and finding dictionary strings that match the pattern approximately.
    
    The design and implementation of this method are based on
    StringScore_Swift by (Yichi Zhang) and StringScore in Javascript (Joshaven Potter)
    
    :param originalString
    The original contents that is going to be searched
    :param stringToMatch
    The specific contents to search for the approximate match
    :param fuzziness
    A Double value to indicate a function of distance between two words,
    which provides a measure of their similarity. The fuzziness value is
    defaulted to 0.
    :return The score value of the approximate match between strings.
    Score of 0 for no match; up to 1 for perfect.
    
    */
    public class func score(#originalString: String, stringToMatch: String, fuzziness: Double? = nil) -> Double
    {
        /*
        Either String objects are empty return score of 0
