package hep.aida.ref.histogram;

import hep.aida.IAnnotation;
import hep.aida.IDataPoint;
import hep.aida.IDataPointSet;
import hep.aida.IMeasurement;
import hep.aida.ref.AidaUtils;
import hep.aida.ref.Annotation;
import hep.aida.ref.ManagedObject;
import hep.aida.ref.event.AIDAListener;
import hep.aida.ref.event.DataPointSetEvent;
import hep.aida.ref.event.IsObservable;

import java.util.ArrayList;
import java.util.EventObject;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import java.io.Serializable;


/**
 * Basic user-level interface class for holding and managing
 * a single set of "data points".
 *
 * @author The AIDA team @ SLAC.
 *
 */
public class DataPointSet extends ManagedObject implements IDataPointSet, IsObservable, Serializable, AIDAListener {
    
    private int defaultSize = 0;
    private IAnnotation annotation;
    //private String title;
    private int dimension;
    private List points;
    
    // Constructors
    protected DataPointSet() {
        super("");
        initDataPointSet();
        annotation.addItem(Annotation.titleKey,"Title", true);
    }
    
    public DataPointSet(String name, String title, int dimOfPoints) {
        this(name, title, dimOfPoints, 0);
    }
    
    public DataPointSet(String name, String title, int dimOfPoints, int defaultCapacity) {
        this(name, title, dimOfPoints, defaultCapacity, null);
    }
    
    public DataPointSet(String name, String title, int dimOfPoints, String options) {
        this(name, title, dimOfPoints, 0, options);
    }
    
    public DataPointSet(String name, String title, int dimOfPoints, int defaultCapacity, String options) {
        super(name);
        //this.title = title;
        defaultSize = defaultCapacity;
        dimension = dimOfPoints;
        initDataPointSet();
        annotation.addItem(Annotation.titleKey,title, true);
        setOptions(options);
    }
    
    private void initDataPointSet() {
        annotation = new Annotation();
        clear();
        points = new ArrayList(defaultSize);
        for ( int i = 0; i < defaultSize; i++ ) {
            DataPoint point = new DataPoint(dimension);
            points.add( point );
            if (point instanceof IsObservable) {
                ((IsObservable) point).addListener(this);
            }
        }
    }
    
    private void setOptions(String options) {
        if (options == null || options.trim().equals("")) return;
        String[] arr = AidaUtils.parseString(options);
        if (arr == null || arr.length == 0) return;
        ArrayList list = new ArrayList();
        for (int i=0; i 11 && tmp.substring(0, 11).equalsIgnoreCase("annotation.")) {
                String key = tmp.substring(11);
                int index = key.indexOf("=");
                if (index > 0) key = key.substring(0, index);
                list.add(key);
            }
        }
        Map optionMap = AidaUtils.parseOptions( options );
        Iterator it = optionMap.keySet().iterator();
        while (it.hasNext()) {
            String key = (String) it.next();
            for (int i=0; i 0) {
            for (int i=0; i= size().
     *
     */
    public void setPoint(int index, IDataPoint point) throws IllegalArgumentException {
        if (index >= points.size() || index < 0) throw new IllegalArgumentException("Wrong argument in setPoint():  index="+index+", size="+points.size());
        IDataPoint oldPoint = (IDataPoint) points.get(index);
        if (oldPoint instanceof IsObservable) {
            ((IsObservable) oldPoint).removeListener(this);
        }
        points.set(index, point);
        if (point instanceof IsObservable) {
            ((IsObservable) point).addListener(this);
        }
        if (isValid) fireStateChanged();
    }
    
    public IDataPoint addPoint() throws java.lang.RuntimeException {
        IDataPoint point = new DataPoint(dimension);
        addPoint( point );
        return point;
    }
    
    public void addPoint(IDataPoint point) throws IllegalArgumentException {
        if (point.dimension() == dimension) points.add(point);
        else throw new IllegalArgumentException("Wrong dimension in addPoint(): DataPointSet.dimension()="+dimension+
        ", DataPoint.dimension()="+point.dimension());
        if (point instanceof IsObservable) {
            ((IsObservable) point).addListener(this);
        }
        if (isValid) fireStateChanged();
    }
    
    public void removePoint(int index) throws IllegalArgumentException {
        if (index >= points.size() || index < 0) throw new IllegalArgumentException("Wrong argument in removePoint()  index="+index+", size="+points.size());
        IDataPoint point = (IDataPoint) points.remove(index);
        if (point instanceof IsObservable) ((IsObservable) point).removeListener(this);
        if (point instanceof DataPoint) ((DataPoint) point).clear();
        
        if (isValid) fireStateChanged();
    }
    
    public double lowerExtent(int coord) throws IllegalArgumentException {
        if (coord<0 || coord>=dimension || points.size()==0)
            throw new IllegalArgumentException("Can not calculate lowerExtent: coord="+coord+", size="+points.size());
        double lowerExtent = Double.NaN;
        for (int i=0; i lower) lowerExtent = lower;
        }
        return lowerExtent;
    }
    
    public double upperExtent(int coord) throws IllegalArgumentException {
        if (coord<0 || coord>=dimension || points.size()==0)
            throw new IllegalArgumentException("Can not calculate upperExtent: coord="+coord+", size="+points.size());
        double upperExtent = Double.NaN;
        for (int i=0; i upperExtent ) upperExtent = upper;
        }
        return upperExtent;
    }
    
    public void scale(double scaleFactor) throws IllegalArgumentException {
        if (scaleFactor<=0)
            throw new IllegalArgumentException("Illegal scale factor: scaleFactor="+scaleFactor);
        for (int i=0; i
                    



        
      

      
Ads help maintain this website.