keychain/ot/proto/generated_source/OTCDPRecoveryInformation.m

   1 // This file was automatically generated by protocompiler
   2 // DO NOT EDIT!
   3 // Compiled from OTCDPRecoveryInformation.proto
   4
   5 #import "OTCDPRecoveryInformation.h"
   6 #import <ProtocolBuffer/PBConstants.h>
   7 #import <ProtocolBuffer/PBHashUtil.h>
   8 #import <ProtocolBuffer/PBDataReader.h>
   9
  10 #if !__has_feature(objc_arc)
  11 # error This generated file depends on ARC but it is not enabled; turn on ARC, or use 'objc_use_arc' option to generate non-ARC code.
  12 #endif
  13
  14 @implementation OTCDPRecoveryInformation
  15
  16 - (BOOL)hasRecoverySecret
  17 {
  18     return _recoverySecret != nil;
  19 }
  20 @synthesize recoverySecret = _recoverySecret;
  21 @synthesize useCachedSecret = _useCachedSecret;
  22 - (void)setUseCachedSecret:(BOOL)v
  23 {
  24     _has.useCachedSecret = YES;
  25     _useCachedSecret = v;
  26 }
  27 - (void)setHasUseCachedSecret:(BOOL)f
  28 {
  29     _has.useCachedSecret = f;
  30 }
  31 - (BOOL)hasUseCachedSecret
  32 {
  33     return _has.useCachedSecret != 0;
  34 }
  35 - (BOOL)hasRecoveryKey
  36 {
  37     return _recoveryKey != nil;
  38 }
  39 @synthesize recoveryKey = _recoveryKey;
  40 @synthesize usePreviouslyCachedRecoveryKey = _usePreviouslyCachedRecoveryKey;
  41 - (void)setUsePreviouslyCachedRecoveryKey:(BOOL)v
  42 {
  43     _has.usePreviouslyCachedRecoveryKey = YES;
  44     _usePreviouslyCachedRecoveryKey = v;
  45 }
  46 - (void)setHasUsePreviouslyCachedRecoveryKey:(BOOL)f
  47 {
  48     _has.usePreviouslyCachedRecoveryKey = f;
  49 }
  50 - (BOOL)hasUsePreviouslyCachedRecoveryKey
  51 {
  52     return _has.usePreviouslyCachedRecoveryKey != 0;
  53 }
  54 @synthesize silentRecoveryAttempt = _silentRecoveryAttempt;
  55 - (void)setSilentRecoveryAttempt:(BOOL)v
  56 {
  57     _has.silentRecoveryAttempt = YES;
  58     _silentRecoveryAttempt = v;
  59 }
  60 - (void)setHasSilentRecoveryAttempt:(BOOL)f
  61 {
  62     _has.silentRecoveryAttempt = f;
  63 }
  64 - (BOOL)hasSilentRecoveryAttempt
  65 {
  66     return _has.silentRecoveryAttempt != 0;
  67 }
  68 @synthesize containsIcdpData = _containsIcdpData;
  69 - (void)setContainsIcdpData:(BOOL)v
  70 {
  71     _has.containsIcdpData = YES;
  72     _containsIcdpData = v;
  73 }
  74 - (void)setHasContainsIcdpData:(BOOL)f
  75 {
  76     _has.containsIcdpData = f;
  77 }
  78 - (BOOL)hasContainsIcdpData
  79 {
  80     return _has.containsIcdpData != 0;
  81 }
  82 @synthesize usesMultipleIcsc = _usesMultipleIcsc;
  83 - (void)setUsesMultipleIcsc:(BOOL)v
  84 {
  85     _has.usesMultipleIcsc = YES;
  86     _usesMultipleIcsc = v;
  87 }
  88 - (void)setHasUsesMultipleIcsc:(BOOL)f
  89 {
  90     _has.usesMultipleIcsc = f;
  91 }
  92 - (BOOL)hasUsesMultipleIcsc
  93 {
  94     return _has.usesMultipleIcsc != 0;
  95 }
  96
  97 - (NSString *)description
  98 {
  99     return [NSString stringWithFormat:@"%@ %@", [super description], [self dictionaryRepresentation]];
 100 }
 101
 102 - (NSDictionary *)dictionaryRepresentation
 103 {
 104     NSMutableDictionary *dict = [NSMutableDictionary dictionary];
 105     if (self->_recoverySecret)
 106     {
 107         [dict setObject:self->_recoverySecret forKey:@"recovery_secret"];
 108     }
 109     if (self->_has.useCachedSecret)
 110     {
 111         [dict setObject:[NSNumber numberWithBool:self->_useCachedSecret] forKey:@"use_cached_secret"];
 112     }
 113     if (self->_recoveryKey)
 114     {
 115         [dict setObject:self->_recoveryKey forKey:@"recovery_key"];
 116     }
 117     if (self->_has.usePreviouslyCachedRecoveryKey)
 118     {
 119         [dict setObject:[NSNumber numberWithBool:self->_usePreviouslyCachedRecoveryKey] forKey:@"use_previously_cached_recovery_key"];
 120     }
 121     if (self->_has.silentRecoveryAttempt)
 122     {
 123         [dict setObject:[NSNumber numberWithBool:self->_silentRecoveryAttempt] forKey:@"silent_recovery_attempt"];
 124     }
 125     if (self->_has.containsIcdpData)
 126     {
 127         [dict setObject:[NSNumber numberWithBool:self->_containsIcdpData] forKey:@"contains_icdp_data"];
 128     }
 129     if (self->_has.usesMultipleIcsc)
 130     {
 131         [dict setObject:[NSNumber numberWithBool:self->_usesMultipleIcsc] forKey:@"uses_multiple_icsc"];
 132     }
 133     return dict;
 134 }
 135
 136 BOOL OTCDPRecoveryInformationReadFrom(__unsafe_unretained OTCDPRecoveryInformation *self, __unsafe_unretained PBDataReader *reader) {
 137     while (PBReaderHasMoreData(reader)) {
 138         uint32_t tag = 0;
 139         uint8_t aType = 0;
 140
 141         PBReaderReadTag32AndType(reader, &tag, &aType);
 142
 143         if (PBReaderHasError(reader))
 144             break;
 145
 146         if (aType == TYPE_END_GROUP) {
 147             break;
 148         }
 149
 150         switch (tag) {
 151
 152             case 1 /* recoverySecret */:
 153             {
 154                 NSString *new_recoverySecret = PBReaderReadString(reader);
 155                 self->_recoverySecret = new_recoverySecret;
 156             }
 157             break;
 158             case 2 /* useCachedSecret */:
 159             {
 160                 self->_has.useCachedSecret = YES;
 161                 self->_useCachedSecret = PBReaderReadBOOL(reader);
 162             }
 163             break;
 164             case 3 /* recoveryKey */:
 165             {
 166                 NSString *new_recoveryKey = PBReaderReadString(reader);
 167                 self->_recoveryKey = new_recoveryKey;
 168             }
 169             break;
 170             case 4 /* usePreviouslyCachedRecoveryKey */:
 171             {
 172                 self->_has.usePreviouslyCachedRecoveryKey = YES;
 173                 self->_usePreviouslyCachedRecoveryKey = PBReaderReadBOOL(reader);
 174             }
 175             break;
 176             case 5 /* silentRecoveryAttempt */:
 177             {
 178                 self->_has.silentRecoveryAttempt = YES;
 179                 self->_silentRecoveryAttempt = PBReaderReadBOOL(reader);
 180             }
 181             break;
 182             case 6 /* containsIcdpData */:
 183             {
 184                 self->_has.containsIcdpData = YES;
 185                 self->_containsIcdpData = PBReaderReadBOOL(reader);
 186             }
 187             break;
 188             case 7 /* usesMultipleIcsc */:
 189             {
 190                 self->_has.usesMultipleIcsc = YES;
 191                 self->_usesMultipleIcsc = PBReaderReadBOOL(reader);
 192             }
 193             break;
 194             default:
 195                 if (!PBReaderSkipValueWithTag(reader, tag, aType))
 196                     return NO;
 197                 break;
 198         }
 199     }
 200     return !PBReaderHasError(reader);
 201 }
 202
 203 - (BOOL)readFrom:(PBDataReader *)reader
 204 {
 205     return OTCDPRecoveryInformationReadFrom(self, reader);
 206 }
 207 - (void)writeTo:(PBDataWriter *)writer
 208 {
 209     /* recoverySecret */
 210     {
 211         if (self->_recoverySecret)
 212         {
 213             PBDataWriterWriteStringField(writer, self->_recoverySecret, 1);
 214         }
 215     }
 216     /* useCachedSecret */
 217     {
 218         if (self->_has.useCachedSecret)
 219         {
 220             PBDataWriterWriteBOOLField(writer, self->_useCachedSecret, 2);
 221         }
 222     }
 223     /* recoveryKey */
 224     {
 225         if (self->_recoveryKey)
 226         {
 227             PBDataWriterWriteStringField(writer, self->_recoveryKey, 3);
 228         }
 229     }
 230     /* usePreviouslyCachedRecoveryKey */
 231     {
 232         if (self->_has.usePreviouslyCachedRecoveryKey)
 233         {
 234             PBDataWriterWriteBOOLField(writer, self->_usePreviouslyCachedRecoveryKey, 4);
 235         }
 236     }
 237     /* silentRecoveryAttempt */
 238     {
 239         if (self->_has.silentRecoveryAttempt)
 240         {
 241             PBDataWriterWriteBOOLField(writer, self->_silentRecoveryAttempt, 5);
 242         }
 243     }
 244     /* containsIcdpData */
 245     {
 246         if (self->_has.containsIcdpData)
 247         {
 248             PBDataWriterWriteBOOLField(writer, self->_containsIcdpData, 6);
 249         }
 250     }
 251     /* usesMultipleIcsc */
 252     {
 253         if (self->_has.usesMultipleIcsc)
 254         {
 255             PBDataWriterWriteBOOLField(writer, self->_usesMultipleIcsc, 7);
 256         }
 257     }
 258 }
 259
 260 - (void)copyTo:(OTCDPRecoveryInformation *)other
 261 {
 262     if (_recoverySecret)
 263     {
 264         other.recoverySecret = _recoverySecret;
 265     }
 266     if (self->_has.useCachedSecret)
 267     {
 268         other->_useCachedSecret = _useCachedSecret;
 269         other->_has.useCachedSecret = YES;
 270     }
 271     if (_recoveryKey)
 272     {
 273         other.recoveryKey = _recoveryKey;
 274     }
 275     if (self->_has.usePreviouslyCachedRecoveryKey)
 276     {
 277         other->_usePreviouslyCachedRecoveryKey = _usePreviouslyCachedRecoveryKey;
 278         other->_has.usePreviouslyCachedRecoveryKey = YES;
 279     }
 280     if (self->_has.silentRecoveryAttempt)
 281     {
 282         other->_silentRecoveryAttempt = _silentRecoveryAttempt;
 283         other->_has.silentRecoveryAttempt = YES;
 284     }
 285     if (self->_has.containsIcdpData)
 286     {
 287         other->_containsIcdpData = _containsIcdpData;
 288         other->_has.containsIcdpData = YES;
 289     }
 290     if (self->_has.usesMultipleIcsc)
 291     {
 292         other->_usesMultipleIcsc = _usesMultipleIcsc;
 293         other->_has.usesMultipleIcsc = YES;
 294     }
 295 }
 296
 297 - (id)copyWithZone:(NSZone *)zone
 298 {
 299     OTCDPRecoveryInformation *copy = [[[self class] allocWithZone:zone] init];
 300     copy->_recoverySecret = [_recoverySecret copyWithZone:zone];
 301     if (self->_has.useCachedSecret)
 302     {
 303         copy->_useCachedSecret = _useCachedSecret;
 304         copy->_has.useCachedSecret = YES;
 305     }
 306     copy->_recoveryKey = [_recoveryKey copyWithZone:zone];
 307     if (self->_has.usePreviouslyCachedRecoveryKey)
 308     {
 309         copy->_usePreviouslyCachedRecoveryKey = _usePreviouslyCachedRecoveryKey;
 310         copy->_has.usePreviouslyCachedRecoveryKey = YES;
 311     }
 312     if (self->_has.silentRecoveryAttempt)
 313     {
 314         copy->_silentRecoveryAttempt = _silentRecoveryAttempt;
 315         copy->_has.silentRecoveryAttempt = YES;
 316     }
 317     if (self->_has.containsIcdpData)
 318     {
 319         copy->_containsIcdpData = _containsIcdpData;
 320         copy->_has.containsIcdpData = YES;
 321     }
 322     if (self->_has.usesMultipleIcsc)
 323     {
 324         copy->_usesMultipleIcsc = _usesMultipleIcsc;
 325         copy->_has.usesMultipleIcsc = YES;
 326     }
 327     return copy;
 328 }
 329
 330 - (BOOL)isEqual:(id)object
 331 {
 332     OTCDPRecoveryInformation *other = (OTCDPRecoveryInformation *)object;
 333     return [other isMemberOfClass:[self class]]
 334     &&
 335     ((!self->_recoverySecret && !other->_recoverySecret) || [self->_recoverySecret isEqual:other->_recoverySecret])
 336     &&
 337     ((self->_has.useCachedSecret && other->_has.useCachedSecret && ((self->_useCachedSecret && other->_useCachedSecret) || (!self->_useCachedSecret && !other->_useCachedSecret))) || (!self->_has.useCachedSecret && !other->_has.useCachedSecret))
 338     &&
 339     ((!self->_recoveryKey && !other->_recoveryKey) || [self->_recoveryKey isEqual:other->_recoveryKey])
 340     &&
 341     ((self->_has.usePreviouslyCachedRecoveryKey && other->_has.usePreviouslyCachedRecoveryKey && ((self->_usePreviouslyCachedRecoveryKey && other->_usePreviouslyCachedRecoveryKey) || (!self->_usePreviouslyCachedRecoveryKey && !other->_usePreviouslyCachedRecoveryKey))) || (!self->_has.usePreviouslyCachedRecoveryKey && !other->_has.usePreviouslyCachedRecoveryKey))
 342     &&
 343     ((self->_has.silentRecoveryAttempt && other->_has.silentRecoveryAttempt && ((self->_silentRecoveryAttempt && other->_silentRecoveryAttempt) || (!self->_silentRecoveryAttempt && !other->_silentRecoveryAttempt))) || (!self->_has.silentRecoveryAttempt && !other->_has.silentRecoveryAttempt))
 344     &&
 345     ((self->_has.containsIcdpData && other->_has.containsIcdpData && ((self->_containsIcdpData && other->_containsIcdpData) || (!self->_containsIcdpData && !other->_containsIcdpData))) || (!self->_has.containsIcdpData && !other->_has.containsIcdpData))
 346     &&
 347     ((self->_has.usesMultipleIcsc && other->_has.usesMultipleIcsc && ((self->_usesMultipleIcsc && other->_usesMultipleIcsc) || (!self->_usesMultipleIcsc && !other->_usesMultipleIcsc))) || (!self->_has.usesMultipleIcsc && !other->_has.usesMultipleIcsc))
 348     ;
 349 }
 350
 351 - (NSUInteger)hash
 352 {
 353     return 0
 354     ^
 355     [self->_recoverySecret hash]
 356     ^
 357     (self->_has.useCachedSecret ? PBHashInt((NSUInteger)self->_useCachedSecret) : 0)
 358     ^
 359     [self->_recoveryKey hash]
 360     ^
 361     (self->_has.usePreviouslyCachedRecoveryKey ? PBHashInt((NSUInteger)self->_usePreviouslyCachedRecoveryKey) : 0)
 362     ^
 363     (self->_has.silentRecoveryAttempt ? PBHashInt((NSUInteger)self->_silentRecoveryAttempt) : 0)
 364     ^
 365     (self->_has.containsIcdpData ? PBHashInt((NSUInteger)self->_containsIcdpData) : 0)
 366     ^
 367     (self->_has.usesMultipleIcsc ? PBHashInt((NSUInteger)self->_usesMultipleIcsc) : 0)
 368     ;
 369 }
 370
 371 - (void)mergeFrom:(OTCDPRecoveryInformation *)other
 372 {
 373     if (other->_recoverySecret)
 374     {
 375         [self setRecoverySecret:other->_recoverySecret];
 376     }
 377     if (other->_has.useCachedSecret)
 378     {
 379         self->_useCachedSecret = other->_useCachedSecret;
 380         self->_has.useCachedSecret = YES;
 381     }
 382     if (other->_recoveryKey)
 383     {
 384         [self setRecoveryKey:other->_recoveryKey];
 385     }
 386     if (other->_has.usePreviouslyCachedRecoveryKey)
 387     {
 388         self->_usePreviouslyCachedRecoveryKey = other->_usePreviouslyCachedRecoveryKey;
 389         self->_has.usePreviouslyCachedRecoveryKey = YES;
 390     }
 391     if (other->_has.silentRecoveryAttempt)
 392     {
 393         self->_silentRecoveryAttempt = other->_silentRecoveryAttempt;
 394         self->_has.silentRecoveryAttempt = YES;
 395     }
 396     if (other->_has.containsIcdpData)
 397     {
 398         self->_containsIcdpData = other->_containsIcdpData;
 399         self->_has.containsIcdpData = YES;
 400     }
 401     if (other->_has.usesMultipleIcsc)
 402     {
 403         self->_usesMultipleIcsc = other->_usesMultipleIcsc;
 404         self->_has.usesMultipleIcsc = YES;
 405     }
 406 }
 407
 408 @end
 409