iOS中跨设备的32/64位CGPoint持久性

Question

I've inherited some freehand drawing code which records a CGPathRef of points that are then converted to a collection of CGPoints which eventually get saved within our core data DB as NSData .

Current conversion code looks like this:

    @interface StoredPath : NSObject
    {
        CGPathRef path;
    }


@implementation StoredPath

            - (NSArray *)getPoints
            {
                // Convert path to an array
                NSMutableArray *a = [NSMutableArray arrayWithObject:[NSNumber numberWithBool:YES]];

                CGPathApply(path, (__bridge void *)(a), saveApplier);
                if (![[a objectAtIndex:0] boolValue])
                {
                    return nil;
                }

                [a removeObjectAtIndex:0];

                return (a);
            }


        static void saveApplier(void *info, const CGPathElement *element)
        {
            NSMutableArray *a = (__bridge NSMutableArray*) info;

            int nPoints;
            switch (element->type)
            {
                case kCGPathElementMoveToPoint:
                    nPoints = 1;
                    break;
                case kCGPathElementAddLineToPoint:
                    nPoints = 1;
                    break;
                case kCGPathElementAddQuadCurveToPoint:
                    nPoints = 2;
                    break;
                case kCGPathElementAddCurveToPoint:
                    nPoints = 3;
                    break;
                case kCGPathElementCloseSubpath:
                    nPoints = 0;
                    break;
                default:
                    [a replaceObjectAtIndex:0 withObject:[NSNumber numberWithBool:NO]];
                    return;
            }

            NSNumber *type = [NSNumber numberWithInt:element->type];

            NSData *points = [NSData dataWithBytes:element->points length:nPoints*sizeof(CGPoint)];

            [a addObject:[NSDictionary dictionaryWithObjectsAndKeys:type, @"type", points, @"points", nil]];
        }

@end

The important part to notice here is the line:

NSData *points = [NSData dataWithBytes:element->points length:nPoints*sizeof(CGPoint)];

It preserves the CGPoint data into a compact NSData object, which then gets saved in our core data DB.

This was fine when the app's data only lived on a single device. But now that this data is synced to other devices, it breaks down due to CGFloat (makes up CGPoint struct) being 32bit or 64bit on various iOS devices.

When the 32bit NSData of CGPoints is read on a 64bit iOS device, the bytes don't quite align and the drawing gets mangled. The same of course happens in vice-versa (64bit NSData of CGPoints is read on a 32bit iOS device).

I've been struggling to refactor this saveApplier: method in a way that is platform independent and can be easily saved in core data.

Update:

I'm considering packing the points into a "|" separated string.

example: pointsToSave = {442, 797.5}|{442, 797.5}|{442, 797.5}

NSString *pointsToSave = [[NSString alloc] init];

// Convert CGPoint's to a "|" separated string.
for (int i=0; i<nPoints; i++)
{
    pointsToSave = [pointsToSave stringByAppendingString:NSStringFromCGPoint(element->points[i])];

    if ((i+1)<nPoints)
    {
        pointsToSave = [pointsToSave stringByAppendingString:@"|"];
    }
}

It makes it fairly simple to parse between platforms as well.

Thoughts?

Answer 1

You could pick either float or double as the data type to save with. This will explicitly set the size, since float is 32-bit and double is 64-bit.

For example, if you want more compactness, you could do this:

float *floats = [self pointsToFloats:element->points];
NSData *points = [NSData dataWithBytes:floats length:nPoints*sizeof(float)*2];

free(floats); // Note will need to free, since assuming pointsToFloats uses malloc. Use delete if you use new.

Where pointsToFloats would be defined something like:

- (float *)pointsToFloats:(CGPoint *)points; // Assuming this is straight-forward enough to implement

This also means you'll need something to unpack the data too.

- (CGPoint *)floatsToPoints:(float *)floats;

You can also use double if you need more precision.

There are of course others ways of doing this too.