EGCustomType implementation in Obj-c

Here is the interface and implementation of class SampleCustomType in demo_advanced_objc inside the Client SDK:

[code2=objc]#import "Common-objc/inc/EGCustomType.h"

#define TYPECODE 1

@interface SampleCustomType : NSObject <EGCustomType>
{
@protected
nByte mFoo;
nByte mBar;
}

- (id) init;
- (id) init:(nByte) foo :(nByte)bar;
- (id) initWithCustomType:(SampleCustomType*)toCopy;
- (void) setData:(nByte)foo :(nByte)bar;

@end[/code2]

[code2=objc]#import "Foundation/NSString.h"
#import "demo_photon_CustomType_objc.h"

@implementation SampleCustomType

- (id) init
{
if(self=[super init])
{
mFoo = 0;
mBar = 0;
}
return self;
}

- (id) init:(nByte)foo :(nByte)bar
{
if(self=[super init])
{
mFoo = foo;
mBar = bar;
}
return self;
}

- (id) initWithCustomType:(SampleCustomType*)toCopy
{
if(self=[super init])
{
mFoo = toCopy->mFoo;
mBar = toCopy->mBar;
}
return self;
}

- (void) dealloc
{
[self cleanup];
[super dealloc];
}

- (nByte) TypeCode
{
return TYPECODE;
}

- (void) setData:(nByte)foo :(nByte)bar
{
mFoo = foo;
mBar = bar;
}


// CustomType callbacks

- (void) cleanup
{
}

- (bool) compare:(const SampleCustomType*)other
{
return mFoo == other->mFoo && mBar == other->mBar;
}

- (void) duplicate:(SampleCustomType* const)retVal
{
if(retVal)
{
retVal->mFoo = mFoo;
retVal->mBar = mBar;
}
}

- (void) deserialize:(const nByte* const)pData :(short)length
{
if(length!=2)
return; // something went wrong
mFoo = pData[0];
mBar = pData[1];
}

- (short) serialize:(nByte* const)retVal
{
if(retVal)
{
retVal[0] = mFoo;
retVal[1] = mBar;
}
return 2;
}

- (NSString*) typeToString
{
return [NSString stringWithFormat:@(;%@);", NSStringFromClass(self.class)];
}

- (NSString*) toString
{
return [self toString:false];
}

- (const NSString*) toString:(bool)withTypes
{
return [NSString stringWithFormat:@&lt;%@%d, %@%d&gt;", withTypes?[NSString stringWithFormat:@(;%@);", EG_STR_UCHAR]:@&quot;", mFoo, withTypes?[NSString stringWithFormat:@(;%@);", EG_STR_UCHAR]:@&quot;", mBar];
}
@end[/code2]


Your deserialize implementation looks definitely incorrect. You are dereferencing the first byte of the serialized data and are then casting the result to short, then you are jumping to the third byte, dereference it and cast the result into a short.
Imagine, your serialized data looks like 0x12 0x34 0x56 0x78, then your first short would end up to be 0x00 0x34 and the second would be 0x00 0x78.
I don't think that that is your intention.

So you should first cast and then dereference, not the other way round:
[code2=objc]-(void)deserialize:(const unsigned char * const)pData :(short)length
{
num = *(short*)pData;
suit = *(1+(short*)pData);
}[/code2]

Your outcommented duplicate implementation also doesn't look right.

It could look like this:
[code2=objc]- (void) duplicate:(SampleCustomType* const)retVal
{
if(retVal)
{
retVal->num = num;
retVal->suit = suit;
}
}[/code2]

Something like your *(Card *)retVal = *(Card *)self would more be the C++ way of doing it (with this instead of self of course), but won't work in objC.

Counting the calls to dealloc only makes sense if you also count the calls to duplicate. If the lib has internally made a copy of the object, then it of course will later release the original and the copy, if it has made 2 copies, then it will to release 3 objects, so dealloc will be called 3 times, although only one object has been past to your app, and so on. You should more look at the amount of calls to dealloc and at the timings, when they are happening as an implementation detail. The copy that gets passed to you will be valid until the end of the callback, as long as you don't invalidate it yourself.