public static object standard_clone(object Current, object other) // Void if `other' is void; otherwise new object // field-by-field identical to `other'. // Always uses default copying semantics. { return(ANY.standard_clone(Current, other)); }
public static bool standard_equal(object Current, object some, object other) // Are `some' and `other' either both void or attached to // field-by-field identical objects of the same type? // Always uses default object comparison criterion. { return(ANY.standard_equal(Current, some, other)); }
public static object clone(object Current, object other) // Void if `other' is void; otherwise new object // equal to `other' // // For non-void `other', `clone' calls `copy'; // to change copying/cloning semantics, redefine `copy'. { return(ANY.clone(Current, other)); }
public static String generator(object o) // Generator class name of `o'. { return(ANY.generator(o)); }
public static bool equal(object Current, object some, object other) // Are `some' and `other' either both void or attached // to objects considered equal? { return(ANY.equal(Current, some, other)); }
public static object deep_twin(object Current) // New object structure recursively duplicated from Current. { return(ANY.deep_twin(Current)); }
public static bool is_deep_equal(object Current, object other) // Are `Current' and `other' attached to isomorphic object structures? { return(ANY.deep_equal(Current, Current, other)); }
public static bool deep_equal(object Current, object some, object other) // Are `some' and `other' either both void // or attached to isomorphic object structures? { return(ANY.deep_equal(Current, some, other)); }
public static String @out(object o) // `out' of `o' { return(ANY.@out(o)); }
public static void copy(object Current, object other) // Update current object using fields of object attached // to `other', so as to yield equal objects. { ANY.copy(Current, other); }
#pragma warning restore 1718 /* * feature -- Redirection to feature of ANY class */ public static bool conforms_to(Object obj1, Object obj2) // Does dynamic type of object attached to `obj1' conform to // dynamic type of object attached to `obj2'? { return(ANY.conforms_to(obj1, obj2)); }
public static object twin(object Current) // New object equal to `Current' // `twin' calls `copy'; to change copying/twining semantics, redefine `copy'. { return(ANY.twin(Current)); }
public static String tagged_out(object o) // `out' of `o' { return(ANY.tagged_out(o)); }
public static object standard_twin(object Current) // New object field-by-field identical to `other'. // Always uses default copying semantics. { return(ANY.standard_twin(Current)); }
public static bool standard_is_equal(object Current, object other) // Is `other' attached to an object of the same type // as current object, and field-by-field identical to it? { return(ANY.standard_is_equal(Current, other)); }
public static String generating_type(object o) // Generating type name of `o'. { return(ANY.generating_type(o)); }
public static bool is_equal(object Current, object other) // Is `other' attached to an object considered // equal to current object? { return(ANY.is_equal(Current, other)); }
public static object deep_clone(object Current, object other) // Obsolete use `deep_twin' instead. { return(ANY.deep_clone(Current, other)); }
public static bool same_type(object Current, object other) // Is type of current object identical to type of `other'? { return(ANY.same_type(Current, other)); }
public static void deep_copy(object Current, object other) // Effect equivalent to that of: // `copy' (`other' . `deep_twin') { ANY.deep_copy(Current, other); }