bundles/org.eclipse.core.resources.semantic/src/org/eclipse/core/internal/resources/semantic/SemanticProperties.java - e4/org.eclipse.e4.resources - Git at Google

 /*******************************************************************************
  * Copyright (c) 2009 SAP AG.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
  *
  * Contributors:
  *    Eduard Bartsch (SAP AG) - initial API and implementation
  *    Mathias Kinzler (SAP AG) - initial API and implementation
  *******************************************************************************/
 package org.eclipse.core.internal.resources.semantic;

 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Map.Entry;

 import org.eclipse.core.filesystem.provider.FileStore;
 import org.eclipse.core.internal.resources.semantic.model.SemanticResourceDB.ResourceTreeNode;
 import org.eclipse.core.resources.semantic.ISemanticProperties;
 import org.eclipse.core.resources.semantic.SemanticResourceException;
 import org.eclipse.core.resources.semantic.SemanticResourceStatusCode;
 import org.eclipse.core.runtime.CoreException;
 import org.eclipse.core.runtime.IPath;
 import org.eclipse.core.runtime.Path;
 import org.eclipse.core.runtime.QualifiedName;

 /**
  * The {@link ISemanticProperties} implementation.
  *
  */
 public abstract class SemanticProperties extends FileStore implements ISemanticProperties {

 	protected ResourceTreeNode node;
 	protected final SemanticFileSystem fs;

 	SemanticProperties(SemanticFileSystem fs, ResourceTreeNode node) {
 		this.fs = fs;
 		this.node = node;
 	}

 	private IPath getPathForTrace() {
 		try {
 			return this.fs.getPathForNode(this.node);
 		} catch (RuntimeException rte) {
 			// $JL-EXC$
 			return new Path(this.node.getName());
 		}
 	}

 	/**
 	 * @throws CoreException
 	 */
 	public Map<QualifiedName, String> getPersistentProperties() throws CoreException {

 		if (SfsTraceLocation.CORE_VERBOSE.isActive()) {
 			SfsTraceLocation.getTrace().traceEntry(SfsTraceLocation.CORE_VERBOSE.getLocation(), getPathForTrace().toString());
 		}

 		checkAccessible();

 		Map<QualifiedName, String> result = new HashMap<QualifiedName, String>();
 		try {
 			this.fs.lockForRead();
 			HashMap<String, String> atts = this.node.getPersistentProperties();
 			if (atts == null) {
 				return result;
 			}
 			for (Map.Entry<String, String> entry : atts.entrySet()) {
 				String qualifier;
 				String localName;
 				int index = entry.getKey().indexOf('^');
 				if (index > 0) {
 					qualifier = entry.getKey().substring(0, index);
 					localName = entry.getKey().substring(index + 1);
 				} else {
 					qualifier = null;
 					localName = entry.getKey();
 				}
 				result.put(new QualifiedName(qualifier, localName), entry.getValue());
 			}

 			return result;
 		} finally {
 			this.fs.unlockForRead();
 			if (SfsTraceLocation.CORE_VERBOSE.isActive()) {
 				SfsTraceLocation.getTrace().traceExit(SfsTraceLocation.CORE_VERBOSE.getLocation(), result);
 			}
 		}

 	}

 	/**
 	 * @throws CoreException
 	 */
 	public String getPersistentProperty(QualifiedName key) throws CoreException {

 		if (SfsTraceLocation.CORE_VERBOSE.isActive()) {
 			SfsTraceLocation.getTrace().traceEntry(SfsTraceLocation.CORE_VERBOSE.getLocation(),
 					new Object[] {getPathForTrace().toString(), key});
 		}

 		String result = null;
 		try {
 			this.fs.lockForRead();
 			HashMap<String, String> nodeProps = this.node.getPersistentProperties();
 			if (nodeProps == null) {
 				return result;
 			}
 			String keyString = Util.qualifiedNameToString(key);
 			result = nodeProps.get(keyString);

 			return result;
 		} finally {
 			this.fs.unlockForRead();
 			if (SfsTraceLocation.CORE_VERBOSE.isActive()) {
 				SfsTraceLocation.getTrace().traceExit(SfsTraceLocation.CORE_VERBOSE.getLocation(), result);
 			}
 		}

 	}

 	public void setPersistentProperty(QualifiedName key, String value) throws CoreException {

 		if (SfsTraceLocation.CORE_VERBOSE.isActive()) {
 			SfsTraceLocation.getTrace().traceEntry(SfsTraceLocation.CORE_VERBOSE.getLocation(), getPathForTrace().toString());
 		}

 		checkAccessible();

 		Util.assertQualifiedNameValid(key);

 		String keyString = Util.qualifiedNameToString(key);
 		try {
 			this.fs.lockForWrite();

 			String oldValue = null;

 			HashMap<String, String> map = this.node.getPersistentProperties();
 			if (map == null) {
 				map = new HashMap<String, String>();
 			} else {
 				oldValue = map.get(keyString);
 			}

 			if (!isEqualValue(value, oldValue)) {
 				if (value != null) {
 					map.put(keyString, value);
 				} else {
 					map.remove(keyString);
 				}
 				this.node.setPersistentProperties(map);

 				this.notifyPersistentPropertySet(keyString, oldValue, value);

 				this.fs.requestFlush(false, this.node);
 			}
 		} finally {
 			this.fs.unlockForWrite();
 		}

 	}

 	public void updatePersistentProperties(Map<QualifiedName, String> propertiesToBeAddedOrUpdated,
 			List<QualifiedName> propertiesToBeDeleted) throws CoreException {
 		if (SfsTraceLocation.CORE_VERBOSE.isActive()) {
 			SfsTraceLocation.getTrace().traceEntry(SfsTraceLocation.CORE_VERBOSE.getLocation(), getPathForTrace().toString());
 		}

 		checkAccessible();

 		// check all keys to be added/updated
 		if (propertiesToBeAddedOrUpdated != null) {
 			for (QualifiedName key : propertiesToBeAddedOrUpdated.keySet()) {
 				Util.assertQualifiedNameValid(key);
 			}
 		}

 		try {
 			this.fs.lockForWrite();

 			boolean needsFlush = false;

 			HashMap<String, String> map = this.node.getPersistentProperties();
 			if (map == null) {
 				map = new HashMap<String, String>();
 			}

 			if (propertiesToBeDeleted != null) {
 				for (QualifiedName key : propertiesToBeDeleted) {
 					String keyString = Util.qualifiedNameToString(key);
 					if (map.get(keyString) != null) {
 						map.remove(keyString);
 						needsFlush = true;
 					}
 				}
 			}

 			if (propertiesToBeAddedOrUpdated != null) {
 				for (Entry<QualifiedName, String> entry : propertiesToBeAddedOrUpdated.entrySet()) {
 					String keyString = Util.qualifiedNameToString(entry.getKey());
 					String oldValue = null;

 					oldValue = map.get(keyString);

 					if (!isEqualValue(entry.getValue(), oldValue) && entry.getValue() != null) {
 						map.put(keyString, entry.getValue());

 						this.notifyPersistentPropertySet(keyString, oldValue, entry.getValue());

 						needsFlush = true;
 					}
 				}
 			}
 			if (needsFlush) {
 				this.node.setPersistentProperties(map);

 				this.fs.requestFlush(false, node);
 			}
 		} finally {
 			this.fs.unlockForWrite();
 		}
 	}

 	protected abstract void notifyPersistentPropertySet(String keyString, String oldValue, String newValue) throws CoreException;

 	/**
 	 * @throws CoreException
 	 */
 	public void setSessionProperty(QualifiedName key, Object value) throws CoreException {

 		if (SfsTraceLocation.CORE_VERBOSE.isActive()) {
 			SfsTraceLocation.getTrace().traceEntry(SfsTraceLocation.CORE_VERBOSE.getLocation(), getPathForTrace().toString());
 		}

 		checkAccessible();

 		Util.assertQualifiedNameValid(key);

 		try {
 			this.fs.lockForWrite();

 			HashMap<QualifiedName, Object> map = this.node.getSessionProperties();
 			if (map == null) {
 				map = new HashMap<QualifiedName, Object>();
 				this.node.setSessionProperties(map);
 			}
 			if (value != null) {
 				map.put(key, value);
 			} else {
 				map.remove(key);
 			}

 		} finally {
 			this.fs.unlockForWrite();
 		}

 	}

 	/**
 	 * @throws CoreException
 	 */
 	public Map<QualifiedName, Object> getSessionProperties() throws CoreException {

 		if (SfsTraceLocation.CORE_VERBOSE.isActive()) {
 			SfsTraceLocation.getTrace().traceEntry(SfsTraceLocation.CORE_VERBOSE.getLocation(), getPathForTrace().toString());
 		}

 		checkAccessible();

 		Map<QualifiedName, Object> result = new HashMap<QualifiedName, Object>();

 		try {
 			this.fs.lockForRead();
 			HashMap<QualifiedName, Object> atts = this.node.getSessionProperties();
 			if (atts == null) {
 				return result;
 			}
 			// we copy the map here (QualifiedName is immutable)
 			for (Map.Entry<QualifiedName, Object> entry : atts.entrySet()) {
 				result.put(entry.getKey(), entry.getValue());
 			}

 			return result;
 		} finally {
 			this.fs.unlockForRead();
 			if (SfsTraceLocation.CORE_VERBOSE.isActive()) {
 				SfsTraceLocation.getTrace().traceExit(SfsTraceLocation.CORE_VERBOSE.getLocation(), result);
 			}
 		}
 	}

 	/**
 	 * @throws CoreException
 	 */
 	public Object getSessionProperty(QualifiedName key) throws CoreException {

 		if (SfsTraceLocation.CORE_VERBOSE.isActive()) {
 			SfsTraceLocation.getTrace().traceEntry(SfsTraceLocation.CORE_VERBOSE.getLocation(),
 					new Object[] {getPathForTrace().toString(), key});
 		}

 		Object result = null;
 		try {
 			this.fs.lockForRead();
 			HashMap<QualifiedName, Object> nodeProps = this.node.getSessionProperties();
 			if (nodeProps == null) {
 				return result;
 			}
 			result = nodeProps.get(key);
 			return result;
 		} finally {
 			this.fs.unlockForRead();
 			if (SfsTraceLocation.CORE_VERBOSE.isActive()) {
 				SfsTraceLocation.getTrace().traceExit(SfsTraceLocation.CORE_VERBOSE.getLocation(), result);
 			}
 		}
 	}

 	/**
 	 * Similar to
 	 * <code>org.eclipse.core.internal.resources.Resource#checkAccessible(int)</code>
 	 * <p>
 	 * The corresponding Resource method is called on:
 	 * <ul>
 	 * <li>Container.memebers()</li>
 	 * <li>Container.setDefaultCharset()</li>
 	 * <li>File.appendContents()</li>
 	 * <li>File.create() (on the parent)</li>
 	 * <li>File.getContentDescription()</li>
 	 * <li>File.getContents()</li>
 	 * <li>File.getEncoding()</li>
 	 * <li>File.setCharset()</li>
 	 * <li>File.setContents()</li>
 	 * <li>Folder.create() (on the parent)</li>
 	 * <li>Project.checkAccessible()</li>
 	 * <li>Project.getDescription()</li>
 	 * <li>Project.getNature()</li>
 	 * <li>Project.getReferencedProjects()</li>
 	 * <li>Project.hasNature</li>
 	 * <li>Project.isNatureEnabled()</li>
 	 * <li>Project.setDescription()</li>
 	 * <li>Resource.accept()</li>
 	 * <li>Resource.createLink()</li>
 	 * <li>Resource.copy()</li>
 	 * <li>Resource.move()</li>
 	 * <li>Resource.createMarker()</li>
 	 * <li>Resource.deleteMarkers()</li>
 	 * <li>Resource.findMarkers()</li>
 	 * <li>Resource.findMaxProblemSeverity()</li>
 	 * <li>Resource.setDerived()</li>
 	 * <li>Resource.setHidden()</li>
 	 * <li>Resource.setTeamPrivateMember()</li>
 	 * </ul>
 	 *
 	 * @throws CoreException
 	 */
 	protected void checkAccessible() throws CoreException {
 		checkAndJoinTreeIfAnotherEntryExists();

 		if (!this.node.isExists()) {
 			throw new SemanticResourceException(SemanticResourceStatusCode.NOT_ACCESSIBLE, getPathForTrace(),
 					Messages.SemanticProperties_StoreNotAccessible_XMSG);
 		}
 	}

 	protected void checkAndJoinTreeIfAnotherEntryExists() {
 		try {
 			this.fs.lockForRead();
 			if (!this.node.isExists()) {
 				ResourceTreeNode other = this.fs.getNodeByPath(this.node.getPath());

 				if (other.isExists()) {
 					this.node = other;
 				}
 			}
 		} finally {
 			this.fs.unlockForRead();
 			if (SfsTraceLocation.CORE_VERBOSE.isActive()) {
 				SfsTraceLocation.getTrace().traceExit(SfsTraceLocation.CORE_VERBOSE.getLocation());
 			}
 		}
 	}

 	private boolean isEqualValue(String value, String oldValue) {
 		if (value == null && oldValue == null) {
 			return true;
 		} else if (value != null && oldValue == null) {
 			return false;
 		} else if (value == null && oldValue != null) {
 			return false;
 		}
 		return value.equals(oldValue);
 	}

 }
	/*******************************************************************************
	* Copyright (c) 2009 SAP AG.
	* All rights reserved. This program and the accompanying materials
	* are made available under the terms of the Eclipse Public License v1.0
	* which accompanies this distribution, and is available at
	* http://www.eclipse.org/legal/epl-v10.html
	*
	* Contributors:
	* Eduard Bartsch (SAP AG) - initial API and implementation
	* Mathias Kinzler (SAP AG) - initial API and implementation
	*******************************************************************************/
	package org.eclipse.core.internal.resources.semantic;

	import java.util.HashMap;
	import java.util.List;
	import java.util.Map;
	import java.util.Map.Entry;

	import org.eclipse.core.filesystem.provider.FileStore;
	import org.eclipse.core.internal.resources.semantic.model.SemanticResourceDB.ResourceTreeNode;
	import org.eclipse.core.resources.semantic.ISemanticProperties;
	import org.eclipse.core.resources.semantic.SemanticResourceException;
	import org.eclipse.core.resources.semantic.SemanticResourceStatusCode;
	import org.eclipse.core.runtime.CoreException;
	import org.eclipse.core.runtime.IPath;
	import org.eclipse.core.runtime.Path;
	import org.eclipse.core.runtime.QualifiedName;

	/**
	* The {@link ISemanticProperties} implementation.
	*
	*/
	public abstract class SemanticProperties extends FileStore implements ISemanticProperties {

	protected ResourceTreeNode node;
	protected final SemanticFileSystem fs;

	SemanticProperties(SemanticFileSystem fs, ResourceTreeNode node) {
	this.fs = fs;
	this.node = node;
	}

	private IPath getPathForTrace() {
	try {
	return this.fs.getPathForNode(this.node);
	} catch (RuntimeException rte) {
	// $JL-EXC$
	return new Path(this.node.getName());
	}
	}

	/**
	* @throws CoreException
	*/
	public Map<QualifiedName, String> getPersistentProperties() throws CoreException {

	if (SfsTraceLocation.CORE_VERBOSE.isActive()) {
	SfsTraceLocation.getTrace().traceEntry(SfsTraceLocation.CORE_VERBOSE.getLocation(), getPathForTrace().toString());
	}

	checkAccessible();

	Map<QualifiedName, String> result = new HashMap<QualifiedName, String>();
	try {
	this.fs.lockForRead();
	HashMap<String, String> atts = this.node.getPersistentProperties();
	if (atts == null) {
	return result;
	}
	for (Map.Entry<String, String> entry : atts.entrySet()) {
	String qualifier;
	String localName;
	int index = entry.getKey().indexOf('^');
	if (index > 0) {
	qualifier = entry.getKey().substring(0, index);
	localName = entry.getKey().substring(index + 1);
	} else {
	qualifier = null;
	localName = entry.getKey();
	}
	result.put(new QualifiedName(qualifier, localName), entry.getValue());
	}

	return result;
	} finally {
	this.fs.unlockForRead();
	if (SfsTraceLocation.CORE_VERBOSE.isActive()) {
	SfsTraceLocation.getTrace().traceExit(SfsTraceLocation.CORE_VERBOSE.getLocation(), result);
	}
	}

	}

	/**
	* @throws CoreException
	*/
	public String getPersistentProperty(QualifiedName key) throws CoreException {

	if (SfsTraceLocation.CORE_VERBOSE.isActive()) {
	SfsTraceLocation.getTrace().traceEntry(SfsTraceLocation.CORE_VERBOSE.getLocation(),
	new Object[] {getPathForTrace().toString(), key});
	}

	String result = null;
	try {
	this.fs.lockForRead();
	HashMap<String, String> nodeProps = this.node.getPersistentProperties();
	if (nodeProps == null) {
	return result;
	}
	String keyString = Util.qualifiedNameToString(key);
	result = nodeProps.get(keyString);

	return result;
	} finally {
	this.fs.unlockForRead();
	if (SfsTraceLocation.CORE_VERBOSE.isActive()) {
	SfsTraceLocation.getTrace().traceExit(SfsTraceLocation.CORE_VERBOSE.getLocation(), result);
	}
	}

	}

	public void setPersistentProperty(QualifiedName key, String value) throws CoreException {

	if (SfsTraceLocation.CORE_VERBOSE.isActive()) {
	SfsTraceLocation.getTrace().traceEntry(SfsTraceLocation.CORE_VERBOSE.getLocation(), getPathForTrace().toString());
	}

	checkAccessible();

	Util.assertQualifiedNameValid(key);

	String keyString = Util.qualifiedNameToString(key);
	try {
	this.fs.lockForWrite();

	String oldValue = null;

	HashMap<String, String> map = this.node.getPersistentProperties();
	if (map == null) {
	map = new HashMap<String, String>();
	} else {
	oldValue = map.get(keyString);
	}

	if (!isEqualValue(value, oldValue)) {
	if (value != null) {
	map.put(keyString, value);
	} else {
	map.remove(keyString);
	}
	this.node.setPersistentProperties(map);

	this.notifyPersistentPropertySet(keyString, oldValue, value);

	this.fs.requestFlush(false, this.node);
	}
	} finally {
	this.fs.unlockForWrite();
	}

	}

	public void updatePersistentProperties(Map<QualifiedName, String> propertiesToBeAddedOrUpdated,
	List<QualifiedName> propertiesToBeDeleted) throws CoreException {
	if (SfsTraceLocation.CORE_VERBOSE.isActive()) {
	SfsTraceLocation.getTrace().traceEntry(SfsTraceLocation.CORE_VERBOSE.getLocation(), getPathForTrace().toString());
	}

	checkAccessible();

	// check all keys to be added/updated
	if (propertiesToBeAddedOrUpdated != null) {
	for (QualifiedName key : propertiesToBeAddedOrUpdated.keySet()) {
	Util.assertQualifiedNameValid(key);
	}
	}

	try {
	this.fs.lockForWrite();

	boolean needsFlush = false;

	HashMap<String, String> map = this.node.getPersistentProperties();
	if (map == null) {
	map = new HashMap<String, String>();
	}

	if (propertiesToBeDeleted != null) {
	for (QualifiedName key : propertiesToBeDeleted) {
	String keyString = Util.qualifiedNameToString(key);
	if (map.get(keyString) != null) {
	map.remove(keyString);
	needsFlush = true;
	}
	}
	}

	if (propertiesToBeAddedOrUpdated != null) {
	for (Entry<QualifiedName, String> entry : propertiesToBeAddedOrUpdated.entrySet()) {
	String keyString = Util.qualifiedNameToString(entry.getKey());
	String oldValue = null;

	oldValue = map.get(keyString);

	if (!isEqualValue(entry.getValue(), oldValue) && entry.getValue() != null) {
	map.put(keyString, entry.getValue());

	this.notifyPersistentPropertySet(keyString, oldValue, entry.getValue());

	needsFlush = true;
	}
	}
	}
	if (needsFlush) {
	this.node.setPersistentProperties(map);

	this.fs.requestFlush(false, node);
	}
	} finally {
	this.fs.unlockForWrite();
	}
	}

	protected abstract void notifyPersistentPropertySet(String keyString, String oldValue, String newValue) throws CoreException;

	/**
	* @throws CoreException
	*/
	public void setSessionProperty(QualifiedName key, Object value) throws CoreException {

	if (SfsTraceLocation.CORE_VERBOSE.isActive()) {
	SfsTraceLocation.getTrace().traceEntry(SfsTraceLocation.CORE_VERBOSE.getLocation(), getPathForTrace().toString());
	}

	checkAccessible();

	Util.assertQualifiedNameValid(key);

	try {
	this.fs.lockForWrite();

	HashMap<QualifiedName, Object> map = this.node.getSessionProperties();
	if (map == null) {
	map = new HashMap<QualifiedName, Object>();
	this.node.setSessionProperties(map);
	}
	if (value != null) {
	map.put(key, value);
	} else {
	map.remove(key);
	}

	} finally {
	this.fs.unlockForWrite();
	}

	}

	/**
	* @throws CoreException
	*/
	public Map<QualifiedName, Object> getSessionProperties() throws CoreException {

	if (SfsTraceLocation.CORE_VERBOSE.isActive()) {
	SfsTraceLocation.getTrace().traceEntry(SfsTraceLocation.CORE_VERBOSE.getLocation(), getPathForTrace().toString());
	}

	checkAccessible();

	Map<QualifiedName, Object> result = new HashMap<QualifiedName, Object>();

	try {
	this.fs.lockForRead();
	HashMap<QualifiedName, Object> atts = this.node.getSessionProperties();
	if (atts == null) {
	return result;
	}
	// we copy the map here (QualifiedName is immutable)
	for (Map.Entry<QualifiedName, Object> entry : atts.entrySet()) {
	result.put(entry.getKey(), entry.getValue());
	}

	return result;
	} finally {
	this.fs.unlockForRead();
	if (SfsTraceLocation.CORE_VERBOSE.isActive()) {
	SfsTraceLocation.getTrace().traceExit(SfsTraceLocation.CORE_VERBOSE.getLocation(), result);
	}
	}
	}

	/**
	* @throws CoreException
	*/
	public Object getSessionProperty(QualifiedName key) throws CoreException {

	if (SfsTraceLocation.CORE_VERBOSE.isActive()) {
	SfsTraceLocation.getTrace().traceEntry(SfsTraceLocation.CORE_VERBOSE.getLocation(),
	new Object[] {getPathForTrace().toString(), key});
	}

	Object result = null;
	try {
	this.fs.lockForRead();
	HashMap<QualifiedName, Object> nodeProps = this.node.getSessionProperties();
	if (nodeProps == null) {
	return result;
	}
	result = nodeProps.get(key);
	return result;
	} finally {
	this.fs.unlockForRead();
	if (SfsTraceLocation.CORE_VERBOSE.isActive()) {
	SfsTraceLocation.getTrace().traceExit(SfsTraceLocation.CORE_VERBOSE.getLocation(), result);
	}
	}
	}

	/**
	* Similar to
	* <code>org.eclipse.core.internal.resources.Resource#checkAccessible(int)</code>
	* <p>
	* The corresponding Resource method is called on:
	* <ul>
	* <li>Container.memebers()</li>
	* <li>Container.setDefaultCharset()</li>
	* <li>File.appendContents()</li>
	* <li>File.create() (on the parent)</li>
	* <li>File.getContentDescription()</li>
	* <li>File.getContents()</li>
	* <li>File.getEncoding()</li>
	* <li>File.setCharset()</li>
	* <li>File.setContents()</li>
	* <li>Folder.create() (on the parent)</li>
	* <li>Project.checkAccessible()</li>
	* <li>Project.getDescription()</li>
	* <li>Project.getNature()</li>
	* <li>Project.getReferencedProjects()</li>
	* <li>Project.hasNature</li>
	* <li>Project.isNatureEnabled()</li>
	* <li>Project.setDescription()</li>
	* <li>Resource.accept()</li>
	* <li>Resource.createLink()</li>
	* <li>Resource.copy()</li>
	* <li>Resource.move()</li>
	* <li>Resource.createMarker()</li>
	* <li>Resource.deleteMarkers()</li>
	* <li>Resource.findMarkers()</li>
	* <li>Resource.findMaxProblemSeverity()</li>
	* <li>Resource.setDerived()</li>
	* <li>Resource.setHidden()</li>
	* <li>Resource.setTeamPrivateMember()</li>
	* </ul>
	*
	* @throws CoreException
	*/
	protected void checkAccessible() throws CoreException {
	checkAndJoinTreeIfAnotherEntryExists();

	if (!this.node.isExists()) {
	throw new SemanticResourceException(SemanticResourceStatusCode.NOT_ACCESSIBLE, getPathForTrace(),
	Messages.SemanticProperties_StoreNotAccessible_XMSG);
	}
	}

	protected void checkAndJoinTreeIfAnotherEntryExists() {
	try {
	this.fs.lockForRead();
	if (!this.node.isExists()) {
	ResourceTreeNode other = this.fs.getNodeByPath(this.node.getPath());

	if (other.isExists()) {
	this.node = other;
	}
	}
	} finally {
	this.fs.unlockForRead();
	if (SfsTraceLocation.CORE_VERBOSE.isActive()) {
	SfsTraceLocation.getTrace().traceExit(SfsTraceLocation.CORE_VERBOSE.getLocation());
	}
	}
	}

	private boolean isEqualValue(String value, String oldValue) {
	if (value == null && oldValue == null) {
	return true;
	} else if (value != null && oldValue == null) {
	return false;
	} else if (value == null && oldValue != null) {
	return false;
	}
	return value.equals(oldValue);
	}

	}