cocoapods-catalyst-validator 0.1.0.beta.1 → 0.1.0.beta.2

data/examples/AExample/Pods/GoogleDataTransport/GoogleDataTransport/GDTCORLibrary/GDTCORFlatFileStorage.m

@@ -1,826 +0,0 @@
-/*
- * Copyright 2018 Google
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#import "GoogleDataTransport/GDTCORLibrary/Private/GDTCORFlatFileStorage.h"
-
-#import "GoogleDataTransport/GDTCORLibrary/Internal/GDTCORAssert.h"
-#import "GoogleDataTransport/GDTCORLibrary/Internal/GDTCORLifecycle.h"
-#import "GoogleDataTransport/GDTCORLibrary/Internal/GDTCORPlatform.h"
-#import "GoogleDataTransport/GDTCORLibrary/Internal/GDTCORStorageEventSelector.h"
-#import "GoogleDataTransport/GDTCORLibrary/Public/GoogleDataTransport/GDTCORConsoleLogger.h"
-#import "GoogleDataTransport/GDTCORLibrary/Public/GoogleDataTransport/GDTCOREvent.h"
-
-#import "GoogleDataTransport/GDTCORLibrary/Private/GDTCOREvent_Private.h"
-#import "GoogleDataTransport/GDTCORLibrary/Private/GDTCORRegistrar_Private.h"
-#import "GoogleDataTransport/GDTCORLibrary/Private/GDTCORUploadCoordinator.h"
-
-#import "GoogleDataTransport/GDTCORLibrary/Internal/GDTCORDirectorySizeTracker.h"
-
-NS_ASSUME_NONNULL_BEGIN
-
-/** A library data key this class uses to track batchIDs. */
-static NSString *const gBatchIDCounterKey = @"GDTCORFlatFileStorageBatchIDCounter";
-
-/** The separator used between metadata elements in filenames. */
-static NSString *const kMetadataSeparator = @"-";
-
-NSString *const kGDTCOREventComponentsEventIDKey = @"GDTCOREventComponentsEventIDKey";
-
-NSString *const kGDTCOREventComponentsQoSTierKey = @"GDTCOREventComponentsQoSTierKey";
-
-NSString *const kGDTCOREventComponentsMappingIDKey = @"GDTCOREventComponentsMappingIDKey";
-
-NSString *const kGDTCOREventComponentsExpirationKey = @"GDTCOREventComponentsExpirationKey";
-
-NSString *const kGDTCORBatchComponentsTargetKey = @"GDTCORBatchComponentsTargetKey";
-
-NSString *const kGDTCORBatchComponentsBatchIDKey = @"GDTCORBatchComponentsBatchIDKey";
-
-NSString *const kGDTCORBatchComponentsExpirationKey = @"GDTCORBatchComponentsExpirationKey";
-
-NSString *const GDTCORFlatFileStorageErrorDomain = @"GDTCORFlatFileStorage";
-
-const uint64_t kGDTCORFlatFileStorageSizeLimit = 20 * 1000 * 1000;  // 20 MB.
-
-@interface GDTCORFlatFileStorage ()
-
-/** An instance of the size tracker to keep track of the disk space consumed by the storage. */
-@property(nonatomic, readonly) GDTCORDirectorySizeTracker *sizeTracker;
-
-@end
-
-@implementation GDTCORFlatFileStorage
-
-@synthesize sizeTracker = _sizeTracker;
-
-+ (void)load {
-#if !NDEBUG
-  [[GDTCORRegistrar sharedInstance] registerStorage:[self sharedInstance] target:kGDTCORTargetTest];
-#endif  // !NDEBUG
-  [[GDTCORRegistrar sharedInstance] registerStorage:[self sharedInstance] target:kGDTCORTargetCCT];
-  [[GDTCORRegistrar sharedInstance] registerStorage:[self sharedInstance] target:kGDTCORTargetFLL];
-  [[GDTCORRegistrar sharedInstance] registerStorage:[self sharedInstance] target:kGDTCORTargetCSH];
-  [[GDTCORRegistrar sharedInstance] registerStorage:[self sharedInstance] target:kGDTCORTargetINT];
-}
-
-+ (instancetype)sharedInstance {
-  static GDTCORFlatFileStorage *sharedStorage;
-  static dispatch_once_t onceToken;
-  dispatch_once(&onceToken, ^{
-    sharedStorage = [[GDTCORFlatFileStorage alloc] init];
-  });
-  return sharedStorage;
-}
-
-- (instancetype)init {
-  self = [super init];
-  if (self) {
-    _storageQueue =
-        dispatch_queue_create("com.google.GDTCORFlatFileStorage", DISPATCH_QUEUE_SERIAL);
-    _uploadCoordinator = [GDTCORUploadCoordinator sharedInstance];
-  }
-  return self;
-}
-
-- (GDTCORDirectorySizeTracker *)sizeTracker {
-  if (_sizeTracker == nil) {
-    _sizeTracker =
-        [[GDTCORDirectorySizeTracker alloc] initWithDirectoryPath:GDTCORRootDirectory().path];
-  }
-  return _sizeTracker;
-}
-
-#pragma mark - GDTCORStorageProtocol
-
-- (void)storeEvent:(GDTCOREvent *)event
-        onComplete:(void (^_Nullable)(BOOL wasWritten, NSError *_Nullable error))completion {
-  GDTCORLogDebug(@"Saving event: %@", event);
-  if (event == nil || event.serializedDataObjectBytes == nil) {
-    GDTCORLogDebug(@"%@", @"The event was nil, so it was not saved.");
-    if (completion) {
-      completion(NO, [NSError errorWithDomain:NSInternalInconsistencyException
-                                         code:-1
-                                     userInfo:nil]);
-    }
-    return;
-  }
-  if (!completion) {
-    completion = ^(BOOL wasWritten, NSError *_Nullable error) {
-      GDTCORLogDebug(@"event %@ stored. success:%@ error:%@", event, wasWritten ? @"YES" : @"NO",
-                     error);
-    };
-  }
-
-  __block GDTCORBackgroundIdentifier bgID = GDTCORBackgroundIdentifierInvalid;
-  bgID = [[GDTCORApplication sharedApplication]
-      beginBackgroundTaskWithName:@"GDTStorage"
-                expirationHandler:^{
-                  // End the background task if it's still valid.
-                  [[GDTCORApplication sharedApplication] endBackgroundTask:bgID];
-                  bgID = GDTCORBackgroundIdentifierInvalid;
-                }];
-
-  dispatch_async(_storageQueue, ^{
-    // Check that a backend implementation is available for this target.
-    GDTCORTarget target = event.target;
-    NSString *filePath = [GDTCORFlatFileStorage pathForTarget:target
-                                                      eventID:event.eventID
-                                                      qosTier:@(event.qosTier)
-                                               expirationDate:event.expirationDate
-                                                    mappingID:event.mappingID];
-    NSError *error;
-    NSData *encodedEvent = GDTCOREncodeArchive(event, nil, &error);
-    if (error) {
-      completion(NO, error);
-      return;
-    }
-
-    // Check storage size limit before storing the event.
-    uint64_t resultingStorageSize = self.sizeTracker.directoryContentSize + encodedEvent.length;
-    if (resultingStorageSize > kGDTCORFlatFileStorageSizeLimit) {
-      NSError *error = [NSError
-          errorWithDomain:GDTCORFlatFileStorageErrorDomain
-                     code:GDTCORFlatFileStorageErrorSizeLimitReached
-                 userInfo:@{
-                   NSLocalizedFailureReasonErrorKey : @"Storage size limit has been reached."
-                 }];
-      completion(NO, error);
-      return;
-    }
-
-    // Write the encoded event to the file.
-    BOOL writeResult = GDTCORWriteDataToFile(encodedEvent, filePath, &error);
-    if (writeResult == NO || error) {
-      GDTCORLogDebug(@"Attempt to write archive failed: path:%@ error:%@", filePath, error);
-      completion(NO, error);
-      return;
-    } else {
-      GDTCORLogDebug(@"Writing archive succeeded: %@", filePath);
-      completion(YES, nil);
-    }
-
-    // Notify size tracker.
-    [self.sizeTracker fileWasAddedAtPath:filePath withSize:encodedEvent.length];
-
-    // Check the QoS, if it's high priority, notify the target that it has a high priority event.
-    if (event.qosTier == GDTCOREventQoSFast) {
-      // TODO: Remove a direct dependency on the upload coordinator.
-      [self.uploadCoordinator forceUploadForTarget:target];
-    }
-
-    // Cancel or end the associated background task if it's still valid.
-    [[GDTCORApplication sharedApplication] endBackgroundTask:bgID];
-    bgID = GDTCORBackgroundIdentifierInvalid;
-  });
-}
-
-- (void)batchWithEventSelector:(nonnull GDTCORStorageEventSelector *)eventSelector
-               batchExpiration:(nonnull NSDate *)expiration
-                    onComplete:
-                        (nonnull void (^)(NSNumber *_Nullable batchID,
-                                          NSSet<GDTCOREvent *> *_Nullable events))onComplete {
-  dispatch_queue_t queue = _storageQueue;
-  void (^onPathsForTargetComplete)(NSNumber *, NSSet<NSString *> *_Nonnull) = ^(
-      NSNumber *batchID, NSSet<NSString *> *_Nonnull paths) {
-    dispatch_async(queue, ^{
-      NSMutableSet<GDTCOREvent *> *events = [[NSMutableSet alloc] init];
-      for (NSString *eventPath in paths) {
-        NSError *error;
-        GDTCOREvent *event =
-            (GDTCOREvent *)GDTCORDecodeArchive([GDTCOREvent class], eventPath, nil, &error);
-        if (event == nil || error) {
-          GDTCORLogDebug(@"Error deserializing event: %@", error);
-          [[NSFileManager defaultManager] removeItemAtPath:eventPath error:nil];
-          continue;
-        } else {
-          NSString *fileName = [eventPath lastPathComponent];
-          NSString *batchPath =
-              [GDTCORFlatFileStorage batchPathForTarget:eventSelector.selectedTarget
-                                                batchID:batchID
-                                         expirationDate:expiration];
-          [[NSFileManager defaultManager] createDirectoryAtPath:batchPath
-                                    withIntermediateDirectories:YES
-                                                     attributes:nil
-                                                          error:nil];
-          NSString *destinationPath = [batchPath stringByAppendingPathComponent:fileName];
-          error = nil;
-          [[NSFileManager defaultManager] moveItemAtPath:eventPath
-                                                  toPath:destinationPath
-                                                   error:&error];
-          if (error) {
-            GDTCORLogDebug(@"An event file wasn't moveable into the batch directory: %@", error);
-          }
-          [events addObject:event];
-        }
-      }
-      if (onComplete) {
-        if (events.count == 0) {
-          onComplete(nil, nil);
-        } else {
-          onComplete(batchID, events);
-        }
-      }
-    });
-  };
-
-  void (^onBatchIDFetchComplete)(NSNumber *) = ^(NSNumber *batchID) {
-    dispatch_async(queue, ^{
-      if (batchID == nil) {
-        if (onComplete) {
-          onComplete(nil, nil);
-          return;
-        }
-      }
-      [self pathsForTarget:eventSelector.selectedTarget
-                  eventIDs:eventSelector.selectedEventIDs
-                  qosTiers:eventSelector.selectedQosTiers
-                mappingIDs:eventSelector.selectedMappingIDs
-                onComplete:^(NSSet<NSString *> *_Nonnull paths) {
-                  onPathsForTargetComplete(batchID, paths);
-                }];
-    });
-  };
-
-  [self nextBatchID:^(NSNumber *_Nullable batchID) {
-    if (batchID == nil) {
-      if (onComplete) {
-        onComplete(nil, nil);
-      }
-    } else {
-      onBatchIDFetchComplete(batchID);
-    }
-  }];
-}
-
-- (void)removeBatchWithID:(nonnull NSNumber *)batchID
-             deleteEvents:(BOOL)deleteEvents
-               onComplete:(void (^_Nullable)(void))onComplete {
-  dispatch_async(_storageQueue, ^{
-    [self syncThreadUnsafeRemoveBatchWithID:batchID deleteEvents:deleteEvents];
-
-    if (onComplete) {
-      onComplete();
-    }
-  });
-}
-
-- (void)batchIDsForTarget:(GDTCORTarget)target
-               onComplete:(nonnull void (^)(NSSet<NSNumber *> *_Nullable))onComplete {
-  dispatch_async(_storageQueue, ^{
-    NSFileManager *fileManager = [NSFileManager defaultManager];
-    NSError *error;
-    NSArray<NSString *> *batchPaths =
-        [fileManager contentsOfDirectoryAtPath:[GDTCORFlatFileStorage batchDataStoragePath]
-                                         error:&error];
-    if (error || batchPaths.count == 0) {
-      if (onComplete) {
-        onComplete(nil);
-      }
-      return;
-    }
-    NSMutableSet<NSNumber *> *batchIDs = [[NSMutableSet alloc] init];
-    for (NSString *path in batchPaths) {
-      NSDictionary<NSString *, id> *components = [self batchComponentsFromFilename:path];
-      NSNumber *targetNumber = components[kGDTCORBatchComponentsTargetKey];
-      NSNumber *batchID = components[kGDTCORBatchComponentsBatchIDKey];
-      if (batchID != nil && targetNumber.intValue == target) {
-        [batchIDs addObject:batchID];
-      }
-    }
-    if (onComplete) {
-      onComplete(batchIDs);
-    }
-  });
-}
-
-- (void)libraryDataForKey:(nonnull NSString *)key
-          onFetchComplete:(nonnull void (^)(NSData *_Nullable, NSError *_Nullable))onFetchComplete
-              setNewValue:(NSData *_Nullable (^_Nullable)(void))setValueBlock {
-  dispatch_async(_storageQueue, ^{
-    NSString *dataPath = [[[self class] libraryDataStoragePath] stringByAppendingPathComponent:key];
-    NSError *error;
-    NSData *data = [NSData dataWithContentsOfFile:dataPath options:0 error:&error];
-    if (onFetchComplete) {
-      onFetchComplete(data, error);
-    }
-    if (setValueBlock) {
-      NSData *newValue = setValueBlock();
-      // The -isKindOfClass check is necessary because without an explicit 'return nil' in the block
-      // the implicit return value will be the block itself. The compiler doesn't detect this.
-      if (newValue != nil && [newValue isKindOfClass:[NSData class]] && newValue.length) {
-        NSError *newValueError;
-        if ([newValue writeToFile:dataPath options:NSDataWritingAtomic error:&newValueError]) {
-          // Update storage size.
-          [self.sizeTracker fileWasRemovedAtPath:dataPath withSize:data.length];
-          [self.sizeTracker fileWasAddedAtPath:dataPath withSize:newValue.length];
-        } else {
-          GDTCORLogDebug(@"Error writing new value in libraryDataForKey: %@", newValueError);
-        }
-      }
-    }
-  });
-}
-
-- (void)storeLibraryData:(NSData *)data
-                  forKey:(nonnull NSString *)key
-              onComplete:(nullable void (^)(NSError *_Nullable error))onComplete {
-  if (!data || data.length <= 0) {
-    if (onComplete) {
-      onComplete([NSError errorWithDomain:NSInternalInconsistencyException code:-1 userInfo:nil]);
-    }
-    return;
-  }
-  dispatch_async(_storageQueue, ^{
-    NSError *error;
-    NSString *dataPath = [[[self class] libraryDataStoragePath] stringByAppendingPathComponent:key];
-    if ([data writeToFile:dataPath options:NSDataWritingAtomic error:&error]) {
-      [self.sizeTracker fileWasAddedAtPath:dataPath withSize:data.length];
-    }
-    if (onComplete) {
-      onComplete(error);
-    }
-  });
-}
-
-- (void)removeLibraryDataForKey:(nonnull NSString *)key
-                     onComplete:(nonnull void (^)(NSError *_Nullable error))onComplete {
-  dispatch_async(_storageQueue, ^{
-    NSError *error;
-    NSString *dataPath = [[[self class] libraryDataStoragePath] stringByAppendingPathComponent:key];
-    GDTCORStorageSizeBytes fileSize =
-        [self.sizeTracker fileSizeAtURL:[NSURL fileURLWithPath:dataPath]];
-
-    if ([[NSFileManager defaultManager] fileExistsAtPath:dataPath]) {
-      if ([[NSFileManager defaultManager] removeItemAtPath:dataPath error:&error]) {
-        [self.sizeTracker fileWasRemovedAtPath:dataPath withSize:fileSize];
-      }
-      if (onComplete) {
-        onComplete(error);
-      }
-    }
-  });
-}
-
-- (void)hasEventsForTarget:(GDTCORTarget)target onComplete:(void (^)(BOOL hasEvents))onComplete {
-  dispatch_async(_storageQueue, ^{
-    NSFileManager *fileManager = [NSFileManager defaultManager];
-    NSString *targetPath = [NSString
-        stringWithFormat:@"%@/%ld", [GDTCORFlatFileStorage eventDataStoragePath], (long)target];
-    [fileManager createDirectoryAtPath:targetPath
-           withIntermediateDirectories:YES
-                            attributes:nil
-                                 error:nil];
-    NSDirectoryEnumerator *enumerator = [fileManager enumeratorAtPath:targetPath];
-    BOOL hasEventAtLeastOneEvent = [enumerator nextObject] != nil;
-    if (onComplete) {
-      onComplete(hasEventAtLeastOneEvent);
-    }
-  });
-}
-
-- (void)checkForExpirations {
-  dispatch_async(_storageQueue, ^{
-    GDTCORLogDebug(@"%@", @"Checking for expired events and batches");
-    NSTimeInterval now = [NSDate date].timeIntervalSince1970;
-    NSFileManager *fileManager = [NSFileManager defaultManager];
-
-    // TODO: Storage may not have enough context to remove batches because a batch may be being
-    // uploaded but the storage has not context of it.
-
-    // Find expired batches and move their events back to the main storage.
-    // If a batch contains expired events they are expected to be removed further in the method
-    // together with other expired events in the main storage.
-    NSString *batchDataPath = [GDTCORFlatFileStorage batchDataStoragePath];
-    NSArray<NSString *> *batchDataPaths = [fileManager contentsOfDirectoryAtPath:batchDataPath
-                                                                           error:nil];
-    for (NSString *path in batchDataPaths) {
-      @autoreleasepool {
-        NSString *fileName = [path lastPathComponent];
-        NSDictionary<NSString *, id> *batchComponents = [self batchComponentsFromFilename:fileName];
-        NSDate *expirationDate = batchComponents[kGDTCORBatchComponentsExpirationKey];
-        NSNumber *batchID = batchComponents[kGDTCORBatchComponentsBatchIDKey];
-        if (expirationDate != nil && expirationDate.timeIntervalSince1970 < now && batchID != nil) {
-          NSNumber *batchID = batchComponents[kGDTCORBatchComponentsBatchIDKey];
-          // Move all events from the expired batch back to the main storage.
-          [self syncThreadUnsafeRemoveBatchWithID:batchID deleteEvents:NO];
-        }
-      }
-    }
-
-    // Find expired events and remove them from the storage.
-    NSString *eventDataPath = [GDTCORFlatFileStorage eventDataStoragePath];
-    NSDirectoryEnumerator *enumerator = [fileManager enumeratorAtPath:eventDataPath];
-    NSString *path;
-
-    while (YES) {
-      @autoreleasepool {
-        // Call `[enumerator nextObject]` under autorelease pool to make sure all autoreleased
-        // objects created under the hood are released on each iteration end to avoid unnecessary
-        // memory growth.
-        path = [enumerator nextObject];
-        if (path == nil) {
-          break;
-        }
-
-        NSString *fileName = [path lastPathComponent];
-        NSDictionary<NSString *, id> *eventComponents = [self eventComponentsFromFilename:fileName];
-        NSDate *expirationDate = eventComponents[kGDTCOREventComponentsExpirationKey];
-        if (expirationDate != nil && expirationDate.timeIntervalSince1970 < now) {
-          NSString *pathToDelete = [eventDataPath stringByAppendingPathComponent:path];
-          NSError *error;
-          [fileManager removeItemAtPath:pathToDelete error:&error];
-          if (error != nil) {
-            GDTCORLogDebug(@"There was an error deleting an expired item: %@", error);
-          } else {
-            GDTCORLogDebug(@"Item deleted because it expired: %@", pathToDelete);
-          }
-        }
-      }
-    }
-
-    [self.sizeTracker resetCachedSize];
-  });
-}
-
-- (void)storageSizeWithCallback:(void (^)(uint64_t storageSize))onComplete {
-  if (!onComplete) {
-    return;
-  }
-
-  dispatch_async(_storageQueue, ^{
-    onComplete([self.sizeTracker directoryContentSize]);
-  });
-}
-
-#pragma mark - Private not thread safe methods
-/** Looks for directory paths containing events for a batch with the specified ID.
- * @param batchID A batch ID.
- * @param outError A pointer to `NSError *` to assign as possible error to.
- * @return An array of an array of paths to directories for event batches with a specified batch ID
- * or `nil` in the case of an error. Usually returns a single path but potentially return more in
- * cases when the app is terminated while uploading a batch.
- */
-- (nullable NSArray<NSString *> *)batchDirPathsForBatchID:(NSNumber *)batchID
-                                                    error:(NSError **_Nonnull)outError {
-  NSFileManager *fileManager = [NSFileManager defaultManager];
-  NSError *error;
-  NSArray<NSString *> *batches =
-      [fileManager contentsOfDirectoryAtPath:[GDTCORFlatFileStorage batchDataStoragePath]
-                                       error:&error];
-  if (batches == nil) {
-    *outError = error;
-    GDTCORLogDebug(@"Failed to find event file paths for batchID: %@, error: %@", batchID, error);
-    return nil;
-  }
-
-  NSMutableArray<NSString *> *batchDirPaths = [NSMutableArray array];
-  for (NSString *path in batches) {
-    NSDictionary<NSString *, id> *components = [self batchComponentsFromFilename:path];
-    NSNumber *pathBatchID = components[kGDTCORBatchComponentsBatchIDKey];
-    if ([pathBatchID isEqual:batchID]) {
-      NSString *batchDirPath =
-          [[GDTCORFlatFileStorage batchDataStoragePath] stringByAppendingPathComponent:path];
-      [batchDirPaths addObject:batchDirPath];
-    }
-  }
-
-  return [batchDirPaths copy];
-}
-
-/** Makes a copy of the contents of a directory to a directory at the specified path.*/
-- (BOOL)moveContentsOfDirectoryAtPath:(NSString *)sourcePath
-                                   to:(NSString *)destinationPath
-                                error:(NSError **_Nonnull)outError {
-  NSFileManager *fileManager = [NSFileManager defaultManager];
-
-  NSError *error;
-  NSArray<NSString *> *contentsPaths = [fileManager contentsOfDirectoryAtPath:sourcePath
-                                                                        error:&error];
-  if (contentsPaths == nil) {
-    *outError = error;
-    return NO;
-  }
-
-  NSMutableArray<NSError *> *errors = [NSMutableArray array];
-  for (NSString *path in contentsPaths) {
-    NSString *contentDestinationPath = [destinationPath stringByAppendingPathComponent:path];
-    NSString *contentSourcePath = [sourcePath stringByAppendingPathComponent:path];
-
-    NSError *moveError;
-    if (![fileManager moveItemAtPath:contentSourcePath
-                              toPath:contentDestinationPath
-                               error:&moveError] &&
-        moveError) {
-      [errors addObject:moveError];
-    }
-  }
-
-  if (errors.count == 0) {
-    return YES;
-  } else {
-    NSError *combinedError = [NSError errorWithDomain:@"GDTCORFlatFileStorage"
-                                                 code:-1
-                                             userInfo:@{NSUnderlyingErrorKey : errors}];
-    *outError = combinedError;
-    return NO;
-  }
-}
-
-- (void)syncThreadUnsafeRemoveBatchWithID:(nonnull NSNumber *)batchID
-                             deleteEvents:(BOOL)deleteEvents {
-  NSError *error;
-  NSArray<NSString *> *batchDirPaths = [self batchDirPathsForBatchID:batchID error:&error];
-
-  if (batchDirPaths == nil) {
-    return;
-  }
-
-  NSFileManager *fileManager = [NSFileManager defaultManager];
-
-  void (^removeBatchDir)(NSString *batchDirPath) = ^(NSString *batchDirPath) {
-    NSError *error;
-    if ([fileManager removeItemAtPath:batchDirPath error:&error]) {
-      GDTCORLogDebug(@"Batch removed at path: %@", batchDirPath);
-    } else {
-      GDTCORLogDebug(@"Failed to remove batch at path: %@", batchDirPath);
-    }
-  };
-
-  for (NSString *batchDirPath in batchDirPaths) {
-    @autoreleasepool {
-      if (deleteEvents) {
-        removeBatchDir(batchDirPath);
-      } else {
-        NSString *batchDirName = [batchDirPath lastPathComponent];
-        NSDictionary<NSString *, id> *components = [self batchComponentsFromFilename:batchDirName];
-        NSString *targetValue = [components[kGDTCORBatchComponentsTargetKey] stringValue];
-        NSString *destinationPath;
-        if (targetValue) {
-          destinationPath = [[GDTCORFlatFileStorage eventDataStoragePath]
-              stringByAppendingPathComponent:targetValue];
-        }
-
-        // `- [NSFileManager moveItemAtPath:toPath:error:]` method fails if an item by the
-        // destination path already exists (which usually is the case for the current method). Move
-        // the events one by one instead.
-        if (destinationPath && [self moveContentsOfDirectoryAtPath:batchDirPath
-                                                                to:destinationPath
-                                                             error:&error]) {
-          GDTCORLogDebug(@"Batched events at path: %@ moved back to the storage: %@", batchDirPath,
-                         destinationPath);
-        } else {
-          GDTCORLogDebug(@"Error encountered whilst moving events back: %@", error);
-        }
-
-        // Even if not all events where moved back to the storage, there is not much can be done at
-        // this point, so cleanup batch directory now to avoid cluttering.
-        removeBatchDir(batchDirPath);
-      }
-    }
-  }
-
-  [self.sizeTracker resetCachedSize];
-}
-
-#pragma mark - Private helper methods
-
-+ (NSString *)eventDataStoragePath {
-  static NSString *eventDataPath;
-  static dispatch_once_t onceToken;
-  dispatch_once(&onceToken, ^{
-    eventDataPath = [NSString stringWithFormat:@"%@/%@/gdt_event_data", GDTCORRootDirectory().path,
-                                               NSStringFromClass([self class])];
-  });
-  NSError *error;
-  [[NSFileManager defaultManager] createDirectoryAtPath:eventDataPath
-                            withIntermediateDirectories:YES
-                                             attributes:0
-                                                  error:&error];
-  GDTCORAssert(error == nil, @"Creating the library data path failed: %@", error);
-  return eventDataPath;
-}
-
-+ (NSString *)batchDataStoragePath {
-  static NSString *batchDataPath;
-  static dispatch_once_t onceToken;
-  dispatch_once(&onceToken, ^{
-    batchDataPath = [NSString stringWithFormat:@"%@/%@/gdt_batch_data", GDTCORRootDirectory().path,
-                                               NSStringFromClass([self class])];
-  });
-  NSError *error;
-  [[NSFileManager defaultManager] createDirectoryAtPath:batchDataPath
-                            withIntermediateDirectories:YES
-                                             attributes:0
-                                                  error:&error];
-  GDTCORAssert(error == nil, @"Creating the batch data path failed: %@", error);
-  return batchDataPath;
-}
-
-+ (NSString *)libraryDataStoragePath {
-  static NSString *libraryDataPath;
-  static dispatch_once_t onceToken;
-  dispatch_once(&onceToken, ^{
-    libraryDataPath =
-        [NSString stringWithFormat:@"%@/%@/gdt_library_data", GDTCORRootDirectory().path,
-                                   NSStringFromClass([self class])];
-  });
-  NSError *error;
-  [[NSFileManager defaultManager] createDirectoryAtPath:libraryDataPath
-                            withIntermediateDirectories:YES
-                                             attributes:0
-                                                  error:&error];
-  GDTCORAssert(error == nil, @"Creating the library data path failed: %@", error);
-  return libraryDataPath;
-}
-
-+ (NSString *)batchPathForTarget:(GDTCORTarget)target
-                         batchID:(NSNumber *)batchID
-                  expirationDate:(NSDate *)expirationDate {
-  return
-      [NSString stringWithFormat:@"%@/%ld%@%@%@%llu", [GDTCORFlatFileStorage batchDataStoragePath],
-                                 (long)target, kMetadataSeparator, batchID, kMetadataSeparator,
-                                 ((uint64_t)expirationDate.timeIntervalSince1970)];
-}
-
-+ (NSString *)pathForTarget:(GDTCORTarget)target
-                    eventID:(NSString *)eventID
-                    qosTier:(NSNumber *)qosTier
-             expirationDate:(NSDate *)expirationDate
-                  mappingID:(NSString *)mappingID {
-  NSMutableCharacterSet *allowedChars = [[NSCharacterSet alphanumericCharacterSet] mutableCopy];
-  [allowedChars addCharactersInString:kMetadataSeparator];
-  mappingID = [mappingID stringByAddingPercentEncodingWithAllowedCharacters:allowedChars];
-  return [NSString stringWithFormat:@"%@/%ld/%@%@%@%@%llu%@%@",
-                                    [GDTCORFlatFileStorage eventDataStoragePath], (long)target,
-                                    eventID, kMetadataSeparator, qosTier, kMetadataSeparator,
-                                    ((uint64_t)expirationDate.timeIntervalSince1970),
-                                    kMetadataSeparator, mappingID];
-}
-
-- (void)pathsForTarget:(GDTCORTarget)target
-              eventIDs:(nullable NSSet<NSString *> *)eventIDs
-              qosTiers:(nullable NSSet<NSNumber *> *)qosTiers
-            mappingIDs:(nullable NSSet<NSString *> *)mappingIDs
-            onComplete:(void (^)(NSSet<NSString *> *paths))onComplete {
-  void (^completion)(NSSet<NSString *> *) = onComplete == nil ? ^(NSSet<NSString *> *paths){} : onComplete;
-  dispatch_async(_storageQueue, ^{
-    NSMutableSet<NSString *> *paths = [[NSMutableSet alloc] init];
-    NSFileManager *fileManager = [NSFileManager defaultManager];
-    NSString *targetPath = [NSString
-        stringWithFormat:@"%@/%ld", [GDTCORFlatFileStorage eventDataStoragePath], (long)target];
-    [fileManager createDirectoryAtPath:targetPath
-           withIntermediateDirectories:YES
-                            attributes:nil
-                                 error:nil];
-    NSError *error;
-    NSArray<NSString *> *dirPaths = [fileManager contentsOfDirectoryAtPath:targetPath error:&error];
-    if (error) {
-      GDTCORLogDebug(@"There was an error reading the contents of the target path: %@", error);
-      completion(paths);
-      return;
-    }
-    BOOL checkingIDs = eventIDs.count > 0;
-    BOOL checkingQosTiers = qosTiers.count > 0;
-    BOOL checkingMappingIDs = mappingIDs.count > 0;
-    BOOL checkingAnything = checkingIDs == NO && checkingQosTiers == NO && checkingMappingIDs == NO;
-    for (NSString *path in dirPaths) {
-      // Skip hidden files that are created as part of atomic file creation.
-      if ([path hasPrefix:@"."]) {
-        continue;
-      }
-      NSString *filePath = [targetPath stringByAppendingPathComponent:path];
-      if (checkingAnything) {
-        [paths addObject:filePath];
-        continue;
-      }
-      NSString *filename = [path lastPathComponent];
-      NSDictionary<NSString *, id> *eventComponents = [self eventComponentsFromFilename:filename];
-      if (!eventComponents) {
-        GDTCORLogDebug(@"There was an error reading the filename components: %@", eventComponents);
-        continue;
-      }
-      NSString *eventID = eventComponents[kGDTCOREventComponentsEventIDKey];
-      NSNumber *qosTier = eventComponents[kGDTCOREventComponentsQoSTierKey];
-      NSString *mappingID = eventComponents[kGDTCOREventComponentsMappingIDKey];
-
-      NSNumber *eventIDMatch = checkingIDs ? @([eventIDs containsObject:eventID]) : nil;
-      NSNumber *qosTierMatch = checkingQosTiers ? @([qosTiers containsObject:qosTier]) : nil;
-      NSNumber *mappingIDMatch =
-          checkingMappingIDs
-              ? @([mappingIDs containsObject:[mappingID stringByRemovingPercentEncoding]])
-              : nil;
-      if ((eventIDMatch == nil || eventIDMatch.boolValue) &&
-          (qosTierMatch == nil || qosTierMatch.boolValue) &&
-          (mappingIDMatch == nil || mappingIDMatch.boolValue)) {
-        [paths addObject:filePath];
-      }
-    }
-    completion(paths);
-  });
-}
-
-- (void)nextBatchID:(void (^)(NSNumber *_Nullable batchID))nextBatchID {
-  __block int32_t lastBatchID = -1;
-  [self libraryDataForKey:gBatchIDCounterKey
-      onFetchComplete:^(NSData *_Nullable data, NSError *_Nullable getValueError) {
-        if (!getValueError) {
-          [data getBytes:(void *)&lastBatchID length:sizeof(int32_t)];
-        }
-        if (data == nil) {
-          lastBatchID = 0;
-        }
-        if (nextBatchID) {
-          nextBatchID(@(lastBatchID));
-        }
-      }
-      setNewValue:^NSData *_Nullable(void) {
-        if (lastBatchID != -1) {
-          int32_t incrementedValue = lastBatchID + 1;
-          return [NSData dataWithBytes:&incrementedValue length:sizeof(int32_t)];
-        }
-        return nil;
-      }];
-}
-
-- (nullable NSDictionary<NSString *, id> *)eventComponentsFromFilename:(NSString *)fileName {
-  NSArray<NSString *> *components = [fileName componentsSeparatedByString:kMetadataSeparator];
-  if (components.count >= 4) {
-    NSString *eventID = components[0];
-    NSNumber *qosTier = @(components[1].integerValue);
-    NSDate *expirationDate = [NSDate dateWithTimeIntervalSince1970:components[2].longLongValue];
-    NSString *mappingID = [[components subarrayWithRange:NSMakeRange(3, components.count - 3)]
-        componentsJoinedByString:kMetadataSeparator];
-    if (eventID == nil || qosTier == nil || mappingID == nil || expirationDate == nil) {
-      GDTCORLogDebug(@"There was an error parsing the event filename components: %@", components);
-      return nil;
-    }
-    return @{
-      kGDTCOREventComponentsEventIDKey : eventID,
-      kGDTCOREventComponentsQoSTierKey : qosTier,
-      kGDTCOREventComponentsExpirationKey : expirationDate,
-      kGDTCOREventComponentsMappingIDKey : mappingID
-    };
-  }
-  GDTCORLogDebug(@"The event filename could not be split: %@", fileName);
-  return nil;
-}
-
-- (nullable NSDictionary<NSString *, id> *)batchComponentsFromFilename:(NSString *)fileName {
-  NSArray<NSString *> *components = [fileName componentsSeparatedByString:kMetadataSeparator];
-  if (components.count == 3) {
-    NSNumber *target = @(components[0].integerValue);
-    NSNumber *batchID = @(components[1].integerValue);
-    NSDate *expirationDate = [NSDate dateWithTimeIntervalSince1970:components[2].doubleValue];
-    if (target == nil || batchID == nil || expirationDate == nil) {
-      GDTCORLogDebug(@"There was an error parsing the batch filename components: %@", components);
-      return nil;
-    }
-    return @{
-      kGDTCORBatchComponentsTargetKey : target,
-      kGDTCORBatchComponentsBatchIDKey : batchID,
-      kGDTCORBatchComponentsExpirationKey : expirationDate
-    };
-  }
-  GDTCORLogDebug(@"The batch filename could not be split: %@", fileName);
-  return nil;
-}
-
-#pragma mark - GDTCORLifecycleProtocol
-
-- (void)appWillBackground:(GDTCORApplication *)app {
-  dispatch_async(_storageQueue, ^{
-    // Immediately request a background task to run until the end of the current queue of work,
-    // and cancel it once the work is done.
-    __block GDTCORBackgroundIdentifier bgID =
-        [app beginBackgroundTaskWithName:@"GDTStorage"
-                       expirationHandler:^{
-                         [app endBackgroundTask:bgID];
-                         bgID = GDTCORBackgroundIdentifierInvalid;
-                       }];
-    // End the background task if it's still valid.
-    [app endBackgroundTask:bgID];
-    bgID = GDTCORBackgroundIdentifierInvalid;
-  });
-}
-
-- (void)appWillTerminate:(GDTCORApplication *)application {
-  dispatch_sync(_storageQueue, ^{
-                });
-}
-
-@end
-
-NS_ASSUME_NONNULL_END