Activity.m

classdef Activity < LayeredNetworkElement
    % A stage of service in a Task of a LayeredNetwork.
    %
    % Copyright (c) 2012-2026, Imperial College London
    % All rights reserved.
        
    properties
        hostDemand;
        hostDemandMean;             %double
        hostDemandSCV;              %double
        parent;
        parentName;                 %string
        boundToEntry;               %string 
        callOrder;                  %string \in {'STOCHASTIC', 'DETERMINISTIC'}
        syncCallDests = cell(0);   %string array
        syncCallMeans = [];        %integer array
        asyncCallDests = cell(0);  %string array
        asyncCallMeans = [];       %integer array
        scheduling = [];
        thinkTime;                 %Distribution object
        thinkTimeMean;             %double
        thinkTimeSCV;              %double
    end
    
    methods
        %public methods, including constructor
        
        %constructor
        function obj = Activity(model, name, hostDemand, boundToEntry, callOrder)
            % OBJ = ACTIVITY(MODEL, NAME, HOSTDEMAND, BOUNDTOENTRY, CALLORDER)
            name = char(name);
            if nargin<2 %~exist('name','var')
                line_error(mfilename,'Constructor requires to specify at least a name.');
            end
            obj@LayeredNetworkElement(name);
            
            if nargin<3 %~exist('hostDemand','var')
                hostDemand = GlobalConstants.FineTol;
            elseif isnumeric(hostDemand) && hostDemand == 0
                hostDemand = GlobalConstants.FineTol;
            end
            if nargin<4 %~exist('boundToEntry','var')
                boundToEntry = '';
            end
            if nargin<5 %~exist('callOrder','var')
                callOrder = 'STOCHASTIC';
            end
            
            obj.setHostDemand(hostDemand);
            obj.boundToEntry = boundToEntry;
            obj.setCallOrder(callOrder);
 
            % Initialize default think time
            obj.thinkTime = Immediate.getInstance();
            obj.thinkTimeMean = GlobalConstants.FineTol;
            obj.thinkTimeSCV = GlobalConstants.FineTol;
 
            if isa(model,'LayeredNetwork')
                model.activities{end+1} = obj;
                obj.model = model;
            elseif isa(model,'JLayeredNetwork')
                % JLayeredNetwork support would go here if it exists
                obj.obj = jline.lang.layered.Activity(model.obj, name, hostDemand, boundToEntry, callOrder);
                model.addActivity(obj);
            end
        end
        
        function obj = setParent(obj, parent)
            % OBJ = SETPARENT(OBJ, PARENT)
            
            if isa(parent,'Entry') || isa(parent,'Task')
                obj.parentName = parent.name;
                obj.parent = parent;
            else
                obj.parentName = parent;
                obj.parent = [];
            end
        end
        
        function self = on(self, parent)
            % OBJ = ON(OBJ, PARENT)
            if ~isa(parent,'Task')
                line_error(mfilename,'Invalid .on() argument: expected a task.')
            end
            if isempty(self.parent)
                parent.addActivity(self);
                self.parent = parent;
            else
                line_error(mfilename,'Parent task already defined.')
            end
        end
        
        function obj = setHostDemand(obj, hostDemand)
            % OBJ = SETHOSTDEMAND(OBJ, HOSTDEMAND)
            
            if isnumeric(hostDemand)
                if hostDemand <= GlobalConstants.FineTol
                    obj.hostDemand = Immediate.getInstance();
                    obj.hostDemandMean = GlobalConstants.FineTol;
                    obj.hostDemandSCV = GlobalConstants.FineTol;
                else
                    obj.hostDemand = Exp(1/hostDemand);
                    obj.hostDemandMean = hostDemand;
                    obj.hostDemandSCV = 1.0;
                end
            elseif isa(hostDemand,'Distribution')
                obj.hostDemand = hostDemand;
                obj.hostDemandMean = hostDemand.getMean();
                obj.hostDemandSCV = hostDemand.getSCV();
            end
        end
        
        function obj = repliesTo(obj, entry)
            % OBJ = REPLIESTO(OBJ, ENTRY)
            
            if ~isempty(obj.parent)
                switch SchedStrategy.fromText(obj.parent.scheduling)
                    case SchedStrategy.REF
                        line_error(mfilename,'Activities in reference tasks cannot reply.');
                    otherwise
                        entry.replyActivity{end+1} = obj.name;
                end
            else
                entry.replyActivity{end+1} = obj.name;
            end
        end
        
        function obj = boundTo(obj, entry)
            % OBJ = BOUNDTO(OBJ, ENTRY)
            
            if isa(entry,'Entry')
                obj.boundToEntry = entry.name;
            elseif ischar(entry)
                obj.boundToEntry = entry;
            else
                line_error(mfilename,'Wrong entry parameter for boundTo method.');
            end
        end
        
        function obj = setCallOrder(obj, callOrder)
            % OBJ = SETCALLORDER(OBJ, CALLORDER)
 
            if strcmpi(callOrder,'STOCHASTIC') || strcmpi(callOrder,'DETERMINISTIC')
                obj.callOrder = upper(callOrder);
            else
                obj.callOrder = 'STOCHASTIC';
            end
        end
 
        function obj = setThinkTime(obj, thinkTime)
            % OBJ = SETTHINKTIME(OBJ, THINKTIME)
 
            if isnumeric(thinkTime)
                if thinkTime <= GlobalConstants.FineTol
                    obj.thinkTime = Immediate.getInstance();
                    obj.thinkTimeMean = GlobalConstants.FineTol;
                    obj.thinkTimeSCV = GlobalConstants.FineTol;
                else
                    obj.thinkTime = Exp(1/thinkTime);
                    obj.thinkTimeMean = thinkTime;
                    obj.thinkTimeSCV = 1.0;
                end
            elseif isa(thinkTime,'Distribution')
                obj.thinkTime = thinkTime;
                obj.thinkTimeMean = thinkTime.getMean();
                obj.thinkTimeSCV = thinkTime.getSCV();
            end
        end
 
        %synchCall
       
        function obj = synchCall(obj, synchCallDest, synchCallMean)
            % OBJ = SYNCHCALL(OBJ, SYNCHCALLDEST, SYNCHCALLMEAN)
           
            if nargin<3 %~exist('synchCallMean','var')
                synchCallMean = 1.0;
            end
            
            % Get the destination entry name
            if ischar(synchCallDest)
                destName = synchCallDest;
            else % object
                destName = synchCallDest.name;
            end
            
            % Check if this entry is already in the synchronous call destinations
            if ~isempty(obj.syncCallDests)
                for i = 1:length(obj.syncCallDests)
                    if strcmp(obj.syncCallDests{i}, destName)
                        error_msg = sprintf('Activity "%s" already has a synchronous call to entry "%s". ', ...
                            obj.name, destName);
                        error_msg = [error_msg, 'If you intend multiple calls, change the mean number of calls using synchCall(entry, mean_calls) or define an activity graph with explicit precedences.'];
                        line_error(mfilename, error_msg);
                    end
                end
            end
            
            % Add the new call destination
            obj.syncCallDests{length(obj.syncCallDests)+1} = destName;
            obj.syncCallMeans = [obj.syncCallMeans; synchCallMean];
        end
        
        %asynchCall
        function obj = asynchCall(obj, asynchCallDest, asynchCallMean)
            % OBJ = ASYNCHCALL(OBJ, ASYNCHCALLDEST, ASYNCHCALLMEAN)
            
            if nargin<3 %~exist('asynchCallMean','var')
                asynchCallMean = 1.0;
            end
            
            % Get the destination entry name
            if ischar(asynchCallDest)
                destName = asynchCallDest;
            else % object
                destName = asynchCallDest.name;
            end
            
            % Check if this entry is already in the asynchronous call destinations
            if ~isempty(obj.asyncCallDests)
                for i = 1:length(obj.asyncCallDests)
                    if strcmp(obj.asyncCallDests{i}, destName)
                        error_msg = sprintf('Activity "%s" already has an asynchronous call to entry "%s". ', ...
                            obj.name, destName);
                        error_msg = [error_msg, 'If you intend multiple calls, change the mean number of calls using asynchCall(entry, mean_calls) or define an activity graph with explicit precedences.'];
                        line_error(mfilename, error_msg);
                    end
                end
            end
            
            % Add the new call destination
            obj.asyncCallDests{length(obj.asyncCallDests)+1} = destName;
            obj.asyncCallMeans = [obj.asyncCallMeans; asynchCallMean];
        end
        
    end
    
end