Order cannot be cast to com.tangosol.util.MapEvent

Question

This code is causing an exception. How should I be writing this filter? I want to listen for events when the status changes for one specific Order object. That Order has an integer key property which is the same integer key value used to store it in the cache. The code causing the exception is:
    public void addStatusChangeListener() {
            Filter f1 = new ValueChangeEventFilter("OrderStatus");
            Filter f2 = new EqualsFilter("Key", this.getKey());
            Filter f3 = new AndFilter(f1,f2);
            Filter statusChangeFilter = new MapEventFilter(MapEventFilter.E_UPDATED, f3);
            System.out.println("ADD STATUS CHANGE LISTENER "+this.symbol+" "+this.getKey());
            this.getCache().addMapListener(this , statusChangeFilter, false);
2009-09-18 10:52:54.796/238.692 Oracle Coherence GE 3.5/459 <Error> (thread=DistributedCache, member=1):
Exception occured during filter evaluation: MapEventFilter(mask=UPDATED, filter=
AndFilter(ValueChangeEventFilter(extractor=.OrderStatus()), EqualsFilter(.Key(), 189000006))); removing the filter...
2009-09-18 10:52:54.796/238.692 Oracle Coherence GE 3.5/459 <Error> (thread=DistributedCache, member=1):
java.lang.ClassCastException: oms.Order cannot be cast to com.tangosol.util.MapEvent
        at com.tangosol.util.filter.ValueChangeEventFilter.evaluate(ValueChangeEventFilter.java:69)
        at com.tangosol.util.filter.AllFilter.evaluate(AllFilter.java:56)
        at com.tangosol.util.filter.MapEventFilter.evaluate(MapEventFilter.java:178)
        at com.tangosol.coherence.component.util.daemon.queueProcessor.service.grid.DistributedCache$Storage.prepareDispatch(DistributedCache.CDB:82)
        at com.tangosol.coherence.component.util.daemon.queueProcessor.service.grid.DistributedCache$Storage.postInvoke(DistributedCache.CDB:10)
        at com.tangosol.coherence.component.util.daemon.queueProcessor.service.grid.DistributedCache$Storage.invoke(DistributedCache.CDB:117)
        at com.tangosol.coherence.component.util.daemon.queueProcessor.service.grid.DistributedCache.onInvokeRequest(DistributedCache.CDB:50)
        at com.tangosol.coherence.component.util.daemon.queueProcessor.service.grid.DistributedCache$InvokeRequest.run(DistributedCache.CDB:1)
        at com.tangosol.coherence.component.net.message.requestMessage.DistributedCacheKeyRequest.onReceived(DistributedCacheKeyRequest.CDB:12)
        at com.tangosol.coherence.component.util.daemon.queueProcessor.service.Grid.onMessage(Grid.CDB:9)
        at com.tangosol.coherence.component.util.daemon.queueProcessor.service.Grid.onNotify(Grid.CDB:136)
        at com.tangosol.coherence.component.util.daemon.queueProcessor.service.grid.DistributedCache.onNotify(DistributedCache.CDB:3)
        at com.tangosol.coherence.component.util.Daemon.run(Daemon.CDB:37)
        at java.lang.Thread.run(Thread.java:619)Thanks,
Andrew

Answer 1

Ok, but isn't it just something wrong with how I wrote/used that filter?
-Andrew
public class Order implements Cloneable, Comparable, java.io.Serializable, MapListener {
    private String symbol = null;
    private OrderStatus orderStatus = OrderStatus.PENDING_NEW;
    private int id = 0; // java int max = 2,147,483,647
    private transient ArrayList<OrderStatusChangeListener> statusChangeListeners = new ArrayList<OrderStatusChangeListener>();
    public static NamedCache getCache() {
        if (cache == null) {
            System.out.println("Order...CacheFactory.getCache(\"orders\")");
            cache = CacheFactory.getCache("orders");
        return cache;
    public void send() {
        getCache().put(this.id, this);
    public static int sendMultiple(Iterable<Order> orders){
        int counter=0;
        HashMap m = new HashMap();
        for (Order o:orders){
            m.put(o.getKey(),o);
            counter++;
        getCache().putAll(m);
        return counter;
    public static class CancelProcessor extends AbstractProcessor {
        public Object process(InvocableMap.Entry entry) {
            Order o = (Order)entry.getValue();
            if (o.cancelCount == 0) {
                o.cancelCount = 1;
            } else {
                logger.info("ignoring dup. cancel req on " + o.symbol + " id=" + o.id);
            return o.cancelCount;
    public void cancel() {
        Filter f = new EqualsFilter("getCancelCount", 0);
        UpdaterProcessor up1 = new UpdaterProcessor("setCancelCount", new Integer(1));
        UpdaterProcessor up2 = new UpdaterProcessor("setCancelSubmittedTime", Base.getSafeTimeMillis() );
        CompositeProcessor cp = new CompositeProcessor(new InvocableMap.EntryProcessor[] {up1,up2});
        ConditionalProcessor x = new ConditionalProcessor(f, cp);
        getCache().invoke(key, x);
    private static NumberIncrementor ni1 = new NumberIncrementor("CancelCount", 1, false);
    public static void cancelMultiple(Collection<Integer> orderIds){
        getCache().invokeAll(orderIds, ni1);
    public static void cancelAllByAccount(String account){
        getCache().invokeAll( new EqualsFilter("getAccount", account), ni1);
    public void cancelAllowingMultipleCancelsOfThisOrder() {
        System.out.println("cancelAllowingMultipleCancelsOfThisOrder symbol=" + symbol + " key="+key+ " id=" + this.id);
        getCache().invoke(key, ni1);
        UpdaterProcessor up = new UpdaterProcessor("setCancelSubmittedTime", Base.getSafeTimeMillis() );
        getCache().invoke(key, up);
    public void entryInserted(MapEvent mapEvent) {
    public void entryUpdated(MapEvent mapEvent) {
        Order o = (Order)mapEvent.getNewValue();
        fireStatusChange(o);
    public void entryDeleted(MapEvent mapEvent) {
    public void removeStatusChangeListener(OrderStatusChangeListener listener) {
        synchronized (statusChangeListeners) {
            statusChangeListeners.remove(listener);
            if (statusChangeListeners.size()==0) {
                this.getCache().removeMapListener(this, statusChangeFilter);
    private transient Filter statusChangeFilter=null;
    public void addStatusChangeListener(OrderStatusChangeListener listener) {
        if (statusChangeFilter==null) {
            Filter f1 = new ValueChangeEventFilter("OrderStatus");
            Filter f2 = new EqualsFilter("Key", this.getKey());
            Filter f3 = new AndFilter(f1,f2);
            statusChangeFilter = new MapEventFilter(MapEventFilter.E_UPDATED, f3);
        System.out.println("ADD STATUS CHANGE LISTENER "+this.symbol+" "+this.getKey());
        synchronized (statusChangeListeners) {
            if (statusChangeListeners.size()==0) {
                this.getCache().addMapListener(this , statusChangeFilter, false);
            statusChangeListeners.add(listener);
    private void fireStatusChange(Order o ) {
        System.out.println("FIRE STATUS CHANGE: starting...");
        // do not depend on the firing of a status change to mean that the
        // status did certainly change.  Use the firing of status change as a
        // trigger to examine the order's status w/getStatus().
        System.out.println("1");
        synchronized (statusChangeListeners) {
            System.out.println("2");
            List<OrderStatusChangeListener> asdf = new LinkedList<OrderStatusChangeListener>(statusChangeListeners);
            System.out.println("3");
            for (OrderStatusChangeListener x : asdf) {
                System.out.println("4");
                try {
                    System.out.println("FIRE STATUS CHANGE: "+x);
                    x.dispatchOrderStatusChange(o);
                } catch (java.util.ConcurrentModificationException e) {
                    logger.error("** fireStatusChange: ConcurrentModificationException " + e.getMessage());
                    logger.error(e.getStackTrace());
                    e.printStackTrace();
        System.out.println("FIRE STATUS CHANGE: done...");
    public int compareTo(Object o) { //assumes ID allways int.
        return this.key - ((Order)o).key;
    public boolean equals(Object o) {
        return (this.key == ((Order)o).key);
    public void setStatus(OrderStatus orderStatus) {
        this.orderStatus = orderStatus;
    public OrderStatus getStatus() {
        return orderStatus;
    public Integer getKey(){
        return key;
    private Integer key;
    public Order() {
        id = generateId();
        key=new Integer(id);
    public Object clone() {
        try {
            Order order = (Order)super.clone();
            order.setId(order.generateId());
            return order;
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        return null;
    public static int generateId() {
        idwLock.lock();
        try {
            if (nextId == flipOverId) {
                // redo this w/a number incrementor passing in null for the member variable
//                ValueManipulator vm=null;
//                NumberIncrementor ni = new NumberIncrementor(vm, 1, false);
                NamedCache omsCache = CacheFactory.getCache("oms");
                omsCache.lock("high_order_id");
                Integer i = (Integer)omsCache.get("high_order_id");
                if (i==null) i=188; // change to 1 once legacy is gone
                omsCache.put("high_order_id", ++i);
                omsCache.unlock("high_order_id");
                flipOverId = (i+1) * MAX_ORDERS_PER_TRADER_ID;
                nextId = (MAX_ORDERS_PER_TRADER_ID * i)+1;
                return nextId;
            } else {
                return ++nextId;
        } finally {
            idwLock.unlock();
    public boolean isCancelRequestedOrIsCanceled() {
        // change to cancelrequested lock, not ack lock
        if (orderStatus==OrderStatus.CANCELED)
            return true;
        //  ValueExtractor extractor = new ReflectionExtractor("getCancelCount");
        //  int cc = (Integer)cache.invoke( this.ID , extractor );
        Order o = (Order)getCache().get(this.id);
        int cc = o.getCancelCount();
        return cc > 0 || o.orderStatus == OrderStatus.CANCELED;
    public void setId(int Id) {
        this.id = Id;
    public int getId() {
        return id;
}