---
title: WWDC2000 Session 125
framework: wwdc
role: article
path: wwdc/wwdc2000-125
---

# WWDC2000 Session 125

## Transcript

Kind: captions Language: en ladies and gentlemen please welcome the is right Mac os10 applications technology manager welcome everybody session 125 core foundation advanced so after the last session I heard two comments one developer said the stuff was blowing him away and someone else said they can't get the wait to get their hands on it so I'm really pleased to introduce more of it in this advanced session so at this time please welcome Becky will rich from the cocoa framework team thank you David Wow well welcome back so we're just going to continue what we started talking about this morning helps if you hold it right side up just a little Keith I'm Becky will rich still and what we're going to do today in this afternoon is continue where the core foundation basics picked up so for those of you that maybe did not make this morning's talk we're going to repeat some of the initial parts where we talked about where core foundation lives inside of Mac OS 10 and then we're going to move on and look at some of the system the subsystems and services that core foundation provides so in particular we're going to be looking at CF bundle and CF plug-in and and what what they can do for you then we're going to talk a little bit about preferences and how CF can make it easier for you to manage user preferences in your application we're going to look very briefly at what XML services are provided and then finally we're going to spend a moment talking about advanced memory tricks that you can use it when working with core foundation as I mentioned in this morning's talk corefoundation lives right above the operating system layer and at that layer we are very concerned with performance because we impact most everything that runs on the system that's reflected in the api's and there are a number of advanced tricks you can use to reduce your memory footprint so just to repeat what I said this morning core foundation is the lingua franca on Mac Mac os10 it is the language by which you can communicate across both carbon and so those the same definition you saw this morning a medium of communication between peoples of different languages and for us we're interested in communicating between carbon and cocoa so there is the architecture diagram for Mac OS 10 and there we are inside the core services layer the core services layer remember is that layer where many common common application needs are provided that are below the graphics layer so in particular you'll see the file manager inside of there the alias resource managers as well and beneath all of that is core foundation providing the basic types used throughout the system so this morning we talked about the basic data types in core foundation strings arrays dictionaries and then finally how it all came together is property list now we're going to focus on the second half of the equation the non graphical services that core foundation provides to all its clients in particular we're going to look at localization support as provided by CF bundle and user preferences so what do I mean when I talk about a CF service what I'm talking about is an integrated sub sub system that's built based on the CF types that we saw this morning there are several inside core foundation some of which you are likely to never use yourself CF run loop is an example that's we use the run loop to maintain the main event loop in both carbon and Coco applications in all likelihood you'll never need to use it but it's silently doing its work inside of a carbon application or a Coco application others you will find yourself using directly see a bundle is an example of that so this this afternoon we're going to be talking particularly about CF bundle which you will use to get at the different pieces inside your applications package CF preferences which you can use to store user preferences see if preferences will do the work of reading and writing to file and creating the persistency format for you CF XML parser which if you're interested in parsing XML files obviously will give you a hand so with that I'm going to turn the stage over to Doug Davidson my colleague who's going to spend some time talking about bundles in the app packaging scheme Doug so I'm Doug Davidson good afternoon I'm here to talk to you about bundles what they are what they do how to use them by the end of this talk you should know what bundles are and what they can do for you how to use the CF bundle api's deal with them and where to go to get more detailed information about them so first of all what is the bundle bundle is a way to treat all of the files associated with an executable as a single object now once upon a time an application was a single simple thing just an executable file but applications need resources so you add a resource for can you put resources in there and you still have a single file but applications have a way of accumulating other files with them additional executables libraries text files quicktime content HTM all sorts of stuff now it's Nicholas ten it gets even worse because you might want to have potentially different versions of this stuff one for Michael is 8 9 14 michaelis 10 plus this is a multilingual system which means if you would want to have different versions of these some of these things for the different languages or language regions that your applications look lies into so how are you going to hold all this stuff the answer is in a bundle now what can a bundle whole first of all a bundle can be wrapped around many different kinds of executables application packages are bundles frameworks are bundles they have loadable bundles plugins can be bundled and a bundle can contain multiple executables and it can potentially contain different versions of these executables one for mac OS 89 one from Michael 10 if you like what else can a bundle hold it can hold what we call bundle resources which are just any kind of file based resource these can be either localized or non localized anything you want to put in there quicktime content that interface builder nibs anything you want and CF bundle will then automatically look up and retrieved for you the right version of this resource based on the user's language preferences in the platform you're running on what else well of course you have resource manager resources as always and with bundles you can have some of your resources that are localized amnon localized potentially but some that are localized and CF bundle can load the correct version according to the user's language preferences what else metadata you can store information about your bundle and how it is configured in what we call the info dictionary or info.plist this is an XML property list particular dictionary the keys can be arbitrary strings Apple is defined a number that has special significance easier to see a bundle itself or to the finder but you can add as many as you like and the values then can be arbitrary property list types what else can you put in a bundle well a bundle is supposed to be self-contained your application should be able to contain everything it needs so you can put subsidiary bundles libraries frameworks etc inside the bundle or basically just anything you want some characteristics of bundles bundles are cross-platform that means Michael s89 and Mac os10 anything in them can be versioned one version for mac O's 891 version 4 10 they are multilingual you can have different versions of your resources or particular languages of particular language regions across binary on Mac os10 we have both CFM and Marco binaries and see a bundle will automatically know the difference understand both and automatically provide the glue to allow you to call between them self-contained movable reen amiable they're designed to be a single object to the user so that for example or install the teacher can just be drag and drop in the finder or you uninstall procedure just a drag-and-drop rename them as long as the internals are not touched the bundle to not break and finally filesystem independent that means the design so that is not necessary to use resource Forks so that these bundles can be moved to file systems that may not have support for different Forks so you could store them on arbitrary file system of arbitrary servers cd-rom etc and without loss of fidelity and just drag and drop from them or maybe you don't even need to install maybe just launch it directly from the server now i should say one thing that bundles don't provide is they don't provide a space for you to write on if you have files that you need to write out so it should probably go somewhere else and one reason for this is because your application might have been launched from a server from the cd-rom it's kind of hard to write to a cd-rom the next section of this talk nazia preferences will go into a little more detail about possible places where you can write out file now I thought that probably the best way to explain about fondles will be to just show you one so we can get the demo to hear I've made up the simple bundle this this happens to be an application package and i called it simple test and so here's my install procedure known as some copying to the desktop that's it here's my own install procedure let's see let's see that again okay now just one thing is obvious i will launch it double click on it and here's my application okay but close i prefer to work in french ok now i'm working in french here's my application in French well maybe I prefer Japanese now one thing I want you to notice is that this is not just picking a single language this is a preference order so suppose I prefer italian my second choice is German than French now I didn't actually localize this application into Italian so when I launch it when i get is my second choice it's with german so now let's take a look and see what's inside this model now what I want to say is this is a typical bundle layout but I don't want you to pay too much attention to exactly the details of where things are located is there are several variations just look at the various components and how they work together see a bundle understands all the variations past present and future and will be looking for you so what do we have first of all we have are executable this is the executable for mac OS 10 and there is another version of the executable for mac OS 8 and 9 called is labeled mackel is classic what else do we have we have the metadata that I talked about there's a special file called packaging so just hold to type and create our information and then we have the info.plist which altering so dictionary so I want to take a special look at that and here that is and i have set up a number of keys in here i just want to point out some of them CS fondle executable that is what tells see a bundle what your primary executable is for this bundle and see a bundled name is the name of the bunch and there are a number of others lse see a bundle identifier this is supposed to be a unique identification string for your bundle and we recommend that people use the format that may be familiar from Java which is calm dot your name up so forth first Internet name so just so that you'll get a unique string so each bundle can be uniquely identified now there are many possible teas that could go in the dictionary and some of them having significant see a bundle some of them have significance to other things like the finder there's going to be another talk tomorrow i believe it is on application packaging in particular which we'll discuss in much more detail what the finder wants to see and some of these entries in the dictionary can be localized themselves and i'll go into that a little later so what else is there in the bundle well we have the resources and first of all let's take a look at the non localized resources those it don't depend on which language using and simple tests are SRC this contains the non localized resource manager resources for this application in the data fork of that file and there is also another version of that simple test matt goss classic which contains the same thing but for mac OS 8 & 9 you don't actually you don't have to have that but if you have separate versions you can have separate versions for different platforms then I have an icon and though maybe a movie anything you want you can put in here now we also have localized resources and these are in separate folders for the seven languages in language regions so for english i have in localized rsrc i have the localized Resource Manager resources for this application and and I have the simple test nib which is one of interface builder interface definitions and if you haven't seen interface builder in action you really should then I have info.plist rings this is what contains the localization for any of these items in the info dictionary that need localizing and localizable dot string which contains localizations for other CS Turing's done we give special attention to the localization of CF strings because the cs string is our basics Unicode savvy internal at nationalisation ready strength and so it's the most common thing you want to localize and then anything else that I want to put in here and then you'll see that the French versions you have French versions of all these things-- and german and japanese and so forth and see if fondle automatically picks the right one based on the user's language preferences and on the platform there is also another talk tomorrow afternoon specifically on maccalister immobilization which will go into this in much more detail now we could get their slice back on so now we just talked about bundles as I live on the disk now what is the CF bundle CF bundle is the programmatic object that represents the bundle on the disk to your application so you know there's a bundle how do you create the CF bundle that corresponds to it canonical way to do so is simple you take the URL the points for the bundles location and pass it in to see up on they'll create and you're going to see a bundle if the code for the bundle is already loaded and running in your process then there are other ways to get ahold of CF bundle for example the bundle for the application itself is called the main bundle and you see a bundle get main bundle and it gives you the main bundle no arguments if you have some other bundle perhaps the framework or a loadable bundle plug in and you know that code is already loaded then you can look it up by its identifier remember the identifier with that unique string that we talked about this is very useful for example if you have a framework a loadable bundle you don't necessarily want to know exactly where it's located on the disk but once it's loaded inside its code you want to be able to find its bundle so you look it up by the identifier now then once you have a CF bundle what can you do with it well probably the most important most common thing is to look up these bundle resources again it's very simple see a bundle copy resource URL you pass you in the name the resource you want MCS on no returns of a URL that points to it it will look up the correct version based on the user's language preference again in the platform the nother thing you may want what to do is to look at the metadata it's on the info dictionary and CF fun will get value for intra dictionary key you pass in a key it passes a lot of value correctly localized if that particular value happens to be localized and there's also see a fund will get package info which the type and creator that I mentioned in the package info file what else can you do is step one well as I mentioned you can have resource manager resources and so there is a nape EIC a bundle open bundle resource files which simply opens both the non-local odds and the localized resource manager resource files for that application now in case of an application bundle you actually don't need to call this it will be done automatically for you or launch but if you have some other kind of bundle framework laudable bundle that had resource manager resources in it you might need to call this API yourself explicitly and as I mentioned we give special attention to the localization of CF strings and so we have a number of functions starting with CF copy localized string to get the localization to see a string out of files like the localizable dot strings that I mentioned what else can see a bundle do well cieplo know can also load code and on again it's very simple all you do is tell your bundle load see a bundle load executable and it loads the code see a bundle automatically figures out on OS 10 whether the code it's the ephemera ma co and uses the correct procedure loaded of course 10 s 89 it's just the FM and once you have the code loaded then you can if you want to call into it and you can look up functions by name and see a bundle will return you a function pointer and whether you're cup you are calling from CFM amok oh and whether the bundle you're loading is CFM bamako see a bundle automatically figures out and returns an appropriate function quarter in either case you can use to call one caveat though on DP floor if you are calling this from CFM then an order for it to work correctly you must have turned on the karbonn Ector libraries this is described in the code fragment manager release note on your CD in future this will be available all the times everyone okay now the next thing I wanted to talk about is CF plugin if you're writing plugins perhaps you have perhaps the functionality I just talked about is perfectly fine for you all you want to do is be able to load load code and look up functions by name or maybe you already have your own plug-in model that manages the interface between the application of plug-in yourself in that case you may not need to look at CS plugin at all however if you are looking for a sophisticated API for managing interfaces between an application and this plugins CF plugin maybe what you want to use and there are a number of apple projects which you may have heard about in various other things that will use the f plugin for their plugins and i don't really have time to go into the detail to see a plug-in right now this one is briefly describe what it does the application will describe the interfaces that it was looking for and the plug-in itself are advertised that information in its info dictionary or it can also register dynamically using the API and then the application will then look at the plug-in interrogated see if what interfaces is support the interfaces are looked up by uuid which is the universal identifier and the interfaces are tables and function pointers they are calm compatible if you use calm in particular we specify the I unknown interface we're not using calm but they should be compatible lay out there is an example of this detail example in the CF bundle mcf plug-in release note and really this is something that is best learn by example so now what I want to reiterate is you take home is bundles our way to treat all the files associated with an executable as a single object and CF bundle is the programmatic interface that you will use to deal with them so I'm going to turn things back over to Becky thanks Doug look simpler than what you're doing today good that's the idea okay so I'm going to go on now to talk about the user preferences services that core foundation provides and it provides its vs CF preferences the idea was to give you a mechanism for easily storing and retrieving your user preferences without forcing you to define your own files your own file structure you give every every preference a name then you assign a value to that name the value can be any of the property list types we talked about this morning you can even make it an array or a dictionary with complex with a complex structure underneath and then you hand it off to us and we handle everything else and in particular the data format and the storage is our problem not yours you will always be dealing with the CF type so the details these are kind of internal implementation details but i thought i'd share them with you anyway we use xml for most of the backing stores there are a couple exceptions to that when in particular when we have to share across the network we cache preference values for efficiency so that every time you ask for a preference and every time you write a preference we don't actually hit the disk and CF preferences like all of core foundation is a thread-safe system the caveats CF preferences is not intended for hundreds upon hundreds of caves of data Doug mentioned that if your application needs to write data it should not go into the bundle you can put it in preferences if it's of an appropriate size in nature on the other hand if you need to write hundreds of K of data you have two solutions available to you if it's a temporary cash write it to the temporary folder if you need a permanent storage mechanism you can still use fine folder to find the Preferences folder and write your own data there that way however we are using property list property lists or XML I may have all the same serialization problems I talked about this morning their band is best used for under 100k of data also CF preferences is not intended for app critical data well what do I mean by that most people consider their preference is critical well I simply mean that if it turns out that a preference value is not in the preferences file your app should not crash okay likewise if someone has gone in there and written a bad value your app should not crash we guarantee when we read the file that if the file itself is corrupted will fail we will fail gracefully and return null your job is just to catch that and make sure that you're not going to crash because we couldn't we couldn't load your preferences to the API is very simple most clients are only ever going to need these three functions CF preferences copy app value will read a preference CF preferences right app value will take a preference value from you and write it out and then see if preferences app synchronizes what you use to synchronize the cache with the permanent storage if you call CF preferences app synchronized every time you read or write a preference then you know you've defeated the cash the idea here is that you would write several preferences at once and then synchronize the cash or perhaps even leave it to a lower library to do the synchronization for you so let's take a look at the three functions in detail CF preferences copy app value takes two arguments the first one is the key or the name of the preference you wish to retrieve and the second the second argument is a string which identifies your application this is going to get a cod CF preferences to go out and look at all the various places that preferences are stored find a match for the key and it's fine assuming it's fine such a match it will return the value the other half is writings you have preferences set appt value you supply the key the new value and again your application ID once you've written make sure that at some point in the future you call CF preferences app synchronize or you know that a library is going to do you do it for you this is mostly of interest for cocoa applications the cocoa frameworks will synchronize for you so what was that application ID in the API most of the time you're simply going to pass KCF preferences current application and that says this is this is a preference for the current application UCF bundles abilities to locate the correct place to store this information in those cases where you're writing code that needs to write preferences to other locations the apps are going to be identified by their bundle identifier we chose the bundle identifier because the bundle ID as Doug mentioned is unique so as he showed you the bundle ID should be set somewhere in the info.plist under the CF bundle identifier key and should be of the form com company named Daphnis now if the f preferences is asked to write a preference for an application that has not set this key see if preferences is going to default back to using the applications name itself but you know as soon as you do that we run the risk of conflicts and that's why we're encouraging everyone to set the bundle identifier okay so there are a handful of convenience functions a lot of times when you're reading a preference value you just want a boolean value true false other times you just need you need to store an value so that's what these two functions are intended for see if preferences get at boolean value and see if preferences get app integer value in both of these cases it returns the value that it finds or if it can't find the value or the values not of the proper type type they default to different values you have preferences get app boolean value is going to return false get app integer value is going to return 0 if you're interested in the difference between a genuine zero value and the the preference not being properly set you use the second is valid argument and we will tell you whether we found a valid preference or not CS preferences these functions will go through and check for several different possible formats so by using CF preferences get at boolean value we will not only check for a true boo cf boolean type but also check for a CF string that matches true or false for instance and also check for some number formats so where are these preferences coming from I've mentioned a kind of alluded a couple different times to the fact that an application preferences could come from several different locations we call each of these locations a domain and then we combine all the different domains that are relevant to a particular application into what we call the search list and when we look for a preference for your application we're going to just walk the search list in a fixed order until we find what until we find the one we're looking for or we fall off the bottom of the list so what's the preference domain a preference preference domain is uniquely identified by three things the user the host and the applications identifier so I could for instance talk about the male preferences for the user Becky will rich on the host this particular host but you can also simply refer to each of these as either the current or any so I can look for the male preferences for the user Becky on the current host or a search for preferences set by by the mail application for the user Becky on any host if on a fully networked environment so in all cases current means the user host or application relevant to the current process the user who that's the user who ran the application the application being run and the host that the application is run on any means that the preference was not is not specific to a particular application so for instance it's very rare to want to write a preference for an application that's specific to just this host most of the time those preference and preferences go to the any host domains so just some examples the preferences for the current user on any host for the currently running application is the most common domain use this is where 90% of your preferences are going to be stored maybe ninety nine percent but you can have other combinations for instance the current user on any host for any any application I might want to set a global font preference in that domain for instance I might also have an have preference that pertains to any user on this particular host for any application so printer preferences might be an example of that once those domains are set here's where CF preferences look this is the search list in general we give preference to current settings over any settings we consider the current users preferences the most important and we consider application preferences more important than hosts so we start by looking at the most specific domain the current user for the current application for the current host and move downwards to the most general and you can see we're going to search all of the crew the current users default before looking at the global user defaults when we write preferences by default we're going to write it to that most common domain I was talking about this user this application but not specific to any particular host so once in a while you find yourself in a situation where you're writing four or five different applications that need to share preferences perhaps they're sharing a library that defines some common common functionality and there's a preference unique to that library in this in these cases you're going to want to use the sweet preferences provided by sea of preferences we consider the applications that are going to share the preferences to form the suite to do this you'll need to simply choose an identifier for your sweet usually if you're using a shared library we recommend that you use the bundles identifier for that for that purpose and then all the applications that link against that library or that wish to partake in the sweet simply add the sweet preferences to their search list they do this by calling CF preferences add sweet preferences to app the first argument is the app ID that's the application to which the sweet preferences will be added the second argument is the sweet ID which which tells us which sweet should be loaded once this is done all queries to CF preferences will search the sweet I the air the sweet preferences as well when you need to write sweet preferences you'd use the same API you would write an application preferences you simply substitute the sweets ID for the application ID once in a blue moon you may find yourself needing to access a specific domain without going through the search list this should be an incredibly rare occurrence in fact I don't think any application needs to do this except for an application like preferences which matt in which itself manages the full preferences database in this case we have the same three kinds of functions we have a read function or write function and a synchronized function however instead of specifying the preference location simply by app ID you're going to have to specify the full triplet of username hostname application name application ID I should say now there's some caveats if you find yourself doing this the first one is that not all of the domains are implemented in particular the defaults for any user any hosts are not implemented yet likewise on Mac OS 9 if you have not installed the login window or if you're not configured for multiple users current user doesn't make any sense the intention behind the low-level API is is to fail gracefully under these conditions and simply return null null to you however you have to be prepared for that on the other promise we make is that the app functions always work and properly take care of you of using only those domains that are relevant debugging preferences so you're an app developer and something's gone wrong there is a command-line tool on DP for it's a default command that allows power users to view and modify the Preferences database directly as I said you run it from the command line there are a number of different options i'm not going to go through them now but if you just go to the command line that executes default help you'll get the full details it's got a lengthy usage statement there and that's all I want to say about preferences so I'm going to go on now to spend a moment to talk about the XML services provided inside of course foundation there are basically three levels of XML supports the first one we've spent a fair bit of time talking about already that's property lists the second one is a handful of simple quick parsing functions that parse XML to and from XML trees and finally there's a fine-tuned parsing API available through CF XML parser so just a reminder of property lists as any tree built from the basic CF types I've listed them again here array dictionary data and string should handle 90 sense of your data on date number in boolean make up the rest property lists have a flattened XML representation and there's a very easy API to convert back and forth between the rich CF type tree and the flat XML data if you're interested in CF property list each for details there's also documentation on the web CF XML tree provides the next level of support well what is a CF XML tree a CF XML tree is a specialized form of a CF tree where each node in addition to just the basic tree structure stores a CF xmlnode the CF xmlnode provides information to you about the XML structure itself so are you looking at a tag are you looking at a comment is this a data string so and what you find yourself doing is to walk the tree structure of the xml file use the CF tree front the functions for cs3 get parents cfq get get child count and so on to examine the XML structure of a particular node use CF xmlnode so from the tree call CF XML tree get node that will give you the node then the node API can be used to extract the information specific to that to the XML structure the API looks like this just a couple functions CF XML tree create from data you pass it the allocator as with any create functions XML data is the flattened xml of the xml file just read from disk or retrieved over the internet or whatever source URL is the URL to use in for any relative references inside the XML data parse options has to do with the different options available on the parser and then the version this last field is very important the version number tells us which version of the API is you're working with as well as what version of XML you're working with we can guarantee binary compatibility for a fixed version number however as XML is revved by the w3c and as the standards change we expect to bump the version numbers and extend the API the other direction is to go from an XML tree to an XML data here the functions a little simpler you just pass an alligator for where to create the data from and the three in question we walk the tree generate the XML and hand it back to you alright so that's all very well and good if you're if you are happy with using the CF XML tree structure to represent the XML however since that can represent any XML file is fairly generic also since we're parsing the entire file and generating the entire tree in one pass it can be very memory expensive you've loaded the entire file into data and then we've duplicated that in constructing the tree for for higher performing and more customized behavior UCF XML parser CF XML parser is callback based it's much the same as shoot I'm blanking on the standard names the fax parsers I think there are a number of options available for configuring the parser that that was that parser option filled the that we looked at in the earlier API just a word of warning in DC for not all of the options are implemented the documentation has the full details and is up to date as to what implemented in DP for and what is not and that's as much as I want to say on XML I'm going to move on now to talk a little bit about some of the advanced memory tricks you can play with CF and I'm going to focus on CF string for those purposes the reason why i chose CF string to focus on in this conversation is well for several reasons first of all it's the most common CF type if people are you're going going to only use one thing from core foundation it's probably the string also it demonstrates many of the different memory strategies that are used throughout the system so once you know how to use CF strings optimizations the other API is should look very very straightforward to you and finally probably because it is the most common type CF stirring supports the most different kinds of memory optimizations so let's start with the simplest things you can do move towards immutable whenever possible immutable strings use the least amount of memory of any string because we don't have to worry about the extra overhead necessary to grow the string right likewise fixed mutable uses less than fully mutable secondly if you're going to have to walk the entire string fetch multiple characters at once and you can do that using beget characters API and simply pass a buffer of characters similarly there's a handful of functions that include the word PTR pointer the pointer functions ask that you check to see if the CF string has the desired type on hand in other words can you return this type to me and OH of one without any memory allocations without any work done now of course if the answer is no we're going to return null and you should be prepared for that so you might well see snippets of code like this CF string get Pascal string pointer if we have it will return it if not you need to check for null and if so you need to allocate a buffer for the for the Pascal string and then call the other um the sorry the other API CF string get Pascal string passing in your buffer and then we fill it a little more complex is to use an inline buffer and this case is useful when you're going to go over sequin when you're going to walk the entire length of the string or when you're going to be moving around a lot in a small area and then move forward and look in another small area so when in other words when your access is either sequential or highly localized it keeps the memory overhead down considerably from either walking character by character right from that in from walking character by character but still keeps the access very fast the cfd in line buffers are all implemented via inline functions and using these functions the actual CF string that provides the backing store from the characters is only rarely accessed and it looks like this create a CF string in line buffer that's a that's a structure that straight up see structure and you can create it on the stack as long as you know that you don't need to pass the buffer out from the from its scope initialize it with your CF string so you give it to CF string in it in line buffer give it the CF string in question give it a pointer to the buffer you allocated and then pass the range of characters you're going to be interested in looking at now when you need to fetch a character instead of going to the CF string go to be in line buffer CF string get character from in line buffer passes pointer to the buffer and the index of the character in question beyond that the most complex level of memory management is the no copy function the no copy functions create CF two strings around your own storage so you are not running into any memory copy overhead or double data overhead when you do this though you are transferring ownership of the backing storage to CF string that means you're going to tell CF string how to free the buffer when you're done um and if you're working with mutable strings you'll also have to tell CF string how to grow that buffer now using this trick you can even use buffers character buffers directly on the stack but if you do that there are a couple things you need to be very careful of first of all obviously if you pass the string outside of the scope of your stack buffer and you're going to have a memory exception right because the buffers been blown away likewise if you it's even within that even within the buffer scope you pass the string down to a function that then retains the string for later use you're going to have the same problem you're you're going to exit the scope of your buffer this whoever it was who retain the string thinks the string is still good but it's not so it looks like this CF string create with characters no copy the first allocator there KCF allocator default explains how the string itself should be allocated then you pass it a pointer to the characters that you have my buffer you pass it the length of the buffer and then finally you pass the buffer allocator this allocator is what the string is going to use to manage the memory of my buffer when the string is freed buffer allocator is going to be consulted on how to free the characters if the buffer needs to grow buffer allocator is going to be used to do that so normally you're going to simply pass my pass whatever allocator you use to allocate my buffer in the first place on the other hand if you don't want CF to do any management / over the my buffer memory pass KCF allocator null ok so these these final slides are mostly a repeat from the from this morning where you can go to get help there's a lot of documentation online it's available on the DP for CD of system developer documentation corefoundation it's available on the web at developer apple com tech pubs core foundation example code and system developer examples course foundation release notes system developer documentation release notes core foundation HTML there's a little additional information for bundle services however inside the release notes directory you will find several different documents of interest CF bundle MCS plug-in provides sample code on how you would use CF bundle and CF plugin to create a plug-in model info.plist describes the keys that we define inside the the bundles information p list that's where we configured all the finder information for the app package and localization dot HTML provides information on how to use the app packaging model to localize your app as simply and effectively as possible here are some of the other talks that you might be interested in core foundation basics already happened hopefully you all had a chance to see that carbon low level is Friday and you can see some of the other the other pieces that comprise that core services level the app packaging and document typing talk is going to go into the details of just exactly what the structure inside the app package is the localization talk will give you the details on how to go about localizing your app and then the localization tools talk will get tell you about the tools available on the system to help you with that oh yes one more thing who to contact David Wright is our technology manager he's the gentleman who introduced me and he'll be coming back up for the QA and we also have an external feedback list CF hyphen feedback at apple.com will reach all of the developers involved in core foundation and now I'm going to go