package org.infinispan.notifications.cachelistener.event.impl;
import java.util.Collection;
import java.util.Collections;
import java.util.Map;
import org.infinispan.Cache;
import org.infinispan.commons.util.Util;
import org.infinispan.distribution.ch.ConsistentHash;
import org.infinispan.metadata.Metadata;
import org.infinispan.notifications.cachelistener.event.CacheEntriesEvictedEvent;
import org.infinispan.notifications.cachelistener.event.CacheEntryActivatedEvent;
import org.infinispan.notifications.cachelistener.event.CacheEntryCreatedEvent;
import org.infinispan.notifications.cachelistener.event.CacheEntryExpiredEvent;
import org.infinispan.notifications.cachelistener.event.CacheEntryInvalidatedEvent;
import org.infinispan.notifications.cachelistener.event.CacheEntryLoadedEvent;
import org.infinispan.notifications.cachelistener.event.CacheEntryModifiedEvent;
import org.infinispan.notifications.cachelistener.event.CacheEntryPassivatedEvent;
import org.infinispan.notifications.cachelistener.event.CacheEntryRemovedEvent;
import org.infinispan.notifications.cachelistener.event.CacheEntryVisitedEvent;
import org.infinispan.notifications.cachelistener.event.DataRehashedEvent;
import org.infinispan.notifications.cachelistener.event.PartitionStatusChangedEvent;
import org.infinispan.notifications.cachelistener.event.TopologyChangedEvent;
import org.infinispan.notifications.cachelistener.event.TransactionCompletedEvent;
import org.infinispan.notifications.cachelistener.event.TransactionRegisteredEvent;
import org.infinispan.partitionhandling.AvailabilityMode;
import org.infinispan.remoting.transport.Address;
import org.infinispan.transaction.xa.GlobalTransaction;
import net.jcip.annotations.NotThreadSafe;
/**
* Basic implementation of an event that covers all event types.
*
* @author Manik Surtani
* @since 4.0
*/
@NotThreadSafe
public class EventImpl<K, V> implements CacheEntryActivatedEvent, CacheEntryCreatedEvent, CacheEntriesEvictedEvent, CacheEntryLoadedEvent, CacheEntryModifiedEvent,
CacheEntryPassivatedEvent, CacheEntryRemovedEvent, CacheEntryVisitedEvent, TransactionCompletedEvent, TransactionRegisteredEvent,
CacheEntryInvalidatedEvent, DataRehashedEvent, TopologyChangedEvent, CacheEntryExpiredEvent, PartitionStatusChangedEvent, Cloneable {
private boolean pre = false; // by default events are after the fact
private transient Cache<K, V> cache;
private K key;
private GlobalTransaction transaction;
private Metadata metadata;
private Metadata oldMetadata;
private boolean originLocal = true; // by default events all originate locally
private boolean transactionSuccessful;
private Type type;
private V value;
private V oldValue;
private ConsistentHash readConsistentHashAtStart, writeConsistentHashAtStart, readConsistentHashAtEnd, writeConsistentHashAtEnd, unionConsistentHash;
private int newTopologyId;
private Map<? extends K, ? extends V> entries;
private boolean created;
private boolean commandRetried;
private AvailabilityMode mode;
public EventImpl() {
}
public static <K, V> EventImpl<K, V> createEvent(Cache<K, V> cache, Type type) {
EventImpl<K, V> e = new EventImpl<K,V>();
e.cache = cache;
e.type = type;
return e;
}
@Override
public Type getType() {
return type;
}
@Override
public boolean isPre() {
return pre;
}
@Override
public Cache<K, V> getCache() {
return cache;
}
@Override
@SuppressWarnings("unchecked")
public K getKey() {
// if (key instanceof MarshalledValue)
// key = (K) ((MarshalledValue) key).get();
return key;
}
@Override
public GlobalTransaction getGlobalTransaction() {
return this.transaction;
}
@Override
public boolean isOriginLocal() {
return originLocal;
}
@Override
public boolean isTransactionSuccessful() {
return transactionSuccessful;
}
// ------------------------------ setters -----------------------------
public void setPre(boolean pre) {
this.pre = pre;
}
public void setKey(K key) {
this.key = key;
}
public void setTransactionId(GlobalTransaction transaction) {
this.transaction = transaction;
}
public void setOriginLocal(boolean originLocal) {
this.originLocal = originLocal;
}
public void setTransactionSuccessful(boolean transactionSuccessful) {
this.transactionSuccessful = transactionSuccessful;
}
public void setReadConsistentHashAtStart(ConsistentHash readConsistentHashAtStart) {
this.readConsistentHashAtStart = readConsistentHashAtStart;
}
public void setWriteConsistentHashAtStart(ConsistentHash writeConsistentHashAtStart) {
this.writeConsistentHashAtStart = writeConsistentHashAtStart;
}
public void setReadConsistentHashAtEnd(ConsistentHash readConsistentHashAtEnd) {
this.readConsistentHashAtEnd = readConsistentHashAtEnd;
}
public void setWriteConsistentHashAtEnd(ConsistentHash writeConsistentHashAtEnd) {
this.writeConsistentHashAtEnd = writeConsistentHashAtEnd;
}
public void setUnionConsistentHash(ConsistentHash unionConsistentHash) {
this.unionConsistentHash = unionConsistentHash;
}
public void setNewTopologyId(int newTopologyId) {
this.newTopologyId = newTopologyId;
}
public void setMetadata(Metadata metadata) {
this.metadata = metadata;
}
@Override
public Metadata getMetadata() {
return metadata;
}
public void setOldMetadata(Metadata metadata) {
this.oldMetadata = metadata;
}
public Metadata getOldMetadata() {
return oldMetadata;
}
@Override
@SuppressWarnings("unchecked")
public V getValue() {
// if (value instanceof MarshalledValue)
// value = (V) ((MarshalledValue) value).get();
return value;
}
public void setCommandRetried(boolean commandRetried) {
this.commandRetried = commandRetried;
}
@Override
public boolean isCommandRetried() {
return commandRetried;
}
@Override
public boolean isCreated() {
return created;
}
@Override
public V getOldValue() {
return oldValue;
}
public void setValue(V value) {
this.value = value;
}
public void setEntries(Map<? extends K, ? extends V> entries) {
this.entries = entries;
}
public void setCreated(boolean created) {
this.created = created;
}
public void setOldValue(V oldValue) {
this.oldValue = oldValue;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
EventImpl<?, ?> event = (EventImpl<?, ?>) o;
if (originLocal != event.originLocal) return false;
if (pre != event.pre) return false;
if (transactionSuccessful != event.transactionSuccessful) return false;
if (cache != null ? !cache.equals(event.cache) : event.cache != null) return false;
if (key != null ? !key.equals(event.key) : event.key != null) return false;
if (transaction != null ? !transaction.equals(event.transaction) : event.transaction != null) return false;
if (type != event.type) return false;
if (value != null ? !value.equals(event.value) : event.value != null) return false;
if (!Util.safeEquals(readConsistentHashAtStart, event.readConsistentHashAtStart)) return false;
if (!Util.safeEquals(writeConsistentHashAtStart, event.writeConsistentHashAtStart)) return false;
if (!Util.safeEquals(readConsistentHashAtEnd, event.readConsistentHashAtEnd)) return false;
if (!Util.safeEquals(writeConsistentHashAtEnd, event.writeConsistentHashAtEnd)) return false;
if (!Util.safeEquals(unionConsistentHash, event.unionConsistentHash)) return false;
if (newTopologyId != event.newTopologyId) return false;
if (created != event.created) return false;
if (oldValue != null ? !oldValue.equals(event.oldValue) : event.oldValue != null) return false;
return true;
}
@Override
public int hashCode() {
int result = (pre ? 1 : 0);
result = 31 * result + (cache != null ? cache.hashCode() : 0);
result = 31 * result + (key != null ? key.hashCode() : 0);
result = 31 * result + (transaction != null ? transaction.hashCode() : 0);
result = 31 * result + (originLocal ? 1 : 0);
result = 31 * result + (transactionSuccessful ? 1 : 0);
result = 31 * result + (type != null ? type.hashCode() : 0);
result = 31 * result + (value != null ? value.hashCode() : 0);
result = 31 * result + (readConsistentHashAtStart != null ? readConsistentHashAtStart.hashCode() : 0);
result = 31 * result + (writeConsistentHashAtStart != null ? writeConsistentHashAtStart.hashCode() : 0);
result = 31 * result + (readConsistentHashAtEnd != null ? readConsistentHashAtEnd.hashCode() : 0);
result = 31 * result + (writeConsistentHashAtEnd != null ? writeConsistentHashAtEnd.hashCode() : 0);
result = 31 * result + (unionConsistentHash != null ? unionConsistentHash.hashCode() : 0);
result = 31 * result + newTopologyId;
result = 31 * result + (created ? 1 : 0);
result = 31 * result + (oldValue != null ? oldValue.hashCode() : 0);
return result;
}
@Override
public String toString() {
if (type == Type.TOPOLOGY_CHANGED || type == Type.DATA_REHASHED)
return "EventImpl{" +
"type=" + type +
", pre=" + pre +
", cache=" + cache +
", readConsistentHashAtStart=" + readConsistentHashAtStart +
", writeConsistentHashAtStart=" + writeConsistentHashAtStart +
", readConsistentHashAtEnd=" + readConsistentHashAtEnd +
", writeConsistentHashAtEnd=" + writeConsistentHashAtEnd +
", unionConsistentHash=" + unionConsistentHash +
", newTopologyId=" + newTopologyId +
'}';
return "EventImpl{" +
"type=" + type +
", pre=" + pre +
", cache=" + cache +
", key=" + key +
", value=" + value +
", oldValue=" + oldValue +
", transaction=" + transaction +
", originLocal=" + originLocal +
", transactionSuccessful=" + transactionSuccessful +
", entries=" + entries +
", created=" + created +
'}';
}
@Override
public Collection<Address> getMembersAtStart() {
return readConsistentHashAtStart != null ? readConsistentHashAtStart.getMembers() : Collections.<Address>emptySet();
}
@Override
public Collection<Address> getMembersAtEnd() {
return readConsistentHashAtEnd != null ? readConsistentHashAtEnd.getMembers() : Collections.<Address>emptySet();
}
@Override
public ConsistentHash getConsistentHashAtStart() {
return readConsistentHashAtStart;
}
@Override
public ConsistentHash getConsistentHashAtEnd() {
return writeConsistentHashAtEnd;
}
@Override
public ConsistentHash getReadConsistentHashAtStart() {
return readConsistentHashAtStart;
}
@Override
public ConsistentHash getWriteConsistentHashAtStart() {
return writeConsistentHashAtStart;
}
@Override
public ConsistentHash getReadConsistentHashAtEnd() {
return readConsistentHashAtEnd;
}
@Override
public ConsistentHash getWriteConsistentHashAtEnd() {
return writeConsistentHashAtEnd;
}
@Override
public ConsistentHash getUnionConsistentHash() {
return unionConsistentHash;
}
@Override
public int getNewTopologyId() {
return newTopologyId;
}
@Override
public AvailabilityMode getAvailabilityMode() {
return mode;
}
public void setAvailabilityMode(AvailabilityMode mode) {
this.mode = mode;
}
@Override
public Map<? extends K, ? extends V> getEntries() {
return entries;
}
@Override
public EventImpl<K, V> clone() {
try {
return (EventImpl<K, V>) super.clone();
} catch (CloneNotSupportedException e) {
throw new RuntimeException("Should never happen!", e);
}
}
}