org.openl.ie.constrainer.impl.ExpressionObserver Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of org.openl.rules.constrainer Show documentation
OpenL Constraint Programming engine
The newest version!
package org.openl.ie.constrainer.impl;

import java.io.Serializable;

import org.openl.ie.constrainer.EventOfInterest;
import org.openl.ie.constrainer.Expression;
import org.openl.ie.constrainer.Failure;
import org.openl.ie.constrainer.Observer;
import org.openl.ie.constrainer.Subject;

///////////////////////////////////////////////////////////////////////////////
/*
 * Copyright Exigen Group 1998, 1999, 2000
 * 320 Amboy Ave., Metuchen, NJ, 08840, USA, www.exigengroup.com
 *
 * The copyright to the computer program(s) herein
 * is the property of Exigen Group, USA. All rights reserved.
 * The program(s) may be used and/or copied only with
 * the written permission of Exigen Group
 * or in accordance with the terms and conditions
 * stipulated in the agreement/contract under which
 * the program(s) have been supplied.
 */
///////////////////////////////////////////////////////////////////////////////

/**
 * An abstract implementation of the observers used in expressions.
 * 
 * Any expression is a subject for other expressions and has an observers for its arguments.
 * 

 * ExpressionObserver maintains transformations between publisher event mask for the expression and subscriber event
 * mask for its arguments.
 */
public abstract class ExpressionObserver extends Observer {
    /**
     * An interface for transforming publisher and subscriber masks.
     */
    interface EventMap extends Serializable {
        /**
         * Transform publisher mask to subscriber mask.
         */
        int publishToSubscribe(int publish_mask);

    }

    /**
     * A generic implementation of the EventMap interface.
     */
    static class EventMapImpl implements EventMap {
        private final int[] _masks;

        EventMapImpl(int[] masks) {
            _masks = masks;
        }

        @Override
        public int publishToSubscribe(int publish_mask) {
            int result_mask = 0;
            for (int i = 0; i < _masks.length; i += 2) {
                if ((_masks[i + 1] & publish_mask) != 0) {
                    result_mask |= _masks[i];
                }
            }
            return result_mask;
        }

    } // ~ EventMapImpl

    /**
     * Trivial event map.
     */
    static final private int[] trival_event_map = {MIN, MIN, MAX, MAX, VALUE, VALUE, REMOVE, REMOVE};

    // protected Expression _expression;
    private final EventMap _event_map;

    /**
     * The mask for event in which the observer is interested in.
     */
    // (eg, from X to X+4)
    private int _subscriber_mask;

    /**
     * Constructor for the ExpressionObserver with a trivial event mask.
     */
    public ExpressionObserver() {
        this(trival_event_map);
    }

    /**
     * Constructor for the ExpressionObserver with a given event map.
     */
    public ExpressionObserver(int[] masks) {
        _event_map = new EventMapImpl(masks);
    }

    // /**
    // * Returns an event map for this observer.
    // */
    // public EventMap eventMap()
    // {
    // return _event_map;
    // }
    //

    /**
     * Subscribes for the events from "exp" with a given "publishMask".
     * 
     * This method will be initiated by any subscriber (constraint on this expression or other expression) which wants
     * to be notified about events presented by the "publishMask" (the constraint subscribes to these events).
     */
    public void publish(int publishMask, Expression exp) {
        subscriberMask(_event_map.publishToSubscribe(publishMask), exp);
    }

    @Override
    public int subscriberMask() {
        return _subscriber_mask;
    }

    /**
     * Changes the subscriber mask for this observer.
     */
    @Override
    public void subscriberMask(int mask, Subject subj) {
        if (_subscriber_mask != mask) {
            // Debug.on();Debug.print("" + this + " mask: "+ mask + " exp:" +
            // expression);Debug.off();

            _subscriber_mask = mask;
        }

        subj.reattachObserver(this);
    }

    /**
     * Returns a String representation of this observer.
     *
     * @return a String representation of this observer.
     */
    @Override
    public String toString() {
        return "ExpressionObserver";
    }

    /**
     * Transforms "MAX" event that is send to this observer.
     */
    public void transformMaxEvent(EventOfInterest event) throws Failure {
    }

    /**
     * Transforms "MIN" event that is send to this observer.
     */
    public void transformMinEvent(EventOfInterest event) throws Failure {
    }

    /**
     * Transforms "REMOVE" event that is send to this observer.
     */
    public void transformRemoveEvent(EventOfInterest event) throws Failure {
    }

    /**
     * Transforms "VALUE" event that is send to this observer.
     */
    public void transformValueEvent(EventOfInterest event) throws Failure {
    }

    @Override
    public void update(Subject exp, EventOfInterest event) throws Failure {
        // Debug.on();Debug.print("" + this + " : "+event);Debug.off();
        if (event.isValueEvent()) {
            transformValueEvent(event);
        } else if (event.isMinEvent()) {
            transformMinEvent(event);
        } else if (event.isMaxEvent()) {
            transformMaxEvent(event);
        } else if (event.isRemoveEvent()) {
            transformRemoveEvent(event);
        }
    }

} // ~ ExpressionObserver