Packages
krug
2.0.5
2.0.36
2.0.35
2.0.34
2.0.33
2.0.32
2.0.31
2.0.30
2.0.29
2.0.27
2.0.26
2.0.25
2.0.24
2.0.23
2.0.22
2.0.20
2.0.19
2.0.18
2.0.17
2.0.16
2.0.15
2.0.14
2.0.13
2.0.12
2.0.11
2.0.10
2.0.9
2.0.8
2.0.7
2.0.6
2.0.5
2.0.4
2.0.1
2.0.0
1.1.53
1.1.52
1.1.50
1.1.49
1.1.48
1.1.47
1.1.46
1.1.45
1.1.44
1.1.43
1.1.42
1.1.41
1.1.40
1.1.39
1.1.38
1.1.37
1.1.36
1.1.35
1.1.34
1.1.33
1.1.32
1.1.31
1.1.30
1.1.29
1.1.28
1.1.27
1.1.26
1.1.25
1.1.24
1.1.23
1.1.22
1.1.21
1.1.20
1.1.19
1.1.18
1.1.17
1.1.16
1.1.15
1.1.14
1.1.12
1.1.10
1.1.9
1.1.8
1.1.7
1.1.6
1.1.5
1.1.4
1.1.3
1.1.2
1.1.1
1.1.0
1.0.9
1.0.8
1.0.7
1.0.6
1.0.5
1.0.4
1.0.3
1.0.2
1.0.1
1.0.0
0.5.5
0.5.4
0.5.3
0.5.2
0.5.1
0.5.0
0.4.31
0.4.30
0.4.29
0.4.28
0.4.27
0.4.26
0.4.25
0.4.24
0.4.23
0.4.22
0.4.20
0.4.19
0.4.18
0.4.17
0.4.16
0.4.15
0.4.14
0.4.13
0.4.12
0.4.11
0.4.10
0.4.9
0.4.8
0.4.7
0.4.6
0.4.5
0.4.4
0.4.3
0.4.2
0.4.1
0.4.0
0.3.9
0.3.8
0.3.7
0.3.6
0.3.5
0.3.4
0.3.3
0.3.2
0.3.1
0.3.0
0.2.1
0.2.0
0.1.0
A Utilitary package functionalities modules for improve a secure performatic development.
Current section
Files
Jump to
Current section
Files
lib/krug/util/map.util.ex
defmodule Krug.MapUtil do
@moduledoc """
Utilitary safe module to manipulate Map structs.
"""
@doc """
Obtain a value from a Map, respective to a key.
If the map or key received is nil/invalid return nil.
If key don't exists in map, return nil.
## Example
```elixir
iex > map = %{a: 1, b: 3}
iex > Krug.MapUtil.get(map,:a)
1
```
"""
def get(map,key) do
cond do
(nil == map
or nil == key)
-> nil
(Map.has_key?(map,key))
-> map
|> Map.get(key)
(Map.has_key?(map,"#{key}"))
-> map["#{key}"]
true
-> nil
end
end
@doc """
Obtain a value from a Map, respective to a ATOM key.
Use only for performatic reasons, and you are sure that key exists on map and is from atom type.
## Example
```elixir
iex > map = %{a: 1, b: 3}
iex > Krug.MapUtil.get_by_atom_key(map,:a)
1
```
```elixir
iex > map = %{a: 1, b: 3}
iex > Krug.MapUtil.get_by_atom_key(map,:c)
throws an exception
```
```elixir
iex > map = %{a: 1, b: 3}
iex > Krug.MapUtil.get_by_atom_key(map,"a")
throws an exception
```
"""
@doc since: "1.1.42"
def get_by_atom_key(map,key) do
Map.get(map,key)
end
@doc """
Obtain a value from a Map, respective to a STRING key.
Use only for performatic reasons, and you are sure that key exists on map and is from string type.
## Example
```elixir
iex > map = %{"a" => 1, "b" => 3}
iex > Krug.MapUtil.get_by_string_key(map,"a")
1
```
```elixir
iex > map = %{"a" => 1, "b" => 3}
iex > Krug.MapUtil.get_by_string_key(map,"c")
throws an exception
```
```elixir
iex > map = %{"a" => 1, "b" => 3}
iex > Krug.MapUtil.get_by_string_key(map,:a)
throws an exception
```
"""
@doc since: "1.1.42"
def get_by_string_key(map,key) do
map["#{key}"]
end
@doc """
Delete a value from a Map, respective to a key.
If receive a nil/invalid/empty key, return the map received.
If receive a nil map or received map is invalid or don't
contains the key, return the map received.
## Example
```elixir
iex > map = %{a: 1, b: 3}
iex > Krug.MapUtil.delete(map,:a)
%{b: 3}
```
"""
def delete(map,key) do
cond do
(nil == map
or nil == key)
-> map
(Map.has_key?(map,key))
-> map
|> Map.delete(key)
(Map.has_key?(map,"#{key}"))
-> map
|> Map.delete("#{key}")
true
-> map
end
end
@doc """
Delete all values from a Map, respective to received keys in list/enum.
If receive a nil/invalid/empty keys list/enum, return the map received.
Ignore keys that are invalid or don't exist in received map.
## Example
```elixir
iex > map = %{a: 1, b: 3, c: 10}
iex > Krug.MapUtil.delete_all(map,[:a,:c,:d])
%{b: 3}
```
"""
def delete_all(map,keys) do
cond do
(nil == map
or nil == keys
or Enum.empty?(keys))
-> map
true
-> map
|> delete(keys |> hd())
|> delete_all(keys |> tl())
end
end
@doc """
Replace/update a value from a Map, respective to a key.
If receive a nil/invalid key, return the map received.
If receive a nil map or received map is invalid or don't
contains the key, return the map received.
If receives a valid value and the key received is valid and not
exists in map, then add the new key and value to map.
## Examples
```elixir
iex > map = %{a: 1, b: 3}
iex > Krug.MapUtil.replace(map,:a,3)
%{a: 3, b: 3}
```
```elixir
iex > map = %{a: 1, b: 3}
iex > Krug.MapUtil.replace(map,:c,101)
%{a: 3, b: 3, c: 101}
```
"""
def replace(map,key,new_value) do
cond do
(nil == map
or nil == key)
-> map
(Map.has_key?(map,key))
-> map
|> Map.replace!(key,new_value)
(Map.has_key?(map,"#{key}"))
-> map
|> Map.replace!("#{key}",new_value)
true
-> map
|> Map.put(key,new_value)
end
end
@doc """
Replace/update a value from a Map, respective to a ATOM key.
Use only for performatic reasons, and you are sure that key exists on map and is from atom type.
## Examples
```elixir
iex > map = %{a: 1, b: 3}
iex > Krug.MapUtil.replace_by_atom_key(map,:a,3)
%{a: 3, b: 3}
```
```elixir
iex > map = %{a: 1, b: 3}
iex > Krug.MapUtil.replace_by_atom_key(map,:c,101)
throws an exception
```
```elixir
iex > map = %{a: 1, b: 3}
iex > Krug.MapUtil.replace_by_atom_key(map,"b",101)
throws an exception
```
"""
@doc since: "1.1.42"
def replace_by_atom_key(map,key,new_value) do
Map.replace!(map,key,new_value)
end
@doc """
Replace/update a value from a Map, respective to a STRING key.
Use only for performatic reasons, and you are sure that key exists on map and is from string type.
## Examples
```elixir
iex > map = %{"a" => 1, "b" => 3}
iex > Krug.MapUtil.replace_by_string_key(map,"a",3)
%{"a" => 3, "b" => 3}
```
```elixir
iex > map = %{"a" => 1, "b" => 3}
iex > Krug.MapUtil.replace_by_string_key(map,"c",3)
throws an exception
```
```elixir
iex > map = %{"a" => 1, "b" => 3}
iex > Krug.MapUtil.replace_by_string_key(map,:b,3)
throws an exception
```
"""
@doc since: "1.1.42"
def replace_by_string_key(map,key,new_value) do
Map.replace!(map,"#{key}",new_value)
end
end