1 /*

     2  * Copyright (c) 2007-2010 Nokia Corporation and/or its subsidiary(-ies). 

     3  * All rights reserved.

     4  * This component and the accompanying materials are made available

     5  * under the terms of "Eclipse Public License v1.0"

     6  * which accompanies this distribution, and is available

     7  * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8  *

     9  * Initial Contributors:

    10  * Nokia Corporation - initial contribution.

    11  *

    12  * Contributors:

    13  *

    14  * Description:

    15  *

    16  * Creates trace objects and provides configurable rules for trace object creation

    17  *

    18  */

    19 package com.nokia.tracebuilder.model;

    20 

    21 import java.util.Iterator;

    22 

    23 import com.nokia.tracebuilder.engine.TraceBuilderGlobals;

    24 import com.nokia.tracebuilder.engine.TraceBuilderErrorCodes.TraceBuilderErrorCode;

    25 

    26 /**

    27  * Creates trace objects and provides configurable rules for trace object

    28  * creation

    29  * 

    30  */

    31 public class TraceObjectFactory {

    32 

    33 	/**

    34 	 * The trace model

    35 	 */

    36 	private TraceModel model;

    37 

    38 	/**

    39 	 * Rule factory

    40 	 */

    41 	private TraceObjectRuleFactory ruleFactory;

    42 

    43 	/**

    44 	 * Creates a new factory

    45 	 * 

    46 	 * @param model

    47 	 *            the model

    48 	 * @param factory

    49 	 *            the rule factory

    50 	 */

    51 	TraceObjectFactory(TraceModel model, TraceObjectRuleFactory factory) {

    52 		this.model = model;

    53 		this.ruleFactory = factory;

    54 		processNewObjectRules(model);

    55 		model.setComplete();

    56 	}

    57 

    58 	/**

    59 	 * Gets the rule factory

    60 	 * 

    61 	 * @return the rule factory

    62 	 */

    63 	public TraceObjectRuleFactory getRuleFactory() {

    64 		return ruleFactory;

    65 	}

    66 

    67 	/**

    68 	 * Creates a new trace group

    69 	 * 

    70 	 * @param id

    71 	 *            the group ID

    72 	 * @param name

    73 	 *            the name for the group

    74 	 * @param extensions

    75 	 *            list of extensions to be added to the group

    76 	 * @return the new group

    77 	 * @throws TraceBuilderException

    78 	 */

    79 	public TraceGroup createTraceGroup(int id, String name,

    80 			TraceModelExtension[] extensions) throws TraceBuilderException {

    81 

    82 		boolean isPredefineGroup = model.isPredefinedGroup(name);

    83 		if (!isPredefineGroup

    84 				&& model.getNumberOfUserdefinedGroups() >= TraceBuilderGlobals

    85 						.getGroupNameHandler()

    86 						.getMaxNumberOfUserDefinedGroups()) {

    87 			throw new TraceBuilderException(

    88 					TraceBuilderErrorCode.RUN_OUT_OF_USER_DEFINED_GROUP_IDS,

    89 					true);

    90 		}

    91 

    92 		TraceGroup group = new TraceGroup(model);

    93 		group.setID(id);

    94 		group.setName(name);

    95 		setExtensions(group, extensions);

    96 		processNewObjectRules(group);

    97 		group.setComplete();

    98 		if (!isPredefineGroup) {

    99 			model.increaseNumberOfUserDefinedGroups();

   100 		}

   101 		return group;

   102 	}

   103 

   104 	/**

   105 	 * Creates a new trace

   106 	 * 

   107 	 * @param group

   108 	 *            the trace group

   109 	 * @param id

   110 	 *            the id for the trace

   111 	 * @param name

   112 	 *            the trace name

   113 	 * @param traceText

   114 	 *            the trace text

   115 	 * @param extensions

   116 	 *            list of extensions to be added to the trace

   117 	 * @return the new trace

   118 	 */

   119 	public Trace createTrace(TraceGroup group, int id, String name,

   120 			String traceText, TraceModelExtension[] extensions) {

   121 		Trace trace = new Trace(group);

   122 		trace.setID(id);

   123 		trace.setName(name);

   124 		trace.setTrace(traceText);

   125 		setExtensions(trace, extensions);

   126 		processNewObjectRules(trace);

   127 		trace.setComplete();

   128 		return trace;

   129 	}

   130 

   131 	/**

   132 	 * Creates a new trace parameter

   133 	 * 

   134 	 * @param trace

   135 	 *            the trace the parameter is associated to

   136 	 * @param id

   137 	 *            the parameter ID

   138 	 * @param name

   139 	 *            the parameter name

   140 	 * @param type

   141 	 *            parameter type

   142 	 * @param extensions

   143 	 *            list of extensions to be added to the parameter

   144 	 * @return the new parameter

   145 	 */

   146 	public TraceParameter createTraceParameter(Trace trace, int id,

   147 			String name, String type, TraceModelExtension[] extensions) {

   148 		TraceParameter parameter = new TraceParameter(trace);

   149 		initializeParameter(parameter, id, name, type, extensions);

   150 		return parameter;

   151 	}

   152 

   153 	/**

   154 	 * Creates a new trace parameter inserting it into the specified index

   155 	 * 

   156 	 * @param objectIndex

   157 	 *            the index for the object

   158 	 * @param trace

   159 	 *            the trace the parameter is associated to

   160 	 * @param id

   161 	 *            the parameter ID

   162 	 * @param name

   163 	 *            the parameter name

   164 	 * @param type

   165 	 *            parameter type

   166 	 * @param extensions

   167 	 *            list of extensions to be added to the parameter

   168 	 * @return the new parameter

   169 	 */

   170 	public TraceParameter createTraceParameter(int objectIndex, Trace trace,

   171 			int id, String name, String type, TraceModelExtension[] extensions) {

   172 		TraceParameter parameter = new TraceParameter(trace, objectIndex);

   173 		initializeParameter(parameter, id, name, type, extensions);

   174 		return parameter;

   175 	}

   176 

   177 	/**

   178 	 * Initializes a parameter

   179 	 * 

   180 	 * @param parameter

   181 	 *            the parameter

   182 	 * @param id

   183 	 *            the parameter ID

   184 	 * @param name

   185 	 *            the parameter name

   186 	 * @param type

   187 	 *            parameter type

   188 	 * @param extensions

   189 	 *            list of extensions to be added to the parameter

   190 	 */

   191 	private void initializeParameter(TraceParameter parameter, int id,

   192 			String name, String type, TraceModelExtension[] extensions) {

   193 		parameter.setID(id);

   194 		parameter.setName(name);

   195 		parameter.setType(type);

   196 		setExtensions(parameter, extensions);

   197 		processNewObjectRules(parameter);

   198 		parameter.setComplete();

   199 	}

   200 

   201 	/**

   202 	 * Creates a new constant table

   203 	 * 

   204 	 * @param id

   205 	 *            id for the table

   206 	 * @param typeName

   207 	 *            the name for the table

   208 	 * @param extensions

   209 	 *            list of extensions to be added to the table

   210 	 * @return the constant table

   211 	 */

   212 	public TraceConstantTable createConstantTable(int id, String typeName,

   213 			TraceModelExtension[] extensions) {

   214 		TraceConstantTable table = new TraceConstantTable(model);

   215 		table.setID(id);

   216 		table.setName(typeName);

   217 		setExtensions(table, extensions);

   218 		processNewObjectRules(table);

   219 		table.setComplete();

   220 		for (TraceGroup group : model) {

   221 			for (Trace trace : group) {

   222 				for (TraceParameter param : trace) {

   223 					if (param.getType().equals(typeName)) {

   224 						table.addParameterReference(param);

   225 					}

   226 				}

   227 			}

   228 		}

   229 		return table;

   230 	}

   231 

   232 	/**

   233 	 * Creates a new constant table entry

   234 	 * 

   235 	 * @param table

   236 	 *            constant table

   237 	 * @param id

   238 	 *            id for the entry

   239 	 * @param value

   240 	 *            value for the entry

   241 	 * @param extensions

   242 	 *            list of extensions to be added to the constant

   243 	 * @return the constant table entry

   244 	 */

   245 	public TraceConstantTableEntry createConstantTableEntry(

   246 			TraceConstantTable table, int id, String value,

   247 			TraceModelExtension[] extensions) {

   248 		TraceConstantTableEntry entry = new TraceConstantTableEntry(table);

   249 		entry.setID(id);

   250 		entry.setName(value);

   251 		setExtensions(entry, extensions);

   252 		processNewObjectRules(entry);

   253 		entry.setComplete();

   254 		return entry;

   255 	}

   256 

   257 	/**

   258 	 * Creates an extension based on its name. This does not add the extension

   259 	 * to the object, since the setData method should be called first

   260 	 * 

   261 	 * @param object

   262 	 *            the target object for the extension

   263 	 * @param name

   264 	 *            the extension name

   265 	 * @return the created extension

   266 	 */

   267 	public TraceModelPersistentExtension createExtension(TraceObject object,

   268 			String name) {

   269 		return ruleFactory.createExtension(object, name);

   270 	}

   271 

   272 	/**

   273 	 * Adds extensions to given object

   274 	 * 

   275 	 * @param object

   276 	 *            the object

   277 	 * @param extensions

   278 	 *            extensions to be added

   279 	 */

   280 	private void setExtensions(TraceObject object,

   281 			TraceModelExtension[] extensions) {

   282 		if (extensions != null) {

   283 			for (TraceModelExtension element : extensions) {

   284 				object.addExtension(element);

   285 			}

   286 		}

   287 	}

   288 

   289 	/**

   290 	 * Processes the rules of a new object

   291 	 * 

   292 	 * @param object

   293 	 *            the object to be processed

   294 	 */

   295 	private void processNewObjectRules(TraceObject object) {

   296 		// Calls the factory to preprocess the extensions passed to

   297 		// create-function

   298 		ruleFactory.preProcessNewRules(object);

   299 		// The rules may contain object creation rules

   300 		Iterator<TraceObjectRule> rules = object

   301 				.getExtensions(TraceObjectRule.class);

   302 		while (rules.hasNext()) {

   303 			TraceObjectRule rule = rules.next();

   304 			if (rule instanceof TraceObjectRuleCreateObject) {

   305 				TraceObjectRuleCreateObject createRule = (TraceObjectRuleCreateObject) rule;

   306 				createRule.createObject();

   307 			}

   308 		}

   309 		// Some rules are removed after the objects have been created

   310 		Iterator<TraceObjectRuleRemoveOnCreate> itr;

   311 		boolean changed;

   312 		do {

   313 			changed = false;

   314 			itr = object.getExtensions(TraceObjectRuleRemoveOnCreate.class);

   315 			while (itr.hasNext() && !changed) {

   316 				TraceObjectRuleRemoveOnCreate ext = itr.next();

   317 				if (ext.canBeRemoved()) {

   318 					object.removeExtension(ext);

   319 					changed = true;

   320 				}

   321 			}

   322 		} while (changed);

   323 		// After processing is complete, the rule factory is used to do

   324 		// post-processing

   325 		ruleFactory.postProcessNewRules(object);

   326 	}

   327 

   328 }