Example of a slightly modified logging setup which would then allow bridging to other logging systems, and an implementation of a CocoaLumberjack bridge.  Bridges can be assigned at runtime.
Make the current logging class a static variable with accessor functions, rather than exposing the global.  Change the core logging method to match the existing LCLNSLogging_RK class which is out there; that class could probably be used as-is for the logging class.  Move the RKLogging definition to the logging config header; it has to be there since the lcl typedefs are only defined by the lcl headers (which import that config file), which need to be defined before we can declare the RKLogging protocol, which in turn should be defined before we use that in the core logging macro definition, which I think must be defined before the rest of the lcl definitions.  So I'm not sure we can move it elsewhere and still use the lcl typedefs.  Moved the implementations to RKLog.m.
Not sure what I was thinking... we can move the RKLogging definitions to RKLog.  The #defines that use them come earlier, but so long as they are declared before the log macro is actually expanded anywhere, it is fine.
Merge branch 'development' into LumberjackBridge
Update the Xcode project file to add the new lumberjack class, and remove an obsoleted .h/.m .
Add a datasource method to indicate whether RKMappingInfo is necessary; it is only needed for CoreData presently, and is a performance hit otherwise.
Add documentation for the new data source method.
Change internal property name to collectsMappingInfo per PR comment
The RKObjectMapping -classForKeyPath: gets called a lot; avoiding the creation of a temporary NSArray for simple keys (the usual case) makes a measurable speed difference.
Whoops, need to deal with a nil key.
Couple of cosmetic tweaks per PR comments.  Also, set the logging class *before* we RKLogInfo("Logging initialized").
Merge pull request #2073 from carllindberg/LumberjackBridge

Allow bridging to other log systems
Add caching for different property mapping types, both in RKObjectMapping, and RKMappingOperation.  Determining simple vs keyPath mappings was somewhat of a hotspot, so caching them in RKMappingOperation helps a bit.  However, these will be identical to the versions in RKObjectMapping if there is no substitution (the most common case), so if we cache the properties there, then we can just re-use the same array for the operation without creating local copies at all, which is a substantial speedup.  Similarly, caching the attribute vs relationship mappings when added to the RKObjectMapping is also a significant speedup during mapping since these don't have to be recalculated for every object being mapped.  Lastly, changed the substitution values to be an individual key and value internally, instead of a dictionary.  This avoids the need to use "allKeys" to obtain the key (and allValues to get the value), which avoids more NSArray instances being created locally.
Updates per PR comments.  Change RKObjectMapping property to keyAttributeMappings, and initialize the properties in -init.  Change internal RKMappingOperation method to cacheMappingsIfNeeded.
Making a few tweaks to RKMappingOperation applyRelationshipMappings.  First, there is a temporary array created which ends up only being used for its count, so changed to an NSUInteger.  Just a small speedup, but it's there.  In another section, the code was calling valueForKeyPath "mapping.propertyMappings.sourceKeyPath" on an RKRelationshipMapping, which if it happens to be an RKDynamicMapping, I think would fail.  Code immediately above has already determined the RKObjectMapping, so it's easier to just call the method directly, and iterate using the RKPropertyMappings directly, which avoids another temporary array allocation.  Also avoided a double call to RKObjectIsCollection though that is a minimal speedup.
Small speedups in RKPropertyInspector.  Regular objects are faster than dictionaries, so for the actual property information using a simple method call instead of -objectForKey: has a small but measurable speedup.  Deprecated the previous key constants, though implemented methods such that if used as a dictionary it should continue to work in most cases.
Updates per PR comments.  Remove deprecation path; this is a slightly incompatible change now, though RestKit usage is fine.  Change to use dot syntax for properties, and use inspector local variable.  Also speed up the NSManagedObject override of rk_classForPropertyAtKeyPath: which I had missed before.
Merge pull request #2082 from carllindberg/2065-ApplyRelationshipMappings

Few changes to applyRelationshipMappings
Cache the propertyMappings in dictionary form by both the destination and source keys, which allows for faster lookup during mapping.  Also, change a couple of CoreData related calls to use the fast-lookup method rather than a method which constructs an entire dictionary to then just look it up by key.  I left the accessor methods as "copy" rather then having immutable dictionaries because those methods are no longer called from the core mapping code (or anywhere else, for that matter).
Merge pull request #2083 from carllindberg/2065-RKPropertyInspector

Small speedups in RKPropertyInspector