ConfRepoManagerAnyStorage.m

Go to the documentation of this file.

classdef ConfRepoManagerAnyStorage<mxberry.core.obj.HandleObjectCloner
    properties (Access=private)
        storage
        cache
        curConfName='';
        getStorageHook
        putStorageHook
    end
    properties (SetAccess=private,GetAccess=protected)
        confPatchRepo
    end
    methods
        function storageDir=getStorageBranchKey(self)
            storageDir=self.storage.getStorageBranchKey();
        end
        %
        function storageDir=getStorageLocation(self)
            storageDir=self.storage.getStorageLocation();
        end
        %
        function storageRootDir=getStorageLocationRoot(self)
            storageRootDir=self.storage.getStorageLocationRoot();
        end
    end
    %
    methods (Access=private)
        function [SConfData,metaData]=getConfFromStorage(self,confName)
            [SConfData,metaData]=self.storage.get(confName);
            SConfData=...
                mxberry.core.struct.updateleaves(SConfData,self.getStorageHook);
        end
        %
    end
    methods
        function isPositive=isCachedConf(self,confName)
            isPositive=self.cache.isKey(confName);
        end
        function putConfToCache(self,varargin)
            self.cacheConf(varargin{:});
        end
        function putConfToCacheAndSelect(self,varargin)
            self.cacheAndSelectConf(varargin{:});
        end
        function putConfToStorage(self,confName,SConfData,metaData)
            SConfData=...
                mxberry.core.struct.updateleaves(SConfData,...
                self.putStorageHook);
            self.storage.put(confName,SConfData,metaData);
        end
    end
    %
    methods (Access=protected,Static)
        function confVersion=getConfVersionFromMetaData(metaData)
            if ~isfield(metaData,'version')
                confVersion=-Inf;
            else
                confVersion=str2double(metaData.version);
            end
        end
        function metaData=putConfVersionToMetaData(metaData,confVersion)
            confVersion=num2str(confVersion);
            metaData.version=confVersion;
        end
    end
    methods
        function otherObj=getCopy(self)
            otherObj=getArrayFromByteStream(getByteStreamFromArray(self));
        end
        function isPos=isConfSelected(self,confName)
            isPos=strcmp(self.curConfName,confName);
        end
        function storeCachedConf(self,confName)
            [SConfData,metaData]=getCachedConf(self,confName);
            self.putConfToStorage(confName,SConfData,metaData)
        end
        function flushCache(self)
            self.initCache();
        end
        function lastRevision=getLastConfVersion(self)
            lastRevision=self.confPatchRepo.getLastRevision();
        end
        function self=ConfRepoManagerAnyStorage(storage,varargin)
            import mxberry.core.parseparext;
            import mxberry.core.struct.*;
            mxberry.core.checkvar(storage,...
                @(x)isa(x,...
                'mxberry.core.cont.ondisk.IOnDiskBranchedStorage'));
            
            self.initCache();
            %
            [reg,isRegSpec,self.putStorageHook,...
                self.getStorageHook]=parseparext(...
                varargin,{...
                'putStorageHook','getStorageHook';...
                @(x,y)x,@(x,y)x;...
                @(x)isa(x,'function_handle'),...
                @(x)isa(x,'function_handle')},...
                'regCheckList',...
                {@(x)isa(x,...
                'mxberry.core.struct.AStructChangeTracker')});
            
            if isRegSpec
                self.confPatchRepo=reg{1};
            else
                self.confPatchRepo=...
                    StructChangeTrackerEmptyPlug();
            end
            %
            self.storage=storage;
            %
        end
        %
        function editConf(self,confName)
            fileName=self.storage.getFileNameByKey(confName);
            edit(fileName);
        end
        %
        function selectConf(self,confName,varargin)
            import mxberry.core.throwerror;
            [~,prop]=mxberry.core.parseparams(varargin,{'reloadIfSelected'},0);
            if ~isempty(prop)
                isReloadedIfSelected=prop{2};
                if ~(islogical(isReloadedIfSelected)&&numel(isReloadedIfSelected)==1)
                    throwerror('wrongInput',...
                        'reloadedIfSelected is expected to be a logical scalar');
                end
            else
                isReloadedIfSelected=true;
            end
            %
            if isReloadedIfSelected||~(isReloadedIfSelected||self.isCachedConf(confName))
                if ~self.storage.isKey(confName)
                    throwerror('unknownConfig',...
                        'configuration %s does not exist in the repository',...
                        confName);
                end
                %
                [SConf,metaData]=self.getConfFromStorage(confName);
                self.cacheAndSelectConf(confName,SConf,metaData);
            else
                self.curConfName=confName;
            end
        end
        %
        function isPositive=isParam(self,paramName)
            if paramName(1)~='.'
                paramName=['.',paramName];
            end
            isPositive=mxberry.core.struct.structcheckpath(...
                self.getCurConf(),paramName);
        end
        %
        function resVal=getParam(self,paramName,varargin)
            import mxberry.core.throwerror;
            import mxberry.core.parseparext;
            %
            [~,~,isCacheSkipped]=parseparext(varargin,...
                {'skipCache';false;@(x)islogical(x)&&isscalar(x)},0);
            %
            if isCacheSkipped
                self.reCacheCurConf();
            end
            try
                resVal=mxberry.core.struct.structgetpath(self.getCurConf(),...
                    paramName);
                %
            catch meObj
                newMeObj=throwerror('invalidParam',...
                    'the requested parameter does not exist');
                newMeObj=newMeObj.addCause(meObj);
                throw(newMeObj);
            end
        end
        %
        function setParam(self,paramName,paramValue,varargin)
            [~,prop]=mxberry.core.parseparams(varargin,{'writedepth'},0);
            isWriteToDisk=true;
            if ~isempty(prop)
                isWriteToDisk=strcmpi(prop{2},'disk');
            end
            %
            if paramName(1)~='.'
                paramName=['.',paramName];
            end
            %
            curConfName=self.getCurConfName(); %#ok<*PROPLC,*PROP>
            [curConf,metaData]=self.getCurConf();
            SConf=mxberry.core.struct.structapplypath(curConf,paramName,...
                paramValue);
            %
            self.cacheAndSelectConf(curConfName,SConf,metaData);
            if isWriteToDisk
                self.putConfToStorage(curConfName,SConf,metaData);
            end
        end
        %
        function putConf(self,confName,SConf,varargin)
            [restArgList,~,isSelected]=mxberry.core.parseparext(varargin,...
                {'selectConf';true;'islogical(x)&&isscalar(x)'});
            %
            self.putConfInternal(confName,SConf,restArgList{:});
            %
            if isSelected
                self.curConfName=confName;
            end
            %
        end
        %
        function [SConf,confVersion,metaData]=getConf(self,confName)
            [SConf,confVersion,metaData]=self.getConfInternal(confName);
        end
        %
        function copyConf(self,fromConfName,toConfName)
            [SConf,metaData]=self.getConfInternal(fromConfName);
            self.putConf(toConfName,SConf,metaData);
        end
        %
        function destFileName=copyConfFile(self,destFolderName,varargin)
            [reg,~,isDestFile]=mxberry.core.parseparext(varargin,...
                {'destIsFile';false;'isscalar(x)&&islogical(x)'},...
                'regCheckList',{'isstring(x)'},...
                'regDefList',{self.getCurConfName()});
            confName=reg{1};
            
            fullFileName=self.storage.getFileNameByKey(confName);
            %make sure that "/" at the end of folder path doesn't matter
            if isDestFile
                destFileName=destFolderName;
            else
                [~,fileName,ext]=fileparts(fullFileName);
                if strcmp(destFolderName(end),filesep)
                    destFolderName=destFolderName(1:end-1);
                end
                if ~mxberry.io.isdir(destFolderName)
                    mxberry.io.mkdir(destFolderName);
                end
                destFileName=[destFolderName,filesep,fileName,ext];
            end
            copyfile(fullFileName,destFileName);
        end
        %
        function removeAll(self)
            self.initCache();
            self.storage.removeAll();
        end
        function confNameList=getConfNameList(self)
            confNameList=self.getConfNameListInternal();
        end
        function confName=getCurConfName(self)
            import mxberry.core.throwerror;
            if isempty(self.curConfName)
                throwerror('wrongActionSequence',...
                    'Current configuration is not selected');
            end
            %
            confName=self.curConfName;
        end
        %
        function [SConf,metaData]=getCurConf(self)
            curConfName=self.getCurConfName();
            [SConf,metaData]=self.getCachedConf(curConfName);
        end
        %
        function isPositive=isConf(self,confName)
            isPositive=self.storage.isKey(confName);
        end
        function removeConf(self,confName)
            if self.cache.isKey(confName)
                self.cache.remove(confName);
            end
            %
            self.storage.remove(confName);
        end
        function setConfPatchRepo(self,confPatchRepo)
            self.confPatchRepo=confPatchRepo;
        end
        function updateConf(self,confName)
            self.updateConfInternal(confName);
        end
        function updateAll(self)
            self.updateAllInternal();
        end
    end
    methods (Access=protected)
        function confNameList=getCachedConfNames(self)
            confNameList=self.cache.keys();
        end
        %
        function updateAllInternal(self)
            confNameList=self.getConfNameListInternal();
            nConfs=length(confNameList);
            for iConf=1:nConfs
                confName=confNameList{iConf};
                self.updateConfInternal(confName);
            end
        end
        %
        function confNameList=getConfNameListInternal(self)
            import mxberry.core.throwerror;
            try
                confNameList=self.storage.getKeyList();
            catch meObj
                if ~isempty(strfind(meObj.identifier,':badKeyValuePair'))
                    newMeObj=throwerror('badConfRepo',...
                        ['configuration repository contains the ',...
                        'inconsistent configurations']);
                    newMeObj=addCause(newMeObj,meObj);
                    throw(newMeObj);
                else
                    rethrow(meObj);
                end
            end
        end
        function updateConfInternal(self,confName)
            [SConf,oldConfVersion,metaData]=self.getConfInternal(confName);
            [SConf,confVersion,metaData]=self.updateConfStructInternal(...
                SConf,oldConfVersion,metaData);
            if (confVersion>oldConfVersion)||isnan(oldConfVersion)
                self.putConfInternal(confName,SConf,confVersion,metaData);
            end
        end
        function [SConf,confVersion,metaData]=updateConfStructInternal(self,SConf,confVersion,metaData)
            [SConf,confVersion]=self.confPatchRepo.applyAllLaterPatches(SConf,confVersion);
            metaData=self.putConfVersionToMetaData(metaData,confVersion);
            
        end
        
        function [SConf,confVersion,metaData]=getConfInternal(self,confName)
            import mxberry.core.throwerror;
            %
            if self.isCachedConf(confName)
                [SConf,metaData]=self.getCachedConf(confName);
            else
                try
                    [SConf,metaData]=self.getConfFromStorage(confName);
                catch meObj
                    if ~isempty(strfind(meObj.identifier,':noRecord'))
                        newMeObj=throwerror('noConfiguration',...
                            'configuration %s does not exist',confName);
                        %
                        newMeObj=addCause(newMeObj,meObj);
                        throw(newMeObj);
                    else
                        rethrow(meObj);
                    end
                end
            end
            confVersion=self.getConfVersionFromMetaData(metaData);
        end
        %
        function putConfInternal(self,confName,SConf,confVersion,metaData)
            if nargin<5
                metaData=struct();
            end
            %
            if nargin<4
                confVersion=self.confPatchRepo.getLastRevision();
            end
            %
            metaData=self.putConfVersionToMetaData(metaData,confVersion);
            %
            self.cacheConf(confName,SConf,metaData);
            self.putConfToStorage(confName,SConf,metaData);
        end
        %
    end
    methods (Access=protected)
        function cacheAndSelectConf(self,confName,SConf,metaData)
            self.cacheConf(confName,SConf,metaData);
            self.curConfName=confName;
        end
        function cacheConf(self,confName,SConf,metaData)
            self.cache(confName)={SConf,metaData};
        end
        function [SConf,metaData]=getCachedConf(self,confName)
            import mxberry.core.throwerror;
            isCached=self.isCachedConf(confName);
            if isCached
                res=self.cache(confName);
                SConf=res{1};
                metaData=res{2};
            else
                throwerror('noKey',...
                    'configuration %s is not cached',confName);
            end
        end
        function reCacheCurConf(self)
            curConfName=self.getCurConfName();
            [conf,metaData]=self.getConfFromStorage(curConfName);
            self.cacheAndSelectConf(curConfName,conf,metaData);
        end
        function initCache(self)
            self.cache=containers.Map;
        end
    end
end