create

Pods/FirebaseFirestoreInternal/Firestore/Source/API/FIRLocalCacheSettings.mm

@@ -0,0 +1,238 @@
+/*
+ * Copyright 2023 Google LLC
+ *
+ * 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.
+ */
+
+#include "FIRLocalCacheSettings.h"
+#include <memory>
+#import "FIRLocalCacheSettings+Internal.h"
+#include "absl/memory/memory.h"
+
+#include "Firestore/core/src/api/settings.h"
+#include "Firestore/core/src/util/exception.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+namespace api = firebase::firestore::api;
+using api::MemoryCacheSettings;
+using api::MemoryEagerGcSettings;
+using api::MemoryLruGcSettings;
+using api::PersistentCacheSettings;
+using api::Settings;
+using firebase::firestore::util::ThrowInvalidArgument;
+
+@implementation FIRPersistentCacheSettings {
+  PersistentCacheSettings _internalSettings;
+}
+
+- (BOOL)isEqual:(id)other {
+  if (self == other) {
+    return YES;
+  } else if (![other isKindOfClass:[FIRPersistentCacheSettings class]]) {
+    return NO;
+  }
+
+  FIRPersistentCacheSettings *otherSettings = (FIRPersistentCacheSettings *)other;
+  return _internalSettings == otherSettings.internalSettings;
+}
+
+- (NSUInteger)hash {
+  return _internalSettings.Hash();
+}
+
+- (id)copyWithZone:(__unused NSZone *_Nullable)zone {
+  FIRPersistentCacheSettings *copy = [[FIRPersistentCacheSettings alloc] init];
+  copy.internalSettings = self.internalSettings;
+  return copy;
+}
+
+- (void)setInternalSettings:(const PersistentCacheSettings &)settings {
+  _internalSettings = settings;
+}
+
+- (const PersistentCacheSettings &)internalSettings {
+  return _internalSettings;
+}
+
+- (instancetype)init {
+  self = [super init];
+  self.internalSettings = PersistentCacheSettings{};
+  return self;
+}
+
+- (instancetype)initWithSizeBytes:(NSNumber *)size {
+  self = [super init];
+  if (size.longLongValue != Settings::CacheSizeUnlimited &&
+      size.longLongValue < Settings::MinimumCacheSizeBytes) {
+    ThrowInvalidArgument("Cache size must be set to at least %s bytes",
+                         Settings::MinimumCacheSizeBytes);
+  }
+
+  self.internalSettings = PersistentCacheSettings{}.WithSizeBytes(size.longLongValue);
+  return self;
+}
+
+@end
+
+@implementation FIRMemoryEagerGCSettings {
+  MemoryEagerGcSettings _internalSettings;
+}
+
+- (BOOL)isEqual:(id)other {
+  if (self == other) {
+    return YES;
+  } else if (![other isKindOfClass:[FIRMemoryEagerGCSettings class]]) {
+    return NO;
+  }
+
+  FIRMemoryEagerGCSettings *otherSettings = (FIRMemoryEagerGCSettings *)other;
+  return _internalSettings == otherSettings.internalSettings;
+}
+
+- (NSUInteger)hash {
+  return _internalSettings.Hash();
+}
+
+- (id)copyWithZone:(__unused NSZone *_Nullable)zone {
+  FIRMemoryEagerGCSettings *copy = [[FIRMemoryEagerGCSettings alloc] init];
+  copy.internalSettings = self.internalSettings;
+  return copy;
+}
+
+- (void)setInternalSettings:(const MemoryEagerGcSettings &)settings {
+  _internalSettings = settings;
+}
+
+- (const MemoryEagerGcSettings &)internalSettings {
+  return _internalSettings;
+}
+
+- (instancetype)init {
+  if (self = [super init]) {
+    self.internalSettings = MemoryEagerGcSettings{};
+  }
+  return self;
+}
+
+@end
+
+@implementation FIRMemoryLRUGCSettings {
+  MemoryLruGcSettings _internalSettings;
+}
+
+- (BOOL)isEqual:(id)other {
+  if (self == other) {
+    return YES;
+  } else if (![other isKindOfClass:[FIRMemoryLRUGCSettings class]]) {
+    return NO;
+  }
+
+  FIRMemoryLRUGCSettings *otherSettings = (FIRMemoryLRUGCSettings *)other;
+  return _internalSettings == otherSettings.internalSettings;
+}
+
+- (NSUInteger)hash {
+  return _internalSettings.Hash();
+}
+
+- (id)copyWithZone:(__unused NSZone *_Nullable)zone {
+  FIRMemoryLRUGCSettings *copy = [[FIRMemoryLRUGCSettings alloc] init];
+  copy.internalSettings = self.internalSettings;
+  return copy;
+}
+
+- (void)setInternalSettings:(const MemoryLruGcSettings &)settings {
+  _internalSettings = settings;
+}
+
+- (const MemoryLruGcSettings &)internalSettings {
+  return _internalSettings;
+}
+
+- (instancetype)init {
+  if (self = [super init]) {
+    self.internalSettings = MemoryLruGcSettings{};
+  }
+  return self;
+}
+
+- (instancetype)initWithSizeBytes:(NSNumber *)size {
+  if (self = [super init]) {
+    self.internalSettings = MemoryLruGcSettings{}.WithSizeBytes(size.longLongValue);
+  }
+  return self;
+}
+
+@end
+
+@implementation FIRMemoryCacheSettings {
+  MemoryCacheSettings _internalSettings;
+}
+
+- (BOOL)isEqual:(id)other {
+  if (self == other) {
+    return YES;
+  } else if (![other isKindOfClass:[FIRMemoryCacheSettings class]]) {
+    return NO;
+  }
+
+  FIRMemoryCacheSettings *otherSettings = (FIRMemoryCacheSettings *)other;
+  return _internalSettings == otherSettings.internalSettings;
+}
+
+- (NSUInteger)hash {
+  return _internalSettings.Hash();
+}
+
+- (id)copyWithZone:(__unused NSZone *_Nullable)zone {
+  FIRMemoryCacheSettings *copy = [[FIRMemoryCacheSettings alloc] init];
+  copy.internalSettings = self.internalSettings;
+  return copy;
+}
+
+- (void)setInternalSettings:(const MemoryCacheSettings &)settings {
+  _internalSettings = settings;
+}
+
+- (const MemoryCacheSettings &)internalSettings {
+  return _internalSettings;
+}
+
+- (instancetype)init {
+  if (self = [super init]) {
+    self.internalSettings = MemoryCacheSettings{};
+  }
+  return self;
+}
+
+- (instancetype)initWithGarbageCollectorSettings:
+    (id<FIRMemoryGarbageCollectorSettings, NSObject>)settings {
+  if (self = [super init]) {
+    if ([settings isKindOfClass:[FIRMemoryEagerGCSettings class]]) {
+      FIRMemoryEagerGCSettings *casted = (FIRMemoryEagerGCSettings *)settings;
+      self.internalSettings =
+          MemoryCacheSettings{}.WithMemoryGarbageCollectorSettings(casted.internalSettings);
+    } else if ([settings isKindOfClass:[FIRMemoryLRUGCSettings class]]) {
+      FIRMemoryLRUGCSettings *casted = (FIRMemoryLRUGCSettings *)settings;
+      self.internalSettings =
+          MemoryCacheSettings{}.WithMemoryGarbageCollectorSettings(casted.internalSettings);
+    }
+  }
+
+  return self;
+}
+
+@end
+
+NS_ASSUME_NONNULL_END