Create ObjCCast<>() and ObjCCastStrict<>() methods

base/mac/foundation_util.h

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef BASE_MAC_FOUNDATION_UTIL_H_
 #define BASE_MAC_FOUNDATION_UTIL_H_
 #pragma once
 
 #include <CoreFoundation/CoreFoundation.h>
 
@@ skipping 206 matching lines @@
 // CFStringRef some_string = base::mac::CFCastStrict<CFStringRef>(
 //     base::mac::GetValueFromDictionary(some_dict,
 //                                       CFSTR("a_key"),
 //                                       CFStringGetTypeID()));
 BASE_EXPORT template<class T>
 T CFCast(const CFTypeRef& cf_val);
 
 BASE_EXPORT template<class T>
 T CFCastStrict(const CFTypeRef& cf_val);
 
+#if defined(__OBJC__)
+
+// ObjCCast<>() and ObjCCastStrict<>() cast a basic id to a more
+// specific (NSObject derived) type. The compatibility of the passed

[Mark Mentovai, 2011/10/19 22:59:32]

Tiny nit: NSObject-derived, with a hyphen in there.

+// object is found by checking if it's a kind of the requested type
+// identifier. If the supplied object is not compatible with the
+// requested return type, ObjCCast<>() returns NULL and
+// ObjCCastStrict<>() will DCHECK. Providing a NULL pointer to either
+// variant results in NULL being returned without triggering any DCHECK.
+//
+// Example usage:
+// NSNumber some_number = base::mac::ObjCCast<NSNumber>(

[Mark Mentovai, 2011/10/19 22:59:32]

NSNumber* for the type in the declaration, right?

+//     [dict objectForKey:@"object"]);
+//
+// TODO: Write a good example for ObjCCastStrict<>()

[Mark Mentovai, 2011/10/19 22:59:32]

The strict variant is handy when you’re retrieving a value that you stuffed into
a collection yourself, and you know you’ve only stuffed values of a certain
type. For example, an NSArray of NSStrings. The non-strict variant is handy when
you’re retrieving values from data that you don’t fully control yourself. For
example, a plist read from disk may be beyond your exclusive control, so you’d
merely want to check that the values you pull from it are of the expected types,
but not crash if they’re not.

[KushalP, 2011/10/19 23:25:24]

All of this is incredibly useful. Should I also add it to the docs for others to
see?

On 2011/10/19 22:59:32, Mark Mentovai wrote:

[KushalP, 2011/10/20 14:59:38]

You didn't state whether I should add what you said here. I think it's useful to
have the case for ObjCCastStrict written in prose like this. What do you think?

On 2011/10/19 23:25:24, KushalP wrote:

[Mark Mentovai, 2011/10/21 14:30:54]

KushalP wrote:
What do you mean, like saying that the strict form is useful when you know
you’ve stuffed a container full of a certain type and just want to check the
objects on the way out? Sure.

+BASE_EXPORT template<class T>
+T* ObjCCast(id objc_val) {
+  if (objc_val == NULL) {

[Mark Mentovai, 2011/10/19 22:59:32]

Use nil for Objective-C. All of your uses of NULL throughout this new code and
its explanatory comment block above should be nil instead.

[Mark Mentovai, 2011/10/19 22:59:32]

Neat trick: you can remove this condition entirely!

Because it’s safe to send messages to nil receivers, and the return value (in
cases where the return type is “simple”—integral fundamental types are simple)
is zero. This means that you can call [nil isKindOfClass:[T class]] and it
returns NO. You’ll return NULL when you return from the function below.

[KushalP, 2011/10/19 23:25:24]

That is very cool!

A quick google for "nil isKindOfClass" didn't return anything useful, but is
this something that's talked about in the spec anywhere?

On 2011/10/19 22:59:32, Mark Mentovai wrote:

[Mark Mentovai, 2011/10/20 14:14:16]

KushalP wrote:
It’s not a feature specific to -isKindOfClass:, it’s a general feature of the
language.

http://developer.apple.com/library/mac/#documentation/cocoa/conceptual/object...

+    return NULL;
+  }
+
+  if ([objc_val isKindOfClass:[T class]]) {
+    return reinterpret_cast<T*>(objc_val);
+  }
+
+  return NULL;
+}
+
+BASE_EXPORT template<class T>
+T* ObjCCastStrict(id objc_val) {
+  T* rv = ObjCCast<T>(objc_val);
+  DCHECK(objc_val == NULL || rv);
+  return rv;
+}
+
+#endif

[Mark Mentovai, 2011/10/19 22:59:32]

#endif  // defined(__OBJC__)

+
 }  // namespace mac
 }  // namespace base
 
 // Stream operations for CFTypes. They can be used with NSTypes as well
 // by using the NSToCFCast methods above.
 // e.g. LOG(INFO) << base::mac::NSToCFCast(@"foo");
 // Operator << can not be overloaded for ObjectiveC types as the compiler
 // can not distinguish between overloads for id with overloads for void*.
 BASE_EXPORT extern std::ostream& operator<<(std::ostream& o,
                                             const CFErrorRef err);
 BASE_EXPORT extern std::ostream& operator<<(std::ostream& o,
                                             const CFStringRef str);
 
 #endif  // BASE_MAC_FOUNDATION_UTIL_H_