it.cnr.istc.pst.platinum.control.lang.Goal - Code Metrics - Inspection of "Merge branch 'master' of https://github.com/pstlab..." - pstlab/PLATINUm - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 674e01...634a3f )

unknown

created 2021-04-23 09:23 UTC

it.cnr.istc.pst.platinum.control.lang.Goal B

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	382
Duplicated Lines	3.14 %

Importance

Changes

Metric	Value
eloc	153
dl	12
loc	382
rs	7.44
c	0
b	0
f	0
wmc	52

39 Methods

Rating	Name	Duplication	Size	Complexity
A	setManagementStrategyTime(long)	0	2	1
A	getFailureCause()	0	2	1
A	getPlanningAttempts()	0	2	1
A	isExistsStrategy()	0	2	1
A	Goal(AgentTaskDescription)	0	21	1
A	setStatus(GoalStatus)	0	2	1
A	clearExecutionTrace()	0	5	1
A	setRepaired(boolean)	0	2	1
A	setExecutionTick(long)	0	2	1
A	getTaskDescription()	0	2	1
A	compare(ExecutionNode,ExecutionNode)	0	7	3
A	getExecutionAttempts()	0	2	1
A	addPlanningAttempt(long)	0	3	1
A	getExecutionTick()	0	2	1
A	addNodeToExecutionTrace(ExecutionNode)	0	6	2
A	getTotalPlanningTime()	0	10	2
A	hashCode()	0	6	1
A	getUppaalTime()	0	2	1
A	isOutOfBounds()	0	2	1
A	getManagementStrategyTime()	0	2	1
A	toString()	0	3	1
A	setPlan(SolutionPlan)	0	4	1
A	addContingencyHandlingAttempt(long)	0	3	1
A	isRepaired()	0	2	1
A	compareTo(Goal)	0	4	3
A	equals(Object)	12	12	5
A	getExecutionTraceByComponentName(String)	0	12	2
A	setUppaalTime(long)	0	2	1
A	addExecutionAttempt(long)	0	3	1
A	getContingencyHandlingAttempts()	0	2	1
A	getStatus()	0	2	1
A	getTotalContingencyHandlingTime()	0	9	2
A	setOutOfBounds(boolean)	0	2	1
A	getTotalExecutionTime()	0	9	2
A	getPlan()	0	2	1
A	setExistsStrategy(boolean)	0	2	1
A	setFailureCause(ExecutionFailureCause)	0	2	1
A	setMaxOutOfBounds(int)	0	2	1
A	getMaxOutOfBounds()	0	2	1

How to fix Duplicated Code Complexity

package it.cnr.istc.pst.platinum.control.lang;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.atomic.AtomicLong;

import it.cnr.istc.pst.platinum.ai.executive.lang.failure.ExecutionFailureCause;
import it.cnr.istc.pst.platinum.ai.executive.pdb.ExecutionNode;
import it.cnr.istc.pst.platinum.ai.framework.microkernel.lang.plan.SolutionPlan;
import it.cnr.istc.pst.platinum.ai.framework.protocol.lang.PlanProtocolDescriptor;
import it.cnr.istc.pst.platinum.ai.framework.time.tn.TimePoint;

/**
 * 
 * @author anacleto
 *
 */
public class Goal implements Comparable<Goal>, Comparator<ExecutionNode>
{
	private static AtomicLong GoalIdCounter = new AtomicLong(0);
	private long id;
	private long timestamp;
	private AgentTaskDescription description;			// goal and facts description 
	private GoalStatus status;
	private SolutionPlan plan;							// (current) solution plan for the goal
	
	private List<Long> planningAttempts;				// array counting planning attempts and keeping track of planning times
	private List<Long> executionAttempts;				// array counting execution attempts and keeping track of execution times
	private List<Long> contingencyAttempts;				// array counting contingency attempts and keeping track of their handling times

	private List<PlanProtocolDescriptor> plans;			// trace of generated plans
	private ExecutionFailureCause failureCause;			// goal execution failure cause
	private Map<String, List<ExecutionNode>> trace;		// execution trace
	
	private boolean repaired;
	private long executionTick;
	//EDIT POINTER
	private long uppaalTime;
	private boolean existsStrategy;
	private long managementStrategyTime;
	private boolean isOutOfBounds;
	private int maxOutOfBounds;
	
	
	/**
	 * 
	 * @param description
	 */
	public Goal(AgentTaskDescription description) 
	{ 
		this.id = GoalIdCounter.getAndIncrement();
		this.timestamp = System.currentTimeMillis();
		this.description = description;
		this.status = null;
		this.plan = null;
		this.planningAttempts = new ArrayList<>();
		this.executionAttempts = new ArrayList<>();
		this.contingencyAttempts = new ArrayList<>();
		this.plans = new ArrayList<>();
		this.trace = new HashMap<>();
		this.failureCause = null;
		this.repaired = false;
		this.executionTick = 0;
		//EDIT POINTER
		this.uppaalTime = -1;
		this.existsStrategy = false;
		this.managementStrategyTime = -1;
		this.isOutOfBounds = false;
		this.maxOutOfBounds = -1;
	}
	
	/**
	 * 
	 * @param repaired
	 */
	public void setRepaired(boolean repaired) {
		this.repaired = repaired;
	}
	
	/**
	 * 
	 */
	public void clearExecutionTrace() {
		// clear trace
		this.trace.clear();
		// clear failure cause
		this.failureCause = null;
	}
	
	/**
	 * 
	 * @return
	 */
	public boolean isRepaired() {
		return this.repaired;
	}
	
	/**
	 * 
	 * @return
	 */
	public long getExecutionTick() {
		return executionTick;
	}
	
	public boolean isOutOfBounds() {
		return isOutOfBounds;
	}

	public void setOutOfBounds(boolean isOutOfBounds) {
		this.isOutOfBounds = isOutOfBounds;
	}

	public int getMaxOutOfBounds() {
		return maxOutOfBounds;
	}

	public void setMaxOutOfBounds(int maxOutOfBounds) {
		this.maxOutOfBounds = maxOutOfBounds;
	}

	/**
	 * 
	 * @param executionTick
	 */
	public void setExecutionTick(long executionTick) {
		this.executionTick = executionTick;
	}
	
	/**
	 * 
	 * @param failureCause
	 */
	public void setFailureCause(ExecutionFailureCause failureCause) {
		this.failureCause = failureCause;
	}
	
	/**
	 * 
	 * @return
	 */
	public ExecutionFailureCause getFailureCause() {
		return failureCause;
	}
	
	/**
	 * 
	 * @param node
	 */
	public void addNodeToExecutionTrace(ExecutionNode node) {
		if (!this.trace.containsKey(node.getComponent())) {
			this.trace.put(node.getComponent(), new ArrayList<>());
		}
		
		this.trace.get(node.getComponent()).add(node);
	}
	
	/**
	 * 
	 * @param name
	 */
	public List<ExecutionNode> getExecutionTraceByComponentName(String name) {
		// list of executed nodes
		List<ExecutionNode> list = new ArrayList<>();
		if (this.trace.containsKey(name)) {
			// add nodes
			list.addAll(this.trace.get(name));
		}
		
		// sort the trace
		Collections.sort(list, this);
		// get the list
		return list;
	}
	
	/**
	 * Add planning attempt time in milliseconds
	 * 
	 * @param time
	 */
	public void addPlanningAttempt(long time) {
		// add planning time
		this.planningAttempts.add(time);
	}
	
	/**
	 * 
	 * @return
	 */
	public int getPlanningAttempts() {
		return this.planningAttempts.size();
	}
	
	/**
	 * Get the total planning time in milliseconds
	 * 
	 * @return
	 */
	public long getTotalPlanningTime() 
	{
		// compute total planning time 
		long total = 0;
		for (Long time : this.planningAttempts) {
			total += time;
		}
		
		// get total planning time
		return total;
	}
	
	/**
	 * Add execution attempt time in milliseconds
	 * 
	 * @param time
	 */
	public void addExecutionAttempt(long time) {
		// add execution time 
		this.executionAttempts.add(time);
	}
	
	/**
	 * 
	 * @return
	 */
	public int getExecutionAttempts() {
		return this.executionAttempts.size();
	}
	
	/**
	 * 
	 * @return
	 */
	public long getTotalExecutionTime() {
		// compute total execution time 
		long total = 0;
		for (Long time : this.executionAttempts) {
			total += time;
		}
		
		// get total planning time
		return total;
	}
	
	/**
	 * Add contingency handling time in milliseconds
	 * 
	 * @param time
	 */
	public void addContingencyHandlingAttempt(long time) {
		// add contingency time
		this.contingencyAttempts.add(time);
	}
	
	/**
	 * 
	 * @return
	 */
	public int getContingencyHandlingAttempts() {
		return this.contingencyAttempts.size();
	}
	
	/**
	 * 
	 * @return
	 */
	public long getTotalContingencyHandlingTime() {
		// compute total contingency handling time 
		long total = 0;
		for (long time : this.contingencyAttempts) {
			total += time;
		}
		
		// get total planning time
		return total;
	}
	
	/**
	 * 
	 * @param plan
	 */
	public void setPlan(SolutionPlan plan) {
		this.plan = plan;
		// add exported plan 
		this.plans.add(plan.export());
	}
	
	/**
	 * 
	 * @return
	 */
	public AgentTaskDescription getTaskDescription() {
		return description;
	}
	
	/**
	 * 
	 * @return
	 */
	public SolutionPlan getPlan() {
		return plan;
	}
	
	/**
	 * 
	 * @return
	 */
	public GoalStatus getStatus() {
		return status;
	}
	
	/**
	 * 
	 * @param status
	 */
	public void setStatus(GoalStatus status) {
		this.status = status;
	}
	
	//EDIT POINTER
	
	public long getUppaalTime() {
		return uppaalTime;
	}

	public void setUppaalTime(long uppaalTime) {
		this.uppaalTime = uppaalTime;
	}

	public long getManagementStrategyTime() {
		return managementStrategyTime;
	}

	public void setManagementStrategyTime(long managementStrategyTime) {
		this.managementStrategyTime = managementStrategyTime;
	}
	
	public boolean isExistsStrategy() {
		return existsStrategy;
	}

	public void setExistsStrategy(boolean existsStrategy) {
		this.existsStrategy = existsStrategy;
	}

	/**
	 * 
	 */
	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + (int) (id ^ (id >>> 32));
		return result;
	}

	/**
	 * 
	 */
	@Override

	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Goal other = (Goal) obj;
		if (id != other.id)
			return false;
		return true;
	}
	
	/**
	 * 
	 */
	@Override
	public int compareTo(Goal o) {
		// chronological order
		return this.timestamp < o.timestamp ? -1 : this.timestamp > o.timestamp ? 1 : 0;
	}
	
	/**
	 * Completely instantiated nodes are expected
	 */
	@Override
	public int compare(ExecutionNode o1, ExecutionNode o2) {
		// compare start times
		TimePoint s1 = o1.getInterval().getStartTime();
		TimePoint s2 = o2.getInterval().getStartTime();
		// compare lower bounds
		return s1.getLowerBound() < s2.getLowerBound() ? -1 : s1.getLowerBound() > s2.getLowerBound() ? 1 : 0;
	}
	
	/**
	 * 
	 */
	@Override
	public String toString() {
		return "[Goal id: " + this.id +", status: " + this.status + "]";
	}

}


1		package it.cnr.istc.pst.platinum.control.lang;
2
3		import java.util.ArrayList;
4		import java.util.Collections;
5		import java.util.Comparator;
6		import java.util.HashMap;
7		import java.util.List;
8		import java.util.Map;
9		import java.util.concurrent.atomic.AtomicLong;
10
11		import it.cnr.istc.pst.platinum.ai.executive.lang.failure.ExecutionFailureCause;
12		import it.cnr.istc.pst.platinum.ai.executive.pdb.ExecutionNode;
13		import it.cnr.istc.pst.platinum.ai.framework.microkernel.lang.plan.SolutionPlan;
14		import it.cnr.istc.pst.platinum.ai.framework.protocol.lang.PlanProtocolDescriptor;
15		import it.cnr.istc.pst.platinum.ai.framework.time.tn.TimePoint;
16
17		/**
18		*
19		* @author anacleto
20		*
21		*/
22		public class Goal implements Comparable<Goal>, Comparator<ExecutionNode>
23		{
24		private static AtomicLong GoalIdCounter = new AtomicLong(0);
25		private long id;
26		private long timestamp;
27		private AgentTaskDescription description; // goal and facts description
28		private GoalStatus status;
29		private SolutionPlan plan; // (current) solution plan for the goal
30
31		private List<Long> planningAttempts; // array counting planning attempts and keeping track of planning times
32		private List<Long> executionAttempts; // array counting execution attempts and keeping track of execution times
33		private List<Long> contingencyAttempts; // array counting contingency attempts and keeping track of their handling times
34
35		private List<PlanProtocolDescriptor> plans; // trace of generated plans
36		private ExecutionFailureCause failureCause; // goal execution failure cause
37		private Map<String, List<ExecutionNode>> trace; // execution trace
38
39		private boolean repaired;
40		private long executionTick;
41		//EDIT POINTER
42		private long uppaalTime;
43		private boolean existsStrategy;
44		private long managementStrategyTime;
45		private boolean isOutOfBounds;
46		private int maxOutOfBounds;
47
48
49		/**
50		*
51		* @param description
52		*/
53		public Goal(AgentTaskDescription description)
54		{
55		this.id = GoalIdCounter.getAndIncrement();
56		this.timestamp = System.currentTimeMillis();
57		this.description = description;
58		this.status = null;
59		this.plan = null;
60		this.planningAttempts = new ArrayList<>();
61		this.executionAttempts = new ArrayList<>();
62		this.contingencyAttempts = new ArrayList<>();
63		this.plans = new ArrayList<>();
64		this.trace = new HashMap<>();
65		this.failureCause = null;
66		this.repaired = false;
67		this.executionTick = 0;
68		//EDIT POINTER
69		this.uppaalTime = -1;
70		this.existsStrategy = false;
71		this.managementStrategyTime = -1;
72		this.isOutOfBounds = false;
73		this.maxOutOfBounds = -1;
74		}
75
76		/**
77		*
78		* @param repaired
79		*/
80		public void setRepaired(boolean repaired) {
81		this.repaired = repaired;
82		}
83
84		/**
85		*
86		*/
87		public void clearExecutionTrace() {
88		// clear trace
89		this.trace.clear();
90		// clear failure cause
91		this.failureCause = null;
92		}
93
94		/**
95		*
96		* @return
97		*/
98		public boolean isRepaired() {
99		return this.repaired;
100		}
101
102		/**
103		*
104		* @return
105		*/
106		public long getExecutionTick() {
107		return executionTick;
108		}
109
110		public boolean isOutOfBounds() {
111		return isOutOfBounds;
112		}
113
114		public void setOutOfBounds(boolean isOutOfBounds) {
115		this.isOutOfBounds = isOutOfBounds;
116		}
117
118		public int getMaxOutOfBounds() {
119		return maxOutOfBounds;
120		}
121
122		public void setMaxOutOfBounds(int maxOutOfBounds) {
123		this.maxOutOfBounds = maxOutOfBounds;
124		}
125
126		/**
127		*
128		* @param executionTick
129		*/
130		public void setExecutionTick(long executionTick) {
131		this.executionTick = executionTick;
132		}
133
134		/**
135		*
136		* @param failureCause
137		*/
138		public void setFailureCause(ExecutionFailureCause failureCause) {
139		this.failureCause = failureCause;
140		}
141
142		/**
143		*
144		* @return
145		*/
146		public ExecutionFailureCause getFailureCause() {
147		return failureCause;
148		}
149
150		/**
151		*
152		* @param node
153		*/
154		public void addNodeToExecutionTrace(ExecutionNode node) {
155		if (!this.trace.containsKey(node.getComponent())) {
156		this.trace.put(node.getComponent(), new ArrayList<>());
157		}
158
159		this.trace.get(node.getComponent()).add(node);
160		}
161
162		/**
163		*
164		* @param name
165		*/
166		public List<ExecutionNode> getExecutionTraceByComponentName(String name) {
167		// list of executed nodes
168		List<ExecutionNode> list = new ArrayList<>();
169		if (this.trace.containsKey(name)) {
170		// add nodes
171		list.addAll(this.trace.get(name));
172		}
173
174		// sort the trace
175		Collections.sort(list, this);
176		// get the list
177		return list;
178		}
179
180		/**
181		* Add planning attempt time in milliseconds
182		*
183		* @param time
184		*/
185		public void addPlanningAttempt(long time) {
186		// add planning time
187		this.planningAttempts.add(time);
188		}
189
190		/**
191		*
192		* @return
193		*/
194		public int getPlanningAttempts() {
195		return this.planningAttempts.size();
196		}
197
198		/**
199		* Get the total planning time in milliseconds
200		*
201		* @return
202		*/
203		public long getTotalPlanningTime()
204		{
205		// compute total planning time
206		long total = 0;
207		for (Long time : this.planningAttempts) {
208		total += time;
209		}
210
211		// get total planning time
212		return total;
213		}
214
215		/**
216		* Add execution attempt time in milliseconds
217		*
218		* @param time
219		*/
220		public void addExecutionAttempt(long time) {
221		// add execution time
222		this.executionAttempts.add(time);
223		}
224
225		/**
226		*
227		* @return
228		*/
229		public int getExecutionAttempts() {
230		return this.executionAttempts.size();
231		}
232
233		/**
234		*
235		* @return
236		*/
237		public long getTotalExecutionTime() {
238		// compute total execution time
239		long total = 0;
240		for (Long time : this.executionAttempts) {
241		total += time;
242		}
243
244		// get total planning time
245		return total;
246		}
247
248		/**
249		* Add contingency handling time in milliseconds
250		*
251		* @param time
252		*/
253		public void addContingencyHandlingAttempt(long time) {
254		// add contingency time
255		this.contingencyAttempts.add(time);
256		}
257
258		/**
259		*
260		* @return
261		*/
262		public int getContingencyHandlingAttempts() {
263		return this.contingencyAttempts.size();
264		}
265
266		/**
267		*
268		* @return
269		*/
270		public long getTotalContingencyHandlingTime() {
271		// compute total contingency handling time
272		long total = 0;
273		for (long time : this.contingencyAttempts) {
274		total += time;
275		}
276
277		// get total planning time
278		return total;
279		}
280
281		/**
282		*
283		* @param plan
284		*/
285		public void setPlan(SolutionPlan plan) {
286		this.plan = plan;
287		// add exported plan
288		this.plans.add(plan.export());
289		}
290
291		/**
292		*
293		* @return
294		*/
295		public AgentTaskDescription getTaskDescription() {
296		return description;
297		}
298
299		/**
300		*
301		* @return
302		*/
303		public SolutionPlan getPlan() {
304		return plan;
305		}
306
307		/**
308		*
309		* @return
310		*/
311		public GoalStatus getStatus() {
312		return status;
313		}
314
315		/**
316		*
317		* @param status
318		*/
319		public void setStatus(GoalStatus status) {
320		this.status = status;
321		}
322
323		//EDIT POINTER
324
325		public long getUppaalTime() {
326		return uppaalTime;
327		}
328
329		public void setUppaalTime(long uppaalTime) {
330		this.uppaalTime = uppaalTime;
331		}
332
333		public long getManagementStrategyTime() {
334		return managementStrategyTime;
335		}
336
337		public void setManagementStrategyTime(long managementStrategyTime) {
338		this.managementStrategyTime = managementStrategyTime;
339		}
340
341		public boolean isExistsStrategy() {
342		return existsStrategy;
343		}
344
345		public void setExistsStrategy(boolean existsStrategy) {
346		this.existsStrategy = existsStrategy;
347		}
348
349		/**
350		*
351		*/
352		@Override
353		public int hashCode() {
354		final int prime = 31;
355		int result = 1;
356		result = prime * result + (int) (id ^ (id >>> 32));
357		return result;
358		}
359
360		/**
361		*
362		*/
363	View Code Duplication	@Override
		0 ignored issues – show Duplication introduced 2021-04-10 16:53 UTC by Report Bug Copy Issue Report This code seems to be duplicated in your project. Loading history...
364		public boolean equals(Object obj) {
365		if (this == obj)
366		return true;
367		if (obj == null)
368		return false;
369		if (getClass() != obj.getClass())
370		return false;
371		Goal other = (Goal) obj;
372		if (id != other.id)
373		return false;
374		return true;
375		}
376
377		/**
378		*
379		*/
380		@Override
381		public int compareTo(Goal o) {
382		// chronological order
383		return this.timestamp < o.timestamp ? -1 : this.timestamp > o.timestamp ? 1 : 0;
384		}
385
386		/**
387		* Completely instantiated nodes are expected
388		*/
389		@Override
390		public int compare(ExecutionNode o1, ExecutionNode o2) {
391		// compare start times
392		TimePoint s1 = o1.getInterval().getStartTime();
393		TimePoint s2 = o2.getInterval().getStartTime();
394		// compare lower bounds
395		return s1.getLowerBound() < s2.getLowerBound() ? -1 : s1.getLowerBound() > s2.getLowerBound() ? 1 : 0;
396		}
397
398		/**
399		*
400		*/
401		@Override
402		public String toString() {
403		return "[Goal id: " + this.id +", status: " + this.status + "]";
404		}
405
406		}
407

pstlab / PLATINUm

Push — master ( 674e01...634a3f )

it.cnr.istc.pst.platinum.control.lang.Goal B

Complexity

Size/Duplication

Importance

39 Methods

How to fix Duplicated Code Complexity

Duplicated Code

Complexity

Duplication Side-by-Side

Filter issues like