class SplitIoClient::Cache::Adapters::MemoryAdapters::MapAdapter

def add_to_map(key, field, value)
  initialize_map(key) unless @map[key]
  @map[key].put(field, value)
end

def add_to_set(key, values)
  if values.is_a? Array
    values.each { |value| add_to_map(key, value, 1) }
  else
    add_to_map(key, values, 1)
  end
end

def bool(key)
  @map[key]
end

def clear(_ = nil)
  initialize
end

def delete(key)
  if key.is_a? Array
    key.each { |k| @map.delete(k) }
  else
    @map.delete(key)
  end
end

def delete_from_map(key, fields)
  if fields.is_a? Array
    fields.each { |field| @map[key].delete(field) }
  else
    @map[key].delete(fields)
  end
end

def empty?
  @map.empty?
end

def exists?(key)
  !@map[key].nil?
end

def find_in_map(key, field)
  return nil if @map[key].nil?
  @map[key].get(field)
end

def find_strings_by_prefix(prefix)
  @map.keys.select { |str| str.start_with? prefix }
end

def get_all_from_set(key)
  @map[key].keys
end

def get_map(key)
  @map[key]
end

def in_map?(key, field)
  return false if @map[key].nil?
  @map[key].key?(field)
end

def initialize
  @map = Concurrent::Map.new
end

def initialize_map(key)
  @map[key] = Concurrent::Map.new
end

def map_keys(key)
  @map[key].keys
end

def multiple_strings(keys)
  keys.each_with_object({}) do |key, memo|
    memo[key] = string(key)
  end
end

def pipelined(&block)
  block.call
end

def set_bool(key, val)
  @map[key] = val
end

def set_string(key, str)
  @map[key] = str
end

def string(key)
  @map[key]
end

def union_sets(set_keys)
  array = set_keys.each_with_object([]) do |key, memo|
    memo << get_set(key)
  end.flatten
  Set.new(array)
end