Appends points from another MultiVertexGeometryImpl at the end of this
one.

@param src
The source MultiVertexGeometryImpl
767570
public void add(MultiVertexGeometryImpl src, int beginIndex, int endIndex) {
		int endIndexC = endIndex < 0 ? src.getPointCount() : endIndex;
		if (beginIndex < 0 || beginIndex > src.getPointCount()
				|| endIndexC < beginIndex)
			throw new IllegalArgumentException();

		if (beginIndex == endIndexC)
			return;

		mergeVertexDescription(src.getDescription());
		int count = endIndexC - beginIndex;
		int oldPointCount = m_pointCount;
		resize(m_pointCount + count);
		_verifyAllStreams();
		for (int iattrib = 0, nattrib = src.getDescription()
				.getAttributeCount(); iattrib < nattrib; iattrib++) {
			int semantics = src.getDescription()._getSemanticsImpl(iattrib);
			int ncomps = VertexDescription.getComponentCount(semantics);
			AttributeStreamBase stream = getAttributeStreamRef(semantics);
			AttributeStreamBase srcStream = src
					.getAttributeStreamRef(semantics);
			stream.insertRange(oldPointCount * ncomps, srcStream, beginIndex
					* ncomps, count * ncomps, true, 1, oldPointCount * ncomps);
		}
	}
910658
public static OGCGeometry createFromEsriCursor(GeometryCursor gc,
			SpatialReference sr) {
		return createFromEsriCursor(gc, sr, false);
	}
359767
private void addMultiVertexGeometry_(MultiVertexGeometry mvg) {
		Point point = new Point();
		Point2D pt_p = new Point2D();

		for (int i = 0; i < mvg.getPointCount(); i++) {
			mvg.getXY(i, pt_p);
			int p = addPoint_(pt_p);

			if (p != -1) {
				mvg.getPointByVal(i, point);
				int tp = m_shape.addPoint(m_path_handle, point);
				m_tree_hull.setElement(p, tp); // reset the place holder to tp
			}
		}
	}
1360341
private void addPoint(Vector2f pt) {
		if (holes == null) {
			Point p = getPoint(pt);
			contour.add(p);
		} else {
			Point p = getPoint(pt);
			holes.add(p);
		}
	}
643591
public void setFromPoints(Point2D[] points) {
		if (points == null || points.length == 0) {
			setEmpty();
			return;
		}

		Point2D pt = points[0];
		setCoords(pt.x, pt.y);
		for (int i = 1; i < points.length; i++) {
			Point2D pt2d = points[i];
			mergeNE(pt2d.x, pt2d.y);
		}
	}
156966
public void addMapping( byte[] src, String dest ) throws IOException
    {
        if( src.length == 1 )
        {
        	singleByteMappings.put( Integer.valueOf( src[0] & 0xff ), dest );
        }
        else if( src.length == 2 )
        {
            int intSrc = src[0]&0xFF;
            intSrc <<= 8;
            intSrc |= (src[1]&0xFF);
            doubleByteMappings.put( Integer.valueOf( intSrc ), dest );
        }
        else
        {
            throw new IOException( "Mapping code should be 1 or two bytes and not " + src.length );
        }
    }
306751
public void setExcludePath(Path src) {
        if (excludePath == null) {
            excludePath = src;
        } else {
            excludePath.append(src);
        }
    }
1047629
public static void addAll(final Vector dest, final Object[] src) {
    if (src == null) {
      return;
    }
    for (final Object element : src) {
      dest.addElement(element);
    }
  }
85372
public static void mergeAndBufferGeometries(List<Geometry> geometries, double buffer,
			final DataCallback<Geometry[]> onFinished) {
		GeometryUtilsRequest request = new GeometryUtilsRequest();
		request.setActionFlags(GeometryUtilsRequest.ACTION_BUFFER | GeometryUtilsRequest.ACTION_MERGE);
		request.setIntermediateResults(true);
		request.setBuffer(buffer);
		request.setGeometries(toDtoGeometries(geometries));

		GwtCommand command = new GwtCommand(GeometryUtilsRequest.COMMAND);
		command.setCommandRequest(request);
		GwtCommandDispatcher.getInstance().execute(command, new AbstractCommandCallback<GeometryUtilsResponse>() {
			public void execute(GeometryUtilsResponse response) {
				if (onFinished != null) {
					Geometry[] geoms = new Geometry[2];
					geoms[0] = GeometryConverter.toGwt(response.getGeometries()[0]);
					geoms[1] = GeometryConverter.toGwt(response.getGeometries()[1]);
					onFinished.execute(geoms);
				}
			}
		});
	}
1012472
public void write(final byte[] src)
	{
		if(src == null) throw new NullPointerException();

		if(src.length < buffer.length - pos) {
			System.arraycopy(src, 0, buffer, pos, src.length);
			pos += src.length;
			size += src.length;
			return;
		}
		writeLoop(src, 0, src.length);
	}
1079977
public void copy(LengthSet src)
    {
        top = src.top;
        right = src.right;
        bottom = src.bottom;
        left = src.left;
    }
495960
public void addPoint(double x, double y)
    {
        if (npoints >= xpoints.length)
        {
            final int newLength = npoints * 2;
            xpoints = Arrays.copyOf(xpoints, newLength);
            ypoints = Arrays.copyOf(ypoints, newLength);
        }
        xpoints[npoints] = x;
        ypoints[npoints] = y;
        npoints++;
        updateBounds();
    }
313744
public void addPoint(PolygonPoint p )    
    {
        p.setPrevious( _last );
        p.setNext( _last.getNext() );
        _last.setNext( p );
        _points.add( p );
    }
117532
public void setAuxAnalyzepath(Path src) {
        boolean nonEmpty = false;

        String[] elementList = src.list();
        for (String anElementList : elementList) {
            if (!"".equals(anElementList)) {
                nonEmpty = true;
                break;
            }
        }

        if (nonEmpty) {
            if (auxAnalyzepath == null) {
                auxAnalyzepath = src;
            } else {
                auxAnalyzepath.append(src);
            }
        }
    }
529657
int addGeometry(Geometry geometry) {
		Geometry.Type gt = geometry.getType();
		if (Geometry.isMultiPath(gt.value()))
			return addMultiPath_((MultiPath) geometry);
		if (gt == Geometry.Type.MultiPoint)
			return addMultiPoint_((MultiPoint) geometry);

		throw GeometryException.GeometryInternalError();
	}
139550
public JsHandlerRegistration addGeometryMergeRemovedHandler(final GeometryMergeRemovedHandler handler) {
		org.geomajas.plugin.editing.client.merge.event.GeometryMergeRemovedHandler h;
		h = new org.geomajas.plugin.editing.client.merge.event.GeometryMergeRemovedHandler() {

			public void onGeometryMergingRemoved(GeometryMergeRemovedEvent event) {
				org.geomajas.plugin.editing.jsapi.client.merge.event.GeometryMergeRemovedEvent e;
				e = new org.geomajas.plugin.editing.jsapi.client.merge.event.GeometryMergeRemovedEvent(
						event.getGeometry());
				handler.onGeometryMergeRemoved(e);
			}
		};
		HandlerRegistration registration = delegate.addGeometryMergeRemovedHandler(h);
		return new JsHandlerRegistration(new HandlerRegistration[] { registration });
	}
543487
public void addSegment(Segment segment, boolean bStartNewPath) {
		mergeVertexDescription(segment.getDescription());
		if (segment.getType() == Type.Line) {
			Point point = new Point();
			if (bStartNewPath || isEmpty()) {
				segment.queryStart(point);
				startPath(point);
			}

			segment.queryEnd(point);
			lineTo(point);
		} else {
			throw GeometryException.GeometryInternalError();
		}
	}