/*

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

* All rights reserved.

* This component and the accompanying materials are made available

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

* which accompanies this distribution, and is available

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

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:

*

* Utility functions for checking properties of trace objects

*

*/

package com.nokia.tracebuilder.model;

import java.util.Comparator;

/**

 * Utility functions for checking properties of trace objects.

 * 

 */

public class TraceObjectUtils {

	/**

	 * Compares a trace to trace ID

	 */

	static Comparator<Object> traceToIDComparator = new Comparator<Object>() {

		/**

		 * Compares a trace to trace name

		 * 

		 * @param t1

		 *            the trace

		 * @param t2

		 *            the trace name

		 * @return the comparison result

		 */

		public int compare(Object t1, Object t2) {

			int n1 = ((Trace) t1).getID();

			int n2 = (Integer) t2;

			return n1 > n2 ? 1 : n1 < n2 ? -1 : 0;

		}

	};

	/**

	 * Compares a trace to trace name

	 */

	static Comparator<Object> traceToNameComparator = new Comparator<Object>() {

		/**

		 * Compares a trace to trace name

		 * 

		 * @param t1

		 *            the trace

		 * @param t2

		 *            the trace name

		 * @return the comparison result

		 */

		public int compare(Object t1, Object t2) {

			String n1 = ((Trace) t1).getName();

			String n2 = (String) t2;

			if (n1 == null) {

				n1 = ""; //$NON-NLS-1$

			}

			if (n2 == null) {

				n2 = ""; //$NON-NLS-1$

			}

			return n1.compareTo(n2);

		}

	};

	/**

	 * Compares a trace to trace text

	 */

	static Comparator<Object> traceToTextComparator = new Comparator<Object>() {

		/**

		 * Compares a trace to trace text

		 * 

		 * @param t1

		 *            the trace

		 * @param t2

		 *            the trace text

		 * @return the comparison result

		 */

		public int compare(Object t1, Object t2) {

			String n1 = ((Trace) t1).getTrace();

			String n2 = (String) t2;

			if (n1 == null) {

				n1 = ""; //$NON-NLS-1$

			}

			if (n2 == null) {

				n2 = ""; //$NON-NLS-1$

			}

			return n1.compareTo(n2);

		}

	};

	/**

	 * Compares trace objects by ID

	 */

	static Comparator<TraceObject> traceObjectIDComparator = new Comparator<TraceObject>() {

		/**

		 * Compares ID's of trace objects

		 * 

		 * @param t1

		 *            trace 1

		 * @param t2

		 *            trace 2

		 * @return the comparison result

		 */

		public int compare(TraceObject t1, TraceObject t2) {

			int n1 = t1.getID();

			int n2 = t2.getID();

			return n1 > n2 ? 1 : n1 < n2 ? -1 : 0;

		}

	};

	/**

	 * Compares trace objects by name

	 */

	static Comparator<TraceObject> traceObjectNameComparator = new Comparator<TraceObject>() {

		/**

		 * Compares names of trace objects

		 * 

		 * @param t1

		 *            trace 1

		 * @param t2

		 *            trace 2

		 * @return the comparison result

		 */

		public int compare(TraceObject t1, TraceObject t2) {

			String n1 = t1.getName();

			String n2 = t2.getName();

			if (n1 == null) {

				n1 = ""; //$NON-NLS-1$

			}

			if (n2 == null) {

				n2 = ""; //$NON-NLS-1$

			}

			return n1.compareTo(n2);

		}

	};

	/**

	 * Prevents construction

	 */

	private TraceObjectUtils() {

	}

	/**

	 * Checks if group name is already in use and changes if it is. The group

	 * name is constructed by merging <code>prefix</code>, <code>base</code>

	 * and <code>postfix</code> together. If a group with the name already

	 * exists, a integer value starting from 1 is added to the <code>base</code>

	 * and the name is re-constructed. The integer value is incremented until a

	 * matching group is not found.

	 * 

	 * @param model

	 *            the trace model

	 * @param name

	 *            the group name

	 * @return the modifier interface

	 */

	public static TraceObjectModifier modifyDuplicateGroupName(

			TraceModel model, String name) {

		DuplicateGroupNameModifier modifier = new DuplicateGroupNameModifier(

				model, name);

		modifier.processName();

		return modifier;

	}

	/**

	 * Checks if trace name is already in use and changes if it is.

	 * 

	 * @param group

	 *            the trace group to be checked

	 * @param name

	 *            the trace name

	 * @return the modifier interface

	 */

	public static TraceObjectModifier modifyDuplicateTraceName(

			TraceGroup group, String name) {

		DuplicateTraceNameModifier modifier = new DuplicateTraceNameModifier(

				group, name);

		modifier.processName();

		return modifier;

	}

	/**

	 * Checks if trace name is already in use globally and changes if it is.

	 * 

	 * @param model

	 *            the trace model

	 * @param name

	 *            the trace name

	 * @return the modifier interface

	 */

	public static TraceObjectModifier modifyDuplicateTraceName(

			TraceModel model, String name) {

		DuplicateTraceNameModifier modifier = new DuplicateTraceNameModifier(

				model, name);

		modifier.processName();

		return modifier;

	}

	/**

	 * Checks if trace parameter name is already in use and changes if it is.

	 * 

	 * @param owner

	 *            the owner of the parameter

	 * @param name

	 *            the parameter name

	 * @return the modifier interface

	 */

	public static TraceObjectModifier modifyDuplicateParameterName(Trace owner,

			String name) {

		DuplicateParameterNameModifier modifier = new DuplicateParameterNameModifier(

				owner, name);

		modifier.processName();

		return modifier;

	}

	/**

	 * Checks if constant table name is already in use and changes if it is

	 * 

	 * @param model

	 *            the trace model

	 * @param name

	 *            the table name

	 * @return the modified name

	 */

	public static TraceObjectModifier modifyDuplicateConstantTableName(

			TraceModel model, String name) {

		DuplicateConstantTableNameModifier modifier = new DuplicateConstantTableNameModifier(

				model, name);

		modifier.processName();

		return modifier;

	}

	/**

	 * Checks if constant table entry name is already in use and changes if it

	 * is.

	 * 

	 * @param table

	 *            the constant table owning the entry

	 * @param name

	 *            the constant table entry name

	 * @return the modifier interface

	 */

	public static TraceObjectModifier modifyDuplicateConstantName(

			TraceConstantTable table, String name) {

		DuplicateConstantNameModifier modifier = new DuplicateConstantNameModifier(

				table, name);

		modifier.processName();

		return modifier;

	}

	/**

	 * Gets the duplicate modifier from given text

	 * 

	 * @param text

	 *            the text

	 * @return the duplicate modifier

	 */

	public static String removeDuplicateModifier(String text) {

		String retval;

		String s = DuplicateValueModifier.getModifier(text);

		if (s != null) {

			retval = text.substring(s.length());

		} else {

			retval = text;

		}

		return retval;

	}

	/**

	 * Finds a property from a trace object. This returns an empty string if not

	 * found

	 * 

	 * @param object

	 *            the object

	 * @param name

	 *            the property name

	 * @return the property value

	 */

	public static String findProperty(TraceObject object, String name) {

		String retval = null;

		TraceObjectPropertyList propertyList = object

				.getExtension(TraceObjectPropertyList.class);

		if (propertyList != null) {

			TraceObjectProperty property = propertyList.getProperty(name);

			if (property != null) {

				retval = property.getValue();

			}

		}

		if (retval == null) {

			retval = ""; //$NON-NLS-1$

		}

		return retval;

	}

}