Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   *
   * 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.airavata.ws.monitor;
 
 import java.util.List;
 
 
 
 public class EventDataRepository implements TableModelBoundedRangeModel {

    
Column
 
     public static enum Column {
        
TIME
 
         TIME("Time"),
        
ID
 
         ID("Component"),
        
STATUS
 
         STATUS("Status"),
        
MESSAGE
 
         MESSAGE("Message");
 
         private String name;
 
         private Column(String name) {
             this. = name;
         }

        

Returns:
The name.
 
         public String getName() {
             return this.;
         }
     }
 
     private static final Logger logger = LoggerFactory.getLogger(EventDataRepository.class);
 
 
 
     private List<EventDataevents;
 
     private int sliderValue;
 
     private boolean sliderAdjusting;
 
 
     private EventFilter filter;
 
     private List<EventDataListenermonitorEventListerners;

    
Constructs a MonitorEventData.
 
    public EventDataRepository() {
        this(null);
    }

    
Constructs a NotificationTableModel.
    public EventDataRepository(EventFilter filter) {
        this. = filter;
        this. = new LinkedList<TableModelListener>();
        this. = new LinkedList<ChangeListener>();
        this. = new ChangeEvent(this); // We only need one.
        this. = new ArrayList<EventData>();
    }
    public void addEvent(XmlElement message) {
    	addEvent(new EventData(message));
    }
    

Parameters:
message
    public void addEvent(EventData event) {
        // no need the check for not null because second clause is evaluated only if
        // not null
        if (this. == null || this..isAcceptable(event)) {
            boolean sliderMax = (this. == this..size());
            this..add(event);
            if (sliderMax) {
                // Move the slider to the max
                this. = this..size();
                // The new event shows up on the table only when the slider is
                // max.
                TableModelEvent tableEvent = new TableModelEvent(thisthis. - 1, this.,
                        ..);
                fireTableChanged(tableEvent);
            }
            // The muxmum of the slider changed regardless whether we move the
            // slider or not.
            fireSliderChanged();
            triggerListenerForMonitorEvent(event);
        }
    }
    public void triggerListenerForPreMonitorStart() {
			try {
catch (Exception e) {
				//just in case
			}
		}
	}
    
    public void triggerListenerForPostMonitorStart() {
			try {
catch (Exception e) {
				//just in case
			}
		}
	}
    
    public void triggerListenerForPreMonitorStop() {
			try {
catch (Exception e) {
				//just in case
			}
		}
	}
    
    public void triggerListenerForPostMonitorStop() {
			try {
catch (Exception e) {
				//just in case
			}
		}
	}
	private void triggerListenerForMonitorEvent(EventData event) {
			try {
				listener.notify(thisevent);
					listener.onCompletion(event);
				}else if (event.getType()==.){
					listener.onFail(event);
				}
catch (Exception e) {
				//just in case
			}
		}
	}

    

Returns:
All events.
    public List<EventDatagetEvents() {
        return this.;
    }

    
Returns a notification at a specified row.

Parameters:
index The specified row.
Returns:
The notification at the specified row
    public EventData getEvent(int index) {
        return this..get(index);
    }

    

Returns:
The number of events.
    public int getEventSize() {
        return this..size();
    }

    
Clears the notifications.
    public void removeAllEvents() {
        int size = this..size();
        this..clear();
        this. = 0;
        TableModelEvent event = new TableModelEvent(this, 0, Math.max(0, size - 1), .,
                .);
        fireTableChanged(event);
        // The muxmum of the slider changed.
        fireSliderChanged();
    }
    // methods implementing TableModel interface.

    
    public int getRowCount() {
        // Only show the events up to the slider value.
        return this.;
    }

    
    public int getColumnCount() {
        return Column.values().length;
    }

    
    public String getColumnName(int columnIndex) {
        Column[] columns = Column.values();
        if (columnIndex < 0 || columnIndex >= columns.length) {
            // Should not happen.
            throw new IllegalArgumentException("columnIndex has be be between 0 to " + columns.length);
        }
        return columns[columnIndex].getName();
    }

    
    public Class<?> getColumnClass(int columnIndex) {
        return String.class;
    }

    
    public boolean isCellEditable(int rowIndexint columnIndex) {
        return false;
    }

    
    public Object getValueAt(int rowIndexint columnIndex) {
        String value;
        try {
            EventData event = this..get(rowIndex);
            value = getTextAt(eventcolumnIndex);
        } catch (RuntimeException e) {
            // This should not happen, but if it happens it blocks the UI.
            // That's why catching it.
            .error(e.getMessage(), e);
            value = "Error";
        }
        return value;
    }

    
    public void setValueAt(Object aValueint rowIndexint columnIndex) {
        throw new UnsupportedOperationException();
    }

    
    public void addTableModelListener(TableModelListener listener) {
        this..add(listener);
    }

    
    public void removeTableModelListener(TableModelListener listener) {
        this..remove(listener);
    }
    // methods implementing BoundedRangeModel interface.

    
    public int getExtent() {
        return 0;
    }

    
    public void setExtent(int newExtent) {
        throw new UnsupportedOperationException();
    }

    
    public int getMaximum() {
        return getEventSize();
    }

    
    public void setMaximum(int newMaximum) {
        throw new UnsupportedOperationException();
    }

    
    public int getMinimum() {
        return 0;
    }

    
    public void setMinimum(int newMinimum) {
        throw new UnsupportedOperationException();
    }

    
    public int getValue() {
        return this.;
    }

    
    public void setValue(int newValue) {
        if (this. == newValue) {
            return;
        }
        // Correct the value to be withing the range.
        if (newValue < 0) {
            newValue = 0;
        }
        if (newValue > this..size()) {
            newValue = this..size();
        }
        int oldRowCount = this.;
        this. = newValue;
        TableModelEvent event;
        if (oldRowCount < this.) {
            event = new TableModelEvent(thisoldRowCountthis..,
                    .);
        } else {
            event = new TableModelEvent(thisthis.oldRowCount.,
                    .);
        }
        fireTableChanged(event);
        fireSliderChanged();
    }

    
    public boolean getValueIsAdjusting() {
        return this.;
    }

    
    public void setValueIsAdjusting(boolean adjusting) {
        this. = adjusting;
        fireSliderChanged();
    }

    
    public void setRangeProperties(int valueint extentint minint maxboolean adjusting) {
        throw new UnsupportedOperationException();
    }

    
    public void addChangeListener(ChangeListener listener) {
        this..add(listener);
    }

    
    public void removeChangeListener(ChangeListener listener) {
        this..remove(listener);
    }
    private String getTextAt(EventData eventint columnIndex) {
        Column[] columns = Column.values();
        if (columnIndex < 0 || columnIndex >= columns.length) {
            // Should not happen.
            throw new IllegalArgumentException("columnIndex has be be between 0 to " + columns.length);
        }
        Column column = columns[columnIndex];
        String value;
        switch (column) {
        case :
            value = event.getTimeText();
            break;
        case :
            value = event.getIDText();
            break;
        case :
            value = event.getStatusText();
            break;
        case :
            value = event.getMessage();
            break;
        default:
            // Should not happen.
            throw new IllegalArgumentException("columnIndex has be be between 0 to " + columns.length);
        }
        return value;
    }
    private void fireTableChanged(TableModelEvent event) {
        for (TableModelListener listener : this.) {
            listener.tableChanged(event);
        }
    }
    private void fireSliderChanged() {
        for (ChangeListener listener : this.) {
            listener.stateChanged(this.);
        }
    }
		}
	}
	public void registerEventListener(EventDataListener listener){
		if (listener!=null) {
		}
	}
		}
	}
New to GrepCode? Check out our FAQ X