HandleObjectCloner.m

Go to the documentation of this file.

classdef HandleObjectCloner<handle
    properties (Access=private)
        comparisonMode=mxberry.core.obj.ObjectComparisonMode.UserDefined;
    end
    %
    methods (Access=protected)
        function blobComparisonHook(self)
        end
    end
    methods (Access=protected, Sealed)
        function prevMode=setComparisonMode(self,comparisonMode)
            if nargout>0
                prevMode=self.getComparisonMode();
            end
            [self.comparisonMode]=deal(comparisonMode);
        end
        %
        function comparisonMode=getComparisonMode(self)
            import mxberry.core.throwerror;
            if numel(self)==1
                comparisonMode=self.comparisonMode;
            elseif isempty(self)
                comparisonMode=...
                    mxberry.core.obj.ObjectComparisonMode.UserDefined;
            else
                isAllCompModeEq=isequal(self.comparisonMode);
                if ~isAllCompModeEq
                    throwerror('wrongInput',['all elements of an object',...
                        'array are expected to have the same value',...
                        'of comparisonMode']);
                end
                comparisonMode=self(1).comparisonMode;
            end
        end
    end
    %
    methods (Access=protected)
        function propCheckCMat=getHandleClonerIsEqualPropCheckCMat(self,propNameList)
            import mxberry.core.obj.ObjectComparisonMode;
            switch self.getComparisonMode
                case ObjectComparisonMode.UserDefined
                    isAsHandleDefault=false;
                    isAsBlobDefault=false;
                case ObjectComparisonMode.Blob
                    isAsBlobDefault=true;
                    isAsHandleDefault=false;
                case ObjectComparisonMode.Handle
                    isAsBlobDefault=false;
                    isAsHandleDefault=true;
            end
            %
            propCheckCMat={'asHandle','asBlob','propEqScalarList','compareClass';...
                isAsHandleDefault,isAsBlobDefault,cell(1,0),true;...
                'isscalar(x)&&islogical(x)','isscalar(x)&&islogical(x)',...
                'iscell(x)&&(isrow(x)||(max(size(x))<=1))',...
                'isscalar(x)&&islogical(x)'};
            if nargin>1
                [isThereVec,indThereVec]=ismember(lower(propNameList),...
                    lower(propCheckCMat(1,:)));
                if ~all(isThereVec)
                    throwerror('wrongInput','not all properties are know');
                end
                propCheckCMat=propCheckCMat(:,indThereVec);
            end
        end
    end
    methods (Access=private,Static)
        function isPositive=isMe(inpObj)
            curClassName=mfilename('class');
            isPositive=isa(inpObj,curClassName);
        end
    end
    methods (Access=protected,Sealed)
        function [regArgList,propEqScalarList]=parseEqScalarProps(self,eqPropCheckCMat,propListToParse)
            import mxberry.core.parseparams;
            import mxberry.core.parseparext;
            %
            propCheckCMat=self.getHandleClonerIsEqualPropCheckCMat(...
                'propEqScalarList');
            nProps=size(eqPropCheckCMat,2);
            [regArgList,~,eqRelatedPropValList]=...
                mxberry.core.parseparext(propListToParse,...
                eqPropCheckCMat,...
                'propRetMode','list','isDefaultPropSpecVec',...
                false(1,nProps));
            %
            [regArgList,~,propEqScalarList]=...
                parseparext(regArgList,propCheckCMat);
            %
            propEqScalarList=[propEqScalarList,eqRelatedPropValList];
        end
    end
    %
    methods (Sealed)
        function varargout=ismember(leftObjVec,rightObjVec,varargin)
            import mxberry.core.obj.ObjectComparisonMode;
            import mxberry.core.ismembersortableobj;
            prevLeftMode=...
                leftObjVec.setComparisonMode(ObjectComparisonMode.Blob);
            prevRightMode=...
                rightObjVec.setComparisonMode(ObjectComparisonMode.Blob);
            %
            try
                if nargout==0
                    ismembersortableobj(leftObjVec,rightObjVec,varargin{:});
                else
                    varargout=cell(1,nargout);
                    [varargout{:}]=ismembersortableobj(leftObjVec,...
                        rightObjVec,varargin{:});
                end
                leftObjVec.setComparisonMode(prevLeftMode);
                rightObjVec.setComparisonMode(prevRightMode);
            catch meObj
                leftObjVec.setComparisonMode(prevLeftMode);
                rightObjVec.setComparisonMode(prevRightMode);
                rethrow(meObj);
            end
        end
        function varargout=unique(inpObjVec,varargin)
            import mxberry.core.obj.ObjectComparisonMode;
            import mxberry.core.uniquesortableobj;
            prevMode=inpObjVec.setComparisonMode(ObjectComparisonMode.Blob);
            try
                if nargout==0
                    uniquesortableobj(inpObjVec,varargin{:});
                else
                    varargout=cell(1,nargout);
                    [varargout{:}]=uniquesortableobj(inpObjVec,varargin{:});
                end
                inpObjVec.setComparisonMode(prevMode);
            catch meObj
                inpObjVec.setComparisonMode(prevMode);
                rethrow(meObj);
            end
        end
        function [resObjVec,indVec]=sort(inpObjVec)
            import mxberry.core.obj.ObjectComparisonMode;
            prevMode=inpObjVec.setComparisonMode(ObjectComparisonMode.Blob);
            try
                [resObjVec,indVec]=mxberry.core.sort.mergesort(inpObjVec);
                inpObjVec.setComparisonMode(prevMode);
            catch meObj
                inpObjVec.setComparisonMode(prevMode);
                rethrow(meObj);
            end
        end
        %
        function isEqArr=ne(varargin)
            isEqArr=eq(varargin{:});
            isEqArr=~isEqArr;
        end
        %
        function isEqArr=eq(varargin)
            import mxberry.core.parseparext;
            propCheckCMat=...
                varargin{1}.getHandleClonerIsEqualPropCheckCMat(...
                'asHandle');
            [regArgList,~,isAsHandle]=parseparext(varargin,...
                propCheckCMat,2);
            if isAsHandle
                isEqArr=eq@handle(regArgList{:});
            else
                isEqArr=isEqualElem(regArgList{:});
            end
        end
        function isLeArr=le(varargin)
            import mxberry.core.parseparext;
            propCheckCMat=...
                varargin{1}.getHandleClonerIsEqualPropCheckCMat(...
                'asHandle');
            [regArgList,~,isAsHandle]=parseparext(varargin,...
                propCheckCMat,2);
            if isAsHandle
                isLeArr=le@handle(regArgList{:});
            else
                [~,~,signOfDiffArr]=isEqualElem(regArgList{:});
                isLeArr=signOfDiffArr<=0;
            end
        end
        %
        function isGeArr=ge(varargin)
            import mxberry.core.parseparext;
            propCheckCMat=...
                varargin{1}.getHandleClonerIsEqualPropCheckCMat(...
                'asHandle');
            [regArgList,~,isAsHandle]=parseparext(varargin,...
                propCheckCMat,2);
            if isAsHandle
                isGeArr=ge@handle(regArgList{:});
            else
                [~,~,signOfDiffArr]=isEqualElem(regArgList{:});
                isGeArr=signOfDiffArr>=0;
            end
        end
        %
        function isLtArr=lt(varargin)
            import mxberry.core.parseparext;
            propCheckCMat=...
                varargin{1}.getHandleClonerIsEqualPropCheckCMat(...
                'asHandle');
            [regArgList,~,isAsHandle]=parseparext(varargin,...
                propCheckCMat,2);
            if isAsHandle
                isLtArr=lt@handle(regArgList{:});
            else
                [~,~,signOfDiffArr]=isEqualElem(regArgList{:});
                isLtArr=signOfDiffArr<0;
            end
        end
        %
        function isGtArr=gt(varargin)
            import mxberry.core.parseparext;
            propCheckCMat=...
                varargin{1}.getHandleClonerIsEqualPropCheckCMat(...
                'asHandle');
            [regArgList,~,isAsHandle]=parseparext(varargin,...
                propCheckCMat,2);
            if isAsHandle
                isGtArr=gt@handle(regArgList{:});
            else
                [~,~,signOfDiffArr]=isEqualElem(regArgList{:});
                isGtArr=signOfDiffArr>0;
            end
        end
        %
        function isEq=isequal(varargin)
            isEq=isEqual(varargin{:});
        end
        function isEq=isequaln(varargin)
            isEq=isequal(varargin{:});
        end
        function isEq=isequalwithequalnans(varargin)
            isEq=isequal(varargin{:});
        end
    end
    %
    methods
        function [isEq,reportStr]=isEqual(varargin)
            import mxberry.core.throwerror;
            import mxberry.core.parseparext;
            import mxberry.core.parseparams;
            NOT_EQ_STR='(object arrays #%d and #%d):%s';
            %
            indObj=find(cellfun(@(x)isa(x,mfilename('class')),varargin),...
                1,'first');
            propCheckCMat=...
                varargin{indObj}.getHandleClonerIsEqualPropCheckCMat();
            %
            isReportRequired=nargout>1;
            %
            [objList,~,isFullCheck,isAsHandle,isAsBlob,propEqScalarList,...
                isClassCompared]=...
                parseparext(varargin,...
                [{'isfullcheck';false;'isscalar(x)&&islogical(x)'},...
                propCheckCMat]);
            %
            checkIsHandleIsBlob(isAsHandle,isAsBlob);
            if isAsBlob&&~isClassCompared
                throwerror('wrongInput',['isClassCompared cannot be ',...
                    'set to false when isAsBlob is true']);
            end
            %
            nObj=length(objList);
            if nObj==1
                throwerror('wrongInput','Not enough input arguments');
            end
            %
            if isReportRequired
                reportStr='';
                reportStrList=cell(1,nObj-1);
                curReportCell=cell(1,1);
            else
                curReportCell={};
            end
            isEq=true;
            for iObj=1:nObj-1
                obj1=objList{iObj};
                obj2=objList{iObj+1};
                if isequal(size(obj1),size(obj2))
                    if ~isClassCompared||isequal(class(obj1),class(obj2))
                        if isAsHandle
                            isEqCur=obj1.eq(obj2,'asHandle',true);
                            if isReportRequired
                                if ~isEqCur
                                    reportStrCur='handles are different';
                                else
                                    reportStrCur='';
                                end
                            end
                        else
                            if isAsBlob
                                [isEqCur,curReportCell{:}]=...
                                    obj1.isEqualScalarAsBlobInternal(...
                                    obj2,propEqScalarList{:});
                            else
                                [isEqCurMat,curReportCell{:}]=...
                                    obj1.isEqualElem(...
                                    obj2,'propEqScalarList',...
                                    propEqScalarList,'compareClass',...
                                    isClassCompared);
                                %
                                isEqCur=all(isEqCurMat(:));
                            end
                            if isReportRequired
                                reportStrCur=curReportCell{1};
                            end
                        end
                        %
                        isEqCur=all(isEqCur(:));
                        if isReportRequired&&~isempty(reportStrCur)
                            reportStrList{iObj}=sprintf(...
                                NOT_EQ_STR,...
                                iObj,iObj+1,reportStrCur);
                        end
                    else
                        isEqCur=false;
                        if nargout>1
                            reportStrList{iObj}=sprintf(...
                                NOT_EQ_STR,...
                                iObj,iObj+1,'classes are not equal');
                        end
                    end
                else
                    isEqCur=false;
                    if nargout>1
                        reportStrList{iObj}=sprintf(...
                            NOT_EQ_STR,...
                            iObj,iObj+1,'sizes are not equal');
                    end
                end
                isEq=isEq&&isEqCur;
                if ~(isEq||isFullCheck)
                    break;
                end
            end
            if isReportRequired
                reportStrList(cellfun('isempty',reportStrList))=[];
                if length(reportStrList)>1
                    reportStr=mxberry.core.string.catwithsep(reportStrList,...
                        sprintf('\n'));
                elseif ~isempty(reportStrList)
                    reportStr=reportStrList{:};
                end
            end
        end
        %
        function [isEqArr,reportStr,signOfDiffArr]=isEqualElem(selfArr,otherArr,varargin)
            import mxberry.core.throwerror;
            import mxberry.core.parseparext;
            %
            propCheckCMat=...
                selfArr.getHandleClonerIsEqualPropCheckCMat();
            %
            [~,~,isAsHandle,isAsBlob,propEqScalarList,isClassCompared]=...
                parseparext(varargin,propCheckCMat,0);
            %
            checkIsHandleIsBlob(isAsHandle,isAsBlob);
            %
            isReportRequired=nargout>1;
            isSignOfDiffRequired=nargout>2;
            %
            sizeVec=size(selfArr);
            if ~isequal(sizeVec,size(otherArr))
                if numel(selfArr)==1
                    sizeVec=size(otherArr);
                    selfArr=repmat(selfArr,sizeVec);
                elseif numel(otherArr)==1
                    otherArr=repmat(otherArr,sizeVec);
                else
                    error('MATLAB:dimagree',...
                        'Matrix dimensions must agree.');
                end
            end
            nElems=numel(selfArr);
            if isReportRequired
                reportStr='';
                reportStrList=cell(1,nElems);
                curExtraOutArgList=cell(1,nargout-1);
            else
                curExtraOutArgList={};
            end
            
            isEqHandleMat=selfArr.eq(otherArr,'asHandle',true);
            %
            if isSignOfDiffRequired
                signOfDiffArr=nan(size(isEqHandleMat));
                signOfDiffArr(isEqHandleMat)=0;
            end
            %
            if ~all(isEqHandleMat(:))
                isEqArr=true(sizeVec);
                if isClassCompared&&(~isa(otherArr,class(selfArr)))
                    isEqArr(:)=false;
                    if nargout>1
                        reportStr='Not equal classes of objects';
                    end
                else
                    if ~isempty(isEqArr)
                        for iElem=1:nElems
                            
                            isEqCur=isEqHandleMat(iElem);
                            %
                            if ~isEqCur
                                if isAsHandle
                                    if isReportRequired
                                        reportStrCur='handles are different';                                    end
                                else
                                    if isAsBlob
                                        [isEqCur,curExtraOutArgList{:}]=...
                                            selfArr(iElem).isEqualScalarAsBlobInternal(...
                                            otherArr(iElem),propEqScalarList{:});
                                        %
                                        if isSignOfDiffRequired
                                            signOfDiffArr(iElem)=curExtraOutArgList{2};
                                        end
                                    else
                                        [isEqCur,curExtraOutArgList{:}]=...
                                            selfArr(iElem).isEqualScalarInternal(...
                                            otherArr(iElem),propEqScalarList{:});
                                    end
                                    if isReportRequired
                                        reportStrCur=curExtraOutArgList{1};
                                    end
                                end
                            end
                            %
                            if (nargout>1)&&~isempty(reportStrCur)
                                reportStrList{iElem}=sprintf(...
                                    '(element #%d):%s',iElem,...
                                    reportStrCur);
                            end
                            isEqArr(iElem)=isEqCur;
                        end
                        if nargout>1
                            reportStrList(...
                                cellfun('isempty',reportStrList))=[];
                            if length(reportStrList)>1
                                reportStr=mxberry.core.string.catwithsep(...
                                    reportStrList,sprintf('\n'));
                            elseif ~isempty(reportStrList)
                                reportStr=reportStrList{:};
                            end
                        end
                    end
                end
            else
                isEqArr=isEqHandleMat;
            end
            if isSignOfDiffRequired
                if any(isnan(signOfDiffArr(:)))
                    throwerror('wrongInput:signNotDefForAllElems',...
                        ['sign of difference is ',...
                        'not assigned for all elements']);
                end
            end
        end
    end
    methods (Access=private)
        function [isEq,reportStr,signOfDiff]=isEqualScalarAsBlobInternal(leftObj,rightObj)
            leftObj.blobComparisonHook();
            if nargout<=2
                isEq=false;
                isEqSize=isequal(size(leftObj),size(rightObj));
                if isEqSize
                    isEqClass=isequal(class(leftObj),class(rightObj));
                    if ~isEqClass
                        reportStr='classes are different';
                    else
                        isEq=true;
                    end
                else
                    if nargout>1
                        reportStr='sizes are different';
                    end
                end
            else
                isEq=true;
            end
            %
            if isEq
                leftBlobVec=getByteStreamFromArray(leftObj);
                rightBlobVec=getByteStreamFromArray(rightObj);
                nLeftElems=numel(leftBlobVec);
                nRightElems=numel(rightBlobVec);
                %
                isEqBlobSize=nLeftElems==nRightElems;
                isEq=isEqBlobSize&&isequal(leftBlobVec,rightBlobVec);
                if nargout>1
                    if isEq
                        reportStr='';
                    else
                        if isEqBlobSize
                            reportStr='blobs are different';
                        else
                            reportStr='blob sizes are different';
                        end
                    end
                    if nargout>2
                        if ~isEq
                            if ~isEqBlobSize
                                if nLeftElems<nRightElems
                                    leftBlobVec=[leftBlobVec,...
                                        zeros(1,nRightElems-nLeftElems)];
                                else
                                    leftBlobVec=[rightBlobVec,...
                                        zeros(1,nLeftElems)-nRightElems];
                                end
                            end
                            [~,indSortedVec]=sortrows([leftBlobVec;rightBlobVec]);
                            signOfDiff=indSortedVec(2)-indSortedVec(1);
                        else
                            signOfDiff=0;
                        end
                    end
                end
            end
        end
    end
    %
    methods (Access=protected)
        function [isOk,reportStr,signOfDiff]=isEqualScalarInternal(self,otherObj,varargin)
            isOk=self.eq(otherObj,'asHandle',true);
            if nargout>1
                if isOk
                    reportStr='';
                else
                    reportStr='handles are different';
                end
                if nargout>2
                    signOfDiff=nan;
                end
            end
        end
    end
    methods
        function obj=clone(self,varargin)
            if isempty(varargin)
                %Performance optimization
                obj = getArrayFromByteStream(getByteStreamFromArray(self));
            else
                obj=self.createInstance(self,varargin{:});
            end
        end
        function resObj=createInstance(self,varargin)
            p=metaclass(self);
            resObj=feval(p.Name,varargin{:});
        end
    end
end
function checkIsHandleIsBlob(isAsHandle,isAsBlob)
import mxberry.core.throwerror;
if isAsBlob&&isAsHandle
    throwerror('wrongInput:blobAndHandleIncompatible',['isAsBlob and isAsHandle ',...
        'cannot both be true']);
end
end