Cloner (cloning 1.9.12 API)
Date: 2019-02-08

com.rits.cloning

## Class Cloner

- java.lang.Object
- - com.rits.cloning.Cloner

-     public class Cloner
      extends Object

  Cloner: deep clone objects. This class is thread safe. One instance can be used by multiple threads on the same time.
  Author:
    kostantinos.kougios 18 Sep 2008

- - ### Constructor Summary

    Constructors
    Constructor and Description
    `Cloner()`
    `Cloner(IInstantiationStrategy instantiationStrategy)`

  - ### Method Summary

    All Methods Static Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `protected List<Field>` | `allFields(Class<?> c)` reflection utils, override this to choose which fields to clone
    `protected <T> T` | `cloneInternal(T o, Map<Object,Object> clones)`
    `protected boolean` | `considerImmutable(Class<?> clz)` override this to decide if a class is immutable.
    `<T,E extends T> void` | `copyPropertiesOfInheritedClass(T src, E dest)` copies all properties from src to dest.
    `<T> T` | `deepClone(T o)` deep clones "o".
    `<T> T` | `deepCloneDontCloneInstances(T o, Object... dontCloneThese)`
    `void` | `dontClone(Class<?>... c)` instances of classes that shouldn't be cloned can be registered using this method.
    `void` | `dontCloneInstanceOf(Class<?>... c)`
    `protected Object` | `fastClone(Object o, Map<Object,Object> clones)`
    `<T> T` | `fastCloneOrNewInstance(Class<T> c)`
    `IDumpCloned` | `getDumpCloned()`
    `protected Class<?>` | `getImmutableAnnotation()`
    `boolean` | `isCloneAnonymousParent()`
    `boolean` | `isCloningEnabled()`
    `boolean` | `isDumpClonedClasses()`
    `boolean` | `isNullTransient()`
    `protected <T> T` | `newInstance(Class<T> c)` creates a new instance of c.
    `void` | `nullInsteadOfClone(Class<?>... c)` instead of cloning these classes will set the field to null
    `void` | `registerCloningStrategy(ICloningStrategy strategy)`
    `void` | `registerConstant(Class<?> c, String privateFieldName)`
    `void` | `registerConstant(Object o)`
    `void` | `registerFastCloner(Class<?> c, IFastCloner fastCloner)`
    `protected void` | `registerFastCloners()` registers a std set of fast cloners.
    `void` | `registerImmutable(Class<?>... c)` registers an immutable class.
    `protected void` | `registerInaccessibleClassToBeFastCloned(String className, IFastCloner fastCloner)`
    `protected void` | `registerKnownConstants()`
    `protected void` | `registerKnownJdkImmutableClasses()` registers some known JDK immutable classes.
    `void` | `registerStaticFields(Class<?>... classes)` registers all static fields of these classes.
    `void` | `setCloneAnonymousParent(boolean cloneAnonymousParent)` if false, anonymous classes parent class won't be cloned.
    `void` | `setCloneSynthetics(boolean cloneSynthetics)`
    `void` | `setCloningEnabled(boolean cloningEnabled)`
    `void` | `setDontCloneInstanceOf(Class<?>... c)`
    `void` | `setDumpCloned(IDumpCloned dumpCloned)` provide a cloned classes dumper (so i.e.
    `void` | `setDumpClonedClasses(boolean dumpClonedClasses)` will println() all cloned classes.
    `void` | `setExtraImmutables(Set<Class<?>> set)`
    `void` | `setExtraNullInsteadOfClone(Set<Class<?>> set)`
    `void` | `setExtraStaticFields(Set<Class<?>> set)` spring framework friendly version of registerStaticFields
    `void` | `setNullTransient(boolean nullTransient)` this makes the cloner to set a transient field to null upon cloning.
    `<T> T` | `shallowClone(T o)` shallow clones "o".
    `static Cloner` | `shared()`
    `static Cloner` | `standard()`
    `void` | `unregisterFastCloner(Class<?> c)`

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### Constructor Detail

    - #### Cloner

          public Cloner()

    - #### Cloner

          public Cloner(IInstantiationStrategy instantiationStrategy)

  - ### Method Detail

    - #### getDumpCloned

          public IDumpCloned getDumpCloned()

    - #### setDumpCloned

          public void setDumpCloned(IDumpCloned dumpCloned)

      provide a cloned classes dumper (so i.e. they can be logged or stored in a file instead of the default behaviour which is to println(cloned) )
      Parameters:
        `dumpCloned` - an implementation of the interface which can dump the cloned classes.

    - #### isNullTransient

          public boolean isNullTransient()

    - #### setNullTransient

          public void setNullTransient(boolean nullTransient)

      this makes the cloner to set a transient field to null upon cloning. NOTE: primitive types can't be nulled. Their value will be set to default, i.e. 0 for int
      Parameters:
        `nullTransient` - true for transient fields to be nulled

    - #### setCloneSynthetics

          public void setCloneSynthetics(boolean cloneSynthetics)

    - #### registerFastCloners

          protected void registerFastCloners()

      registers a std set of fast cloners.

    - #### registerInaccessibleClassToBeFastCloned

          protected void registerInaccessibleClassToBeFastCloned(String className,
                                                                 IFastCloner fastCloner)

    - #### fastClone

          protected Object fastClone(Object o,
                                     Map<Object,Object> clones)

    - #### registerConstant

          public void registerConstant(Object o)

    - #### registerConstant

          public void registerConstant(Class<?> c,
                                       String privateFieldName)

    - #### registerKnownJdkImmutableClasses

          protected void registerKnownJdkImmutableClasses()

      registers some known JDK immutable classes. Override this to register your own list of jdk's immutable classes

    - #### registerKnownConstants

          protected void registerKnownConstants()

    - #### registerCloningStrategy

          public void registerCloningStrategy(ICloningStrategy strategy)

    - #### registerStaticFields

          public void registerStaticFields(Class<?>... classes)

      registers all static fields of these classes. Those static fields won't be cloned when an instance of the class is cloned. This is useful i.e. when a static field object is added into maps or sets. At that point, there is no way for the cloner to know that it was static except if it is registered.
      Parameters:
        `classes` - array of classes

    - #### setExtraStaticFields

          public void setExtraStaticFields(Set<Class<?>> set)

      spring framework friendly version of registerStaticFields
      Parameters:
        `set` - a set of classes which will be scanned for static fields

    - #### dontClone

          public void dontClone(Class<?>... c)

      instances of classes that shouldn't be cloned can be registered using this method.
      Parameters:
        `c` - The class that shouldn't be cloned. That is, whenever a deep clone for an object is created and c is encountered, the object instance of c will be added to the clone.

    - #### dontCloneInstanceOf

          public void dontCloneInstanceOf(Class<?>... c)

    - #### setDontCloneInstanceOf

          public void setDontCloneInstanceOf(Class<?>... c)

    - #### nullInsteadOfClone

          public void nullInsteadOfClone(Class<?>... c)

      instead of cloning these classes will set the field to null
      Parameters:
        `c` - the classes to nullify during cloning

    - #### setExtraNullInsteadOfClone

          public void setExtraNullInsteadOfClone(Set<Class<?>> set)

    - #### registerImmutable

          public void registerImmutable(Class<?>... c)

      registers an immutable class. Immutable classes are not cloned.
      Parameters:
        `c` - the immutable class

    - #### setExtraImmutables

          public void setExtraImmutables(Set<Class<?>> set)

    - #### registerFastCloner

          public void registerFastCloner(Class<?> c,
                                         IFastCloner fastCloner)

    - #### unregisterFastCloner

          public void unregisterFastCloner(Class<?> c)

    - #### newInstance

          protected <T> T newInstance(Class<T> c)

      creates a new instance of c. Override to provide your own implementation
      Type Parameters:
        `T` - the type of c
      Parameters:
        `c` - the class
      Returns:
        a new instance of c

    - #### fastCloneOrNewInstance

          public <T> T fastCloneOrNewInstance(Class<T> c)

    - #### deepClone

          public <T> T deepClone(T o)

      deep clones "o".
      Type Parameters:
        `T` - the type of "o"
      Parameters:
        `o` - the object to be deep-cloned
      Returns:
        a deep-clone of "o".

    - #### deepCloneDontCloneInstances

          public <T> T deepCloneDontCloneInstances(T o,
                                                   Object... dontCloneThese)

    - #### shallowClone

          public <T> T shallowClone(T o)

      shallow clones "o". This means that if c=shallowClone(o) then c!=o. Any change to c won't affect o.
      Type Parameters:
        `T` - the type of o
      Parameters:
        `o` - the object to be shallow-cloned
      Returns:
        a shallow clone of "o"

    - #### considerImmutable

          protected boolean considerImmutable(Class<?> clz)

      override this to decide if a class is immutable. Immutable classes are not cloned.
      Parameters:
        `clz` - the class under check
      Returns:
        true to mark clz as immutable and skip cloning it

    - #### getImmutableAnnotation

          protected Class<?> getImmutableAnnotation()

    - #### cloneInternal

          protected <T> T cloneInternal(T o,
                                        Map<Object,Object> clones)
                                 throws IllegalAccessException

      Throws:
        `IllegalAccessException`

    - #### copyPropertiesOfInheritedClass

          public <T,E extends T> void copyPropertiesOfInheritedClass(T src,
                                                                     E dest)

      copies all properties from src to dest. Src and dest can be of different class, provided they contain same field names/types
      Parameters:
        `src` - the source object
        `dest` - the destination object which must contain as minimum all the fields of src

    - #### allFields

          protected List<Field> allFields(Class<?> c)

      reflection utils, override this to choose which fields to clone

    - #### isDumpClonedClasses

          public boolean isDumpClonedClasses()

    - #### setDumpClonedClasses

          public void setDumpClonedClasses(boolean dumpClonedClasses)

      will println() all cloned classes. Useful for debugging only. Use setDumpCloned() if you want to control where to print the cloned classes.
      Parameters:
        `dumpClonedClasses` - true to enable printing all cloned classes

    - #### isCloningEnabled

          public boolean isCloningEnabled()

    - #### setCloningEnabled

          public void setCloningEnabled(boolean cloningEnabled)

    - #### setCloneAnonymousParent

          public void setCloneAnonymousParent(boolean cloneAnonymousParent)

      if false, anonymous classes parent class won't be cloned. Default is true

    - #### isCloneAnonymousParent

          public boolean isCloneAnonymousParent()

    - #### standard

          public static Cloner standard()

      Returns:
        a standard cloner instance, will do for most use cases

    - #### shared

          public static Cloner shared()

      Returns:
        if Cloner lib is in a shared jar folder for a container (i.e. tomcat/shared), then this method is preferable in order to instantiate cloner. Please see https://code.google.com/p/cloning/issues/detail?id=23

Copyright © 2019. All rights reserved.