Compare values in a list of maps in clojure

Question

I have a list of maps like

       (def listofmaps
       ({:directory_path "/some/path/1", :directory_size "8.49 GB"} {:directory_path "/user/dod/yieldbook/yb_sec_char", :directory_size "14.1 MB"})

containing many values and size can be in gb or mb.

Also I have a limitlistofmaps like

     (def limitlistofmaps
     ({:directory_path "/some/path/8", :directory_size "15.2 GB"}  {:directory_path "some/path/3", :directory_size "2.1 GB"}
     {:directory_path "/some/path/1", :directory_size "17.2 GB"})

with many values..

I need to print "limit exceeded" if any map in list of maps had the same :directory_path as in limitlistofmaps but :directory_size exceeds the value specified. The problem is that size is in string format and unit has to be considered.

Can you help me with a way to do this in clojure?

Answer 1

I don't get why people down voted your question. I think as a Clojure community we are much better. I'm also a Clojure newb and I have nothing but great things to say about the community. I would like that it stays this way.

Firstly, why not have all the directory sizes in the same unit ? That way it's easier to compare them, say in KB.

Here is one version of a function that would transform any string like "100.23 Gb", "12 B", "123.3443 MB" to a Double representing Kilobytes.

(defn convert-to-kb
  "Converts a string 'number (B|KB|MB|GB)' to Double representing KBytes"
  [str]
  (let [[number-str unit] (map str/lower-case (str/split (str/trim str) #"\s+"))
        number (Double/parseDouble number-str)]
    (condp = unit
      "b"  (/ number 1000)
      "kb" number
      "mb" (* number 1000)
      "gb" (* number 1000000))))

Secondly, I would suggest you put the directory size limits in the same map data that lives inside your listofmaps, so you don't have state duplication like you have now in limitslistofmaps. But if for some reason you need this second map, here a piece of ugly code that returns a list of maps that are the same as in your listofmaps with two added key/val entries, :max_size_kb and :directory_size_kb.

for [dir listofmaps :let [{:keys [directory_path directory_size]} dir]]
  (let [limit-map (first
                    (get (group-by :directory_path limitlistofmaps) directory_path))
        max-size-kb (convert-to-kb (:directory_size limit-map))]
    (-> dir
        (assoc :max_size_kb max-size-kb)
        (assoc :directory_size_kb (convert-to-kb directory_size)))))