1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
|
/*******************************************************************************
* Copyright (c) 2004, 2007 Boeing.
* 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:
* Boeing - initial API and implementation
*******************************************************************************/
package org.eclipse.osee.framework.skynet.core.artifact;
import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
import java.util.Set;
import org.eclipse.osee.framework.core.data.IArtifactType;
import org.eclipse.osee.framework.core.data.IOseeBranch;
import org.eclipse.osee.framework.core.enums.ModificationType;
import org.eclipse.osee.framework.core.model.Branch;
import org.eclipse.osee.framework.core.model.type.ArtifactType;
import org.eclipse.osee.framework.core.util.Conditions;
import org.eclipse.osee.framework.database.core.ConnectionHandler;
import org.eclipse.osee.framework.jdk.core.type.OseeCoreException;
import org.eclipse.osee.framework.jdk.core.util.GUID;
import org.eclipse.osee.framework.jdk.core.util.Strings;
/**
* @author Ryan D. Brooks
* @author Donald G. Dunne
*/
public abstract class ArtifactFactory {
private final Set<IArtifactType> artifactTypeNames = new HashSet<IArtifactType>(5);
protected ArtifactFactory(IArtifactType... artifactTypes) {
for (IArtifactType artifactType : artifactTypes) {
registerAsResponsible(artifactType);
}
}
public Artifact makeNewArtifact(IOseeBranch branch, IArtifactType artifactTypeToken, String guid) throws OseeCoreException {
return makeNewArtifact(branch, artifactTypeToken, null, guid);
}
/**
* Used to create a new artifact (one that has never been saved into the datastore)
*/
public Artifact makeNewArtifact(IOseeBranch branch, IArtifactType artifactTypeToken, String artifactName, String guid) throws OseeCoreException {
ArtifactType artifactType = ArtifactTypeManager.getType(artifactTypeToken);
Conditions.checkExpressionFailOnTrue(artifactType.isAbstract(),
"Cannot create an instance of abstract type [%s]", artifactType);
if (guid == null) {
guid = GUID.create();
} else {
Conditions.checkExpressionFailOnTrue(!GUID.isValid(guid),
"Invalid guid [%s] during artifact creation [name: %s]", guid, artifactName);
}
Artifact artifact = getArtifactInstance(guid, BranchManager.getBranch(branch), artifactType, false);
artifact.setArtId(ConnectionHandler.getSequence().getNextArtifactId());
artifact.meetMinimumAttributeCounts(true);
ArtifactCache.cache(artifact);
artifact.setLinksLoaded(true);
if (Strings.isValid(artifactName)) {
artifact.setName(artifactName);
}
return artifact;
}
public synchronized Artifact reflectExisitingArtifact(int artId, String guid, IArtifactType artifactType, int gammaId, IOseeBranch branch, ModificationType modificationType) throws OseeCoreException {
Artifact toReturn =
internalExistingArtifact(artId, guid, artifactType, gammaId, branch, modificationType, false,
Artifact.TRANSACTION_SENTINEL, true);
ArtifactCache.cache(toReturn);
return toReturn;
}
/**
* This method does not cache the artifact, ArtifactLoader will cache existing artifacts
*/
private Artifact internalExistingArtifact(int artId, String guid, IArtifactType artifactType, int gammaId, IOseeBranch branch, ModificationType modType, boolean historical, int transactionId, boolean useBackingData) throws OseeCoreException {
Artifact artifact = getArtifactInstance(guid, BranchManager.getBranch(branch), artifactType, true);
artifact.setArtId(artId);
artifact.internalSetPersistenceData(gammaId, transactionId, modType, historical, useBackingData);
return artifact;
}
/**
* This method does not cache the artifact, ArtifactLoader will cache existing artifacts
*/
public synchronized Artifact loadExisitingArtifact(int artId, String guid, IArtifactType artifactType, int gammaId, Branch branch, int transactionId, ModificationType modType, boolean historical) throws OseeCoreException {
return internalExistingArtifact(artId, guid, artifactType, gammaId, branch, modType, historical, transactionId,
false);
}
/**
* Request the factory to create a new instance of the type. The implementation of this method should not result in a
* call to the persistence manager to acquire the <code>Artifact</code> or else an infinite loop will occur since
* this method is used by the persistence manager when it needs a new instance of the class to work with and can not
* come up with it on its own.
*
* @param branch branch on which this instance of this artifact will be associated
* @param hrid
*/
protected abstract Artifact getArtifactInstance(String guid, Branch branch, IArtifactType artifactType, boolean inDataStore) throws OseeCoreException;
@Override
public String toString() {
return getClass().getName();
}
/**
* Return true if this artifact factory is responsible for creating artifactType.
*/
public boolean isResponsibleFor(IArtifactType artifactType) {
return artifactTypeNames.contains(artifactType);
}
protected void registerAsResponsible(IArtifactType artifactType) {
if (!artifactTypeNames.contains(artifactType)) {
artifactTypeNames.add(artifactType);
}
}
/**
* Return any artifact types of artifacts that should never be garbage collected. This includes artifacts like user
* artifacts and config artifacts that should always stay loaded for performance reasons.
*/
public Collection<IArtifactType> getEternalArtifactTypes() {
return Collections.emptyList();
}
}
|
