bundles/org.eclipse.core.resources/src/org/eclipse/core/internal/resources/MarkerWriter.java - platform/eclipse.platform.resources - Git at Google

 /*******************************************************************************
  * Copyright (c) 2000, 2002 IBM Corporation and others.
  * All rights reserved.   This program and the accompanying materials
  * are made available under the terms of the Common Public License v0.5
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/cpl-v05.html
  *
  * Contributors:
  * IBM - Initial API and implementation
  ******************************************************************************/
 package org.eclipse.core.internal.resources;

 import org.eclipse.core.resources.*;
 import java.util.*;
 import java.io.IOException;
 import java.io.DataOutputStream;
 //
 public class MarkerWriter {

 	protected MarkerManager manager;

 	// version numbers
 	public static final int MARKERS_SAVE_VERSION = 3;
 	public static final int MARKERS_SNAP_VERSION = 2;

 	// type constants
 	public static final byte INDEX = 1;
 	public static final byte QNAME = 2;

 	// marker attribute types
 	public static final byte ATTRIBUTE_NULL = 0;
 	public static final byte ATTRIBUTE_BOOLEAN = 1;
 	public static final byte ATTRIBUTE_INTEGER = 2;
 	public static final byte ATTRIBUTE_STRING = 3;

 public MarkerWriter(MarkerManager manager) {
 	super();
 	this.manager = manager;
 }
 /**
  * Returns an Object array of length 2. The first element is an Integer which is the number
  * of persistent markers found. The second element is an array of boolean values, with a
  * value of true meaning that the marker at that index is to be persisted.
  */
 private Object[] filterMarkers(IMarkerSetElement[] markers) {
 	Object[] result = new Object[2];
 	boolean[] isPersistent = new boolean[markers.length];
 	int count = 0;
 	MarkerTypeDefinitionCache cache = manager.getCache();
 	for (int i = 0; i < markers.length; i++) {
 		MarkerInfo info = (MarkerInfo) markers[i];
 		if (cache.isPersistent(info.getType())) {
 			isPersistent[i] = true;
 			count++;
 		}
 	}
 	result[0] = new Integer(count);
 	result[1] = isPersistent;
 	return result;
 }
 /**
  * SAVE_FILE -> VERSION_ID RESOURCE+
  * VERSION_ID -> int
  * RESOURCE -> RESOURCE_PATH MARKERS_SIZE MARKER+
  * RESOURCE_PATH -> String
  * MARKERS_SIZE -> int
  * MARKER -> MARKER_ID TYPE ATTRIBUTES_SIZE ATTRIBUTE* CREATION_TIME
  * MARKER_ID -> long
  * TYPE -> INDEX | QNAME
  * INDEX -> byte int
  * QNAME -> byte String
  * ATTRIBUTES_SIZE -> short
  * ATTRIBUTE -> ATTRIBUTE_KEY ATTRIBUTE_VALUE
  * ATTRIBUTE_KEY -> String
  * ATTRIBUTE_VALUE -> INTEGER_VALUE | BOOLEAN_VALUE | STRING_VALUE | NULL_VALUE
  * INTEGER_VALUE -> byte int
  * BOOLEAN_VALUE -> byte boolean
  * STRING_VALUE -> byte String
  * NULL_VALUE -> byte
  * CREATION_TIME -> long
  *
  */
 public void save(IResource resource, DataOutputStream output, List writtenTypes) throws IOException {
 	ResourceInfo info = ((Resource) resource).getResourceInfo(false, false);
 	if (info == null)
 		return;
 	MarkerSet markers = info.getMarkers();
 	if (markers == null)
 		return;
 	IMarkerSetElement[] elements = markers.elements();
 	// filter out the markers...determine if there are any persistent ones
 	Object[] result = filterMarkers(elements);
 	int count = ((Integer) result[0]).intValue();
 	if (count == 0)
 		return;
 	// if this is the first set of markers that we have written, then
 	// write the version id for the file.
 	if (output.size() == 0)
 		output.writeInt(MARKERS_SAVE_VERSION);
 	boolean[] isPersistent = (boolean[]) result[1];
 	output.writeUTF(resource.getFullPath().toString());
 	output.writeInt(count);
 	for (int i = 0; i < elements.length; i++)
 		if (isPersistent[i])
 			write((MarkerInfo) elements[i], output, writtenTypes);
 }
 /**
  * Snapshot the markers for the specified resource to the given output stream.
  *
  * SNAP_FILE -> [VERSION_ID RESOURCE]*
  * VERSION_ID -> int (used for backwards compatibiliy)
  * RESOURCE -> RESOURCE_PATH MARKER_SIZE MARKER+
  * RESOURCE_PATH -> String
  * MARKER_SIZE -> int
  * MARKER -> MARKER_ID TYPE ATTRIBUTES_SIZE ATTRIBUTE* CREATION_TIME
  * MARKER_ID -> long
  * TYPE -> INDEX | QNAME
  * INDEX -> byte int
  * QNAME -> byte String
  * ATTRIBUTES_SIZE -> short
  * ATTRIBUTE -> ATTRIBUTE_KEY ATTRIBUTE_VALUE
  * ATTRIBUTE_KEY -> String
  * ATTRIBUTE_VALUE -> BOOLEAN_VALUE | INTEGER_VALUE | STRING_VALUE | NULL_VALUE
  * BOOLEAN_VALUE -> byte boolean
  * INTEGER_VALUE -> byte int
  * STRING_VALUE -> byte String
  * NULL_VALUE -> byte
  * CREATION_TIME -> long
  */
 public void snap(IResource resource, DataOutputStream output) throws IOException {
 	ResourceInfo info = ((Resource) resource).getResourceInfo(false, false);
 	if (info == null)
 		return;
 	if (!info.isSet(ICoreConstants.M_MARKERS_SNAP_DIRTY))
 		return;
 	MarkerSet markers = info.getMarkers();
 	if (markers == null)
 		return;
 	IMarkerSetElement[] elements = markers.elements();
 	// filter out the markers...determine if there are any persistent ones
 	Object[] result = filterMarkers(elements);
 	int count = ((Integer) result[0]).intValue();
 	// write the version id for the snapshot.
 	output.writeInt(MARKERS_SNAP_VERSION);
 	boolean[] isPersistent = (boolean[]) result[1];
 	output.writeUTF(resource.getFullPath().toString());
 	// always write out the count...even if its zero. this will help
 	// use pick up marker deletions from our snapshot.
 	output.writeInt(count);
 	List writtenTypes = new ArrayList();
 	for (int i = 0; i < elements.length; i++)
 		if (isPersistent[i])
 			write((MarkerInfo) elements[i], output, writtenTypes);
 	info.clear(ICoreConstants.M_MARKERS_SNAP_DIRTY);
 }
 /*
  * Write out the given marker attributes to the given output stream.
  */
 private void write(Map attributes, DataOutputStream output) throws IOException {
 	output.writeShort(attributes.size());
 	for (Iterator i = attributes.keySet().iterator(); i.hasNext();) {
 		String key = (String) i.next();
 		output.writeUTF(key);
 		Object value = attributes.get(key);
 		if (value instanceof Integer) {
 			output.writeByte(ATTRIBUTE_INTEGER);
 			output.writeInt(((Integer) value).intValue());
 			continue;
 		}
 		if (value instanceof Boolean) {
 			output.writeByte(ATTRIBUTE_BOOLEAN);
 			output.writeBoolean(((Boolean) value).booleanValue());
 			continue;
 		}
 		if (value instanceof String) {
 			output.writeByte(ATTRIBUTE_STRING);
 			output.writeUTF((String) value);
 			continue;
 		}
 		// otherwise we came across an attribute of an unknown type
 		// so just write out null since we don't know how to marshal it.
 		output.writeByte(ATTRIBUTE_NULL);
 	}
 }
 private void write(MarkerInfo info, DataOutputStream output, List writtenTypes) throws IOException {
 	output.writeLong(info.getId());
 	// if we have already written the type once, then write an integer
 	// constant to represent it instead to remove duplication
 	String type = info.getType();
 	int index = writtenTypes.indexOf(type);
 	if (index == -1) {
 		output.writeByte(QNAME);
 		output.writeUTF(type);
 		writtenTypes.add(type);
 	} else {
 		output.writeByte(INDEX);
 		output.writeInt(index);
 	}

 	// write out the size of the attribute table and
 	// then each attribute.
 	if (info.getAttributes(false) == null) {
 		output.writeShort(0);
 	} else
 		write(info.getAttributes(false), output);

 	// write out the creation time
 	output.writeLong(info.getCreationTime());
 }
 }
	/*******************************************************************************
	* Copyright (c) 2000, 2002 IBM Corporation and others.
	* All rights reserved. This program and the accompanying materials
	* are made available under the terms of the Common Public License v0.5
	* which accompanies this distribution, and is available at
	* http://www.eclipse.org/legal/cpl-v05.html
	*
	* Contributors:
	* IBM - Initial API and implementation
	******************************************************************************/
	package org.eclipse.core.internal.resources;

	import org.eclipse.core.resources.*;
	import java.util.*;
	import java.io.IOException;
	import java.io.DataOutputStream;
	//
	public class MarkerWriter {

	protected MarkerManager manager;

	// version numbers
	public static final int MARKERS_SAVE_VERSION = 3;
	public static final int MARKERS_SNAP_VERSION = 2;

	// type constants
	public static final byte INDEX = 1;
	public static final byte QNAME = 2;

	// marker attribute types
	public static final byte ATTRIBUTE_NULL = 0;
	public static final byte ATTRIBUTE_BOOLEAN = 1;
	public static final byte ATTRIBUTE_INTEGER = 2;
	public static final byte ATTRIBUTE_STRING = 3;

	public MarkerWriter(MarkerManager manager) {
	super();
	this.manager = manager;
	}
	/**
	* Returns an Object array of length 2. The first element is an Integer which is the number
	* of persistent markers found. The second element is an array of boolean values, with a
	* value of true meaning that the marker at that index is to be persisted.
	*/
	private Object[] filterMarkers(IMarkerSetElement[] markers) {
	Object[] result = new Object[2];
	boolean[] isPersistent = new boolean[markers.length];
	int count = 0;
	MarkerTypeDefinitionCache cache = manager.getCache();
	for (int i = 0; i < markers.length; i++) {
	MarkerInfo info = (MarkerInfo) markers[i];
	if (cache.isPersistent(info.getType())) {
	isPersistent[i] = true;
	count++;
	}
	}
	result[0] = new Integer(count);
	result[1] = isPersistent;
	return result;
	}
	/**
	* SAVE_FILE -> VERSION_ID RESOURCE+
	* VERSION_ID -> int
	* RESOURCE -> RESOURCE_PATH MARKERS_SIZE MARKER+
	* RESOURCE_PATH -> String
	* MARKERS_SIZE -> int
	* MARKER -> MARKER_ID TYPE ATTRIBUTES_SIZE ATTRIBUTE* CREATION_TIME
	* MARKER_ID -> long
	* TYPE -> INDEX \| QNAME
	* INDEX -> byte int
	* QNAME -> byte String
	* ATTRIBUTES_SIZE -> short
	* ATTRIBUTE -> ATTRIBUTE_KEY ATTRIBUTE_VALUE
	* ATTRIBUTE_KEY -> String
	* ATTRIBUTE_VALUE -> INTEGER_VALUE \| BOOLEAN_VALUE \| STRING_VALUE \| NULL_VALUE
	* INTEGER_VALUE -> byte int
	* BOOLEAN_VALUE -> byte boolean
	* STRING_VALUE -> byte String
	* NULL_VALUE -> byte
	* CREATION_TIME -> long
	*
	*/
	public void save(IResource resource, DataOutputStream output, List writtenTypes) throws IOException {
	ResourceInfo info = ((Resource) resource).getResourceInfo(false, false);
	if (info == null)
	return;
	MarkerSet markers = info.getMarkers();
	if (markers == null)
	return;
	IMarkerSetElement[] elements = markers.elements();
	// filter out the markers...determine if there are any persistent ones
	Object[] result = filterMarkers(elements);
	int count = ((Integer) result[0]).intValue();
	if (count == 0)
	return;
	// if this is the first set of markers that we have written, then
	// write the version id for the file.
	if (output.size() == 0)
	output.writeInt(MARKERS_SAVE_VERSION);
	boolean[] isPersistent = (boolean[]) result[1];
	output.writeUTF(resource.getFullPath().toString());
	output.writeInt(count);
	for (int i = 0; i < elements.length; i++)
	if (isPersistent[i])
	write((MarkerInfo) elements[i], output, writtenTypes);
	}
	/**
	* Snapshot the markers for the specified resource to the given output stream.
	*
	* SNAP_FILE -> [VERSION_ID RESOURCE]*
	* VERSION_ID -> int (used for backwards compatibiliy)
	* RESOURCE -> RESOURCE_PATH MARKER_SIZE MARKER+
	* RESOURCE_PATH -> String
	* MARKER_SIZE -> int
	* MARKER -> MARKER_ID TYPE ATTRIBUTES_SIZE ATTRIBUTE* CREATION_TIME
	* MARKER_ID -> long
	* TYPE -> INDEX \| QNAME
	* INDEX -> byte int
	* QNAME -> byte String
	* ATTRIBUTES_SIZE -> short
	* ATTRIBUTE -> ATTRIBUTE_KEY ATTRIBUTE_VALUE
	* ATTRIBUTE_KEY -> String
	* ATTRIBUTE_VALUE -> BOOLEAN_VALUE \| INTEGER_VALUE \| STRING_VALUE \| NULL_VALUE
	* BOOLEAN_VALUE -> byte boolean
	* INTEGER_VALUE -> byte int
	* STRING_VALUE -> byte String
	* NULL_VALUE -> byte
	* CREATION_TIME -> long
	*/
	public void snap(IResource resource, DataOutputStream output) throws IOException {
	ResourceInfo info = ((Resource) resource).getResourceInfo(false, false);
	if (info == null)
	return;
	if (!info.isSet(ICoreConstants.M_MARKERS_SNAP_DIRTY))
	return;
	MarkerSet markers = info.getMarkers();
	if (markers == null)
	return;
	IMarkerSetElement[] elements = markers.elements();
	// filter out the markers...determine if there are any persistent ones
	Object[] result = filterMarkers(elements);
	int count = ((Integer) result[0]).intValue();
	// write the version id for the snapshot.
	output.writeInt(MARKERS_SNAP_VERSION);
	boolean[] isPersistent = (boolean[]) result[1];
	output.writeUTF(resource.getFullPath().toString());
	// always write out the count...even if its zero. this will help
	// use pick up marker deletions from our snapshot.
	output.writeInt(count);
	List writtenTypes = new ArrayList();
	for (int i = 0; i < elements.length; i++)
	if (isPersistent[i])
	write((MarkerInfo) elements[i], output, writtenTypes);
	info.clear(ICoreConstants.M_MARKERS_SNAP_DIRTY);
	}
	/*
	* Write out the given marker attributes to the given output stream.
	*/
	private void write(Map attributes, DataOutputStream output) throws IOException {
	output.writeShort(attributes.size());
	for (Iterator i = attributes.keySet().iterator(); i.hasNext();) {
	String key = (String) i.next();
	output.writeUTF(key);
	Object value = attributes.get(key);
	if (value instanceof Integer) {
	output.writeByte(ATTRIBUTE_INTEGER);
	output.writeInt(((Integer) value).intValue());
	continue;
	}
	if (value instanceof Boolean) {
	output.writeByte(ATTRIBUTE_BOOLEAN);
	output.writeBoolean(((Boolean) value).booleanValue());
	continue;
	}
	if (value instanceof String) {
	output.writeByte(ATTRIBUTE_STRING);
	output.writeUTF((String) value);
	continue;
	}
	// otherwise we came across an attribute of an unknown type
	// so just write out null since we don't know how to marshal it.
	output.writeByte(ATTRIBUTE_NULL);
	}
	}
	private void write(MarkerInfo info, DataOutputStream output, List writtenTypes) throws IOException {
	output.writeLong(info.getId());
	// if we have already written the type once, then write an integer
	// constant to represent it instead to remove duplication
	String type = info.getType();
	int index = writtenTypes.indexOf(type);
	if (index == -1) {
	output.writeByte(QNAME);
	output.writeUTF(type);
	writtenTypes.add(type);
	} else {
	output.writeByte(INDEX);
	output.writeInt(index);
	}

	// write out the size of the attribute table and
	// then each attribute.
	if (info.getAttributes(false) == null) {
	output.writeShort(0);
	} else
	write(info.getAttributes(false), output);

	// write out the creation time
	output.writeLong(info.getCreationTime());
	}
	}