private ClassInfo NewUserClassMeta(IReflectClass claxx)
{
ClassInfo classMeta = ClassInfo.NewUserClass(claxx.GetName());
classMeta.SetSuperClass(MapSuperclass(claxx));
RegisterClassMeta(claxx.GetName(), classMeta);
classMeta.SetFields(MapFields(claxx.GetDeclaredFields(), ShouldStoreTransientFields
(claxx)));
return classMeta;
}
private ClassInfo NewUserClassMeta(IReflectClass claxx)
{
ClassInfo classMeta = ClassInfo.NewUserClass(claxx.GetName());
classMeta.SetSuperClass(MapSuperclass(claxx));
RegisterClassMeta(claxx.GetName(), classMeta);
classMeta.SetFields(MapFields(claxx.GetDeclaredFields(), ShouldStoreTransientFields
(claxx)));
return(classMeta);
}
public virtual ClassInfo GetClassMeta(IReflectClass claxx)
{
if (IsObjectClass(claxx))
{
return ClassInfo.NewSystemClass(claxx.GetName());
}
ClassInfo existing = LookupClassMeta(claxx.GetName());
if (existing != null)
{
return existing;
}
return NewUserClassMeta(claxx);
}
public virtual ClassInfo GetClassMeta(IReflectClass claxx)
{
if (IsObjectClass(claxx))
{
return(ClassInfo.NewSystemClass(claxx.GetName()));
}
ClassInfo existing = LookupClassMeta(claxx.GetName());
if (existing != null)
{
return(existing);
}
return(NewUserClassMeta(claxx));
}
public IObjectClass ObjectClass(object clazz)
{
string className = null;
if (clazz is string)
{
className = (string)clazz;
}
else
{
IReflectClass claxx = ReflectorFor(clazz);
if (claxx == null)
{
return(null);
}
className = claxx.GetName();
}
if (ReflectPlatform.FullyQualifiedName(typeof(object)).Equals(className))
{
throw new ArgumentException("Configuration of the Object class is not supported."
);
}
Hashtable4 xClasses = ExceptionalClasses();
Config4Class c4c = (Config4Class)xClasses.Get(className);
if (c4c == null)
{
c4c = new Config4Class(this, className);
xClasses.Put(className, c4c);
}
return(c4c);
}
private void ThrowUnsupportedAdd(IReflectClass runtimeAncestor)
{
throw new InvalidOperationException("Unsupported class hierarchy change. Class "
+ runtimeAncestor.GetName() + " was added to hierarchy of " +
_runtimeClass.GetName
());
}
private void AssertFullyQualifiedName(Type clazz)
{
IReflectClass reflectClass = Platform4.ReflectorForType(clazz).ForClass(clazz);
Assert.AreEqual(ReflectPlatform.FullyQualifiedName(clazz), reflectClass.GetName()
);
}
private void ThrowUnsupportedAdd(IReflectClass runtimeAncestor)
{
throw new InvalidOperationException("Unsupported class hierarchy change. Class "
+ runtimeAncestor.GetName() + " was added to hierarchy of " +
_runtimeClass.GetName
());
}
internal QConClass(Transaction trans, QCon parent, QField field, IReflectClass claxx
) : base(trans, parent, field, null)
{
// C/S
if (claxx != null)
{
ObjectContainerBase container = trans.Container();
_classMetadata = container.ClassMetadataForReflectClass(claxx);
if (_classMetadata == null)
{
// could be an aliased class, try to resolve.
string className = claxx.GetName();
string aliasRunTimeName = container.Config().ResolveAliasStoredName(className);
if (!className.Equals(aliasRunTimeName))
{
_classMetadata = container.ClassMetadataForName(aliasRunTimeName);
}
}
if (claxx.Equals(container._handlers.IclassObject))
{
_classMetadata = (ClassMetadata)_classMetadata.TypeHandler();
}
}
_claxx = claxx;
}
public List <TreeGridViewRenderer> ExpandObjectNode(object obj, bool activate)
{
try
{
//object obj = Db4oClient.Client.Ext().GetByID(id);
if (obj == null)
{
return(null);
}
IReflectClass rclass = DataLayerCommon.ReflectClassFor(obj);
if (rclass == null)
{
return(null);
}
string classname = rclass.GetName();
if (classname != string.Empty)
{
TraverseObjTree(GetLocalID(obj), classname);
}
return(listTreeGridViewRenderers);
}
catch (Exception oEx)
{
LoggingHelper.HandleException(oEx);
return(null);
}
}
public TreeGridViewRenderer FillValuesInTreeGridViewRenderer(long id, string classname)
{
TreeGridViewRenderer treeGridViewRenderer = new TreeGridViewRenderer();
try
{
object currObj = Db4oClient.Client.Ext().GetByID(id);
Db4oClient.Client.Ext().Activate(currObj, 1);
IReflectClass rclass = DataLayerCommon.ReflectClassForName(classname);
IType type = ResolveType(rclass);
treeGridViewRenderer.QualifiedName = rclass.GetName();
treeGridViewRenderer.DisplayFieldName = AppendIDTo(type.FullName, id, type);
treeGridViewRenderer.FieldName = type.FullName;
treeGridViewRenderer.FieldValue = type.DisplayName;
treeGridViewRenderer.FieldType = SetFieldType(type);
treeGridViewRenderer.ReadOnlyStatus = true;
treeGridViewRenderer.ObjectId = id;
treeGridViewRenderer.ObjectType = type;
}
catch (Exception e)
{
LoggingHelper.HandleException(e);
}
return(treeGridViewRenderer);
}
public void ExpandObjectNode(TreeGridNode node, bool activate)
{
try
{
object obj = node.Tag;
if (obj == null)
{
return;
}
IReflectClass rclass = DataLayerCommon.ReflectClassFor(obj);
if (rclass == null)
{
return;
}
string classname = rclass.GetName();
if (classname != string.Empty)
{
TraverseObjTree(ref node, obj, classname);
}
}
catch (Exception oEx)
{
LoggingHelper.HandleException(oEx);
}
}
internal QConClass(Transaction trans, QCon parent, QField field, IReflectClass claxx
) : base(trans, parent, field, null)
{
// C/S
if (claxx != null)
{
ObjectContainerBase container = trans.Container();
_classMetadata = container.ClassMetadataForReflectClass(claxx);
if (_classMetadata == null)
{
// could be an aliased class, try to resolve.
string className = claxx.GetName();
string aliasRunTimeName = container.Config().ResolveAliasStoredName(className);
if (!className.Equals(aliasRunTimeName))
{
_classMetadata = container.ClassMetadataForName(aliasRunTimeName);
}
}
if (claxx.Equals(container._handlers.IclassObject))
{
_classMetadata = (ClassMetadata)_classMetadata.TypeHandler();
}
}
_claxx = claxx;
}
private static TypeName NameOf(IReflectClass typeToFind)
{
var name = TypeNameParser.ParseString(typeToFind.GetName());
if (typeToFind.IsArray() && !name.ArrayOf.HasValue)
{
return TypeName.CreateArrayOf(name, 1);
}
return name;
}
public virtual void TestInternalClassesAreNotVisible()
{
IReflectClass[] knownClassArray = Container().KnownClasses();
for (int knownClassIndex = 0; knownClassIndex < knownClassArray.Length; ++knownClassIndex)
{
IReflectClass knownClass = knownClassArray[knownClassIndex];
AssertIsNotInternal(knownClass.GetName());
}
}
public virtual void TestNoPrimitives()
{
IReflectClass[] knownClassArray = Container().KnownClasses();
for (int knownClassIndex = 0; knownClassIndex < knownClassArray.Length; ++knownClassIndex)
{
IReflectClass knownClass = knownClassArray[knownClassIndex];
Assert.IsFalse(knownClass.IsPrimitive(), knownClass.GetName());
}
}
private IReflectClass PrimitiveClass(IReflectClass baseClass)
{
Type primitive = (Type)Primitives.Get(baseClass.GetName());
if (primitive != null)
{
return(baseClass.Reflector().ForClass(primitive));
}
return(baseClass);
}
private static TypeName NameOf(IReflectClass typeToFind)
{
var name = TypeNameParser.ParseString(typeToFind.GetName());
if (typeToFind.IsArray() && !name.ArrayOf.HasValue)
{
return(TypeName.CreateArrayOf(name, 1));
}
return(name);
}
private ClassMetadata ReadClassMetadata(IReflectClass reflectClazz)
{
var clazz = (ClassMetadata)_classMetadataByBytes.Remove(GetNameBytes(reflectClazz
.GetName()));
if (clazz == null)
{
return(null);
}
return(ReadClassMetadata(clazz, reflectClazz));
}
private bool IsKnownClass(string expected)
{
IReflectClass[] knownClassArray = Container().KnownClasses();
for (int knownClassIndex = 0; knownClassIndex < knownClassArray.Length; ++knownClassIndex)
{
IReflectClass knownClass = knownClassArray[knownClassIndex];
string className = knownClass.GetName();
if (className.Equals(expected))
{
return(true);
}
}
return(false);
}
public IType Resolve(IReflectClass klass)
{
if (klass == null)
{
return null;
}
string className = klass.GetName();
if (!_resolved.ContainsKey(className))
{
_resolved[className] = new TypeImpl(klass, this);
}
return _resolved[className];
}
public IType Resolve(IReflectClass klass)
{
if (klass == null)
{
return(null);
}
string className = klass.GetName();
if (!_resolved.ContainsKey(className))
{
_resolved[className] = new TypeImpl(klass, this);
}
return(_resolved[className]);
}
public virtual void TestValueTypes()
{
Container().Reflector().ForName("System.Guid, mscorlib");
bool found = false;
IReflectClass[] knownClassArray = Container().KnownClasses();
for (int knownClassIndex = 0; knownClassIndex < knownClassArray.Length; ++knownClassIndex)
{
IReflectClass knownClass = knownClassArray[knownClassIndex];
if (knownClass.GetName().Equals("System.Guid, mscorlib"))
{
found = true;
}
}
Assert.IsTrue(found);
}
private IReflectClass NormalizeFieldClass(RawFieldSpec fieldInfo, IReflectClass fieldClass
)
{
// TODO: why the following line is necessary?
IReflectClass theClass = _stream.Reflector().ForName(fieldClass.GetName());
if (fieldInfo.IsPrimitive())
{
theClass = PrimitiveClass(theClass);
}
if (fieldInfo.IsArray())
{
theClass = ArrayClass(theClass);
}
return(theClass);
}
public override bool CreateClassMetadata(ClassMetadata clazz, IReflectClass claxx
, ClassMetadata superClazz)
{
Write(Msg.CreateClass.GetWriterForString(SystemTransaction(), Config().ResolveAliasRuntimeName
(claxx.GetName())));
Msg resp = GetResponse();
if (resp == null)
{
return(false);
}
if (resp.Equals(Msg.Failed))
{
// if the class can not be created on the server, send class meta to the server.
SendClassMeta(claxx);
resp = GetResponse();
}
if (resp.Equals(Msg.Failed))
{
if (ConfigImpl.ExceptionsOnNotStorable())
{
throw new ObjectNotStorableException(claxx);
}
return(false);
}
if (!resp.Equals(Msg.ObjectToClient))
{
return(false);
}
MsgObject message = (MsgObject)resp;
StatefulBuffer bytes = message.Unmarshall();
if (bytes == null)
{
return(false);
}
bytes.SetTransaction(SystemTransaction());
if (!base.CreateClassMetadata(clazz, claxx, superClazz))
{
return(false);
}
clazz.SetID(message.GetId());
clazz.ReadName1(SystemTransaction(), bytes);
ClassCollection().AddClassMetadata(clazz);
ClassCollection().ReadClassMetadata(clazz, claxx);
return(true);
}
private Db4objects.Db4o.Reflect.Generic.GenericClass GenericClass(IReflectClass clazz
)
{
Db4objects.Db4o.Reflect.Generic.GenericClass ret;
string name = clazz.GetName();
if (name.Equals(ReflectPlatform.FullyQualifiedName(typeof(GenericArray))))
{
// special case, comparing name because can't compare class == class directly with ReflectClass
ret = new GenericArrayClass(this, clazz, name, null);
}
else
{
ret = new Db4objects.Db4o.Reflect.Generic.GenericClass(this, clazz, name, null);
}
return(ret);
}
internal ClassMetadata ClassMetadataForReflectClass(IReflectClass reflectClazz)
{
ClassMetadata cached = (ClassMetadata)_classMetadataByClass.Get(reflectClazz);
if (cached != null)
{
return(cached);
}
ClassMetadata byName = (ClassMetadata)_classMetadataByName.Get(reflectClazz.GetName
());
if (byName != null)
{
return(byName);
}
return(ReadClassMetadata(reflectClazz));
}
public static bool CheckForDatetimeOrString(object expandedObj)
{
try
{
IReflectClass refClass = ReflectClassFor(expandedObj);// objectContainer.Ext().Reflector().ForObject(expandedObj);
if (refClass != null)
{
string type = PrimitiveType(refClass.GetName());
return(CommonValues.IsDateTimeOrString(type));
}
return(false);
}
catch (Exception oEx)
{
LoggingHelper.HandleException(oEx);
return(false);
}
}
public override string ToString()
{
try
{
int id = GetID();
string str = "ObjectReference\nID=" + id;
object obj = GetObject();
if (obj == null && _class != null)
{
ObjectContainerBase container = _class.Container();
if (container != null && id > 0)
{
obj = container.PeekPersisted(container.Transaction, id, container.DefaultActivationDepth
(ClassMetadata()), true).ToString();
}
}
if (obj == null)
{
str += "\nfor [null]";
}
else
{
string objToString = string.Empty;
try
{
objToString = obj.ToString();
}
catch (Exception)
{
}
if (ClassMetadata() != null)
{
IReflectClass claxx = ClassMetadata().Reflector().ForObject(obj);
str += "\n" + claxx.GetName();
}
str += "\n" + objToString;
}
return(str);
}
catch (Exception)
{
}
return("ObjectReference " + GetID());
}
internal virtual GenericClass EnsureDelegate(IReflectClass
clazz)
{
if (clazz == null)
{
return(null);
}
var claxx = (GenericClass
)_repository.LookupByName(clazz.GetName());
if (claxx == null)
{
// We don't have to worry about the superclass, it can be null
// because handling is delegated anyway
claxx = GenericClass(clazz);
_repository.Register(claxx);
}
return(claxx);
}
/// <summary>
/// This is to ensure that reflector.forObject(GenericArray) returns an instance of GenericArrayClass instead of GenericClass
/// http://tracker.db4o.com/jira/browse/COR-376
/// </summary>
public virtual void TestGenericArrayClass()
{
IExtObjectContainer oc = Fixture().Db();
InitGenericObjects();
IReflectClass elementType = oc.Reflector().ForName(PersonClassname);
object array = Reflector().Array().NewInstance(elementType, 5);
IReflectClass arrayClass = oc.Reflector().ForObject(array);
Assert.IsTrue(arrayClass.IsArray());
Assert.IsTrue(arrayClass is GenericArrayClass);
arrayClass = oc.Reflector().ForName(array.GetType().FullName);
Assert.IsTrue(arrayClass.IsArray());
Assert.IsTrue(arrayClass is GenericArrayClass);
arrayClass = oc.Reflector().ForClass(array.GetType());
Assert.IsTrue(arrayClass.IsArray());
Assert.IsTrue(arrayClass is GenericArrayClass);
Assert.AreEqual(arrayClass.GetName(), ReflectPlatform.FullyQualifiedName(array.GetType
()));
Assert.AreEqual("(GA) " + elementType.GetName(), array.ToString());
}
private TernaryBool CallConstructorSpecialized(IReflectClass clazz)
{
Config4Class clazzConfig = _config.ConfigClass(clazz.GetName());
if (clazzConfig != null)
{
TernaryBool res = clazzConfig.CallConstructor();
if (!res.IsUnspecified())
{
return res;
}
}
if (Platform4.IsEnum(_config.Reflector(), clazz))
{
return TernaryBool.No;
}
IReflectClass ancestor = clazz.GetSuperclass();
if (ancestor != null)
{
return CallConstructorSpecialized(ancestor);
}
return TernaryBool.Unspecified;
}
/// <summary>returns a prototype object for a specific class.</summary>
/// <remarks>returns a prototype object for a specific class.</remarks>
public virtual object PrototypeForClass(Type clazz)
{
if (clazz == null)
{
throw new PrototypesException("Class can not be null");
}
IReflectClass claxx = _reflector.ForClass(clazz);
if (claxx == null)
{
throw new PrototypesException("Not found in the reflector: " + clazz);
}
string className = claxx.GetName();
Prototypes.Prototype prototype = (Prototypes.Prototype)_prototypes.Get(className);
if (prototype != null)
{
return(prototype.Object());
}
prototype = new Prototypes.Prototype(this, claxx);
_prototypes.Put(className, prototype);
return(prototype.Object());
}
public static void SaveValues(long id, string attribName, object newValue, int offset)
{
try
{
object targetObject = Db4oClient.Client.Ext().GetByID(id);
Db4oClient.Client.Ext().Activate(targetObject, 2);
IReflectClass rclass = DataLayerCommon.ReflectClassFor(targetObject);
IReflectField rfield = DataLayerCommon.GetDeclaredFieldInHeirarchy(rclass, attribName);
IType type = new FieldDetails(rclass.GetName(), attribName).GetFieldType();
object obj = rfield.Get(targetObject);
if (obj is IDictionary)
{
SaveDictionary(targetObject, attribName, newValue, KeyAtIndex((IDictionary)obj, offset / 2));
}
else
{
if (rfield != null && !(rfield is GenericVirtualField || rfield.IsStatic()))
{
if (type.IsArray || type.IsCollection)
{
IList list = obj as IList;
if (null != list)
{
list[offset] = newValue;
rfield.Set(targetObject, list);
}
}
}
}
}
catch (Exception oEx)
{
Db4oClient.Client.Rollback();
LoggingHelper.HandleException(oEx);
}
}
public static List <IReflectField> GetFieldList(IReflectClass aClass)
{
try
{
if (aClass == null)
{
return(null);
}
List <IReflectField> ret = NonVirtualFieldsFor(aClass);
IReflectClass parent = aClass.GetSuperclass();
if (parent != null && !(parent.GetName().StartsWith("System.")))
{
ret.AddRange(GetFieldList(parent));
}
return(ret);
}
catch (Exception e)
{
LoggingHelper.HandleException(e);
}
return(null);
}
private TernaryBool CallConstructorSpecialized(IReflectClass clazz)
{
Config4Class clazzConfig = _config.ConfigClass(clazz.GetName());
if (clazzConfig != null)
{
TernaryBool res = clazzConfig.CallConstructor();
if (!res.IsUnspecified())
{
return(res);
}
}
if (Platform4.IsEnum(_config.Reflector(), clazz))
{
return(TernaryBool.No);
}
IReflectClass ancestor = clazz.GetSuperclass();
if (ancestor != null)
{
return(CallConstructorSpecialized(ancestor));
}
return(TernaryBool.Unspecified);
}
internal virtual string ResolveName(IReflectClass claxx)
{
if (i_nameBytes != null)
{
var name = _container.StringIO().Read(i_nameBytes);
return ConfigImpl().ResolveAliasStoredName(name);
}
if (claxx != null)
{
return ConfigImpl().ResolveAliasStoredName(claxx.GetName());
}
throw new InvalidOperationException();
}
public override bool CreateClassMetadata(ClassMetadata clazz, IReflectClass claxx
, ClassMetadata superClazz)
{
Write(Msg.CreateClass.GetWriterForString(SystemTransaction(), Config().ResolveAliasRuntimeName
(claxx.GetName())));
Msg resp = GetResponse();
if (resp == null)
{
return false;
}
if (resp.Equals(Msg.Failed))
{
// if the class can not be created on the server, send class meta to the server.
SendClassMeta(claxx);
resp = GetResponse();
}
if (resp.Equals(Msg.Failed))
{
if (ConfigImpl.ExceptionsOnNotStorable())
{
throw new ObjectNotStorableException(claxx);
}
return false;
}
if (!resp.Equals(Msg.ObjectToClient))
{
return false;
}
MsgObject message = (MsgObject)resp;
StatefulBuffer bytes = message.Unmarshall();
if (bytes == null)
{
return false;
}
bytes.SetTransaction(SystemTransaction());
if (!base.CreateClassMetadata(clazz, claxx, superClazz))
{
return false;
}
clazz.SetID(message.GetId());
clazz.ReadName1(SystemTransaction(), bytes);
ClassCollection().AddClassMetadata(clazz);
ClassCollection().ReadClassMetadata(clazz, claxx);
return true;
}
public override ClassMetadata ClassMetadataForReflectClass(IReflectClass claxx)
{
ClassMetadata classMetadata = base.ClassMetadataForReflectClass(claxx);
if (classMetadata != null)
{
return classMetadata;
}
string className = Config().ResolveAliasRuntimeName(claxx.GetName());
if (ClassMetadataIdForName(className) == 0)
{
return null;
}
return ProduceClassMetadata(claxx);
}
internal virtual GenericClass EnsureDelegate(IReflectClass
clazz)
{
if (clazz == null)
{
return null;
}
var claxx = (GenericClass
) _repository.LookupByName(clazz.GetName());
if (claxx == null)
{
// We don't have to worry about the superclass, it can be null
// because handling is delegated anyway
claxx = GenericClass(clazz);
_repository.Register(claxx);
}
return claxx;
}
private GenericClass GenericClass(IReflectClass clazz
)
{
GenericClass ret;
var name = clazz.GetName();
if (name.Equals(ReflectPlatform.FullyQualifiedName(typeof (GenericArray))))
{
// special case, comparing name because can't compare class == class directly with ReflectClass
ret = new GenericArrayClass(this, clazz, name, null);
}
else
{
ret = new GenericClass(this, clazz, name, null);
}
return ret;
}
public ObjectNotStorableException(IReflectClass clazz, string message) : base(clazz
.GetName() + ": " + message)
{
}
private IReflectClass PrimitiveClass(IReflectClass baseClass)
{
Type primitive = (Type)Primitives.Get(baseClass.GetName());
if (primitive != null)
{
return baseClass.Reflector().ForClass(primitive);
}
return baseClass;
}
private bool ShouldStoreTransientFields(IReflectClass claxx)
{
Config4Class configClass = _config.ConfigClass(claxx.GetName());
return(configClass == null ? false : configClass.StoreTransientFields());
}
public ObjectNotStorableException(IReflectClass a_class) : base(Db4objects.Db4o.Internal.Messages
.Get(a_class.IsPrimitive() ? 59 : 45, a_class.GetName()))
{
}
public Prototype(Prototypes _enclosing, IReflectClass claxx)
{
this._enclosing = _enclosing;
this._object = (object)claxx.NewInstance();
if (this._object == null)
{
throw new PrototypesException("Prototype could not be created for class " + claxx
.GetName());
}
this.Analyze(this._object, claxx, this._enclosing._recursionDepth, null);
}
public bool Match(IReflectClass candidate)
{
return candidate.GetName().Equals(_className);
}
/// <summary>
/// analyzes the passed expression and tries to find the path to the
/// backing field that is accessed.
/// </summary>
/// <remarks>
/// analyzes the passed expression and tries to find the path to the
/// backing field that is accessed.
/// </remarks>
public virtual IEnumerator BackingFieldPath(IReflectClass claxx, object expression
)
{
return BackingFieldPath(claxx.GetName(), expression);
}
private ClassMetadata ReadClassMetadata(IReflectClass reflectClazz)
{
ClassMetadata clazz = (ClassMetadata)_classMetadataByBytes.Remove(GetNameBytes(reflectClazz
.GetName()));
if (clazz == null)
{
return null;
}
return ReadClassMetadata(clazz, reflectClazz);
}
public ObjectNotStorableException(IReflectClass clazz) : base(Messages
.Get(clazz.IsImmutable() ? 59 : 45, clazz.GetName()))
{
}
private bool ShouldStoreTransientFields(IReflectClass claxx)
{
Config4Class configClass = _config.ConfigClass(claxx.GetName());
return configClass == null ? false : configClass.StoreTransientFields();
}
private IReflectClass NormalizeFieldClass(RawFieldSpec fieldInfo, IReflectClass fieldClass
)
{
// TODO: why the following line is necessary?
IReflectClass theClass = _stream.Reflector().ForName(fieldClass.GetName());
if (fieldInfo.IsPrimitive())
{
theClass = PrimitiveClass(theClass);
}
if (fieldInfo.IsArray())
{
theClass = ArrayClass(theClass);
}
return theClass;
}
internal ClassMetadata ClassMetadataForReflectClass(IReflectClass reflectClazz)
{
ClassMetadata cached = (ClassMetadata)_classMetadataByClass.Get(reflectClazz);
if (cached != null)
{
return cached;
}
ClassMetadata byName = (ClassMetadata)_classMetadataByName.Get(reflectClazz.GetName
());
if (byName != null)
{
return byName;
}
return ReadClassMetadata(reflectClazz);
}
public virtual void Register(IReflectClass clazz)
{
Register(clazz.GetName(), clazz);
}
public ObjectNotStorableException(IReflectClass clazz) : base(Db4objects.Db4o.Internal.Messages
.Get(clazz.IsSimple() ? 59 : 45, clazz.GetName()))
{
}
