@josuelmm/capacitor-background-geolocation 1.0.0

package/ios/common/BackgroundGeolocation/Reachability.m

@@ -0,0 +1,475 @@
+/*
+ Copyright (c) 2011, Tony Million.
+ All rights reserved.
+ 
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are met:
+ 
+ 1. Redistributions of source code must retain the above copyright notice, this
+ list of conditions and the following disclaimer.
+ 
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+ 
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#import "Reachability.h"
+
+#import <sys/socket.h>
+#import <netinet/in.h>
+#import <netinet6/in6.h>
+#import <arpa/inet.h>
+#import <ifaddrs.h>
+#import <netdb.h>
+
+
+NSString *const kReachabilityChangedNotification = @"kReachabilityChangedNotification";
+
+
+@interface Reachability ()
+
+@property (nonatomic, assign) SCNetworkReachabilityRef  reachabilityRef;
+@property (nonatomic, strong) dispatch_queue_t          reachabilitySerialQueue;
+@property (nonatomic, strong) id                        reachabilityObject;
+
+-(void)reachabilityChanged:(SCNetworkReachabilityFlags)flags;
+-(BOOL)isReachableWithFlags:(SCNetworkReachabilityFlags)flags;
+
+@end
+
+
+static NSString *reachabilityFlags(SCNetworkReachabilityFlags flags)
+{
+    return [NSString stringWithFormat:@"%c%c %c%c%c%c%c%c%c",
+#if	TARGET_OS_IPHONE
+            (flags & kSCNetworkReachabilityFlagsIsWWAN)               ? 'W' : '-',
+#else
+            'X',
+#endif
+            (flags & kSCNetworkReachabilityFlagsReachable)            ? 'R' : '-',
+            (flags & kSCNetworkReachabilityFlagsConnectionRequired)   ? 'c' : '-',
+            (flags & kSCNetworkReachabilityFlagsTransientConnection)  ? 't' : '-',
+            (flags & kSCNetworkReachabilityFlagsInterventionRequired) ? 'i' : '-',
+            (flags & kSCNetworkReachabilityFlagsConnectionOnTraffic)  ? 'C' : '-',
+            (flags & kSCNetworkReachabilityFlagsConnectionOnDemand)   ? 'D' : '-',
+            (flags & kSCNetworkReachabilityFlagsIsLocalAddress)       ? 'l' : '-',
+            (flags & kSCNetworkReachabilityFlagsIsDirect)             ? 'd' : '-'];
+}
+
+// Start listening for reachability notifications on the current run loop
+static void TMReachabilityCallback(SCNetworkReachabilityRef target, SCNetworkReachabilityFlags flags, void* info)
+{
+#pragma unused (target)
+    
+    Reachability *reachability = ((__bridge Reachability*)info);
+    
+    // We probably don't need an autoreleasepool here, as GCD docs state each queue has its own autorelease pool,
+    // but what the heck eh?
+    @autoreleasepool
+    {
+        [reachability reachabilityChanged:flags];
+    }
+}
+
+
+@implementation Reachability
+
+#pragma mark - Class Constructor Methods
+
++(instancetype)reachabilityWithHostName:(NSString*)hostname
+{
+    return [Reachability reachabilityWithHostname:hostname];
+}
+
++(instancetype)reachabilityWithHostname:(NSString*)hostname
+{
+    SCNetworkReachabilityRef ref = SCNetworkReachabilityCreateWithName(NULL, [hostname UTF8String]);
+    if (ref)
+    {
+        id reachability = [[self alloc] initWithReachabilityRef:ref];
+        
+        return reachability;
+    }
+    
+    return nil;
+}
+
++(instancetype)reachabilityWithAddress:(void *)hostAddress
+{
+    SCNetworkReachabilityRef ref = SCNetworkReachabilityCreateWithAddress(kCFAllocatorDefault, (const struct sockaddr*)hostAddress);
+    if (ref)
+    {
+        id reachability = [[self alloc] initWithReachabilityRef:ref];
+        
+        return reachability;
+    }
+    
+    return nil;
+}
+
++(instancetype)reachabilityForInternetConnection
+{
+    struct sockaddr_in zeroAddress;
+    bzero(&zeroAddress, sizeof(zeroAddress));
+    zeroAddress.sin_len = sizeof(zeroAddress);
+    zeroAddress.sin_family = AF_INET;
+    
+    return [self reachabilityWithAddress:&zeroAddress];
+}
+
++(instancetype)reachabilityForLocalWiFi
+{
+    struct sockaddr_in localWifiAddress;
+    bzero(&localWifiAddress, sizeof(localWifiAddress));
+    localWifiAddress.sin_len            = sizeof(localWifiAddress);
+    localWifiAddress.sin_family         = AF_INET;
+    // IN_LINKLOCALNETNUM is defined in <netinet/in.h> as 169.254.0.0
+    localWifiAddress.sin_addr.s_addr    = htonl(IN_LINKLOCALNETNUM);
+    
+    return [self reachabilityWithAddress:&localWifiAddress];
+}
+
+
+// Initialization methods
+
+-(instancetype)initWithReachabilityRef:(SCNetworkReachabilityRef)ref
+{
+    self = [super init];
+    if (self != nil)
+    {
+        self.reachableOnWWAN = YES;
+        self.reachabilityRef = ref;
+        
+        // We need to create a serial queue.
+        // We allocate this once for the lifetime of the notifier.
+        
+        self.reachabilitySerialQueue = dispatch_queue_create("com.tonymillion.reachability", NULL);
+    }
+    
+    return self;
+}
+
+-(void)dealloc
+{
+    [self stopNotifier];
+    
+    if(self.reachabilityRef)
+    {
+        CFRelease(self.reachabilityRef);
+        self.reachabilityRef = nil;
+    }
+    
+    self.reachableBlock          = nil;
+    self.unreachableBlock        = nil;
+    self.reachabilityBlock       = nil;
+    self.reachabilitySerialQueue = nil;
+}
+
+#pragma mark - Notifier Methods
+
+// Notifier
+// NOTE: This uses GCD to trigger the blocks - they *WILL NOT* be called on THE MAIN THREAD
+// - In other words DO NOT DO ANY UI UPDATES IN THE BLOCKS.
+//   INSTEAD USE dispatch_async(dispatch_get_main_queue(), ^{UISTUFF}) (or dispatch_sync if you want)
+
+-(BOOL)startNotifier
+{
+    // allow start notifier to be called multiple times
+    if(self.reachabilityObject && (self.reachabilityObject == self))
+    {
+        return YES;
+    }
+    
+    
+    SCNetworkReachabilityContext    context = { 0, NULL, NULL, NULL, NULL };
+    context.info = (__bridge void *)self;
+    
+    if(SCNetworkReachabilitySetCallback(self.reachabilityRef, TMReachabilityCallback, &context))
+    {
+        // Set it as our reachability queue, which will retain the queue
+        if(SCNetworkReachabilitySetDispatchQueue(self.reachabilityRef, self.reachabilitySerialQueue))
+        {
+            // this should do a retain on ourself, so as long as we're in notifier mode we shouldn't disappear out from under ourselves
+            // woah
+            self.reachabilityObject = self;
+            return YES;
+        }
+        else
+        {
+#ifdef DEBUG
+            NSLog(@"SCNetworkReachabilitySetDispatchQueue() failed: %s", SCErrorString(SCError()));
+#endif
+            
+            // UH OH - FAILURE - stop any callbacks!
+            SCNetworkReachabilitySetCallback(self.reachabilityRef, NULL, NULL);
+        }
+    }
+    else
+    {
+#ifdef DEBUG
+        NSLog(@"SCNetworkReachabilitySetCallback() failed: %s", SCErrorString(SCError()));
+#endif
+    }
+    
+    // if we get here we fail at the internet
+    self.reachabilityObject = nil;
+    return NO;
+}
+
+-(void)stopNotifier
+{
+    // First stop, any callbacks!
+    SCNetworkReachabilitySetCallback(self.reachabilityRef, NULL, NULL);
+    
+    // Unregister target from the GCD serial dispatch queue.
+    SCNetworkReachabilitySetDispatchQueue(self.reachabilityRef, NULL);
+    
+    self.reachabilityObject = nil;
+}
+
+#pragma mark - reachability tests
+
+// This is for the case where you flick the airplane mode;
+// you end up getting something like this:
+//Reachability: WR ct-----
+//Reachability: -- -------
+//Reachability: WR ct-----
+//Reachability: -- -------
+// We treat this as 4 UNREACHABLE triggers - really apple should do better than this
+
+#define testcase (kSCNetworkReachabilityFlagsConnectionRequired | kSCNetworkReachabilityFlagsTransientConnection)
+
+-(BOOL)isReachableWithFlags:(SCNetworkReachabilityFlags)flags
+{
+    BOOL connectionUP = YES;
+    
+    if(!(flags & kSCNetworkReachabilityFlagsReachable))
+        connectionUP = NO;
+    
+    if( (flags & testcase) == testcase )
+        connectionUP = NO;
+    
+#if	TARGET_OS_IPHONE
+    if(flags & kSCNetworkReachabilityFlagsIsWWAN)
+    {
+        // We're on 3G.
+        if(!self.reachableOnWWAN)
+        {
+            // We don't want to connect when on 3G.
+            connectionUP = NO;
+        }
+    }
+#endif
+    
+    return connectionUP;
+}
+
+-(BOOL)isReachable
+{
+    SCNetworkReachabilityFlags flags;
+    
+    if(!SCNetworkReachabilityGetFlags(self.reachabilityRef, &flags))
+        return NO;
+    
+    return [self isReachableWithFlags:flags];
+}
+
+-(BOOL)isReachableViaWWAN
+{
+#if	TARGET_OS_IPHONE
+    
+    SCNetworkReachabilityFlags flags = 0;
+    
+    if(SCNetworkReachabilityGetFlags(self.reachabilityRef, &flags))
+    {
+        // Check we're REACHABLE
+        if(flags & kSCNetworkReachabilityFlagsReachable)
+        {
+            // Now, check we're on WWAN
+            if(flags & kSCNetworkReachabilityFlagsIsWWAN)
+            {
+                return YES;
+            }
+        }
+    }
+#endif
+    
+    return NO;
+}
+
+-(BOOL)isReachableViaWiFi
+{
+    SCNetworkReachabilityFlags flags = 0;
+    
+    if(SCNetworkReachabilityGetFlags(self.reachabilityRef, &flags))
+    {
+        // Check we're reachable
+        if((flags & kSCNetworkReachabilityFlagsReachable))
+        {
+#if	TARGET_OS_IPHONE
+            // Check we're NOT on WWAN
+            if((flags & kSCNetworkReachabilityFlagsIsWWAN))
+            {
+                return NO;
+            }
+#endif
+            return YES;
+        }
+    }
+    
+    return NO;
+}
+
+
+// WWAN may be available, but not active until a connection has been established.
+// WiFi may require a connection for VPN on Demand.
+-(BOOL)isConnectionRequired
+{
+    return [self connectionRequired];
+}
+
+-(BOOL)connectionRequired
+{
+    SCNetworkReachabilityFlags flags;
+    
+    if(SCNetworkReachabilityGetFlags(self.reachabilityRef, &flags))
+    {
+        return (flags & kSCNetworkReachabilityFlagsConnectionRequired);
+    }
+    
+    return NO;
+}
+
+// Dynamic, on demand connection?
+-(BOOL)isConnectionOnDemand
+{
+    SCNetworkReachabilityFlags flags;
+    
+    if (SCNetworkReachabilityGetFlags(self.reachabilityRef, &flags))
+    {
+        return ((flags & kSCNetworkReachabilityFlagsConnectionRequired) &&
+                (flags & (kSCNetworkReachabilityFlagsConnectionOnTraffic | kSCNetworkReachabilityFlagsConnectionOnDemand)));
+    }
+    
+    return NO;
+}
+
+// Is user intervention required?
+-(BOOL)isInterventionRequired
+{
+    SCNetworkReachabilityFlags flags;
+    
+    if (SCNetworkReachabilityGetFlags(self.reachabilityRef, &flags))
+    {
+        return ((flags & kSCNetworkReachabilityFlagsConnectionRequired) &&
+                (flags & kSCNetworkReachabilityFlagsInterventionRequired));
+    }
+    
+    return NO;
+}
+
+
+#pragma mark - reachability status stuff
+
+-(NetworkStatus)currentReachabilityStatus
+{
+    if([self isReachable])
+    {
+        if([self isReachableViaWiFi])
+            return ReachableViaWiFi;
+        
+#if	TARGET_OS_IPHONE
+        return ReachableViaWWAN;
+#endif
+    }
+    
+    return NotReachable;
+}
+
+-(SCNetworkReachabilityFlags)reachabilityFlags
+{
+    SCNetworkReachabilityFlags flags = 0;
+    
+    if(SCNetworkReachabilityGetFlags(self.reachabilityRef, &flags))
+    {
+        return flags;
+    }
+    
+    return 0;
+}
+
+-(NSString*)currentReachabilityString
+{
+    NetworkStatus temp = [self currentReachabilityStatus];
+    
+    if(temp == ReachableViaWWAN)
+    {
+        // Updated for the fact that we have CDMA phones now!
+        return NSLocalizedString(@"Cellular", @"");
+    }
+    if (temp == ReachableViaWiFi)
+    {
+        return NSLocalizedString(@"WiFi", @"");
+    }
+    
+    return NSLocalizedString(@"No Connection", @"");
+}
+
+-(NSString*)currentReachabilityFlags
+{
+    return reachabilityFlags([self reachabilityFlags]);
+}
+
+#pragma mark - Callback function calls this method
+
+-(void)reachabilityChanged:(SCNetworkReachabilityFlags)flags
+{
+    if([self isReachableWithFlags:flags])
+    {
+        if(self.reachableBlock)
+        {
+            self.reachableBlock(self);
+        }
+    }
+    else
+    {
+        if(self.unreachableBlock)
+        {
+            self.unreachableBlock(self);
+        }
+    }
+    
+    if(self.reachabilityBlock)
+    {
+        self.reachabilityBlock(self, flags);
+    }
+    
+    // this makes sure the change notification happens on the MAIN THREAD
+    dispatch_async(dispatch_get_main_queue(), ^{
+        [[NSNotificationCenter defaultCenter] postNotificationName:kReachabilityChangedNotification
+                                                            object:self];
+    });
+}
+
+#pragma mark - Debug Description
+
+- (NSString *) description
+{
+    NSString *description = [NSString stringWithFormat:@"<%@: %#x (%@)>",
+                             NSStringFromClass([self class]), (unsigned int) self, [self currentReachabilityFlags]];
+    return description;
+}
+
+@end

package/ios/common/BackgroundGeolocation/SQLQueryBuilder/README.md

@@ -0,0 +1,170 @@
+# Objective-C SQL Query Builder
+
+This Objective-C SQLite project is a lightweight library that offers more than just a set of [SQLite](http://www.sqlite.org/)
+wrapper classes.  It is divided up into five parts.  The first part consists of a set of Objective-C classes that handle
+communications with an SQLite database.  Inside the "src" folder, these Objective-C classes are further subdivided into five
+folders.  The "db" folder (formerly, the "dao" folder) contains an SQLite wrapper class that easily manages the database
+connection. The "ext" folder contains some class extensions. The "sql" folder contains a collection of SQL builder classes
+that can be used to construct well-formed SQL statements for SQLite via a plethora of convenience methods similar to those
+found in LINQ.  Likewise, the "orm" folder has an assortment of classes that can control and manipulate data within an SQLite
+database via the Active Record design pattern. And, the "util" folder contains a set of various helper classes.  The
+second part consists of an easy-to-read API, which both documents and diagrams each Objective-C class and XML/DTD file.
+The third part consists of a BASH script that can be used to generate the necessary ORM models using the SQLite's database
+schema.  The fourth part consists of the database configuration files for the SQLite database connection.  The final part
+has the schema for handling XML to DDL.
+
+All classes are designed to be used in iPhone/iOS applications.  The classes in the "ARC" branches are compliant with iOS 5's
+[automatic reference counting](http://clang.llvm.org/docs/AutomaticReferenceCounting.html).  For projects still using Retains,
+Releases, and Autoreleases (i.e. Pre-ARC) use the classes in the "RRA" branches.
+
+## Supported Platforms
+
+- Mac OS X 10.7+
+- iOS 4.0+
+
+## Motivation
+
+The goal of this project is to make these classes the "de facto" standard for communicating with SQLite databases on
+iPhone/iOS devices.
+
+With the abundance of third-party libraries for Objective-C, it was apparent that a successful SQLite library needs to
+be simple to learn and intuitive.  It must also be cleanly written with clear naming conventions and must be well-documented
+for too many SQLite libraries are hard to understand and are not user-friendly.  For these reasons, this SQLite library was
+written.
+
+## Features
+
+The following is a short-list of some of the features:
+
+* [Automatic reference counting](http://longweekendmobile.com/2011/09/07/objc-automatic-reference-counting-in-xcode-explained/);
+* Cleanly wraps-up the sqlite3 C based functions.
+* Automatically places the SQLite database in the "Document" directory.
+* Allows for read-only databases.
+* Provides multi-threading support for asynchronous SQLite database calls;
+* Utilizes a PLIST file for configuring SQLite database connections;
+* Allows database privileges to be restricted.
+* Has an easy to use SQLite database connection pool.
+* Capable of executing an SQL statement with one line of code.
+* Able to execute more than one SQL statement at a time.
+* Has a huge collection of SQL builder classes with methods that mimic their SQL statement equivalents.
+* Converts XML to DDL/SQL statements.
+* Helps ensure that SQL statements are well-formed.
+* Supports all major Objective-C datatypes, including NSNull, NSNumber, NSDecimalNumber, NSString, NSData, and NSDate.
+* Sanitizes data using best practices.
+* Handles most complex queries and works with raw SQL statements.
+* Has a powerful SQLite tokenizer.
+* Contains a message digest to hash strings using md2, md4, md5, sha1, sha224, sha256, sha384, and sha512.
+* Has a data access layer (DAL) that offers Object Relational Mapping (ORM).
+* Data access objects (DAO) handle composite primary keys.
+* Via a Bash script, models (i.e. Active Records) can be auto-generated for each table in the SQLite database.
+* Handles foreign keys via true lazy loading.
+* Requires only those Objective-C classes that are absolutely needed.
+* Classes are easily extendible.
+* Has clear API documentation generated via [Doxygen](http://www.stack.nl/~dimitri/doxygen/).
+
+## Getting Started
+
+Using these classes in an Xcode project is easy to do.  Here is how:
+
+1. Download the source code via Github as a tarball (i.e. .tar.gz).
+2. Navigate to the tarball in Finder.
+3. Unarchive the tarball by double-clicking it in a Finder window.
+4. Open an Xcode project.
+5. Right-click on the "Classes" folder and click on the "Add >> Existing Files..." option.
+6. Highlight the files, then click the "Add" button.
+7. Check "Copy items into destination group's folder (if needed)".
+8. Select "Default" for the "Reference Type".
+9. Choose "Recursively create groups for any added folders".
+10. Click "Add".
+
+### Required Files
+
+A lot of work has gone into making the classes in this repository as independent as possible; however, a few
+dependencies just can't be avoided.  To make life easier, the following SDK import files have been created to
+make the implementation process as painless as possible:
+
+* ZIMDaoSdk.h
+* ZIMSqlSdk.h
+* ZIMOrmSdk.h
+
+Based on which SDK is needed, only those classes listed (i.e. imported) in the SDK import file are needed to be
+added to the respective Xcode project.
+
+### Required Frameworks
+
+To use these Objective-C classes in an Xcode project, add the following framework:
+
+* libsqlite3.dylib
+
+### Documentation
+
+All classes are heavily documented using [HeaderDoc](http://developer.apple.com/library/mac/#documentation/DeveloperTools/Conceptual/HeaderDoc/intro/intro.html#//apple_ref/doc/uid/TP40001215-CH345-SW1).
+You can get familiar with each class by simply looking at the API or by opening its respective ".h" file.  Similarly,
+all XML/DTD files are documented using [DTDDoc](http://dtddoc.sourceforge.net). You can also find more information on
+this repository's Wiki.
+
+### Tutorials / Examples
+
+Checkout this SQLite repository's Wiki for a handful of examples.  There, you will find examples on how to make
+an SQLite database connection and how to build [DCL, DDL, DML, and TCL commands](http://download.oracle.com/docs/cd/B12037_01/server.101/b10759/statements_1001.htm)
+(including Create, Read, Update, and Delete (CRUD) statements).  The Wiki also has tutorials on how to use Object
+Relational Mapping (ORM) and how to generate the necessary models (i.e. active records).
+
+### Further Assistance
+
+If you need further assistance in implementing these classes, you can always send an email to oss@ziminji.com with
+any questions that you may have about this repository.  Any frequently asked questions (FAQ) will be posted on this
+repository's Wiki.
+
+You can also seek assistance via the blogs.  A great Web site for community assistance is [Stack Overflow](http://stackoverflow.com).
+
+## Reporting Bugs & Making Recommendations
+
+Help debug the code in repository by reporting any bugs.  The more detailed the report the better.  If you have a bug-fix
+or a unit-test, please create an issue under the "Issues" tab of this repository and someone will follow-up with it as
+soon as possible.
+
+Likewise, if you would like to make a recommendation on how to improve the code in this repository, take the time to send
+a message so that it can be considered for an upcoming release.  Or, if you would like to contribute to the development of
+this Objective-C SQLite repository, go ahead and create a fork.
+
+You can also email any bug-fixes, unit-tests, or recommendations to oss@ziminji.com.
+
+### Known Issues
+
+Usually, code is not posted to this SQLite repository unless it works; however, there are times when some code may get
+posted even though it still contains some bugs.  When this occurs, every attempt will be made to list these known bugs
+in this README (if they are not already listed under the "Issues" tab).
+
+At the current time, there are no known bugs. However, the "XML to DDL" schema processing is still being developed.
+
+### Updates
+
+This Objective-C SQLite project is updated frequently with bug-fixes and new features.  Be sure to add this repository
+to your watch list so that you can be notified when such updates are made.  You can also request email notifications
+regarding updates by emailing oss@ziminji.com.
+
+## Future Development
+
+This project is under heavy development.  There are development plans to add:
+
+* Improved functionality to parse "XML to DDL" schema and raw SQLite statements into their SQL builder class equivalents;
+* More utilities (e.g. classes to handle validation, filtering, imports, exports, pagination, partitioning, and migration);
+* A database encryption layer for password protecting an SQLite database;
+* Unit-tests; and,
+* Additional tutorials and examples.
+
+Help expand this list with your feedback.
+
+## License (Apache v2.0)
+
+>Copyright 2011-2015 Ziminji
+>
+>Licensed under the Apache License, Version 2.0 (the "License"); you may not use these files except in compliance with the
+>License. You may obtain a copy of the License at:
+>
+>[http://www.apache.org/licenses/LICENSE-2.0](http://www.apache.org/licenses/LICENSE-2.0)
+>
+>Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an
+>"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific
+>language governing permissions and limitations under the License.

package/ios/common/BackgroundGeolocation/SQLQueryBuilder/ext/NSString+ZIMString.h

@@ -0,0 +1,55 @@
+/*
+ * Copyright 2011-2015 Ziminji
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ * 
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import <Foundation/Foundation.h>
+
+/*!
+ @category			NSString (ZIMString)
+ @discussion		This category extends the functionality of the NSString class.
+ @updated			2011-07-16
+ */
+@interface NSString (ZIMString)
+/*!
+ @method			matchesRegex:options:
+ @discussion		This method determines whether the pattern is matched.
+ @param pattern		The regular expression to be used.
+ @param options		The options to be used.
+ @return			A boolean value denoting whether the pattern was matched.
+ @updated			2012-03-20
+ @see				http://developer.apple.com/library/ios/#documentation/Foundation/Reference/NSRegularExpression_Class/Reference/Reference.html
+ @see				http://quickies.seriot.ch/index.php?id=279
+ */
+- (BOOL) matchesRegex: (NSString *)pattern options: (NSRegularExpressionOptions)options;
+/*!
+ @method			capitalizeFirstCharacterInString:
+ @discussion		This method will capitalize the first letter in the specified string.
+ @param string		The string to be modified.
+ @return			The modified string.
+ @updated			2011-06-29
+ @see				http://stackoverflow.com/questions/883897/easy-way-to-set-a-single-character-of-an-nsstring-to-uppercase
+ */
++ (NSString *) capitalizeFirstCharacterInString: (NSString *)string;
+/*!
+ @method			firstTokenInString:scanUpToCharactersFromSet:
+ @discussion		This method returns the first token found in the specified string.
+ @param string		The string to be parsed.
+ @param stopSet		The set of characters up to which to scan.
+ @return			The first token found.
+ @updated			2011-06-29
+ */
++ (NSString *) firstTokenInString: (NSString *)string scanUpToCharactersFromSet: (NSCharacterSet *)stopSet;
+
+@end