ram_{free,total}: choose_method

Author: scivision

+stdlib/+sys/filesystem_type.m

@@ -1,9 +1,8 @@
 function t = filesystem_type(p)
 
-if ~stdlib.exists(p)
-  t = string.empty;
-  return
-end
+t = string.empty;
+
+if ~stdlib.exists(p), return, end
 
 if ispc()
   dl = extractBefore(stdlib.absolute(p), 2);
@@ -17,8 +16,6 @@
 [s, t] = system(cmd);
 if s == 0
   t = string(strip(t));
-else
-  t = string.empty;
 end
 
 end

+stdlib/private/choose_method.m

@@ -13,9 +13,19 @@
 
 for m = method
   switch m
+    case "dotnet"
+      if endsWith(name, "ram_total")
+        if stdlib.dotnet_api() < 6, continue, end
+      end
     case "legacy", has = true;
     case "native", has = stdlib.strempty(minVersion) || ~isMATLABReleaseOlderThan(minVersion);
-    otherwise, has = str2func("stdlib.has_" + m);
+    case "sys"
+      has = true;
+    otherwise
+      has = str2func("stdlib.has_" + m);
+      if endsWith(name, ["filesystem_type", "ram_total", "ram_free"])
+        if ~stdlib.python.has_psutil(); continue, end
+      end
   end
 
   if has()

+stdlib/ram_free.m

@@ -8,24 +8,20 @@
 %%% Outputs
 % * freebytes: free physical RAM [bytes]
 %
-% This is done using Java on non-Windows platforms.
-%
-% VisualBasic (needs Windows) is needed to do this with .NET,
-%
-% builtin memory() on Windows includes swap. The user could do that themselves.
-%
-% we installed use Java or Python psutil, which are consistent with each other.
+% Java or Python psutil are consistent with each other.
 %
 % Fallback is to shell commands.
 
-function bytes = ram_free()
-
-if stdlib.has_java()
-  bytes = stdlib.java.ram_free();
-elseif stdlib.python.has_psutil()
-  bytes = stdlib.python.ram_free();
-else
-  bytes = stdlib.sys.ram_free();
+function bytes = ram_free(method)
+arguments
+  method (1,:) string = ["java", "python", "sys"]
 end
 
+fun = choose_method(method, "ram_free");
+
+bytes = fun();
+
+% * VisualBasic (needs Windows) is needed to do this with .NET.
+% * builtin memory() on Windows includes swap. The user could do that themselves.
+
 end

+stdlib/ram_total.m

@@ -6,18 +6,13 @@
 %%% Outputs
 % * bytes: total physical RAM [bytes]
 
-function bytes = ram_total()
-
-if stdlib.dotnet_api() >= 6
-  bytes = stdlib.dotnet.ram_total();
-elseif stdlib.has_java()
-  bytes = stdlib.java.ram_total();
-elseif stdlib.python.has_psutil()
-  bytes = stdlib.python.ram_total();
-else
-  bytes = stdlib.sys.ram_total();
+function bytes = ram_total(method)
+arguments
+  method (1,:) string = ["java", "dotnet", "python", "sys"]
 end
 
-end
+fun = choose_method(method, "ram_total");
 
-%!assert(ram_total()>0)
+bytes = fun();
+
+end

test/TestSys.m

@@ -11,8 +11,8 @@
 host_fun = {@stdlib.hostname, @stdlib.sys.get_hostname, @stdlib.dotnet.get_hostname, @stdlib.java.get_hostname, @stdlib.python.get_hostname}
 user_fun = {@stdlib.get_username, @stdlib.sys.get_username, @stdlib.dotnet.get_username, @stdlib.java.get_username, @stdlib.python.get_username}
 is_admin_fun = {@stdlib.is_admin, @stdlib.sys.is_admin, @stdlib.dotnet.is_admin, @stdlib.java.is_admin, @stdlib.python.is_admin}
-ram_free_fun = {@stdlib.ram_free, @stdlib.sys.ram_free, @stdlib.java.ram_free, @stdlib.python.ram_free}
-ram_total_fun = {@stdlib.ram_total, @stdlib.sys.ram_total, @stdlib.dotnet.ram_total, @stdlib.java.ram_total, @stdlib.python.ram_total}
+ram_free_method = {'sys', 'java', 'python'}
+ram_total_method = {'sys', 'java', 'python'}
 end
 
 methods(TestClassSetup)
@@ -144,20 +144,20 @@ function test_cpu_arch(tc, cpu_arch_fun)
 tc.verifyGreaterThan(strlength(arch), 0, "CPU architecture should not be empty")
 end
 
-function test_ram_total(tc, ram_total_fun)
-is_capable(tc, ram_total_fun)
+function test_ram_total(tc, ram_total_method)
+is_capable(tc, str2func("stdlib." + ram_total_method + ".ram_total"))
 
-t = ram_total_fun();
+t = stdlib.ram_total(ram_total_method);
 tc.verifyGreaterThan(t, 0)
 tc.verifyClass(t, 'uint64')
 end
 
 
-function test_ram_free(tc, ram_free_fun)
+function test_ram_free(tc, ram_free_method)
 % don't verify less than or equal total due to shaky system measurements
-is_capable(tc, ram_free_fun)
+is_capable(tc, str2func("stdlib." + ram_free_method + ".ram_free"))
 
-f = ram_free_fun();
+f = stdlib.ram_free(ram_free_method);
 tc.verifyGreaterThan(f, 0)
 tc.verifyClass(f, 'uint64')
 end