| /* |
| * Copyright (c) 2012, 2013, 2015, 2016 Eike Stepper (Berlin, Germany) and others. |
| * 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: |
| * Eike Stepper - initial API and implementation |
| */ |
| package org.eclipse.emf.cdo.server.internal.lissome; |
| |
| import org.eclipse.emf.cdo.common.branch.CDOBranch; |
| import org.eclipse.emf.cdo.common.branch.CDOBranchManager; |
| import org.eclipse.emf.cdo.common.branch.CDOBranchPoint; |
| import org.eclipse.emf.cdo.common.branch.CDOBranchVersion; |
| import org.eclipse.emf.cdo.common.commit.CDOChangeSetData; |
| import org.eclipse.emf.cdo.common.commit.CDOCommitData; |
| import org.eclipse.emf.cdo.common.commit.CDOCommitInfo; |
| import org.eclipse.emf.cdo.common.commit.CDOCommitInfoManager; |
| import org.eclipse.emf.cdo.common.id.CDOID; |
| import org.eclipse.emf.cdo.common.id.CDOIDProvider; |
| import org.eclipse.emf.cdo.common.id.CDOIDReference; |
| import org.eclipse.emf.cdo.common.lob.CDOLobStore; |
| import org.eclipse.emf.cdo.common.lock.CDOLockChangeInfo; |
| import org.eclipse.emf.cdo.common.lock.CDOLockOwner; |
| import org.eclipse.emf.cdo.common.lock.CDOLockState; |
| import org.eclipse.emf.cdo.common.lock.IDurableLockingManager.LockArea; |
| import org.eclipse.emf.cdo.common.model.CDOClassifierRef; |
| import org.eclipse.emf.cdo.common.model.CDOPackageInfo; |
| import org.eclipse.emf.cdo.common.model.CDOPackageRegistry; |
| import org.eclipse.emf.cdo.common.model.CDOPackageUnit; |
| import org.eclipse.emf.cdo.common.model.CDOPackageUnit.Type; |
| import org.eclipse.emf.cdo.common.model.CDOType; |
| import org.eclipse.emf.cdo.common.protocol.CDODataInput; |
| import org.eclipse.emf.cdo.common.protocol.CDODataOutput; |
| import org.eclipse.emf.cdo.common.revision.CDOIDAndBranch; |
| import org.eclipse.emf.cdo.common.revision.CDOIDAndVersion; |
| import org.eclipse.emf.cdo.common.revision.CDOList; |
| import org.eclipse.emf.cdo.common.revision.CDOListFactory; |
| import org.eclipse.emf.cdo.common.revision.CDORevisable; |
| import org.eclipse.emf.cdo.common.revision.CDORevision; |
| import org.eclipse.emf.cdo.common.revision.CDORevisionFactory; |
| import org.eclipse.emf.cdo.common.revision.CDORevisionKey; |
| import org.eclipse.emf.cdo.common.revision.delta.CDOFeatureDelta; |
| import org.eclipse.emf.cdo.common.revision.delta.CDORevisionDelta; |
| import org.eclipse.emf.cdo.common.security.CDOPermissionProvider; |
| import org.eclipse.emf.cdo.spi.common.protocol.CDODataInputImpl; |
| import org.eclipse.emf.cdo.spi.common.protocol.CDODataOutputImpl; |
| import org.eclipse.emf.cdo.spi.common.revision.CDORevisionUnchunker; |
| import org.eclipse.emf.cdo.spi.common.revision.DetachedCDORevision; |
| |
| import org.eclipse.net4j.util.concurrent.IRWLockManager.LockType; |
| import org.eclipse.net4j.util.io.DataInputExtender; |
| import org.eclipse.net4j.util.io.DataInputOutputFile; |
| import org.eclipse.net4j.util.io.DataOutputExtender; |
| import org.eclipse.net4j.util.io.ExtendedDataInput; |
| import org.eclipse.net4j.util.io.ExtendedDataOutput; |
| import org.eclipse.net4j.util.io.ExtendedIOUtil.ClassResolver; |
| import org.eclipse.net4j.util.io.IORuntimeException; |
| |
| import org.eclipse.emf.ecore.EClass; |
| import org.eclipse.emf.ecore.EClassifier; |
| import org.eclipse.emf.ecore.EStructuralFeature; |
| import org.eclipse.emf.ecore.resource.ResourceSet; |
| |
| import java.io.FileNotFoundException; |
| import java.io.IOException; |
| |
| /** |
| * @author Eike Stepper |
| */ |
| public class LissomeFileHandle extends DataInputOutputFile implements CDODataInput, CDODataOutput, LissomeFile.RevisionProvider |
| { |
| private LissomeFile file; |
| |
| private CDODataInput in; |
| |
| private CDODataOutput out; |
| |
| public LissomeFileHandle(LissomeFile file, String mode) throws FileNotFoundException |
| { |
| super(file, mode); |
| this.file = file; |
| } |
| |
| public LissomeFile getFile() |
| { |
| return file; |
| } |
| |
| public LissomeStore getStore() |
| { |
| return file.getStore(); |
| } |
| |
| public CDOPackageRegistry getPackageRegistry() |
| { |
| return getStore().getRepository().getPackageRegistry(); |
| } |
| |
| public CDOBranchManager getBranchManager() |
| { |
| return getStore().getRepository().getBranchManager(); |
| } |
| |
| public CDOCommitInfoManager getCommitInfoManager() |
| { |
| return getStore().getRepository().getCommitInfoManager(); |
| } |
| |
| public CDORevisionUnchunker getRevisionUnchunker() |
| { |
| return null; |
| } |
| |
| public CDORevisionFactory getRevisionFactory() |
| { |
| return CDORevisionFactory.DEFAULT; |
| } |
| |
| public CDOListFactory getListFactory() |
| { |
| return CDOListFactory.DEFAULT; |
| } |
| |
| public CDOLobStore getLobStore() |
| { |
| return null; |
| } |
| |
| public CDOIDProvider getIDProvider() |
| { |
| return CDOIDProvider.NOOP; |
| } |
| |
| public CDOPermissionProvider getPermissionProvider() |
| { |
| return out().getPermissionProvider(); |
| } |
| |
| public CDORevision getRevision(long pointer) |
| { |
| try |
| { |
| seek(pointer); |
| return readCDORevision(); |
| } |
| catch (IOException ex) |
| { |
| throw new IORuntimeException(ex); |
| } |
| } |
| |
| private CDODataInput in() |
| { |
| if (in == null) |
| { |
| in = createDataInput(); |
| } |
| |
| return in; |
| } |
| |
| protected CDODataInput createDataInput() |
| { |
| ExtendedDataInput extendedDataInput = new DataInputExtender(this); |
| return new CDODataInputImpl(extendedDataInput) |
| { |
| @Override |
| public CDORevision readCDORevision(boolean freeze) throws IOException |
| { |
| boolean detached = readBoolean(); |
| if (detached) |
| { |
| int cid = readInt(); |
| EClass eClass = (EClass)file.getStore().getMetaObject(cid); |
| |
| CDOID id = readCDOID(); |
| CDOBranch branch = readCDOBranch(); |
| int version = readInt(); |
| long timeStamp = readLong(); |
| long revised = readLong(); |
| |
| return new DetachedCDORevision(eClass, id, branch, version, timeStamp, revised); |
| } |
| |
| return super.readCDORevision(freeze); |
| } |
| |
| public CDOPackageRegistry getPackageRegistry() |
| { |
| return LissomeFileHandle.this.getPackageRegistry(); |
| } |
| |
| @Override |
| protected CDOBranchManager getBranchManager() |
| { |
| return LissomeFileHandle.this.getBranchManager(); |
| } |
| |
| @Override |
| protected CDOCommitInfoManager getCommitInfoManager() |
| { |
| return LissomeFileHandle.this.getCommitInfoManager(); |
| } |
| |
| @Override |
| protected CDORevisionFactory getRevisionFactory() |
| { |
| return LissomeFileHandle.this.getRevisionFactory(); |
| } |
| |
| @Override |
| protected CDOListFactory getListFactory() |
| { |
| return LissomeFileHandle.this.getListFactory(); |
| } |
| |
| @Override |
| protected CDOLobStore getLobStore() |
| { |
| return LissomeFileHandle.this.getLobStore(); |
| } |
| }; |
| } |
| |
| public byte[] readByteArray() throws IOException |
| { |
| return in().readByteArray(); |
| } |
| |
| public Object readObject() throws IOException |
| { |
| return in().readObject(); |
| } |
| |
| public Object readObject(ClassLoader classLoader) throws IOException |
| { |
| return in().readObject(classLoader); |
| } |
| |
| public Object readObject(ClassResolver classResolver) throws IOException |
| { |
| return in().readObject(classResolver); |
| } |
| |
| public String readString() throws IOException |
| { |
| return in().readString(); |
| } |
| |
| public <T extends Enum<?>> T readEnum(Class<T> type) throws IOException |
| { |
| return in().readEnum(type); |
| } |
| |
| public Throwable readException() throws IOException |
| { |
| return in().readException(); |
| } |
| |
| public CDOPackageUnit readCDOPackageUnit(ResourceSet resourceSet) throws IOException |
| { |
| return in().readCDOPackageUnit(resourceSet); |
| } |
| |
| public CDOPackageUnit[] readCDOPackageUnits(ResourceSet resourceSet) throws IOException |
| { |
| return in().readCDOPackageUnits(resourceSet); |
| } |
| |
| public Type readCDOPackageUnitType() throws IOException |
| { |
| return in().readCDOPackageUnitType(); |
| } |
| |
| public CDOPackageInfo readCDOPackageInfo() throws IOException |
| { |
| return in().readCDOPackageInfo(); |
| } |
| |
| public CDOClassifierRef readCDOClassifierRef() throws IOException |
| { |
| return in().readCDOClassifierRef(); |
| } |
| |
| public EClassifier readCDOClassifierRefAndResolve() throws IOException |
| { |
| return in().readCDOClassifierRefAndResolve(); |
| } |
| |
| public String readCDOPackageURI() throws IOException |
| { |
| return in().readCDOPackageURI(); |
| } |
| |
| public CDOType readCDOType() throws IOException |
| { |
| return in().readCDOType(); |
| } |
| |
| public CDOBranch readCDOBranch() throws IOException |
| { |
| return in().readCDOBranch(); |
| } |
| |
| public CDOBranchPoint readCDOBranchPoint() throws IOException |
| { |
| return in().readCDOBranchPoint(); |
| } |
| |
| public CDOBranchVersion readCDOBranchVersion() throws IOException |
| { |
| return in().readCDOBranchVersion(); |
| } |
| |
| public CDOChangeSetData readCDOChangeSetData() throws IOException |
| { |
| return in().readCDOChangeSetData(); |
| } |
| |
| public CDOCommitData readCDOCommitData() throws IOException |
| { |
| return in().readCDOCommitData(); |
| } |
| |
| public CDOCommitInfo readCDOCommitInfo() throws IOException |
| { |
| return in().readCDOCommitInfo(); |
| } |
| |
| public CDOID readCDOID() throws IOException |
| { |
| return in().readCDOID(); |
| } |
| |
| public CDOIDReference readCDOIDReference() throws IOException |
| { |
| return in().readCDOIDReference(); |
| } |
| |
| public CDOIDAndVersion readCDOIDAndVersion() throws IOException |
| { |
| return in().readCDOIDAndVersion(); |
| } |
| |
| public CDOIDAndBranch readCDOIDAndBranch() throws IOException |
| { |
| return in().readCDOIDAndBranch(); |
| } |
| |
| public CDORevisionKey readCDORevisionKey() throws IOException |
| { |
| return in().readCDORevisionKey(); |
| } |
| |
| public CDORevision readCDORevision() throws IOException |
| { |
| return in().readCDORevision(); |
| } |
| |
| public CDORevision readCDORevision(boolean freeze) throws IOException |
| { |
| return in().readCDORevision(freeze); |
| } |
| |
| public CDORevisable readCDORevisable() throws IOException |
| { |
| return in().readCDORevisable(); |
| } |
| |
| public CDOList readCDOList(EClass owner, EStructuralFeature feature) throws IOException |
| { |
| return in().readCDOList(owner, feature); |
| } |
| |
| public Object readCDOFeatureValue(EStructuralFeature feature) throws IOException |
| { |
| return in().readCDOFeatureValue(feature); |
| } |
| |
| public CDORevisionDelta readCDORevisionDelta() throws IOException |
| { |
| return in().readCDORevisionDelta(); |
| } |
| |
| public CDOFeatureDelta readCDOFeatureDelta(EClass owner) throws IOException |
| { |
| return in().readCDOFeatureDelta(owner); |
| } |
| |
| public Object readCDORevisionOrPrimitive() throws IOException |
| { |
| return in().readCDORevisionOrPrimitive(); |
| } |
| |
| public Object readCDORevisionOrPrimitiveOrClassifier() throws IOException |
| { |
| return in().readCDORevisionOrPrimitiveOrClassifier(); |
| } |
| |
| public LockType readCDOLockType() throws IOException |
| { |
| return in().readCDOLockType(); |
| } |
| |
| public CDOLockChangeInfo readCDOLockChangeInfo() throws IOException |
| { |
| return in().readCDOLockChangeInfo(); |
| } |
| |
| public CDOLockOwner readCDOLockOwner() throws IOException |
| { |
| return in().readCDOLockOwner(); |
| } |
| |
| public CDOLockState readCDOLockState() throws IOException |
| { |
| return in().readCDOLockState(); |
| } |
| |
| public LockArea readCDOLockArea() throws IOException |
| { |
| return in().readCDOLockArea(); |
| } |
| |
| private CDODataOutput out() |
| { |
| if (out == null) |
| { |
| out = createDataOutput(); |
| } |
| |
| return out; |
| } |
| |
| protected CDODataOutput createDataOutput() |
| { |
| ExtendedDataOutput extendedDataOutput = new DataOutputExtender(this); |
| return new CDODataOutputImpl(extendedDataOutput) |
| { |
| @Override |
| public void writeCDORevision(CDORevision revision, int referenceChunk, CDOBranchPoint securityContext) throws IOException |
| { |
| boolean detached = revision instanceof DetachedCDORevision; |
| writeBoolean(detached); |
| if (detached) |
| { |
| int cid = file.getStore().getMetaID(revision.getEClass()); |
| writeInt(cid); |
| |
| writeCDOID(revision.getID()); |
| writeCDOBranch(revision.getBranch()); |
| writeInt(revision.getVersion()); |
| writeLong(revision.getTimeStamp()); |
| writeLong(revision.getRevised()); |
| } |
| else |
| { |
| super.writeCDORevision(revision, referenceChunk, securityContext); |
| } |
| } |
| |
| @Override |
| public CDOPackageRegistry getPackageRegistry() |
| { |
| return LissomeFileHandle.this.getPackageRegistry(); |
| } |
| |
| @Override |
| public CDOIDProvider getIDProvider() |
| { |
| return LissomeFileHandle.this.getIDProvider(); |
| } |
| }; |
| } |
| |
| public void writeByteArray(byte[] b) throws IOException |
| { |
| out().writeByteArray(b); |
| } |
| |
| public void writeObject(Object object) throws IOException |
| { |
| out().writeObject(object); |
| } |
| |
| public void writeString(String str) throws IOException |
| { |
| out().writeString(str); |
| } |
| |
| public void writeEnum(Enum<?> literal) throws IOException |
| { |
| out().writeEnum(literal); |
| } |
| |
| public void writeException(Throwable t) throws IOException |
| { |
| out().writeException(t); |
| } |
| |
| public void writeCDOPackageUnit(CDOPackageUnit packageUnit, boolean withPackages) throws IOException |
| { |
| out().writeCDOPackageUnit(packageUnit, withPackages); |
| } |
| |
| public void writeCDOPackageUnits(CDOPackageUnit... packageUnit) throws IOException |
| { |
| out().writeCDOPackageUnits(packageUnit); |
| } |
| |
| public void writeCDOPackageUnitType(Type type) throws IOException |
| { |
| out().writeCDOPackageUnitType(type); |
| } |
| |
| public void writeCDOPackageInfo(CDOPackageInfo packageInfo) throws IOException |
| { |
| out().writeCDOPackageInfo(packageInfo); |
| } |
| |
| public void writeCDOClassifierRef(CDOClassifierRef eClassifierRef) throws IOException |
| { |
| out().writeCDOClassifierRef(eClassifierRef); |
| } |
| |
| public void writeCDOClassifierRef(EClassifier eClassifier) throws IOException |
| { |
| out().writeCDOClassifierRef(eClassifier); |
| } |
| |
| public void writeCDOPackageURI(String uri) throws IOException |
| { |
| out().writeCDOPackageURI(uri); |
| } |
| |
| public void writeCDOType(CDOType cdoType) throws IOException |
| { |
| out().writeCDOType(cdoType); |
| } |
| |
| public void writeCDOBranch(CDOBranch branch) throws IOException |
| { |
| out().writeCDOBranch(branch); |
| } |
| |
| public void writeCDOBranchPoint(CDOBranchPoint branchPoint) throws IOException |
| { |
| out().writeCDOBranchPoint(branchPoint); |
| } |
| |
| public void writeCDOBranchVersion(CDOBranchVersion branchVersion) throws IOException |
| { |
| out().writeCDOBranchVersion(branchVersion); |
| } |
| |
| public void writeCDOChangeSetData(CDOChangeSetData changeSetData) throws IOException |
| { |
| out().writeCDOChangeSetData(changeSetData); |
| } |
| |
| public void writeCDOCommitData(CDOCommitData commitData) throws IOException |
| { |
| out().writeCDOCommitData(commitData); |
| } |
| |
| public void writeCDOCommitInfo(CDOCommitInfo commitInfo) throws IOException |
| { |
| out().writeCDOCommitInfo(commitInfo); |
| } |
| |
| public void writeCDOID(CDOID id) throws IOException |
| { |
| out().writeCDOID(id); |
| } |
| |
| public void writeCDOIDReference(CDOIDReference idReference) throws IOException |
| { |
| out().writeCDOIDReference(idReference); |
| } |
| |
| public void writeCDOIDAndVersion(CDOIDAndVersion idAndVersion) throws IOException |
| { |
| out().writeCDOIDAndVersion(idAndVersion); |
| } |
| |
| public void writeCDOIDAndBranch(CDOIDAndBranch idAndBranch) throws IOException |
| { |
| out().writeCDOIDAndBranch(idAndBranch); |
| } |
| |
| public void writeCDORevisionKey(CDORevisionKey revisionKey) throws IOException |
| { |
| out().writeCDORevisionKey(revisionKey); |
| } |
| |
| public void writeCDORevision(CDORevision revision, int referenceChunk) throws IOException |
| { |
| out().writeCDORevision(revision, referenceChunk); |
| } |
| |
| public void writeCDORevision(CDORevision revision, int referenceChunk, CDOBranchPoint securityContext) throws IOException |
| { |
| out().writeCDORevision(revision, referenceChunk, securityContext); |
| } |
| |
| public void writeCDORevisable(CDORevisable revisable) throws IOException |
| { |
| out().writeCDORevisable(revisable); |
| } |
| |
| public void writeCDOList(EClass owner, EStructuralFeature feature, CDOList list, int referenceChunk) throws IOException |
| { |
| out().writeCDOList(owner, feature, list, referenceChunk); |
| } |
| |
| public void writeCDOFeatureValue(EStructuralFeature feature, Object value) throws IOException |
| { |
| out().writeCDOFeatureValue(feature, value); |
| } |
| |
| public void writeCDORevisionDelta(CDORevisionDelta revisionDelta) throws IOException |
| { |
| out().writeCDORevisionDelta(revisionDelta); |
| } |
| |
| public void writeCDOFeatureDelta(EClass owner, CDOFeatureDelta featureDelta) throws IOException |
| { |
| out().writeCDOFeatureDelta(owner, featureDelta); |
| } |
| |
| public void writeCDORevisionOrPrimitive(Object value) throws IOException |
| { |
| out().writeCDORevisionOrPrimitive(value); |
| } |
| |
| public void writeCDORevisionOrPrimitiveOrClassifier(Object value) throws IOException |
| { |
| out().writeCDORevisionOrPrimitiveOrClassifier(value); |
| } |
| |
| public void writeCDOLockType(LockType lockType) throws IOException |
| { |
| out().writeCDOLockType(lockType); |
| } |
| |
| public void writeCDOLockChangeInfo(CDOLockChangeInfo lockChangeInfo) throws IOException |
| { |
| out().writeCDOLockChangeInfo(lockChangeInfo); |
| } |
| |
| public void writeCDOLockState(CDOLockState lockState) throws IOException |
| { |
| out().writeCDOLockState(lockState); |
| } |
| |
| public void writeCDOLockOwner(CDOLockOwner lockOwner) throws IOException |
| { |
| out().writeCDOLockOwner(lockOwner); |
| } |
| |
| public void writeCDOLockArea(LockArea lockArea) throws IOException |
| { |
| out().writeCDOLockArea(lockArea); |
| } |
| |
| public int write(long startPointer, LissomeFileOperation operation) |
| { |
| try |
| { |
| seek(startPointer); |
| operation.execute(this); |
| flush(); |
| |
| long endPointer = getFilePointer(); |
| return (int)(endPointer - startPointer); |
| } |
| catch (IOException ex) |
| { |
| throw new IORuntimeException(ex); |
| } |
| } |
| |
| public long append(LissomeFileOperation operation) |
| { |
| try |
| { |
| long startPointer = length(); |
| write(startPointer, operation); |
| return startPointer; |
| } |
| catch (IOException ex) |
| { |
| throw new IORuntimeException(ex); |
| } |
| } |
| } |