Method lock

plugins/e57/libE57Format/src/Packet.cpp:62–140

}

std::unique_ptr<PacketLock> PacketReadCache::lock( uint64_t packetLogicalOffset, char *&pkt )
{
#ifdef E57_VERBOSE
   std::cout << "PacketReadCache::lock() called, packetLogicalOffset=" << packetLogicalOffset
             << std::endl;
#endif

   // Only allow one locked packet at a time.
   if ( lockCount_ > 0 )
   {
      throw E57_EXCEPTION2( ErrorInternal, "lockCount=" + toString( lockCount_ ) );
   }

   // Offset can't be 0
   if ( packetLogicalOffset == 0 )
   {
      throw E57_EXCEPTION2( ErrorInternal,
                            "packetLogicalOffset=" + toString( packetLogicalOffset ) );
   }

   // Linear scan for matching packet offset in cache
   for ( unsigned i = 0; i < entries_.size(); ++i )
   {
      auto &entry = entries_[i];

      if ( packetLogicalOffset == entry.logicalOffset_ )
      {
         // Found a match, so don't have to read anything
#ifdef E57_VERBOSE
         std::cout << "  Found matching cache entry, index=" << i << std::endl;
#endif
         // Mark entry with current useCount (keeps track of age of entry).
         entry.lastUsed_ = ++useCount_;

         // Publish buffer address to caller
         pkt = entry.buffer_;

         // Create lock so we are sure that we will be unlocked when use is finished.
         std::unique_ptr<PacketLock> plock( new PacketLock( this, i ) );

         // Increment cache lock just before return
         ++lockCount_;

         return plock;
      }
   }
   // Get here if didn't find a match already in cache.

   // Find least recently used (LRU) packet buffer
   unsigned oldestEntry = 0;
   unsigned oldestUsed = entries_.at( 0 ).lastUsed_;

   for ( unsigned i = 0; i < entries_.size(); ++i )
   {
      const auto &entry = entries_[i];

      if ( entry.lastUsed_ < oldestUsed )
      {