X-Git-Url: http://git.nikiroo.be/?p=jvcard.git;a=blobdiff_plain;f=src%2Fbe%2Fnikiroo%2Fjvcard%2FBaseClass.java;h=026c5b43c0951a02ceb69e3bbda049be4303945c;hp=26863902e59c8ec1447bbc44b9e1006b60843b5e;hb=aecb3399b756d2ba04223bc6f553999fce73f9fb;hpb=0b6140e4a200c4952c9dc003d8389f375191564e

diff --git a/src/be/nikiroo/jvcard/BaseClass.java b/src/be/nikiroo/jvcard/BaseClass.java
index 2686390..026c5b4 100644
--- a/src/be/nikiroo/jvcard/BaseClass.java
+++ b/src/be/nikiroo/jvcard/BaseClass.java
@@ -1,5 +1,6 @@
 package be.nikiroo.jvcard;
 
+import java.security.InvalidParameterException;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Collections;
@@ -9,19 +10,24 @@ import java.util.LinkedList;
 import java.util.List;
 import java.util.ListIterator;
 
-import be.nikiroo.jvcard.tui.StringUtils;
+import be.nikiroo.jvcard.resources.StringUtils;
 
 /**
  * This class is basically a List with a parent and a "dirty" state check. It
  * sends all commands down to the initial list, but will mark itself and its
  * children as dirty or not when needed.
  * 
- * All child elements can identify their parent.
+ * <p>
+ * All child elements can identify their parent, and must not be added to 2
+ * different objects without without first being removed from the previous one.
+ * </p>
  * 
+ * <p>
  * The dirty state is bubbling up (when dirty = true) or down (when dirty =
  * false) -- so, making changes to a child element will also mark its parent as
  * "dirty", and marking an element as pristine will also affect all its child
  * elements.
+ * </p>
  * 
  * @author niki
  *
@@ -119,8 +125,8 @@ public abstract class BaseClass<E extends BaseClass<?>> implements List<E> {
 	 * If not equals, the differences will be represented by the given
 	 * {@link List}s if they are not NULL.
 	 * <ul>
-	 * <li><tt>added</tt>will represent the elements in <tt>list</tt> but not in
-	 * <tt>this</tt></li>
+	 * <li><tt>added</tt> will represent the elements in <tt>list</tt> but not
+	 * in <tt>this</tt></li>
 	 * <li><tt>removed</tt> will represent the elements in <tt>this</tt> but not
 	 * in <tt>list</tt></li>
 	 * <li><tt>from<tt> will represent the elements in <tt>list</tt> that are
@@ -155,17 +161,20 @@ public abstract class BaseClass<E extends BaseClass<?>> implements List<E> {
 		Collections.sort(other, comparator);
 
 		boolean equ = true;
-		while (mine.size() > 0 || other.size() > 0) {
-			E here = (mine.size() > 0) ? mine.remove(0) : null;
-			E there = (other.size() > 0) ? other.remove(0) : null;
+		E here = mine.size() > 0 ? mine.remove(0) : null;
+		E there = other.size() > 0 ? other.remove(0) : null;
 
-			if (here == null || comparator.compare(here, there) > 0) {
+		while (here != null || there != null) {
+			if (here == null
+					|| (there != null && comparator.compare(here, there) > 0)) {
 				if (added != null)
 					added.add(there);
+				there = null;
 				equ = false;
 			} else if (there == null || comparator.compare(here, there) < 0) {
 				if (removed != null)
 					removed.add(here);
+				here = null;
 				equ = false;
 			} else {
 				// they represent the same item
@@ -176,7 +185,14 @@ public abstract class BaseClass<E extends BaseClass<?>> implements List<E> {
 						to.add(there);
 					equ = false;
 				}
+				here = null;
+				there = null;
 			}
+
+			if (here == null && mine.size() > 0)
+				here = mine.remove(0);
+			if (there == null && other.size() > 0)
+				there = other.remove(0);
 		}
 
 		return equ;
@@ -240,15 +256,25 @@ public abstract class BaseClass<E extends BaseClass<?>> implements List<E> {
 	}
 
 	/**
-	 * Get the recursive state of the current object, i.e., its children. It
-	 * represents the full state information about this object's children.
+	 * Get the recursive state of the current object, i.e., its children
+	 * included. It represents the full state information about this object's
+	 * children. It may not contains spaces nor new lines.
+	 * 
+	 * <p>
+	 * Not that this state is <b>lossy</b>. You cannot retrieve the data from
+	 * the state, it can only be used as an ID to check if data are identical.
+	 * </p>
+	 * 
+	 * @param self
+	 *            also include state information about the current object itself
+	 *            (as opposed to its children)
 	 * 
 	 * @return a {@link String} representing the current content state of this
 	 *         object, i.e., its children included
 	 */
-	public String getContentState() {
+	public String getContentState(boolean self) {
 		StringBuilder builder = new StringBuilder();
-		buildContentStateRaw(builder);
+		buildContentStateRaw(builder, self);
 		return StringUtils.getHash(builder.toString());
 	}
 
@@ -274,6 +300,23 @@ public abstract class BaseClass<E extends BaseClass<?>> implements List<E> {
 		return null;
 	}
 
+	/**
+	 * Return a {@link String} that can be used to identify this object in DEBUG
+	 * mode, i.e., a "toString" method that can identify the object's content
+	 * but still be readable in a log.
+	 * 
+	 * @param depth
+	 *            the depth into which to descend (0 = only this object, not its
+	 *            children)
+	 * 
+	 * @return the debug {@link String}
+	 */
+	public String getDebugInfo(int depth) {
+		StringBuilder builder = new StringBuilder();
+		getDebugInfo(builder, depth, 0);
+		return builder.toString();
+	}
+
 	/**
 	 * Return the current ID of this object -- it is allowed to change over time
 	 * (so, do not cache it).
@@ -285,7 +328,14 @@ public abstract class BaseClass<E extends BaseClass<?>> implements List<E> {
 	/**
 	 * Get the state of the current object, children <b>not included</b>. It
 	 * represents the full state information about this object, but do not check
-	 * its children (see {@link BaseClass#getContentState()} for that).
+	 * its children (see {@link BaseClass#getContentState()} for that). It may
+	 * not contains spaces nor new lines.
+	 * 
+	 * <p>
+	 * Not that this state is <b>lossy</b>. You cannot retrieve the data from
+	 * the state, it can only be used as an ID to check if thw data are
+	 * identical.
+	 * </p>
 	 * 
 	 * @return a {@link String} representing the current state of this object,
 	 *         children not included
@@ -293,19 +343,59 @@ public abstract class BaseClass<E extends BaseClass<?>> implements List<E> {
 	abstract public String getState();
 
 	/**
-	 * Get the recursive state of the current object, i.e., its children. It
-	 * represents the full state information about this object's children.
+	 * Get the recursive state of the current object, i.e., its children
+	 * included. It represents the full state information about this object's
+	 * children.
 	 * 
 	 * It is not hashed.
 	 * 
 	 * @param builder
 	 *            the {@link StringBuilder} that will represent the current
 	 *            content state of this object, i.e., its children included
+	 * @param self
+	 *            also include state information about the current object itself
+	 *            (as opposed to its children)
 	 */
-	void buildContentStateRaw(StringBuilder builder) {
-		builder.append(getState());
+	void buildContentStateRaw(StringBuilder builder, boolean self) {
+		Collections.sort(this.list, comparator);
+		if (self)
+			builder.append(getState());
 		for (E child : this) {
-			child.buildContentStateRaw(builder);
+			child.buildContentStateRaw(builder, true);
+		}
+	}
+
+	/**
+	 * Populate a {@link StringBuilder} that can be used to identify this object
+	 * in DEBUG mode, i.e., a "toString" method that can identify the object's
+	 * content but still be readable in a log.
+	 * 
+	 * @param depth
+	 *            the depth into which to descend (0 = only this object, not its
+	 *            children)
+	 * 
+	 * @param tab
+	 *            the current tabulation increment
+	 */
+	void getDebugInfo(StringBuilder builder, int depth, int tab) {
+		for (int i = 0; i < tab; i++)
+			builder.append("	");
+		builder.append(getContentState(false) + "	" + getId());
+
+		if (depth > 0)
+			builder.append(": [");
+
+		if (depth > 0) {
+			for (E child : this) {
+				builder.append("\n");
+				child.getDebugInfo(builder, depth - 1, tab + 1);
+			}
+		}
+		if (depth > 0) {
+			builder.append("\n");
+			for (int i = 0; i < tab; i++)
+				builder.append("	");
+			builder.append("]");
 		}
 	}
 
@@ -343,6 +433,39 @@ public abstract class BaseClass<E extends BaseClass<?>> implements List<E> {
 		}
 	}
 
+	/**
+	 * Escape the given value to VCF standard.
+	 * 
+	 * @param value
+	 *            the value to escape
+	 * 
+	 * @return the escaped value
+	 */
+	protected String escape(String value) {
+		if (value == null)
+			return null;
+
+		return value.replaceAll(",", "\\\\,").replaceAll(";", "\\\\;")
+				.replaceAll("\n", "\\\\n");
+	}
+
+	/**
+	 * Escape the given value to VCF standard.
+	 * 
+	 * @param value
+	 *            the value to escape
+	 * 
+	 * @return the escaped value
+	 */
+	protected String unescape(String value) {
+		if (value == null)
+			return null;
+
+		return value.replaceAll("\\\\,", ",").replaceAll("\\\\;", ";")
+
+		.replaceAll("\\\\n", "\n");
+	}
+
 	/**
 	 * Each element that leaves the parent will pass trough here.
 	 * 
@@ -350,6 +473,12 @@ public abstract class BaseClass<E extends BaseClass<?>> implements List<E> {
 	 *            the element to remove from this
 	 */
 	private void _leave(E child) {
+		if (child.parent != null && child.parent != this) {
+			throw new InvalidParameterException(
+					"You are removing this child from its rightful parent, it must be yours to do so");
+		}
+
+		child.parent = null;
 		setDirty();
 	}
 
@@ -370,6 +499,11 @@ public abstract class BaseClass<E extends BaseClass<?>> implements List<E> {
 	 *            the element to add to this
 	 */
 	private void _enter(E child, boolean initialLoad) {
+		if (child.parent != null && child.parent != this) {
+			throw new InvalidParameterException(
+					"You are stealing this child from its rightful parent, you must remove it first");
+		}
+
 		child.setParent(this);
 		if (!initialLoad) {
 			setDirty();