00001 /* 00002 * Copyright (c) 2000, 2020, Oracle and/or its affiliates. 00003 * 00004 * Licensed under the Universal Permissive License v 1.0 as shown at 00005 * http://oss.oracle.com/licenses/upl. 00006 */ 00007 #ifndef COH_EVOLVABLE_OBJECT_HPP 00008 #define COH_EVOLVABLE_OBJECT_HPP 00009 00010 #include "coherence/lang.ns" 00011 00012 #include "coherence/io/Evolvable.hpp" 00013 00014 #include "coherence/io/pof/EvolvableHolder.hpp" 00015 00016 COH_OPEN_NAMESPACE3(coherence,io,pof) 00017 00018 using coherence::io::Evolvable; 00019 00020 /** 00021 * Defines an interface that should be implemented by the classes that want to 00022 * support evolution. 00023 * 00024 * @author as 2013.04.24 00025 * 00026 * @since 12.2.1 00027 */ 00028 class COH_EXPORT EvolvableObject 00029 : public interface_spec<EvolvableObject> 00030 { 00031 // ----- EvolvableObject interface -------------------------------------- 00032 00033 public: 00034 /** 00035 * Return Evolvable holder object for the specified type id. 00036 * 00037 * This method should only return Evolvable instance if the specified type 00038 * id matches its own type id. Otherwise, it should delegate to the parent: 00039 * <pre> 00040 * // assuming type ID of this class is 1234 00041 * FinalView<Evolvable> f_vEvolvable; 00042 * ... 00043 * // in constructor 00044 * : f_vEvolvable(self(), SimpleEvolvable::create(IMPL_VERSION)) 00045 * ... 00046 * Evolvable::View getEvolvable(int32_t nTypeId) 00047 * { 00048 * if (1234 == nTypeId) 00049 * { 00050 * return f_vEvolvable; 00051 * } 00052 * 00053 * return super::getEvolvable(nTypeId); 00054 * } 00055 * </pre> 00056 * 00057 * @param nTypeId type id to get Evolvable instance for 00058 * 00059 * @return Evolvable instance for the specified type id 00060 */ 00061 virtual Evolvable::View getEvolvable(int32_t nTypeId) const = 0; 00062 00063 /** 00064 * Return Evolvable holder object for the specified type id. 00065 * 00066 * This method should only return Evolvable instance if the specified type 00067 * id matches its own type id. Otherwise, it should delegate to the parent: 00068 * <pre> 00069 * // assuming type ID of this class is 1234 00070 * FinalView<Evolvable> f_vEvolvable; 00071 * ... 00072 * // in constructor 00073 * : f_vEvolvable(self(), SimpleEvolvable::create(IMPL_VERSION)) 00074 * ... 00075 * Evolvable::Handle getEvolvable(int32_t nTypeId) 00076 * { 00077 * if (1234 == nTypeId) 00078 * { 00079 * return f_vEvolvable; 00080 * } 00081 * 00082 * return super::getEvolvable(nTypeId); 00083 * } 00084 * </pre> 00085 * 00086 * @param nTypeId type id to get Evolvable instance for 00087 * 00088 * @return Evolvable instance for the specified type id 00089 */ 00090 virtual Evolvable::Handle getEvolvable(int32_t nTypeId) = 0; 00091 00092 /** 00093 * Return EvolvableHolder that can be used to store information 00094 * about evolvable objects that are not known during deserialization. 00095 * 00096 * For example, it is possible to evolve the class hierarchy by adding new 00097 * classes at any level in the hierarchy. Normally this would cause a problem 00098 * during deserialization on older clients that don't have new classes at all, 00099 * but EvolvableHolder allows us to work around that issue and simply store 00100 * type id to opaque binary value mapping within it. 00101 * 00102 * @return EvolvableHolder instance 00103 */ 00104 virtual EvolvableHolder::View getEvolvableHolder() const = 0; 00105 }; 00106 00107 COH_CLOSE_NAMESPACE3 00108 00109 #endif // COH_PORTABLE_TYPE_HPP