impl localcache and globalcache

4 files changed, 351 insertions, 14 deletions

diff --git a/tests/modules/cache/test.lua b/tests/modules/cache/test.lua
index ad37ccdb8..0096f0f03 100644
--- a/tests/modules/cache/test.lua
+++ b/tests/modules/cache/test.lua
@@ -1,4 +1,6 @@
 import("core.cache.memcache")
+import("core.cache.localcache")
+import("core.cache.globalcache")
 
 function test_memcache(t)
     memcache.set("mycache", "xyz", {1, 2, 3})
@@ -13,3 +15,28 @@ function test_memcache(t)
     t:are_equal(memcache.get2("mycache", "foo", "bar"), nil)
 end
 
+function test_localcache(t)
+    localcache.set("mycache", "xyz", {1, 2, 3})
+    localcache.set2("mycache", "foo", "bar", "1")
+    t:are_equal(localcache.get("mycache", "xyz"), {1, 2, 3})
+    t:are_equal(localcache.get2("mycache", "foo", "bar"), "1")
+    localcache.clear("mycache")
+    t:are_equal(localcache.get2("mycache", "foo", "bar"), nil)
+    localcache.set2("mycache", "foo", "bar", "1")
+    localcache.clear()
+    t:are_equal(localcache.get("mycache", "xyz"), nil)
+    t:are_equal(localcache.get2("mycache", "foo", "bar"), nil)
+end
+
+function test_globalcache(t)
+    globalcache.set("mycache", "xyz", {1, 2, 3})
+    globalcache.set2("mycache", "foo", "bar", "1")
+    t:are_equal(globalcache.get("mycache", "xyz"), {1, 2, 3})
+    t:are_equal(globalcache.get2("mycache", "foo", "bar"), "1")
+    globalcache.clear("mycache")
+    t:are_equal(globalcache.get2("mycache", "foo", "bar"), nil)
+    globalcache.set2("mycache", "foo", "bar", "1")
+    globalcache.clear()
+    t:are_equal(globalcache.get("mycache", "xyz"), nil)
+    t:are_equal(globalcache.get2("mycache", "foo", "bar"), nil)
+end
diff --git a/xmake/core/cache/globalcache.lua b/xmake/core/cache/globalcache.lua
index c0e938726..3529b259b 100644
--- a/xmake/core/cache/globalcache.lua
+++ b/xmake/core/cache/globalcache.lua
@@ -19,15 +19,168 @@
 --
 
 -- define module: globalcache
-local globalcache = globalcache or {}
+local globalcache  = globalcache or {}
+local _instance = _instance or {}
 
 -- load modules
-local io     = require("base/io")
-local os     = require("base/os")
-local path   = require("base/path")
-local table  = require("base/table")
-local utils  = require("base/utils")
-local global = require("base/global")
+local table   = require("base/table")
+local io      = require("base/io")
+local path    = require("base/path")
+local global  = require("base/global")
+
+-- new an instance
+function _instance.new(name)
+    local instance = table.inherit(_instance)
+    instance._NAME = name
+    instance:load()
+    instance._DATA = instance._DATA or {}
+    return instance
+end
+
+-- get cache name
+function _instance:name()
+    return self._NAME
+end
+
+-- get cache data
+function _instance:data()
+    return self._DATA
+end
+
+-- load cache
+function _instance:load()
+    local result = io.load(path.join(global.cachedir(), self:name()))
+    if result then
+        self._DATA = result
+    end
+end
+
+-- save cache
+function _instance:save()
+    local ok, errors = io.save(path.join(config.cachedir(), self:name()), self._DATA)
+    if not ok then
+        os.raise(errors)
+    end
+end
+
+-- get cache value in level/1
+function _instance:get(key)
+    return self._DATA[key]
+end
+
+-- get cache value in level/2
+function _instance:get2(key1, key2)
+    local value1 = self:get(key1)
+    if value1 ~= nil then
+        return value1[key2]
+    end
+end
+
+-- get cache value in level/3
+function _instance:get3(key1, key2, key3)
+    local value2 = self:get2(key1)
+    if value2 ~= nil then
+        return value2[key3]
+    end
+end
+
+-- set cache value in level/1
+function _instance:set(key, value)
+    self._DATA[key] = value
+end
+
+-- set cache value in level/2
+function _instance:set2(key1, key2, value2)
+    local value1 = self:get(key1)
+    if value1 == nil then
+        value1 = {}
+        self:set(key1, value1)
+    end
+    value1[key2] = value2
+end
+
+-- set cache value in level/3
+function _instance:set3(key1, key2, key3, value3)
+    local value2 = self:get2(key1, key2)
+    if value2 == nil then
+        value2 = {}
+        self:set2(key1, key2, value2)
+    end
+    value2[key3] = value3
+end
+
+-- clear cache scopes
+function _instance:clear()
+    self._DATA = {}
+end
+
+-- get cache instance
+function globalcache.cache(cachename)
+    local caches = globalcache._CACHES
+    if not caches then
+        caches = {}
+        globalcache._CACHES = caches
+    end
+    local instance = caches[cachename]
+    if not instance then
+        instance = _instance.new(cachename)
+        caches[cachename] = instance
+    end
+    return instance
+end
+
+-- get all caches
+function globalcache.caches()
+    return globalcache._CACHES
+end
+
+-- get cache value in level/1
+function globalcache.get(cachename, key)
+    return globalcache.cache(cachename):get(key)
+end
+
+-- get cache value in level/2
+function globalcache.get2(cachename, key1, key2)
+    return globalcache.cache(cachename):get2(key1, key2)
+end
+
+-- get cache value in level/3
+function globalcache.get3(cachename, key1, key2, key3)
+    return globalcache.cache(cachename):get3(key1, key2, key3)
+end
+
+-- set cache value in level/1
+function globalcache.set(cachename, key, value)
+    return globalcache.cache(cachename):set(key, value)
+end
+
+-- set cache value in level/2
+function globalcache.set2(cachename, key1, key2, value)
+    return globalcache.cache(cachename):set2(key1, key2, value)
+end
+
+-- set cache value in level/3
+function globalcache.set3(cachename, key1, key2, key3, value)
+    return globalcache.cache(cachename):set3(key1, key2, key3, value)
+end
+
+-- clear the given cache, it will clear all caches if cache name is nil
+function globalcache.clear(cachename)
+    local caches = globalcache.caches()
+    if caches then
+        for _, cache in pairs(caches) do
+            if cachename then
+                if cache:name() == cachename then
+                    cache:clear()
+                end
+            else
+                cache:clear()
+            end
+        end
+    end
+end
 
 -- return module: globalcache
 return globalcache
+
+
diff --git a/xmake/core/cache/localcache.lua b/xmake/core/cache/localcache.lua
index 647d74aa8..f937bc9d0 100644
--- a/xmake/core/cache/localcache.lua
+++ b/xmake/core/cache/localcache.lua
@@ -19,15 +19,167 @@
 --
 
 -- define module: localcache
-local localcache = localcache or {}
+local localcache  = localcache or {}
+local _instance = _instance or {}
 
 -- load modules
-local io     = require("base/io")
-local os     = require("base/os")
-local path   = require("base/path")
-local table  = require("base/table")
-local utils  = require("base/utils")
-local global = require("base/global")
+local table   = require("base/table")
+local io      = require("base/io")
+local path    = require("base/path")
+local config  = require("project/config")
+
+-- new an instance
+function _instance.new(name)
+    local instance = table.inherit(_instance)
+    instance._NAME = name
+    instance:load()
+    instance._DATA = instance._DATA or {}
+    return instance
+end
+
+-- get cache name
+function _instance:name()
+    return self._NAME
+end
+
+-- get cache data
+function _instance:data()
+    return self._DATA
+end
+
+-- load cache
+function _instance:load()
+    local result = io.load(path.join(config.cachedir(), self:name()))
+    if result then
+        self._DATA = result
+    end
+end
+
+-- save cache
+function _instance:save()
+    local ok, errors = io.save(path.join(config.cachedir(), self:name()), self._DATA)
+    if not ok then
+        os.raise(errors)
+    end
+end
+
+-- get cache value in level/1
+function _instance:get(key)
+    return self._DATA[key]
+end
+
+-- get cache value in level/2
+function _instance:get2(key1, key2)
+    local value1 = self:get(key1)
+    if value1 ~= nil then
+        return value1[key2]
+    end
+end
+
+-- get cache value in level/3
+function _instance:get3(key1, key2, key3)
+    local value2 = self:get2(key1)
+    if value2 ~= nil then
+        return value2[key3]
+    end
+end
+
+-- set cache value in level/1
+function _instance:set(key, value)
+    self._DATA[key] = value
+end
+
+-- set cache value in level/2
+function _instance:set2(key1, key2, value2)
+    local value1 = self:get(key1)
+    if value1 == nil then
+        value1 = {}
+        self:set(key1, value1)
+    end
+    value1[key2] = value2
+end
+
+-- set cache value in level/3
+function _instance:set3(key1, key2, key3, value3)
+    local value2 = self:get2(key1, key2)
+    if value2 == nil then
+        value2 = {}
+        self:set2(key1, key2, value2)
+    end
+    value2[key3] = value3
+end
+
+-- clear cache scopes
+function _instance:clear()
+    self._DATA = {}
+end
+
+-- get cache instance
+function localcache.cache(cachename)
+    local caches = localcache._CACHES
+    if not caches then
+        caches = {}
+        localcache._CACHES = caches
+    end
+    local instance = caches[cachename]
+    if not instance then
+        instance = _instance.new(cachename)
+        caches[cachename] = instance
+    end
+    return instance
+end
+
+-- get all caches
+function localcache.caches()
+    return localcache._CACHES
+end
+
+-- get cache value in level/1
+function localcache.get(cachename, key)
+    return localcache.cache(cachename):get(key)
+end
+
+-- get cache value in level/2
+function localcache.get2(cachename, key1, key2)
+    return localcache.cache(cachename):get2(key1, key2)
+end
+
+-- get cache value in level/3
+function localcache.get3(cachename, key1, key2, key3)
+    return localcache.cache(cachename):get3(key1, key2, key3)
+end
+
+-- set cache value in level/1
+function localcache.set(cachename, key, value)
+    return localcache.cache(cachename):set(key, value)
+end
+
+-- set cache value in level/2
+function localcache.set2(cachename, key1, key2, value)
+    return localcache.cache(cachename):set2(key1, key2, value)
+end
+
+-- set cache value in level/3
+function localcache.set3(cachename, key1, key2, key3, value)
+    return localcache.cache(cachename):set3(key1, key2, key3, value)
+end
+
+-- clear the given cache, it will clear all caches if cache name is nil
+function localcache.clear(cachename)
+    local caches = localcache.caches()
+    if caches then
+        for _, cache in pairs(caches) do
+            if cachename then
+                if cache:name() == cachename then
+                    cache:clear()
+                end
+            else
+                cache:clear()
+            end
+        end
+    end
+end
 
 -- return module: localcache
 return localcache
+
diff --git a/xmake/core/project/config.lua b/xmake/core/project/config.lua
index 2ccc6ff1a..f27fc2857 100644
--- a/xmake/core/project/config.lua
+++ b/xmake/core/project/config.lua
@@ -148,6 +148,11 @@ function config.filepath()
     return path.join(config.directory(), xmake._NAME .. ".conf")
 end
 
+-- get the local cache directory
+function config.cachedir()
+    return path.join(config.directory(), "cache")
+end
+
 -- get the configure directory on the current host/arch platform
 function config.directory()
     if config._DIRECTORY == nil then