class ActiveSupport::Cache::Entry

:nodoc:
using short instance variable names that are lazily defined.
Since cache entries in most instances will be serialized, the internals of this class are highly optimized
mismatches.
on the cache. The version is used to support the :version option on the cache for rejecting
expiration time, and an optional version. The expiration time is used to support the :race_condition_ttl option
This class is used to represent cache entries. Cache entries have a value, an optional

def bytesize

value.bytesize if the data is compressed.
Returns the size of the cached value. This could be less than

def bytesize
  case value
  when NilClass
    0
  when String
    @value.bytesize
  else
    @s ||= Marshal.dump(@value).bytesize
  end
end

def compressed(compress_threshold)

def compressed(compress_threshold)
  return self if compressed?
  case @value
  when nil, true, false, Numeric
    uncompressed_size = 0
  when String
    uncompressed_size = @value.bytesize
  else
    serialized = Marshal.dump(@value)
    uncompressed_size = serialized.bytesize
  end
  if uncompressed_size >= compress_threshold
    serialized ||= Marshal.dump(@value)
    compressed = Zlib::Deflate.deflate(serialized)
    if compressed.bytesize < uncompressed_size
      return Entry.new(compressed, compressed: true, expires_at: expires_at, version: version)
    end
  end
  self
end

def compressed? # :nodoc:

:nodoc:

def compressed? # :nodoc:
  defined?(@compressed)
end

def dup_value!

serialize entries to protect against accidental cache modifications.
Duplicates the value in a class. This is used by cache implementations that don't natively

def dup_value!
  if @value && !compressed? && !(@value.is_a?(Numeric) || @value == true || @value == false)
    if @value.is_a?(String)
      @value = @value.dup
    else
      @value = Marshal.load(Marshal.dump(@value))
    end
  end
end

def expired?

the value set when the entry was created.
Checks if the entry is expired. The +expires_in+ parameter can override

def expired?
  @expires_in && @created_at + @expires_in <= Time.now.to_f
end

def expires_at

def expires_at
  @expires_in ? @created_at + @expires_in : nil
end

def expires_at=(value)

def expires_at=(value)
  if value
    @expires_in = value.to_f - @created_at
  else
    @expires_in = nil
  end
end

def initialize(value, compressed: false, version: nil, expires_in: nil, expires_at: nil, **)

+:compressed+, +:version+, +:expires_at+ and +:expires_in+.
Creates a new cache entry for the specified value. Options supported are

def initialize(value, compressed: false, version: nil, expires_in: nil, expires_at: nil, **)
  @value      = value
  @version    = version
  @created_at = 0.0
  @expires_in = expires_at&.to_f || expires_in && (expires_in.to_f + Time.now.to_f)
  @compressed = true if compressed
end

def local?

def local?
  false
end

def mismatched?(version)

def mismatched?(version)
  @version && version && @version != version
end

def pack

def pack
  members = [value, expires_at, version]
  members.pop while !members.empty? && members.last.nil?
  members
end

def uncompress(value)

def uncompress(value)
  Marshal.load(Zlib::Inflate.inflate(value))
end

def unpack(members)

def unpack(members)
  new(members[0], expires_at: members[1], version: members[2])
end

def value

def value
  compressed? ? uncompress(@value) : @value
end

Modules

Classes