proton-j/src/main/java/org/apache/qpid/proton/engine/impl/EventImpl.java

/*
 *
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 *
 */
package org.apache.qpid.proton.engine.impl;

import java.util.Iterator;

import org.apache.qpid.proton.engine.Connection;
import org.apache.qpid.proton.engine.Delivery;
import org.apache.qpid.proton.engine.Event;
import org.apache.qpid.proton.engine.EventType;
import org.apache.qpid.proton.engine.Handler;
import org.apache.qpid.proton.engine.HandlerException;
import org.apache.qpid.proton.engine.Link;
import org.apache.qpid.proton.engine.Receiver;
import org.apache.qpid.proton.engine.Record;
import org.apache.qpid.proton.engine.Sender;
import org.apache.qpid.proton.engine.Session;
import org.apache.qpid.proton.engine.Transport;
import org.apache.qpid.proton.reactor.Reactor;
import org.apache.qpid.proton.reactor.Selectable;
import org.apache.qpid.proton.reactor.Task;
import org.apache.qpid.proton.reactor.impl.ReactorImpl;

/**
 * EventImpl
 *
 */

class EventImpl implements Event
{

    EventType type;
    Object context;
    EventImpl next;
    RecordImpl attachments = new RecordImpl();

    EventImpl()
    {
        this.type = null;
    }

    void init(EventType type, Object context)
    {
        this.type = type;
        this.context = context;
        this.attachments.clear();
    }

    void clear()
    {
        type = null;
        context = null;
        attachments.clear();
    }

    @Override
    public EventType getEventType()
    {
        return type;
    }

    @Override
    public Type getType() {
        if (type instanceof Type) {
            return (Type)type;
        }
        return Type.NON_CORE_EVENT;
    }

    @Override
    public Object getContext()
    {
        return context;
    }

    @Override
    public Handler getRootHandler() {
        return ReactorImpl.ROOT.get(this);
    }

    private Handler delegated = null;

    @Override
    public void dispatch(Handler handler) throws HandlerException
    {
        Handler old_delegated = delegated;
        try {
            delegated = handler;
            try {
                handler.handle(this);
            } catch(HandlerException handlerException) {
                throw handlerException;
            } catch(RuntimeException runtimeException) {
                throw new HandlerException(handler, runtimeException);
            }
            delegate();
        } finally {
            delegated = old_delegated;
        }
    }

    @Override
    public void delegate() throws HandlerException
    {
        if (delegated == null) {
            return; // short circuit
        }
        Iterator<Handler> children = delegated.children();
        delegated = null;
        while(children.hasNext()) {
            dispatch(children.next());
        }
    }

    @Override
    public void redispatch(EventType as_type, Handler handler) throws HandlerException 
    {
        if (!as_type.isValid()) {
            throw new IllegalArgumentException("Can only redispatch valid event types");
        }
        EventType old = type;
        try {
            type = as_type;
            dispatch(handler);
        }
        finally {
            type = old;
        }
    }

    @Override
    public Connection getConnection()
    {
        if (context instanceof Connection) {
            return (Connection) context;
        } else if (context instanceof Transport) {
            Transport transport = getTransport();
            if (transport == null) {
                return null;
            }
            return ((TransportImpl) transport).getConnectionImpl();
        } else {
            Session ssn = getSession();
            if (ssn == null) {
                return null;
            }
            return ssn.getConnection();
        }
    }

    @Override
    public Session getSession()
    {
        if (context instanceof Session) {
            return (Session) context;
        } else {
            Link link = getLink();
            if (link == null) {
                return null;
            }
            return link.getSession();
        }
    }

    @Override
    public Link getLink()
    {
        if (context instanceof Link) {
            return (Link) context;
        } else {
            Delivery dlv = getDelivery();
            if (dlv == null) {
                return null;
            }
            return dlv.getLink();
        }
    }

    @Override
    public Sender getSender()
    {
        if (context instanceof Sender) {
            return (Sender) context;
        } else {
            Link link = getLink();
            if (link instanceof Sender) {
                return (Sender) link;
            }
            return null;
        }
    }

    @Override
    public Receiver getReceiver()
    {
        if (context instanceof Receiver) {
            return (Receiver) context;
        } else {
            Link link = getLink();
            if (link instanceof Receiver) {
                return (Receiver) link;
            }
            return null;
        }
    }

    @Override
    public Delivery getDelivery()
    {
        if (context instanceof Delivery) {
            return (Delivery) context;
        } else {
            return null;
        }
    }

    @Override
    public Transport getTransport()
    {
        if (context instanceof Transport) {
            return (Transport) context;
        } else if (context instanceof Connection) {
            return ((Connection)context).getTransport();
        } else {
            Session session = getSession();
            if (session == null) {
                return null;
            }

            Connection connection = session.getConnection();
            if (connection == null) {
                return null;
            }

            return connection.getTransport();
        }
    }

    @Override
    public Selectable getSelectable() {
        if (context instanceof Selectable) {
            return (Selectable) context;
        } else {
            return null;
        }
    }

    @Override
    public Reactor getReactor() {
        if (context instanceof Reactor) {
            return (Reactor) context;
        } else if (context instanceof Task) {
            return ((Task)context).getReactor();
        } else if (context instanceof Transport) {
            return ((TransportImpl)context).getReactor();
        } else if (context instanceof Delivery) {
            return ((Delivery)context).getLink().getSession().getConnection().getReactor();
        } else if (context instanceof Link) {
            return ((Link)context).getSession().getConnection().getReactor();
        } else if (context instanceof Session) {
            return ((Session)context).getConnection().getReactor();
        } else if (context instanceof Connection) {
            return ((Connection)context).getReactor();
        } else if (context instanceof Selectable) {
            return ((Selectable)context).getReactor();
        }
        return null;
    }

    @Override
    public Task getTask() {
        if (context instanceof Task) {
            return (Task) context;
        } else {
            return null;
        }
    }

    @Override
    public Record attachments() {
        return attachments;
    }

    @Override
    public Event copy()
    {
       EventImpl newEvent = new EventImpl();
       newEvent.init(type, context);
       newEvent.attachments.copy(attachments);
       return newEvent;
    }

    @Override
    public String toString()
    {
        return "EventImpl{" + "type=" + type + ", context=" + context + '}';
    }


}