@Override
protected final boolean makeCompetitionStart() {
if (!super.makeCompetitionStart()) {
return false;
}
Participant par;
for (int i = 0; i < _teamOneSize; i++) {
par = _teamOne[i];
if (par.getPlayer() == null) {
return false;
}
par.getPlayer().setIsOlympiadStart(true);
par.getPlayer().updateEffectIcons();
}
for (int i = 0; i < _teamTwoSize; i++) {
par = _teamTwo[i];
if (par.getPlayer() == null) {
return false;
}
par.getPlayer().setIsOlympiadStart(true);
par.getPlayer().updateEffectIcons();
}
return true;
}
public Set<Participant> getOrgGroupMembers(OrgGroup o) {
Set<Participant> result = new HashSet<Participant>();
for (Participant p : participantMap.values()) {
if (p.isOrgGroupMember(o)) result.add(p);
}
return result;
}
InvitationEntity(Invitation invitation)
{
zzFG = 2;
zzahV = new GameEntity(invitation.getGame());
zzaek = invitation.getInvitationId();
zzajw = invitation.getCreationTimestamp();
zzajx = invitation.getInvitationType();
zzajA = invitation.getVariant();
zzajB = invitation.getAvailableAutoMatchSlots();
String s = invitation.getInviter().getParticipantId();
Object obj = null;
ArrayList arraylist = invitation.getParticipants();
int j = arraylist.size();
zzajz = new ArrayList(j);
int i = 0;
invitation = obj;
for (; i < j; i++)
{
Participant participant = (Participant)arraylist.get(i);
if (participant.getParticipantId().equals(s))
{
invitation = participant;
}
zzajz.add((ParticipantEntity)participant.freeze());
}
zzx.zzb(invitation, "Must have a valid inviter!");
zzajy = (ParticipantEntity)invitation.freeze();
}
public String resolveParticipantIdsAsXML(String anyID) {
XNode node = new XNode("participantids");
for (Participant p : resolveParticipants(anyID)) {
node.addChild("id", p.getID());
}
return node.toString();
}
InvitationEntity(Invitation invitation)
{
xH = 2;
Lt = new GameEntity(invitation.getGame());
IV = invitation.getInvitationId();
Mu = invitation.getCreationTimestamp();
Mv = invitation.getInvitationType();
My = invitation.getVariant();
Mz = invitation.getAvailableAutoMatchSlots();
String s = invitation.getInviter().getParticipantId();
Object obj = null;
ArrayList arraylist = invitation.getParticipants();
int j = arraylist.size();
Mx = new ArrayList(j);
int i = 0;
invitation = obj;
for (; i < j; i++)
{
Participant participant = (Participant)arraylist.get(i);
if (participant.getParticipantId().equals(s))
{
invitation = participant;
}
Mx.add((ParticipantEntity)participant.freeze());
}
fq.b(invitation, "Must have a valid inviter!");
Mw = (ParticipantEntity)invitation.freeze();
}
public int compareTo(Participant<M, S> o) {
if (this.coefficient != null
&& o.getCoefficient() != null
&& this.coefficient instanceof Comparable) {
int coefComparison = ((Comparable) this.coefficient).compareTo(o.getCoefficient());
if (coefComparison != 0) {
return coefComparison;
}
}
if (o instanceof CompartmentalisedParticipant) {
CompartmentalisedParticipant co = (CompartmentalisedParticipant) o;
if (this.compartment != null
&& co.getCompartment() != null
&& this.compartment instanceof Comparable) {
int compComparison = ((Comparable) this.compartment).compareTo(co.getCompartment());
if (compComparison != 0) {
return compComparison;
}
}
}
if (this.molecule != null && o.getMolecule() != null && this.molecule instanceof Comparable) {
return ((Comparable) this.molecule).compareTo(o.getMolecule());
}
return 0;
}
public void testMultipleListenersOnSingleObserver() {
Participant one = new Participant("one");
Participant two = new Participant("two");
final Observer obsA = newObserver(one, InterfaceA.class);
final ObserverListener lisAone = new ObserverListener(one);
final ObserverListener lisAtwo = new ObserverListener(one);
obsA.registerListener(lisAone);
obsA.registerListener(lisAtwo);
lisAone.expectInvocations(2);
lisAtwo.expectInvocations(2);
two.createA(A);
two.createAB(AB);
two.registerObject(A);
two.registerObject(AB);
Lambda ok =
new Lambda() {
@Override
public boolean func() {
return lisAone.getCounter() == 0 && lisAtwo.getCounter() == 0;
}
};
boolean result = waitForLambda(3000, ok);
assertTrue("Count one = " + lisAone.getCounter() + ", two = " + lisAtwo.getCounter(), result);
}
protected OlympiadGameTeams(int id, Participant[] teamOne, Participant[] teamTwo) {
super(id);
_teamOneSize = Math.min(teamOne.length, MAX_TEAM_SIZE);
_teamTwoSize = Math.min(teamTwo.length, MAX_TEAM_SIZE);
_teamOne = new Participant[MAX_TEAM_SIZE];
_teamTwo = new Participant[MAX_TEAM_SIZE];
Participant par;
for (int i = 0; i < MAX_TEAM_SIZE; i++) {
if (i < _teamOneSize) {
par = teamOne[i];
_teamOne[i] = par;
if (par.getPlayer() != null) {
par.getPlayer().setOlympiadGameId(id);
}
} else {
_teamOne[i] = new Participant(IdFactory.getInstance().getNextId(), 1);
}
if (i < _teamTwoSize) {
par = teamTwo[i];
_teamTwo[i] = par;
if (par.getPlayer() != null) {
par.getPlayer().setOlympiadGameId(id);
}
} else {
_teamTwo[i] = new Participant(IdFactory.getInstance().getNextId(), 2);
}
}
}
public Set<String> resolveParticipantIds(String anyID) {
Set<String> idSet = new HashSet<String>();
for (Participant p : resolveParticipants(anyID)) {
idSet.add(p.getID());
}
return idSet;
}
public Participant getParticipant(String username) {
for (Participant p : participants) {
if (p.getEmployee().getUsername().equals(username)) {
return p;
}
}
return null;
}
public String getParticipantsAsXML() {
List<Participant> pList = sortFullParticipantListByName();
StringBuilder xml = new StringBuilder("<participants>");
for (Participant p : pList) xml.append(p.toXML());
xml.append("</participants>");
return xml.toString();
}
private void addParticipantToView(Participant participant) {
getView()
.addParticipant(
participant.getUserId(),
participant.getDisplayEmail(),
participant.getDisplayName(),
participant.getColor());
}
public Participant getParticipantFromUserID(String userID) {
for (Participant p : getParticipants()) {
if (p.getUserID().equals(userID)) {
return p;
}
}
return null;
}
// @return a csv listing of the full name of each participant
public String getParticipantNames() {
List<Participant> pList = sortFullParticipantListByName();
StringBuilder csvList = new StringBuilder();
for (Participant p : pList) {
if (csvList.length() > 0) csvList.append(",");
csvList.append(p.getFullName());
}
return csvList.toString();
}
@Override
protected final boolean haveWinner() {
if (!checkBattleStatus()) {
return true;
}
boolean teamOneLost = true;
boolean teamTwoLost = true;
Participant par;
for (int i = _teamOneSize; --i >= 0; ) {
par = _teamOne[i];
if (!par.isDisconnected()) {
if ((par.getPlayer() != null) && (par.getPlayer().getOlympiadGameId() == _stadiumID)) {
teamOneLost &= par.getPlayer().isDead();
}
}
}
for (int i = _teamTwoSize; --i >= 0; ) {
par = _teamTwo[i];
if (!par.isDisconnected()) {
if ((par.getPlayer() != null) && (par.getPlayer().getOlympiadGameId() == _stadiumID)) {
teamTwoLost &= par.getPlayer().isDead();
}
}
}
return teamOneLost || teamTwoLost;
}
private void waitForEvent(
ObserverListener listener, Participant provider, String name, boolean register) {
listener.expectInvocations(1);
if (register) {
provider.registerObject(name);
} else {
provider.unregisterObject(name);
}
Lambda ok = new SingleLambda(listener);
assertTrue(waitForLambda(WAIT_TIMEOUT, ok));
}
public static String getParticipantId(ArrayList<Participant> paramArrayList, String paramString) {
int j = paramArrayList.size();
int i = 0;
while (i < j) {
Participant localParticipant = (Participant) paramArrayList.get(i);
Player localPlayer = localParticipant.getPlayer();
if ((localPlayer != null) && (localPlayer.getPlayerId().equals(paramString))) {
return localParticipant.getParticipantId();
}
i += 1;
}
return null;
}
public Map<ParticipantRole, Integer> getRoleCount() {
final Map<ParticipantRole, Integer> retVal = new HashMap<ParticipantRole, Integer>();
for (Participant p : this) {
Integer rc = retVal.get(p.getRole());
if (rc == null) {
rc = 0;
}
rc++;
retVal.put(p.getRole(), rc);
}
return retVal;
}
private synchronized void disconnectResources(AbstractResourceAttribute attrib) {
Set<AbstractResource> resources = attrib.getResources();
// get ids to avoid ConcurrentModificationException
List<String> ids = new ArrayList<String>();
for (AbstractResource resource : resources) ids.add(resource.getID());
for (String id : ids) {
Participant p = getParticipant(id);
if (attrib instanceof Role) p.removeRole((Role) attrib);
else if (attrib instanceof Capability) p.removeCapability((Capability) attrib);
else if (attrib instanceof Position) p.removePosition((Position) attrib);
updateParticipant(p);
}
}
public String listeDesParticipants() {
if (unSeulParticipant != null) {
return unSeulParticipant.toString();
} else {
return "aucun participant affecté à ce cours";
}
}
/*
* (non-Javadoc)
*
* @see ca.unb.cs.pcsf.db.DBAccessService#deleteCollaboration(ca.unb.cs.pcsf.db.Collaboration)
*/
public void deleteCollaboration(Collaboration collaboration) {
logger.debug(LOGPRE + "deleteCollaboration() start" + LOGPRE);
if (isCollaborationExist(collaboration.getName())) {
logger.info("Deleting participants...");
List<Participant> participants = collaboration.getParticipants();
for (Participant p : participants) {
sdb.deleteAttributes(new DeleteAttributesRequest(DOMAIN_PARTICIPANT, p.getId()));
}
sdb.deleteAttributes(
new DeleteAttributesRequest(DOMAIN_COLLABORATION, collaboration.getId()));
logger.info("Delete Done!");
logger.debug(LOGPRE + "deleteCollaboration() end" + LOGPRE);
}
}
@Override
public void tearDown() throws Exception {
for (Observer observer : observers) {
observer.close();
}
for (Participant participant : participants) {
participant.stop();
}
participants.clear();
assertFalse(failure);
System.gc();
System.gc();
System.runFinalization();
System.runFinalization();
Thread.sleep(100);
}
/** ********************************* */
public String addParticipant(Participant p) {
if (isDataEditable(ResUnit.Participant)) {
String newID = getDataSource(ResUnit.Participant).insert(p);
if (!hasDefaultDataSource(ResUnit.Participant)) p.setID(newID);
putParticipant(p); // add it to the data set
return newID;
} else return fail("External Participant dataset is read-only");
}
public void testGetFirstNext() {
Participant consumer = new Participant("one");
Participant provider = new Participant("two");
final Observer obs = newObserver(consumer, InterfaceA.class);
final ObserverListener listener = new ObserverListener(consumer);
obs.registerListener(listener);
assertNull(obs.getFirst());
assertNull(obs.getNext(null));
ArrayList<ProxyBusObject> objects = null;
String[] names = new String[] {A, AB, B, C};
for (int i = 0; i < names.length; ) {
provider.createA(names[i]);
waitForEvent(listener, provider, names[i]);
objects = checkObjects(++i, obs);
}
assertNotNull(objects);
ProxyBusObject obj = objects.get(1);
unregisterObject(provider, obj, listener);
assertSame(objects.get(2), obs.getNext(obj));
assertSame(objects.get(2), obs.getNext(objects.get(0)));
objects = checkObjects(3, obs);
assertFalse(objects.contains(obj));
obj = objects.get(2);
unregisterObject(provider, obj, listener);
assertNull(obs.getNext(obj));
assertNull(obs.getNext(objects.get(1)));
objects = checkObjects(2, obs);
assertFalse(objects.contains(obj));
obj = objects.get(0);
unregisterObject(provider, obj, listener);
assertSame(objects.get(1), obs.getNext(obj));
assertSame(objects.get(1), obs.getFirst());
objects = checkObjects(1, obs);
assertFalse(objects.contains(obj));
obj = objects.get(0);
unregisterObject(provider, obj, listener);
assertNull(obs.getNext(obj));
assertNull(obs.getFirst());
}
/** ********************************* */
public synchronized boolean removeParticipant(Participant p) {
boolean editable = isDataEditable(ResUnit.Participant);
if (editable) {
p.removeAttributeReferences();
getDataSource(ResUnit.Participant).delete(p);
delParticipant(p);
}
return editable;
}
public void testExceptionInListener() {
Participant consumer = new Participant("one");
Participant provider = new Participant("two");
final Observer obs = newObserver(consumer, InterfaceA.class);
final ObserverListener listener = new ObserverListener(consumer);
final ObserverListener lateJoiner = new ObserverListener(consumer);
final Observer.Listener badListener =
new Observer.Listener() {
@Override
public void objectLost(ProxyBusObject object) {
exceptionCount.incrementAndGet();
throw new RuntimeException();
}
@Override
public void objectDiscovered(ProxyBusObject object) {
exceptionCount.incrementAndGet();
throw new RuntimeException();
}
};
obs.registerListener(badListener);
obs.registerListener(listener);
provider.createA(A);
waitForEvent(listener, provider, A);
obs.registerListener(badListener, false);
obs.registerListener(badListener, true);
lateJoiner.expectInvocations(1);
obs.registerListener(lateJoiner, true);
waitForLambda(WAIT_TIMEOUT, new SingleLambda(lateJoiner));
waitForEvent(listener, provider, A, false);
assertTrue(
waitForLambda(
WAIT_TIMEOUT,
new Lambda() {
@Override
public boolean func() {
return 5 == exceptionCount.get();
}
}));
assertEquals(5, exceptionCount.get());
}
public void testListenTwiceOnSameObserver() throws Exception {
/* reuse the same listener for two observers */
Participant provider = new Participant("prov");
Participant consumer = new Participant("cons");
provider.createA(A);
final ObserverListener listener = new ObserverListener(consumer);
final Observer obs = newObserver(consumer, InterfaceA.class);
obs.registerListener(listener);
Lambda ok = new SingleLambda(listener);
/*
* use listener twice on observer, so we expect to see all events twice
*/
listener.expectInvocations(1);
provider.registerObject(A);
assertTrue(waitForLambda(3000, ok));
/*
* one observer is gone, so we expect to see every event just once.
*/
listener.allowDuplicates = true;
listener.expectInvocations(1);
obs.registerListener(listener, true);
boolean result = waitForLambda(3000, ok);
assertTrue("Counter value = " + listener.getCounter(), result);
listener.expectInvocations(2);
provider.createAB(AB);
provider.registerObject(AB);
result = waitForLambda(3000, ok);
assertTrue("Counter value = " + listener.getCounter(), result);
obs.unregisterListener(listener);
listener.expectInvocations(1);
provider.unregisterObject(AB);
assertTrue(waitForLambda(3000, ok));
obs.unregisterListener(listener);
provider.unregisterObject(A);
Thread.sleep(100);
listener.expectInvocations(0);
obs.unregisterListener(listener); // the listener is not registered
// anymore, but this should work.
obs.unregisterListener(null); // Does nothing sensible, but should not
// trigger an exception.
obs.registerListener(listener);
obs.registerListener(new ObserverListener(consumer));
// We should be able to unregisterAll multiple times
obs.unregisterAllListeners();
obs.unregisterAllListeners();
obs.unregisterAllListeners();
obs.unregisterAllListeners();
obs.unregisterAllListeners();
}
@Override
protected final void handleDisconnect(L2PcInstance player) {
Participant par;
for (int i = _teamOneSize; --i >= 0; ) {
par = _teamOne[i];
if (par.getObjectId() == player.getObjectId()) {
par.setDisconnected(true);
return;
}
}
for (int i = _teamTwoSize; --i >= 0; ) {
par = _teamTwo[i];
if (par.getObjectId() == player.getObjectId()) {
par.setDisconnected(true);
return;
}
}
}
public String toString() {
SimpleDateFormat sdf = new SimpleDateFormat("dd/MM/yyyy");
StringBuilder sb = new StringBuilder("=>").append(intituleCours).append(" le");
sb.append(sdf.format(getDateCours())).append(" a ").append(heureCours).append("h - maximum\n");
sb.append("Moniteur : ").append(leMoniteur.toString()).append("\n");
// if (unSeulParticipant != null) {
// sb.append("Participant : ").append(unSeulParticipant.toString()).append("\n");
// }
return sb.toString();
}
@Override
protected final void portPlayersBack() {
Participant par;
for (int i = _teamOneSize; --i >= 0; ) {
par = _teamOne[i];
if ((par.getPlayer() != null) && !par.isDefaulted() && !par.isDisconnected()) {
portPlayerBack(par.getPlayer());
}
}
for (int i = _teamTwoSize; --i >= 0; ) {
par = _teamTwo[i];
if ((par.getPlayer() != null) && !par.isDefaulted() && !par.isDisconnected()) {
portPlayerBack(par.getPlayer());
}
}
}
