Add a separate property, isCacheable, to SharedKeys.

API/fleece/Expert.hh

@@ -110,6 +110,7 @@ namespace fleece {
         inline void writeState(const Encoder &enc);
         unsigned count() const                              {return FLSharedKeys_Count(_sk);}
         void revertToCount(unsigned count)                  {FLSharedKeys_RevertToCount(_sk, count);}
+        void disableCaching()                               {if (_sk) FLSharedKeys_DisableCaching(_sk);}
 
         operator FLSharedKeys FL_NULLABLE () const          {return _sk;}
         bool operator== (SharedKeys other) const            {return _sk == other._sk;}

API/fleece/FLExpert.h

@@ -154,6 +154,9 @@ extern "C" {
     /** Reverts an FLSharedKeys by "forgetting" any keys added since it had the count `oldCount`. */
     FLEECE_PUBLIC void FLSharedKeys_RevertToCount(FLSharedKeys, unsigned oldCount) FLAPI;
 
+    /** Disable caching of the SharedKeys.. */
+    FLEECE_PUBLIC void FLSharedKeys_DisableCaching(FLSharedKeys) FLAPI;
+
     /** Increments the reference count of an FLSharedKeys. */
     FLEECE_PUBLIC FLSharedKeys FL_NULLABLE FLSharedKeys_Retain(FLSharedKeys FL_NULLABLE) FLAPI;
 

Fleece/API_Impl/Fleece.cc

@@ -457,6 +457,7 @@ bool FLSharedKeys_LoadState(FLSharedKeys sk, FLValue s)    FLAPI {return sk->loa
 FLSliceResult FLSharedKeys_GetStateData(FLSharedKeys sk)   FLAPI {return toSliceResult(sk->stateData());}
 FLString FLSharedKeys_Decode(FLSharedKeys sk, int key)     FLAPI {return sk->decode(key);}
 void FLSharedKeys_RevertToCount(FLSharedKeys sk, unsigned c) FLAPI {sk->revertToCount(c);}
+void FLSharedKeys_DisableCaching(FLSharedKeys sk)          FLAPI { sk->disableCaching(); }
 
 FLSharedKeys FLSharedKeys_NewWithRead(FLSharedKeysReadCallback callback, void* FL_NULLABLE context) FLAPI {
     return retain(new FLPersistentSharedKeys(callback, context));

Fleece/Core/Dict.cc

@@ -132,7 +132,7 @@ namespace fleece { namespace impl {
                     // shared key, because the transaction might be rolled back. If the found
                     // shared key is rolled back as part of rolling back the transaction, continuing
                     // to use it would lead to incorrect lookup results.
-                    keyToFind._hasNumericKey = !sharedKeys->isInTransaction();
+                    keyToFind._hasNumericKey = sharedKeys->isCacheable();
                     return get(keyToFind._numericKey);
                 }
             }

Fleece/Core/Dict.hh

@@ -70,6 +70,7 @@ namespace fleece { namespace impl {
             slice string() const noexcept                {return _rawString;}
             int compare(const key &k) const noexcept     {return _rawString.compare(k._rawString);}
             key(const key&) =delete;
+            bool isShared() const noexcept               {return _hasNumericKey;}
         private:
             void setSharedKeys(SharedKeys*);
 

Fleece/Core/SharedKeys.cc

@@ -252,6 +252,7 @@ namespace fleece { namespace impl {
         LOCK(_refreshMutex);
         throwIf(_inTransaction, SharedKeysStateError, "already in transaction");
         _inTransaction = true;
+        disableCaching();
         read();     // Catch up with any external changes
     }
 
@@ -260,6 +261,7 @@ namespace fleece { namespace impl {
         if (_inTransaction) {
             _committedPersistedCount = _persistedCount;
             _inTransaction = false;
+            enableCaching();
         }
     }
 

Fleece/Core/SharedKeys.hh

@@ -106,8 +106,6 @@ namespace fleece { namespace impl {
 
         bool isUnknownKey(int key) const FLPURE;
 
-        bool isInTransaction() const FLPURE             {return _inTransaction;}
-
         virtual bool refresh()                          {return false;}
 
         static const size_t kMaxCount = 2048;               // Max number of keys to store
@@ -124,7 +122,12 @@ namespace fleece { namespace impl {
         void setPlatformStringForKey(int key, PlatformString) const;
         PlatformString platformStringForKey(int key) const;
 
+        bool isCacheable() const FLPURE { return _isCacheable; }
+        void disableCaching()           { _isCacheable = false; }
+
     protected:
+        void enableCaching()            { _isCacheable = true; }
+
         virtual ~SharedKeys();
 
         /** Determines whether a new string should be added. Default implementation returns true
@@ -143,6 +146,7 @@ namespace fleece { namespace impl {
         mutable std::mutex _mutex;
         unsigned _count {0};
         bool _inTransaction {true};                     // (for PersistentSharedKeys)
+        bool _isCacheable   {true};                     // SharedKeys are cacheable unless explicitly disabled.
         mutable std::vector<PlatformString> _platformStringsByKey; // Reverse mapping, int->platform key
         ConcurrentMap _table;                             // Hash table mapping slice->int
         std::array<slice, kMaxCount> _byKey;      // Reverse mapping, int->slice

Tests/SharedKeysTests.cc

@@ -430,9 +430,11 @@ TEST_CASE("encoding", "[SharedKeys]") {
         Dict::key typeKey("type"_sl), attsKey("_attachments"_sl);
 
         const Value *v = root->get(typeKey);
+        CHECK(typeKey.isShared());
         REQUIRE(v);
         REQUIRE(v->asString() == "animal"_sl);
         const Dict *atts = root->get(attsKey)->asDict();
+        CHECK(attsKey.isShared());
         REQUIRE(atts);
         REQUIRE(atts->get("thumbnail.jpg"_sl) != nullptr);
         REQUIRE(atts->get(typeKey) != nullptr);
@@ -442,6 +444,23 @@ TEST_CASE("encoding", "[SharedKeys]") {
         Dict::key thumbKey("thumbnail.jpg"_sl);
         REQUIRE(atts->get(thumbKey) != nullptr);
     }
+    SECTION("Dict::key Not Cache") {
+        sk->disableCaching();
+
+        // Use a Dict::key:
+        Dict::key typeKey("type"_sl), attsKey("_attachments"_sl);
+        CHECK(!typeKey.isShared());
+        const Value *v = root->get(typeKey);
+        REQUIRE(v);
+        REQUIRE(v->asString() == "animal"_sl);
+
+        const Dict *atts = root->get(attsKey)->asDict();
+        CHECK(!attsKey.isShared());
+        REQUIRE(atts);
+        REQUIRE(atts->get("thumbnail.jpg"_sl) != nullptr);
+        REQUIRE(atts->get(typeKey) != nullptr);
+        REQUIRE(atts->get(attsKey) == nullptr);
+    }
     SECTION("Path lookup") {
         Path attsTypePath("_attachments.type");
         const Value *t = attsTypePath.eval(root);

Tests/ValueTests.cc

@@ -262,7 +262,7 @@ namespace fleece {
 
         caughtException = false;
         // ++iter will throw if already at the end.
-        // OutOfRange exception should contain the backtrace.
+        // OutOfRange exception should not contain the backtrace.
         try {
             ++iter;
         } catch (const FleeceException& exc) {