Question

I need to change the header informations of a file in document folder.
What is the most recommended way to read and write back binary data?

1. How to read the data from document folder binary to array / stream
2. How to write the data back from array / stream to local iPad document folder?

Answer 1

This one is hard to answer without you being a little more specific, but the most efficient way to do this would arguably be to not change the file at all.

Since we’re talking about iOS, there is no file-system-level access to those documents apart from your application itself. So why not save the additional/customized header data that you want to associate with your files in an application-wide meta-data-store (like e.g. iTunes or iPhoto do) and interleave them with the actual file headers during exports only?

Regardless of that, I don’t really see a compelling reason to drop down to the C-level file functions to change those data: NSInputStream provides you with streaming file reading-access and NSOutputStream can be used to stream data to a file.

If you go with my suggestion from above you’d likely end up with an API like this:

typedef void (^DataExportHandler)(NSData *resultData, NSError *exportError);

@interface DataStore (FileExport)

/** If you wanted to abort the export, you could pass the stream into the `abort…:`-method
@param  identifier  Something that you use internally to manage your stored files.
@param  error       For good measure…
@return The export stream for the object or `nil` if an error occurred.
*/
- (NSInputStream *)exportStreamForObjectWithIdentifier:(id)identifier error:(NSError * __autoreleasing*)error;

/** If your data are mostly small, it may be more convenient to not consume the exports as streams but as BLOBs, if the sizes vary you could implement this as a convenience…
@param  identifier  Equivalent to the identifier in the method above
@param  handler     Callback that is invoked once some time later when the export finished or failed. **Must not** be `nil`.
*/
@return A cancellation token.
- (id)asynchronouslyExportDataForObjectWithIdentifier:(id)identifier resultHandler:(DataExportHandler)handler;

/**
@param  exportToken  Either a stream from the first method or a token returned from the second one.
*/
- (void)abortAsynchronousExportWithToken:(id)exportToken;

@end

Assuming ARC and not knowing what you have to do to interleave the additional metadata with the original, here is what the boilerplate part of the implementation might look like.

The beef would clearly be in the part that I don’t show here: implementation of the delegate for the rawDataStream where you’d consume the data from the original file, interleaving the headers with your additional information.
Although this should probably be factored out into a separate class, I’ve just implied that the data-store implements the NSStreamDelegate callbacks accordingly.

After the headers you’d just pass through the rest of the file…

/// Scribble of another helper class that can be used whenever one needs to consume a stream for its aggregate data:
@interface _StreamConsumer : NSObject <NSStreamDelegate> {
    NSInputStream *_stream;
    DataExportHandler _handler;
    NSMutableData *_data;
}

// initiate the data, set itself as the stream’s delegate, open and schedule the stream in a runloop.
- (id)initWithInputStream:(NSInputStream *)stream resultHandler:(DataExportHandler)handler;

// forward the close to the stream
- (void)close;

// Implementation of the stream delegate callbacks can be more or less copy-pasted from Apple’s Stream Programming Guide (https://developer.apple.com/library/ios/documentation/Cocoa/Conceptual/Streams/Streams.html)
@end

@implementation DataStore (FileExport)

- (id)asynchronouslyExportDataForObjectWithIdentifier:(id)someUniqueIdentifier resultHandler:(void (^)(NSData *fileData, NSError *exportError))
{
    NSParameterAssert(handler);
    handler = [handler copy];

    NSError *setupError;
    NSInputStream *exportStream = [self exportStreamForObjectWithIdentifier:someUniqueIdentifier error:&setupError];
    if (!exportStream)
    {
        dispatch_async(dispatch_get_current_queue(), ^{
            handler(nil, setupError);
        });

        return nil;
    }

    _StreamConsumer *helper = [[_StreamConsumer alloc] initWithStream:exportStream resultHandler:handler];

    return helper;
}

- (void)abortAsynchronousExportWithToken:(id)exportToken
{
    [exportToken close];
}

- (NSInputStream *)exportStreamForObjectWithIdentifier:(id)identifier error:(NSError * __autoreleasing*)error
{
    // do your thing to retrieve the URL to the actual data-file and then:
    NSInputStream *rawDataStream = [NSInputStream inputStreamWithURL:rawFileURL];

    if (!rawDataStream)
    {
        // populate the error in a meaningful way
        return nil;
    }

    CFReadStream cfExportStream;
    CFWriteStream cfBuffer;
    CFStreamCreateBoundPair(kCFAllocatorDefault, &cfExportStream, &cfBuffer, someValueYouHaveTuned);

    if (!cfExportStream || !cfBuffer)
    {
        // error population
        return nil;
    }

    NSInputStream *exportStream = (__bridge_transfer NSInputStream *)cfExportStream;

    // HACKITY HACK: In reality, you’d want this stuff separated!
    // For the sake of simplicity, take the responsibility for that ourselves
    _exportBuffer = (__bridge_transfer NSOutputStream *)cfBuffer;

    rawDataStream.delegate = self;
    [rawDataStream open];
    [rawDataStream scheduleInRunLoop:[NSRunLoop currentRunLoop] forMode:NSRunloopDefaultMode];
    // END: HACKITY HACK

    return exportStream;
}

@end