Package com.rits.cloning

Class 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.

    • Method Detail

      • 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)

      • 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)

      • nullInsteadOfCloneFieldAnnotation

        @SafeVarargs
public final void nullInsteadOfCloneFieldAnnotation​(Class<? extends Annotation>... a)
        instead of cloning, fields annotated with this annotations will be set to null
        Parameters:
        a - the annotations to nullify during cloning

      • setExtraNullInsteadOfCloneFieldAnnotation

        public void setExtraNullInsteadOfCloneFieldAnnotation​(Set<Class<? extends Annotation>> 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)

      • 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