直接注册为默认mapping

@param src
@param dest
8926
public void register(Class src, Class target) {
        List<BeanMappingObject> objects = BeanMappingParser.parseMapping(src, target);
        for (BeanMappingObject object : objects) {
            register(object);
        }
    }
115924
function(src, dest) {
    var i = 0;
    var len = Math.min(src.length, dest.length);
    while(i < len) {
      dest[i] = src[i];
      i++;
    }
    return dest;
  }
975555
def memcpy_dtoh(self, dest, src):
        
        if isinstance(src, drv.DeviceAllocation):
            drv.memcpy_dtoh(dest, src)
        else:
            dest = src
667279
public void toNormalImage(String src, String dest) {
        toNormalImage(new File(src), new File(dest));
    }
1224242
public static function image_resize($src, $dest, $w, $h) {
        $img = getimagesize($src);
        switch ($img[2]) {
            case 1:
                $im_in = imagecreatefromgif($src);
                $im_out = imagecreate($w, $h);
                $bgcolor = imagecolorallocate($im_out, 0, 0, 0);
                $bgcolortrans = ImageColorTransparent($im_out, $bgcolor);
                break;
            case 2:
                $im_in = imagecreatefromjpeg($src);
                $im_out = imagecreatetruecolor($w, $h);
                break;
            case 3:
                $im_in = imagecreatefrompng($src);
                $im_out = imagecreatetruecolor($w, $h);
                imagealphablending($im_out, true);
                imagesavealpha($im_out, true);
                $trans_colour = imagecolorallocatealpha($im_out, 0, 0, 0, 127);
                imagefill($im_out, 0, 0, $trans_colour);
                break;
            default:
                copy($src, $dest);
        }
        if (!$im_in || !$im_out) {
            return false;
        }
        imagecopyresampled($im_out, $im_in, 0, 0, 0, 0, $w, $h, $img[0], $img[1]);
        switch ($img[2]) {
            case 1:
                imagegif($im_out, $dest);
                break;
            case 2:
                imagejpeg($im_out, $dest);
                break;
            case 3:
                imagepng($im_out, $dest);
                break;
            default:
                return -5;  //保存失败
        }
        imagedestroy($im_out);
        imagedestroy($im_in);
    }
1000584
public static JSONObject merge(JSONObject src, UnmodifiableJSONObject dest) {
        return merge(src, copy(dest));
    }
18067
function(src, dest){
      self.logger.info('generating '+dest); 
      fs.createReadStream(src).pipe(fs.createWriteStream(dest)); 
    }
1343851
public static TextContainer copy(TextContainer src, TextContainer dest) {
        dest.setBackGround(src.getBackGround());

        dest.setBackgroundColor(src.getBackgroundColor());

        dest.setGravity(src.getGravity());

        dest.setRefreshFrequency(src.getRefreshFrequency());

        dest.setText(src.getText());

        dest.setTextSize(src.getTextSize());

        dest.setTextColor(src.getTextColor());

        dest.setTypeface(src.getTypeface());

        return dest;
    }
1277775
public static Object copy(Object src, Object dest, int length) {
		System.arraycopy(src, 0, dest, 0, length);
		return dest;
	}
1204640
function _arrayCopy(dest, src) {
    if (Array.isArray(src)) {
        src.forEach(function (item) {
            dest.push(item);
        });
    }
}
196807
def memcpy_dtoh(self, dest, src):
        
        if isinstance(src, cl.Buffer):
            cl.enqueue_copy(self.queue, dest, src)
951494
public static void copyFile(File src, File dest, StreamMonitor monitor) throws IOException, FileNotFoundException {
        FileInputStream fis = null;
        FileOutputStream fos = null;
        int length = (int) src.length();
        try {
            fis = new FileInputStream(src);
            fos = new FileOutputStream(dest);
            StreamUtils.copyStream(monitor, src.toURI().toURL(), length, fis, fos, true);
        } catch (FileNotFoundException e) {
            reportError(monitor, e, src.toURI().toURL());
            throw e;
        } catch (NullArgumentException e) {
            reportError(monitor, e, src.toURI().toURL());
            throw e;
        } catch (MalformedURLException e) {
            reportError(monitor, e, src.toURI().toURL());
            throw e;
        } catch (IOException e) {
            reportError(monitor, e, src.toURI().toURL());
            throw e;
        }
    }
1053489
function extend(dest, src) {
    var result = dest;
    for(var n in src) {
        result[n] = src[n];
    }
    return result;
}
729436
public BufferedImage filter(BufferedImage src, BufferedImage dest) {
        if (dest == null) {
            dest = createCompatibleDestImage(src, null);
        }

        // Make image faded/washed out/red-ish
        // DARK WARM
        float[] scales = new float[] { 2.2f, 2.0f, 1.55f};
        float[] offsets = new float[] {-20.0f, -90.0f, -110.0f};

        // BRIGHT NATURAL
//        float[] scales = new float[] { 1.1f, .9f, .7f};
//        float[] offsets = new float[] {20, 30, 80};

        // Faded, old-style
//        float[] scales = new float[] { 1.1f, .7f, .3f};
//        float[] offsets = new float[] {20, 30, 80};

//        float[] scales = new float[] { 1.2f, .4f, .4f};
//        float[] offsets = new float[] {0, 120, 120};

        // BRIGHT WARM
//        float[] scales = new float[] {1.1f, .8f, 1.6f};
//        float[] offsets = new float[] {60, 70, -80};
        BufferedImage image = new RescaleOp(scales, offsets, getRenderingHints()).filter(src, null);

        // Blur
        image = ImageUtil.blur(image, 2.5f);

        Graphics2D g = dest.createGraphics();
        try {
            g.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
            g.setRenderingHint(RenderingHints.KEY_COLOR_RENDERING, RenderingHints.VALUE_COLOR_RENDER_QUALITY);
            g.drawImage(image, 0, 0, null);

            // Rotate it slightly for a more analogue feeling
            double angle = .0055;
            g.rotate(angle);

            // Scratches
            g.setComposite(AlphaComposite.SrcOver.derive(.025f));
            for (int i = 0; i < 100; i++) {
                g.setColor(random.nextBoolean() ? Color.WHITE : Color.BLACK);
                g.setStroke(new BasicStroke(random.nextFloat() * 2f));
                int x = random.nextInt(image.getWidth());

                int off = random.nextInt(100);
                for (int j = random.nextInt(3); j > 0; j--) {
                    g.drawLine(x + j, 0, x + off - 50 + j, image.getHeight());
                }
            }

            // Vignette/border
            g.setComposite(AlphaComposite.SrcOver.derive(.75f));
            int focus = Math.min(image.getWidth() / 8, image.getHeight() / 8);
            g.setPaint(new RadialGradientPaint(
                    new Point(image.getWidth() / 2, image.getHeight() / 2),
                    Math.max(image.getWidth(), image.getHeight()) / 1.6f,
                    new Point(focus, focus),
                    new float[] {0, .3f, .9f, 1f},
                    new Color[] {new Color(0x99FFFFFF, true), new Color(0x00FFFFFF, true), new Color(0x0, true), Color.BLACK},
                    MultipleGradientPaint.CycleMethod.NO_CYCLE
            ));
            g.fillRect(-2, -2, image.getWidth() + 4, image.getHeight() + 4);

            g.rotate(-angle);

            g.setComposite(AlphaComposite.SrcOver.derive(.35f));
            g.setPaint(new RadialGradientPaint(
                    new Point(image.getWidth() / 2, image.getHeight() / 2),
                    Math.max(image.getWidth(), image.getHeight()) / 1.65f,
                    new Point(image.getWidth() / 2, image.getHeight() / 2),
                    new float[] {0, .85f, 1f},
                    new Color[] {new Color(0x0, true), new Color(0x0, true), Color.BLACK},
                    MultipleGradientPaint.CycleMethod.NO_CYCLE
            ));
            g.fillRect(0, 0, image.getWidth(), image.getHeight());

            // Highlight
            g.setComposite(AlphaComposite.SrcOver.derive(.35f));
            g.setPaint(new RadialGradientPaint(
                    new Point(image.getWidth(), image.getHeight()),
                    Math.max(image.getWidth(), image.getHeight()) * 1.1f,
                    new Point(image.getWidth() / 2, image.getHeight() / 2),
                    new float[] {0, .75f, 1f},
                    new Color[] {new Color(0x00FFFFFF, true), new Color(0x00FFFFFF, true), Color.PINK},
                    MultipleGradientPaint.CycleMethod.NO_CYCLE
            ));
            g.fillRect(0, 0, image.getWidth(), image.getHeight());
        }
        finally {
            g.dispose();
        }

        // Noise
        NoiseFilter noise = new NoiseFilter();
        noise.setAmount(10);
        noise.setDensity(2);
        dest = noise.filter(dest, dest);

        // Round corners
        BufferedImage foo = new BufferedImage(image.getWidth(), image.getHeight(), BufferedImage.TYPE_INT_ARGB);
        Graphics2D graphics = foo.createGraphics();
        try {
            graphics.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
            graphics.setRenderingHint(RenderingHints.KEY_COLOR_RENDERING, RenderingHints.VALUE_COLOR_RENDER_QUALITY);
            graphics.setColor(Color.WHITE);
            double angle = (random.nextDouble() * .01) - .005;
            graphics.rotate(angle);
            graphics.fillRoundRect(4, 4, image.getWidth() - 8, image.getHeight() - 8, 20, 20);
        }
        finally {
            graphics.dispose();
        }

        noise.setAmount(20);
        noise.setDensity(1);
        noise.setMonochrome(true);
        foo = noise.filter(foo, foo);

        foo = ImageUtil.blur(foo, 4.5f);

        // Compose image into rounded corners
        graphics = foo.createGraphics();
        try {
            graphics.setComposite(AlphaComposite.SrcIn);
            graphics.drawImage(dest, 0, 0, null);
        }
        finally {
            graphics.dispose();
        }

        // Draw it all back to dest
        g = dest.createGraphics();
        try {
            if (dest.getTransparency() != Transparency.OPAQUE) {
                g.setComposite(AlphaComposite.Clear);
            }
            g.setColor(Color.WHITE);
            g.fillRect(0, 0, image.getWidth(), image.getHeight());
            g.setComposite(AlphaComposite.SrcOver);
            g.drawImage(foo, 0, 0, null);
        }
        finally {
            g.dispose();
        }

        return dest;
    }
1066167
public static void copy(final Object src, final int srcPos, final Object dest, final int destPos, final int length) {
        if (Array.getLength(src) < srcPos + length) {
            throw new IllegalArgumentException("The size of src array less than " + (srcPos + length));
        }

        if (Array.getLength(dest) < destPos + length) {
            throw new IllegalArgumentException("The size of dest array less than " + (destPos + length));
        }

        System.arraycopy(src, srcPos, dest, destPos, length);
    }
217409
public static TextContainer copy(TextContainer src, TextContainer dest) {
        return TextParams.copy(src, dest);
    }
131586
public void swap(int src, int dest) {
        List<FeatureTypeStyle> ftss = style.featureTypeStyles();
        if (src >= 0 && src < ftss.size() && dest >= 0 && dest < ftss.size()) {
            Collections.swap(ftss, src, dest);
            Collections.swap(featureTypeStylesWrapperList, src, dest);
        }
    }