/**********************************************************************
Copyright (c) 2007 Erik Bengtson and others. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
Contributors:
...
**********************************************************************/
/**
* Class defining JPOX schema definition tables. Represents a table in the
* datastore storing the class and table mappings. This table is used when
* restarting a JPOX system so that it is 'aware' of what classes were
* supported the previous time this datastore was used. It uses this
* information to pre-populate the RDBMSManager with the classes stored in this
* table. The table names are not used as such, other than as a record of what
* table a class maps to - because it goes off and finds the MetaData for the
* class which, with the JPOX naming scheme, defines the table name anyway.
*
*/
package org.jpox.store.rdbms;
import javax.jdo.JDOFatalInternalException;
import javax.jdo.PersistenceManager;
import javax.jdo.identity.StringIdentity;
import javax.jdo.spi.JDOImplHelper;
import javax.jdo.spi.JDOPermission;
import javax.jdo.spi.PersistenceCapable;
import javax.jdo.spi.StateManager;
/**
* Schema Table
*/
public class SchemaTable2 implements PersistenceCapable
{
/** class name * */
String className;
/** table name * */
String tableName;
/** type * */
String type;
/** owner * */
String owner;
/** version * */
String version;
/** interface name * */
String interfaceName;
public SchemaTable2()
{
}
public String getClassName()
{
return jdoGetclassName(this);
}
public void setClassName(String className)
{
jdoSetclassName(this, className);
}
public String getInterfaceName()
{
return jdoGetinterfaceName(this);
}
public void setInterfaceName(String interfaceName)
{
jdoSetinterfaceName(this, interfaceName);
}
public String getOwner()
{
return jdoGetowner(this);
}
public void setOwner(String owner)
{
jdoSetowner(this, owner);
}
public String getTableName()
{
return jdoGettableName(this);
}
public void setTableName(String tableName)
{
jdoSettableName(this, tableName);
}
public String getType()
{
return jdoGettype(this);
}
public void setType(String type)
{
jdoSettype(this, type);
}
public String getVersion()
{
return jdoGetversion(this);
}
public void setVersion(String version)
{
jdoSetversion(this, version);
}
// ------------------ PersistenceCapable interface --------------------
public void jdoCopyKeyFieldsFromObjectId(javax.jdo.spi.PersistenceCapable.ObjectIdFieldConsumer fc, Object oid)
{
if (fc == null)
{
throw new IllegalArgumentException("ObjectIdFieldConsumer is null");
}
if (!(oid instanceof StringIdentity))
{
throw new ClassCastException("oid is not instanceof javax.jdo.identity.StringIdentity");
}
else
{
StringIdentity o = (StringIdentity) oid;
fc.storeStringField(0, o.getKey());
return;
}
}
protected void jdoCopyKeyFieldsFromObjectId(Object oid)
{
if (!(oid instanceof StringIdentity))
{
throw new ClassCastException("key class is not javax.jdo.identity.StringIdentity or null");
}
else
{
StringIdentity o = (StringIdentity) oid;
className = o.getKey();
return;
}
}
public final void jdoCopyKeyFieldsToObjectId(Object oid)
{
throw new JDOFatalInternalException("It's illegal to call jdoCopyKeyFieldsToObjectId for a class with Single Field Identity.");
}
public final void jdoCopyKeyFieldsToObjectId(javax.jdo.spi.PersistenceCapable.ObjectIdFieldSupplier fs, Object oid)
{
throw new JDOFatalInternalException("It's illegal to call jdoCopyKeyFieldsToObjectId for a class with Single Field Identity.");
}
public final Object jdoGetObjectId()
{
return jdoStateManager == null ? null : jdoStateManager.getObjectId(this);
}
public final Object jdoGetVersion()
{
return jdoStateManager == null ? null : jdoStateManager.getVersion(this);
}
protected final void jdoPreSerialize()
{
if (jdoStateManager != null)
{
jdoStateManager.preSerialize(this);
}
}
public final PersistenceManager jdoGetPersistenceManager()
{
return jdoStateManager == null ? null : jdoStateManager.getPersistenceManager(this);
}
public final Object jdoGetTransactionalObjectId()
{
return jdoStateManager == null ? null : jdoStateManager.getTransactionalObjectId(this);
}
public final boolean jdoIsDeleted()
{
return jdoStateManager == null ? false : jdoStateManager.isDeleted(this);
}
public final boolean jdoIsDirty()
{
return jdoStateManager == null ? false : jdoStateManager.isDirty(this);
}
public final boolean jdoIsNew()
{
return jdoStateManager == null ? false : jdoStateManager.isNew(this);
}
public final boolean jdoIsPersistent()
{
return jdoStateManager == null ? false : jdoStateManager.isPersistent(this);
}
public final boolean jdoIsTransactional()
{
return jdoStateManager == null ? false : jdoStateManager.isTransactional(this);
}
public final boolean jdoIsDetached()
{
return jdoIsDetachedInternal();
}
public final void jdoMakeDirty(String fieldName)
{
if (jdoStateManager != null)
{
jdoStateManager.makeDirty(this, fieldName);
}
}
public final Object jdoNewObjectIdInstance()
{
return new StringIdentity(getClass(), className);
}
public final Object jdoNewObjectIdInstance(Object key)
{
if (key == null)
{
throw new IllegalArgumentException("key is null");
}
if (!(key instanceof String))
{
return new StringIdentity(getClass(), (String) key);
}
else
{
return new StringIdentity(getClass(), (String) key);
}
}
public final void jdoProvideFields(int fieldId[])
{
if (fieldId == null)
{
throw new IllegalArgumentException("argment is null");
}
int i = fieldId.length - 1;
if (i >= 0)
{
do
{
jdoProvideField(fieldId[i]);
}
while (--i >= 0);
}
}
public final void jdoReplaceFields(int fieldId[])
{
if (fieldId == null)
{
throw new IllegalArgumentException("argument is null");
}
int i = fieldId.length;
if (i > 0)
{
int j = 0;
do
{
jdoReplaceField(fieldId[j]);
}
while (++j < i);
}
}
public final void jdoReplaceFlags()
{
if (jdoStateManager != null)
{
jdoFlags = jdoStateManager.replacingFlags(this);
}
}
public final synchronized void jdoReplaceStateManager(StateManager stateManager)
{
if (jdoStateManager != null)
{
jdoStateManager = jdoStateManager.replacingStateManager(this, stateManager);
return;
}
SecurityManager securityManager = System.getSecurityManager();
if (securityManager != null)
{
securityManager.checkPermission(new JDOPermission("setStateManager"));
}
jdoStateManager = stateManager;
jdoFlags = 1;
}
protected boolean jdoIsDetachedInternal()
{
return false;
}
public PersistenceCapable jdoNewInstance(StateManager sm)
{
SchemaTable2 result = new SchemaTable2();
result.jdoFlags = 1;
result.jdoStateManager = sm;
return result;
}
public PersistenceCapable jdoNewInstance(StateManager sm, Object o)
{
SchemaTable2 result = new SchemaTable2();
result.jdoFlags = 1;
result.jdoStateManager = sm;
result.jdoCopyKeyFieldsFromObjectId(o);
return result;
}
public void jdoReplaceField(int fieldIndex)
{
if (jdoStateManager == null)
{
throw new IllegalStateException("state manager is null");
}
switch (fieldIndex)
{
case 0 :
className = jdoStateManager.replacingStringField(this, fieldIndex);
return;
case 1 :
interfaceName = jdoStateManager.replacingStringField(this, fieldIndex);
return;
case 2 :
owner = jdoStateManager.replacingStringField(this, fieldIndex);
return;
case 3 :
tableName = jdoStateManager.replacingStringField(this, fieldIndex);
return;
case 4 :
type = jdoStateManager.replacingStringField(this, fieldIndex);
return;
case 5 :
version = jdoStateManager.replacingStringField(this, fieldIndex);
return;
}
throw new IllegalArgumentException("out of field index :" + fieldIndex);
}
public void jdoProvideField(int fieldIndex)
{
if (jdoStateManager == null)
{
throw new IllegalStateException("state manager is null");
}
switch (fieldIndex)
{
case 0 :
jdoStateManager.providedStringField(this, fieldIndex, className);
return;
case 1 :
jdoStateManager.providedStringField(this, fieldIndex, interfaceName);
return;
case 2 :
jdoStateManager.providedStringField(this, fieldIndex, owner);
return;
case 3 :
jdoStateManager.providedStringField(this, fieldIndex, tableName);
return;
case 4 :
jdoStateManager.providedStringField(this, fieldIndex, type);
return;
case 5 :
jdoStateManager.providedStringField(this, fieldIndex, version);
return;
}
throw new IllegalArgumentException("out of field index :" + fieldIndex);
}
protected final void jdoCopyField(SchemaTable2 obj, int index)
{
switch (index)
{
case 0 :
className = obj.className;
break;
case 1 :
interfaceName = obj.interfaceName;
break;
case 2 :
owner = obj.owner;
break;
case 3 :
tableName = obj.tableName;
break;
case 4 :
type = obj.type;
break;
case 5 :
version = obj.version;
break;
default :
throw new IllegalArgumentException("out of field index :" + index);
}
}
public void jdoCopyFields(Object obj, int fieldNumbers[])
{
if (jdoStateManager == null)
{
throw new IllegalStateException("state manager is null");
}
if (fieldNumbers == null)
{
throw new IllegalStateException("fieldNumbers is null");
}
if (!(obj instanceof SchemaTable2))
{
throw new IllegalArgumentException("object is not org.jpox.store.rdbms.SchemaTable");
}
SchemaTable2 me = (SchemaTable2) obj;
if (jdoStateManager != me.jdoStateManager)
{
throw new IllegalArgumentException("state manager unmatch");
}
int i = fieldNumbers.length - 1;
if (i >= 0)
{
do
{
jdoCopyField(me, fieldNumbers[i]);
}
while (--i >= 0);
}
}
private static final String[] __jdoFieldNamesInit()
{
return (new String[]{"className", "interfaceName", "owner", "tableName", "type", "version"});
}
private static final Class[] __jdoFieldTypesInit()
{
return (new Class[]{___jdo$loadClass("java.lang.String"), ___jdo$loadClass("java.lang.String"), ___jdo$loadClass("java.lang.String"),
___jdo$loadClass("java.lang.String"), ___jdo$loadClass("java.lang.String"), ___jdo$loadClass("java.lang.String")});
}
private static final byte[] __jdoFieldFlagsInit()
{
return (new byte[]{24, 21, 21, 21, 21, 21});
}
protected static int __jdoGetInheritedFieldCount()
{
return 0;
}
protected static int jdoGetManagedFieldCount()
{
return 6;
}
private static Class __jdoPersistenceCapableSuperclassInit()
{
return null;
}
public static Class ___jdo$loadClass(String className)
{
try
{
return Class.forName(className);
}
catch (ClassNotFoundException e)
{
throw new NoClassDefFoundError(e.getMessage());
}
}
static void jdoSetclassName(SchemaTable2 objPC, String className_m)
{
if (objPC.jdoStateManager == null)
{
objPC.className = className_m;
}
else
{
objPC.jdoStateManager.setStringField(objPC, 0, objPC.className, className_m);
}
}
static String jdoGetclassName(SchemaTable2 objPC)
{
return objPC.className;
}
static void jdoSetinterfaceName(SchemaTable2 objPC, String interfaceName_c)
{
if (objPC.jdoFlags != 0 && objPC.jdoStateManager != null)
{
objPC.jdoStateManager.setStringField(objPC, 1, objPC.interfaceName, interfaceName_c);
return;
}
else
{
objPC.interfaceName = interfaceName_c;
return;
}
}
static String jdoGetinterfaceName(SchemaTable2 objPC)
{
if (objPC.jdoFlags > 0 && objPC.jdoStateManager != null && !objPC.jdoStateManager.isLoaded(objPC, 1))
{
return objPC.jdoStateManager.getStringField(objPC, 1, objPC.interfaceName);
}
else
{
return objPC.interfaceName;
}
}
static void jdoSetowner(SchemaTable2 objPC, String owner_c)
{
if (objPC.jdoFlags != 0 && objPC.jdoStateManager != null)
{
objPC.jdoStateManager.setStringField(objPC, 2, objPC.owner, owner_c);
return;
}
else
{
objPC.owner = owner_c;
return;
}
}
static String jdoGetowner(SchemaTable2 objPC)
{
if (objPC.jdoFlags > 0 && objPC.jdoStateManager != null && !objPC.jdoStateManager.isLoaded(objPC, 2))
{
return objPC.jdoStateManager.getStringField(objPC, 2, objPC.owner);
}
else
{
return objPC.owner;
}
}
static void jdoSettableName(SchemaTable2 objPC, String tableName_c)
{
if (objPC.jdoFlags != 0 && objPC.jdoStateManager != null)
{
objPC.jdoStateManager.setStringField(objPC, 3, objPC.tableName, tableName_c);
return;
}
else
{
objPC.tableName = tableName_c;
return;
}
}
static String jdoGettableName(SchemaTable2 objPC)
{
if (objPC.jdoFlags > 0 && objPC.jdoStateManager != null && !objPC.jdoStateManager.isLoaded(objPC, 3))
{
return objPC.jdoStateManager.getStringField(objPC, 3, objPC.tableName);
}
else
{
return objPC.tableName;
}
}
static void jdoSettype(SchemaTable2 objPC, String type_c)
{
if (objPC.jdoFlags != 0 && objPC.jdoStateManager != null)
{
objPC.jdoStateManager.setStringField(objPC, 4, objPC.type, type_c);
return;
}
else
{
objPC.type = type_c;
return;
}
}
static String jdoGettype(SchemaTable2 objPC)
{
if (objPC.jdoFlags > 0 && objPC.jdoStateManager != null && !objPC.jdoStateManager.isLoaded(objPC, 4))
{
return objPC.jdoStateManager.getStringField(objPC, 4, objPC.type);
}
else
{
return objPC.type;
}
}
static void jdoSetversion(SchemaTable2 objPC, String version_c)
{
if (objPC.jdoFlags != 0 && objPC.jdoStateManager != null)
{
objPC.jdoStateManager.setStringField(objPC, 5, objPC.version, version_c);
return;
}
else
{
objPC.version = version_c;
return;
}
}
static String jdoGetversion(SchemaTable2 objPC)
{
if (objPC.jdoFlags > 0 && objPC.jdoStateManager != null && !objPC.jdoStateManager.isLoaded(objPC, 5))
{
return objPC.jdoStateManager.getStringField(objPC, 5, objPC.version);
}
else
{
return objPC.version;
}
}
protected transient StateManager jdoStateManager;
protected transient byte jdoFlags;
private static final byte jdoFieldFlags[];
private static final Class jdoPersistenceCapableSuperclass;
private static final Class jdoFieldTypes[];
private static final String jdoFieldNames[];
static
{
jdoFieldNames = __jdoFieldNamesInit();
jdoFieldTypes = __jdoFieldTypesInit();
jdoFieldFlags = __jdoFieldFlagsInit();
jdoPersistenceCapableSuperclass = __jdoPersistenceCapableSuperclassInit();
JDOImplHelper.registerClass(___jdo$loadClass("org.jpox.store.rdbms.SchemaTable"), jdoFieldNames, jdoFieldTypes, jdoFieldFlags,
jdoPersistenceCapableSuperclass, new SchemaTable2());
}
}