/** * Factory method for path query. Getting all changes from source to target. * * @param source source version * @param target target version * @param allVersions include all versions, from all branches * @param includeCp include changepackages * @return query */ public static PathQuery pathQuery( PrimaryVersionSpec source, PrimaryVersionSpec target, boolean allVersions, boolean includeCp) { final PathQuery query = VersioningFactory.eINSTANCE.createPathQuery(); query.setSource(ModelUtil.clone(source)); query.setTarget(ModelUtil.clone(target)); query.setIncludeAllVersions(allVersions); query.setIncludeChangePackages(includeCp); return query; }
private BranchInfo createNewBranch( ProjectHistory projectHistory, PrimaryVersionSpec baseSpec, PrimaryVersionSpec primarySpec, BranchVersionSpec branch) { primarySpec.setBranch(branch.getBranch()); final BranchInfo branchInfo = VersioningFactory.eINSTANCE.createBranchInfo(); branchInfo.setName(branch.getBranch()); branchInfo.setSource(ModelUtil.clone(baseSpec)); branchInfo.setHead(ModelUtil.clone(primarySpec)); projectHistory.getBranches().add(branchInfo); return branchInfo; }
/** * Returns all branches for the project with the given ID. * * @param projectId the ID of a project * @return a list containing information about each branch * @throws ESException in case of failure */ @ESMethod(MethodId.GETBRANCHES) public List<BranchInfo> getBranches(ProjectId projectId) throws ESException { synchronized (getMonitor()) { final ProjectHistory projectHistory = getSubInterface(ProjectSubInterfaceImpl.class).getProject(projectId); final ArrayList<BranchInfo> result = new ArrayList<BranchInfo>(); for (final BranchInfo branch : projectHistory.getBranches()) { result.add(ModelUtil.clone(branch)); } return result; } }
private PrimaryVersionSpec resolveTagVersionSpec( ProjectHistory projectHistory, TagVersionSpec versionSpec) throws InvalidVersionSpecException { for (final Version version : projectHistory.getVersions()) { for (final TagVersionSpec tag : version.getTagSpecs()) { if (versionSpec.equals(tag)) { return ModelUtil.clone(version.getPrimarySpec()); } } } throw new InvalidVersionSpecException(Messages.VersionSubInterfaceImpl_TagVersionNotFound); }
/** * Factory method for modelelements range queries. * * @param source source version * @param modelElements modelelements * @param upper upper limit * @param lower lower limit * @param allVersions include all versions, from all branches * @param includeCp include change packages * @return query */ public static ModelElementQuery modelelementQuery( PrimaryVersionSpec source, List<ModelElementId> modelElements, int upper, int lower, boolean allVersions, boolean includeCp) { final ModelElementQuery query = VersioningFactory.eINSTANCE.createModelElementQuery(); query.setSource(ModelUtil.clone(source)); query.getModelElements().addAll(modelElements); query.setUpperLimit(upper); query.setLowerLimit(lower); query.setIncludeAllVersions(allVersions); query.setIncludeChangePackages(includeCp); query.setIncludeIncoming(false); query.setIncludeOutgoing(false); return query; }
/** * Factory method for range query. * * @param source source version * @param upper upper limit * @param lower lower limit * @param allVersions include all versions, from all branches * @param incoming include incoming versions, only if allVersions is false * @param outgoing include outgoing versions * @param includeCp include changepackges * @return query */ public static RangeQuery<?> rangeQuery( PrimaryVersionSpec source, int upper, int lower, boolean allVersions, boolean incoming, boolean outgoing, boolean includeCp) { final RangeQuery<?> query = VersioningFactory.eINSTANCE.createRangeQuery(); query.setSource(ModelUtil.clone(source)); query.setUpperLimit(upper); query.setLowerLimit(lower); query.setIncludeAllVersions(allVersions); query.setIncludeIncoming(incoming); query.setIncludeOutgoing(outgoing); query.setIncludeChangePackages(includeCp); return query; }
private Version performRegularCommit( PrimaryVersionSpec baseVersionSpec, LogMessage logMessage, final ACUser user, final ProjectHistory projectHistory, final BranchInfo baseBranch, final Version baseVersion, final Project newProjectState) throws ESUpdateRequiredException, ESException { Version newVersion; // If branch is null or branch equals base branch, create new // version for specific branch if (!baseVersionSpec.equals(isHeadOfBranch(projectHistory, baseVersion.getPrimarySpec()))) { throw new ESUpdateRequiredException(); } newVersion = createVersion(projectHistory, newProjectState, logMessage, user, baseVersion); newVersion.setPreviousVersion(baseVersion); baseBranch.setHead(ModelUtil.clone(newVersion.getPrimarySpec())); return newVersion; }
private void rollback( final ProjectHistory projectHistory, final BranchInfo baseBranch, final Version baseVersion, Version newVersion, BranchInfo newBranch, final FatalESException e) throws StorageException { projectHistory.getVersions().remove(newVersion); if (newBranch == null) { // normal commit baseVersion.setNextVersion(null); baseBranch.setHead(ModelUtil.clone(baseVersion.getPrimarySpec())); } else { // branch commit baseVersion.getBranchedVersions().remove(newVersion); projectHistory.getBranches().remove(newBranch); } // TODO: delete obsolete project, change package and version files throw new StorageException(StorageException.NOSAVE, e); }
/** * Returns all changes within the specified version range for a given project. * * @param projectId the ID of a project * @param source the source version * @param target the target version (inclusive) * @return a list of change packages containing all the changes for the specified version range * @throws InvalidVersionSpecException if an invalid version has been specified * @throws ESException in case of failure */ @ESMethod(MethodId.GETCHANGES) public List<AbstractChangePackage> getChanges( ProjectId projectId, VersionSpec source, VersionSpec target) throws InvalidVersionSpecException, ESException { sanityCheckObjects(projectId, source, target); final PrimaryVersionSpec resolvedSource = resolveVersionSpec(projectId, source); final PrimaryVersionSpec resolvedTarget = resolveVersionSpec(projectId, target); // if target and source are equal return empty list if (resolvedSource.getIdentifier() == resolvedTarget.getIdentifier()) { return new ArrayList<AbstractChangePackage>(); } synchronized (getMonitor()) { final boolean updateForward = resolvedTarget.getIdentifier() > resolvedSource.getIdentifier(); // Example: if you want the changes to get from version 5 to 7, you // need the changes contained in version 6 // and 7. The reason is that each version holds the changes which // occurred from the predecessor to the // version itself. Version 5 holds the changes to get from version 4 // to 5 and therefore is irrelevant. // For that reason the first version is removed, since getVersions // always sorts ascending order. final List<Version> versions = getVersions(projectId, resolvedSource, resolvedTarget); if (versions.size() > 1) { versions.remove(0); } List<AbstractChangePackage> result = new ArrayList<AbstractChangePackage>(); for (final Version version : versions) { final AbstractChangePackage changes = version.getChanges(); if (changes != null) { changes.setLogMessage(ModelUtil.clone(version.getLogMessage())); result.add(changes); } } // if source is after target in time if (!updateForward) { // reverse list and change packages final List<AbstractChangePackage> resultReverse = new ArrayList<AbstractChangePackage>(); for (final AbstractChangePackage changePackage : result) { final ChangePackage changePackageReverse = VersioningFactory.eINSTANCE.createChangePackage(); final ESCloseableIterable<AbstractOperation> reversedOperations = changePackage.reversedOperations(); final ArrayList<AbstractOperation> copiedReversedOperations = new ArrayList<AbstractOperation>(); try { for (final AbstractOperation op : reversedOperations.iterable()) { copiedReversedOperations.add(op.reverse()); } } finally { reversedOperations.close(); } for (final AbstractOperation reversedOperation : copiedReversedOperations) { changePackageReverse.add(reversedOperation); } // copy again log message // reverse() created a new change package without copying // existent attributes changePackageReverse.setLogMessage(ModelUtil.clone(changePackage.getLogMessage())); resultReverse.add(changePackageReverse); } Collections.reverse(resultReverse); result = resultReverse; } return result; } }