source: trunk/src/org/expeditee/core/bounds/CombinationBounds.java@ 1097

package org.expeditee.core.bounds;

import java.util.LinkedList;
import java.util.List;

import org.expeditee.core.Point;

/**
 * The CombinationBounds class represents a collection of bounds, which
 * may be disjoint. A point is considered inside the CombinationBounds if
 * it is inside any of the individual bounds in the collection (i.e. if it
 * is inside the conjunction of the individual bounds). If the combination
 * bounds has no component bounds, then no points are inside it.
 * 
 * @author cts16
 */
public class CombinationBounds extends Bounds {

        /** The collection of bounds. */
        protected List<Bounds> _bounds;
        
        /** Default constructor. */
        public CombinationBounds()
        {
                this(null);
        }
        
        /** Standard constructor. */
        public CombinationBounds(Bounds b)
        {
                _bounds = new LinkedList<Bounds>();
                add(b);
        }
        
        /** Copy constructor. */
        public CombinationBounds(CombinationBounds other)
        {
                _bounds = new LinkedList<Bounds>();
                for (Bounds b : other._bounds) add(b);
        }
        
        /** Adds a bounds to the combination. */
        public CombinationBounds add(Bounds b)
        {
                // Only valid Bounds are allowed in the collection
                if (b == null) return this;
                
                _bounds.add(b);
                
                return this;
        }
        
        /** Gets the bounds at the given index in this combination. */
        public Bounds get(int index)
        {
                if (0 <= index && index < _bounds.size()) return _bounds.get(index);
                
                return null;
        }
        
        /** Removes all component bounds. */
        public CombinationBounds clear()
        {
                _bounds.clear();
                
                return this;
        }
        
        /** Whether this combination bounds has no component bounds. */
        public boolean isEmpty()
        {
                return _bounds.isEmpty();
        }
        
        @Override
        public boolean contains(int x, int y)
        {
                // If any component bounds contains the point, then the combination as
                // a whole does as well
                for (Bounds b : _bounds) {
                        if (b.contains(x, y)) return true;
                }
                
                // No component contained the point
                return false;
        }

        @Override
        public int getMaxX() 
        {
                int maxX = Integer.MIN_VALUE;
                
                for (Bounds b : _bounds) {
                        int thisX = b.getMaxX();
                        if (thisX > maxX) maxX = thisX;
                }
                
                return maxX;
        }

        @Override
        public int getMinX()
        {
                int minX = Integer.MAX_VALUE;
                
                for (Bounds b : _bounds) {
                        int thisX = b.getMinX();
                        if (thisX < minX) minX = thisX;
                }
                
                return minX;
        }

        @Override
        public int getMaxY()
        {
                int maxY = Integer.MIN_VALUE;
                
                for (Bounds b : _bounds) {
                        int thisY = b.getMaxY();
                        if (thisY > maxY) maxY = thisY;
                }
                
                return maxY;
        }

        @Override
        public int getMinY()
        {
                int minY = Integer.MAX_VALUE;
                
                for (Bounds b : _bounds) {
                        int thisY = b.getMinY();
                        if (thisY < minY) minY = thisY;
                }
                
                return minY;
        }
        
        @Override
        public CombinationBounds translate(int x, int y)
        {
                for (Bounds b : _bounds) {
                        b.translate(x, y);
                }
                
                return this;
        }

        @Override
        public boolean equals(Bounds other)
        {
                if (other instanceof CombinationBounds) {
                        CombinationBounds c = (CombinationBounds) other;
                        if (_bounds.size() == c._bounds.size()) {
                                for (int i = 0; i < _bounds.size(); i++) {
                                        if (!(_bounds.get(i).equals(c._bounds.get(i)))) return false;
                                }
                                return true;
                        }
                }
                return false;
        }
        
        @Override
        public boolean intersects(Bounds other)
        {
                for (Bounds b : _bounds) {
                        if (b.intersects(other)) return true;
                }
                
                return false;
        }

        @Override
        public boolean intersects(AxisAlignedBoxBounds other)
        {
                return intersects((Bounds) other);
        }

        @Override
        public boolean intersects(CombinationBounds other)
        {
                return intersects((Bounds) other);
        }

        @Override
        public boolean intersects(EllipticalBounds other)
        {
                return intersects((Bounds) other);
        }

        @Override
        public boolean intersects(PolygonBounds other)
        {
                return intersects((Bounds) other);
        }

        @Override
        public double getArea()
        {
                // TODO Complete. Difficult as have to take into account overlapping areas. cts16
                System.err.println("Unimplemented method: CombinationBounds.getArea()");
                return 0;
        }

        @Override
        public boolean perimeterContains(Point p, double error)
        {
                for (Bounds b : _bounds) {
                        if (b.perimeterContains(p, error)) {
                                for (Bounds b2 : _bounds) {
                                        if (b2 != b && b2.contains(p) && !b2.perimeterContains(p, error)) return false;
                                }
                                return true;
                        }
                }
                
                return false;
        }

        @Override
        public boolean completelyContains(AxisAlignedBoxBounds other)
        {
                // TODO Complete. Difficult as we have to take into account conjoined areas. cts16
                System.err.println("Unimplemented method: CombinationBounds.completelyContains(AxisAlignedBoxBounds)");
                return false;
        }

        @Override
        public boolean completelyContains(CombinationBounds other)
        {
                // TODO Complete. Difficult as we have to take into account conjoined areas. cts16
                System.err.println("Unimplemented method: CombinationBounds.completelyContains(CombinationBounds)");
                return false;
        }

        @Override
        public boolean completelyContains(EllipticalBounds other)
        {
                // TODO Complete. Difficult as we have to take into account conjoined areas. cts16
                System.err.println("Unimplemented method: CombinationBounds.completelyContains(EllipticalBounds)");
                return false;
        }

        @Override
        public boolean completelyContains(PolygonBounds other)
        {
                // TODO Complete. Difficult as we have to take into account conjoined areas. cts16
                System.err.println("Unimplemented method: CombinationBounds.completelyContains(PolygonBounds)");
                return false;
        }
        
        @Override
        public CombinationBounds clone()
        {
                return new CombinationBounds(this);
        }
}