How to use

EventController

in

de.tsl2.nano.core.messaging

  /**
   * provides the un-threaded super fire-method. see {@link EventController#fireEvent(Object)}
   * 
   * @param e new event
   */
  public void sendEvent(final Object e) {
    super.fireEvent(e);
  }
}

  @Override
  public EventController changeHandler() {
    if (eventController == null) {
      eventController = new EventController();
    }
    return eventController;
  }
}

public boolean add(Object o) {
  boolean r = c.add(o);
  changeHandler.fireValueChange(c, null, o, true);
  return r;
};

public EProcess() {
  prc.getEventController().addListener(this, Object.class);
}
 

/**
 * uses the information of {@link #attributeID} to inject the real {@link AttributeDefinition} into registered
 * change listeners
 * 
 * @throws CloneNotSupportedException
 */
void injectAttributeOnChangeListeners(BeanDefinition beandef) {
  //provide dependency listeners their attribute-definition
  if (hasListeners()) {
    Collection<IListener> listener = changeHandler().getListeners(null);
    boolean isBean = beandef instanceof Bean;
    for (IListener l : listener) {
      if (l instanceof AbstractDependencyListener) {
        AbstractDependencyListener<?, ?> dl = (AbstractDependencyListener<?, ?>) l;
        if (isBean) {//create a specific listener instance for the given bean!
          LOG.debug(beandef.getId() + ": re-assigning dependency-listener-clone " + dl);
          dl = (AbstractDependencyListener<?, ?>) dl.clone();
          Class eventType = changeHandler().getEventType(l);
          changeHandler().removeListener(l);
          changeHandler().addListener(dl, eventType);
        }
        if (dl.attributeID != null) {
          String name = StringUtil.substring(dl.attributeID, ".", null);
          LOG.debug(beandef.getId() + ": resetting value of attribute " + name);
          dl.setAttribute((AttributeDefinition) beandef.getAttribute(name));
        }
      }
    }
  }
}

/**
 * {@inheritDoc}
 */
@Override
public void setValue(T object) {
  if (changeHandler == null || !changeHandler.hasListeners()) {
    this.value = object;
  } else {
    final T oldValue = getValue();
    final ChangeEvent event = new ChangeEvent(this, false, false, oldValue, object);
    changeHandler.fireEvent(event);
    if (!event.breakEvent) {
      this.value = object;
      event.hasChanged = true;
      changeHandler.fireEvent(event);
    }
  }
}

/**
 * looks for registered change handlers without creating an {@link EventController} instance.
 * 
 * @return
 */
public boolean hasListeners() {
  return eventController != null && eventController.hasListeners();
}

/**
 * notify
 * 
 * @param notification
 */
public void notify(Notification notification) {
  //sets the status to notified - the handle-runner will reset it to idle after finishing
  increaseStatus();
  controller.handle(this, notification);
}

  /**
   * a new listener will be created to set the new value of this bean to the given beanvalue.
   * 
   * @param anotherValue beanvalue to bind
   */
  public void bind(final BeanValue<T> anotherValue) {
//        if (!getType().equals(anotherValue.getType()))
//            ManagedException.implementationError("binding beanvalues must have the same type", anotherValue.getType());
    changeHandler().addListener(new IListener<ChangeEvent>() {
      @Override
      public void handleEvent(ChangeEvent changeEvent) {
        if (changeEvent.hasChanged) {
          anotherValue.setValue((T) changeEvent.newValue);
        }
      }
    });
  }
 

/**
 * constructor
 * @param path for nodes to be notified
 * @param notification the notification content
 * @param response any node response
 * @param responseListener listeners to node responses
 */
public Notification(String path,
    Object notification,
    Map<String, Object> response,
    IListener<Notification> responseListener) {
  super();
  this.notification = notification;
  this.path = path;
  this.response = response;
  if (responseListener != null) {
    getResponseController().addListener(responseListener);
  }
}

  /**
   * provides the un-threaded super fire-method. see {@link EventController#fireEvent(Object)}
   * 
   * @param e new event
   */
  public void sendEvent(final Object e) {
    super.fireEvent(e);
  }
}

/**
 * {@inheritDoc}
 */
@Override
public EventController changeHandler() {
  if (eventController == null) {
    eventController = new EventController();
  }
  return eventController;
}

  public boolean remove(Object o) {
    boolean r = c.remove(o);
    changeHandler.fireValueChange(c, o, null, true);
    return r;
  };
}

private void createBinding() {
  firstValue.changeHandler().addListener(new IListener<ChangeEvent>() {
    @Override
    public void handleEvent(ChangeEvent changeEvent) {
      if (!updating && changeEvent.hasChanged) {
        try {
          updating = true;
          secondValue.setValue(converter.to((FIRST) changeEvent.newValue));
        } finally {
          updating = false;
        }
      }
    }
  });
  secondValue.changeHandler().addListener(new IListener<ChangeEvent>() {
    @Override
    public void handleEvent(ChangeEvent changeEvent) {
      if (!updating && changeEvent.hasChanged) {
        try {
          updating = true;
          firstValue.setValue(converter.from((SECOND) changeEvent.newValue));
        } finally {
          updating = false;
        }
      }
    }
  });
}

/**
 * addResponse
 * @param srcPath path of responding node
 * @param aresponse response of a node
 */
public void addResponse(String srcPath, Object aresponse) {
  if (response == null) {
    response = new ConcurrentHashMap<String, Object>();
  }
  //concurrenthashmap is not able to store null values!
  if (aresponse != null) {
    response.put(srcPath, aresponse);
  }
  if (responseController != null) {
    responseController.fireEvent(new Notification(srcPath, aresponse));
  }
}

  /**
   * {@inheritDoc}
   */
  @Override
  public EventController changeHandler() {
    if (eventController == null) {
      eventController = new EventController();
    }
    return eventController;
  }
}

/**
 * constructor
 * 
 * @param ovalue orginal value to be bound to this wrapper instance. the value is holding an enum
 * @param enumValues enumeration values
 */
public OptionsWrapper(IValueAccess<E> ovalue, E[] enumValues) {
  super();
  assert enumValues.length <= ATTR_NAMES.length : "maximum count of "+ ATTR_NAMES.length + " enumeration values exceeded";
  this.enumerations = enumValues;
  this.ovalue = ovalue;
  /*
   * if the value was set from outside, we listen to it to refresh our wrapper and
   * perhaps other data-bound values
   */
  ovalue.changeHandler().addListener(new IListener<ChangeEvent>() {
    @SuppressWarnings("unchecked")
    @Override
    public void handleEvent(ChangeEvent event) {
      if (!changingValue) {
        Object value = event.getSource();
        BeanValue.getBeanValue(OptionsWrapper.this, ATTR_NAMES[indexOf((E) value)]).setValue(true);
      }
    }
  });
}

cons.addAll(evalTimedConsiliums(cons, timer.from, timer.until));
CommandManager cmdManager = new CommandManager();
getEventController().fireEvent(cons.size());
for (IConsilium c : cons) {
  if (stop.get()) {
    eventController.fireEvent(STOPPED);
    break;
      eventController.fireEvent(c);
      log("expired: " + c.getName() + " with timer: "+ c.getTimer());
      cmdManager.doIt(c.getExsecutios().toArray(new ICommand[0]));
      c.setStatus(Status.ACTIVE);
      c.refreshSeal(ID);
      eventController.fireEvent(c);
    } catch (Exception ex) {
      LOG.error(ex);
      eventController.fireEvent(ex);
eventController.fireEvent(FINISHED);
log("processing finished");
log("------------------------------------------------------------------------------");

@Override
public EventController changeHandler() {
  if (eventController == null) {
    eventController = new EventController();
  }
  return eventController;
}

/**
 * convenience method add a listener to all enumvalues.
 * 
 * @param wrapper wrapper instance to have an instance using booleans for each enum type that was selected.
 * @param listener user defined listener to act on selection changes.
 * @param enumConstants enum constants
 */
protected void setEnumBooleanListener(OptionsWrapper<?> wrapper,
    IListener<ChangeEvent> listener,
    Enum[] enumConstants) {
  for (int i = 0; i < enumConstants.length; i++) {
    LOG.debug("adding valuechange-listener for attribute: " + OptionsWrapper.ATTR_NAMES[i]);
    BeanValue.getBeanValue(wrapper, OptionsWrapper.ATTR_NAMES[i]).changeHandler().addListener(listener);
    //TODO: listener bei dispose evtl. wieder abbauen!
  }
}