Return-Path: X-Original-To: apmail-db-jdo-commits-archive@www.apache.org Delivered-To: apmail-db-jdo-commits-archive@www.apache.org Received: from mail.apache.org (hermes.apache.org [140.211.11.3]) by minotaur.apache.org (Postfix) with SMTP id B009317AC6 for ; Fri, 22 May 2015 17:25:50 +0000 (UTC) Received: (qmail 56471 invoked by uid 500); 22 May 2015 17:25:50 -0000 Mailing-List: contact jdo-commits-help@db.apache.org; run by ezmlm Precedence: bulk List-Help: List-Unsubscribe: List-Post: List-Id: Reply-To: jdo-dev@db.apache.org Delivered-To: mailing list jdo-commits@db.apache.org Received: (qmail 56462 invoked by uid 99); 22 May 2015 17:25:50 -0000 Received: from eris.apache.org (HELO hades.apache.org) (140.211.11.105) by apache.org (qpsmtpd/0.29) with ESMTP; Fri, 22 May 2015 17:25:50 +0000 Received: from hades.apache.org (localhost [127.0.0.1]) by hades.apache.org (ASF Mail Server at hades.apache.org) with ESMTP id 706DDAC0637 for ; Fri, 22 May 2015 17:25:50 +0000 (UTC) Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit Subject: svn commit: r1681162 - in /db/jdo/trunk/tck/src/conf: jdo-3_1-signatures.txt jdo-signatures.txt Date: Fri, 22 May 2015 17:25:50 -0000 To: jdo-commits@db.apache.org From: andyj@apache.org X-Mailer: svnmailer-1.0.9 Message-Id: <20150522172550.706DDAC0637@hades.apache.org> Author: andyj Date: Fri May 22 17:25:50 2015 New Revision: 1681162 URL: http://svn.apache.org/r1681162 Log: JDO-742 Rename jdo signatures file Added: db/jdo/trunk/tck/src/conf/jdo-signatures.txt (with props) Removed: db/jdo/trunk/tck/src/conf/jdo-3_1-signatures.txt Added: db/jdo/trunk/tck/src/conf/jdo-signatures.txt URL: http://svn.apache.org/viewvc/db/jdo/trunk/tck/src/conf/jdo-signatures.txt?rev=1681162&view=auto ============================================================================== --- db/jdo/trunk/tck/src/conf/jdo-signatures.txt (added) +++ db/jdo/trunk/tck/src/conf/jdo-signatures.txt Fri May 22 17:25:50 2015 @@ -0,0 +1,1685 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You 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. + */ + +public interface javax.jdo.Constants { + static String JAVAX_JDO = "javax.jdo"; + static String JAVAX_JDO_PREFIX = "javax.jdo."; + static String SERVICE_LOOKUP_PMF_RESOURCE_NAME + = "META-INF/services/javax.jdo.PersistenceManagerFactory"; + static String SERVICE_LOOKUP_ENHANCER_RESOURCE_NAME + = "META-INF/services/javax.jdo.JDOEnhancer"; + static String JDOCONFIG_RESOURCE_NAME + = "META-INF/jdoconfig.xml"; + static String JDOCONFIG_XSD_NS + = "http://java.sun.com/xml/ns/jdo/jdoconfig"; + static String JDO_XSD_NS + = "http://java.sun.com/xml/ns/jdo/jdo"; + static String ORM_XSD_NS + = "http://java.sun.com/xml/ns/jdo/orm"; + static String JDOQUERY_XSD_NS + = "http://java.sun.com/xml/ns/jdo/jdoquery"; + static String ELEMENT_PERSISTENCE_MANAGER_FACTORY + = "persistence-manager-factory"; + static String PMF_ATTRIBUTE_CLASS + = "class"; + static String PMF_ATTRIBUTE_NAME + = "name"; + static String PMF_ATTRIBUTE_PERSISTENCE_UNIT_NAME + = "persistence-unit-name"; + static String PMF_ATTRIBUTE_OPTIMISTIC + = "optimistic"; + static String PMF_ATTRIBUTE_READONLY + = "readonly"; + static String PMF_ATTRIBUTE_RETAIN_VALUES + = "retain-values"; + static String PMF_ATTRIBUTE_RESTORE_VALUES + = "restore-values"; + static String PMF_ATTRIBUTE_IGNORE_CACHE + = "ignore-cache"; + static String PMF_ATTRIBUTE_NONTRANSACTIONAL_READ + = "nontransactional-read"; + static String PMF_ATTRIBUTE_NONTRANSACTIONAL_WRITE + = "nontransactional-write"; + static String PMF_ATTRIBUTE_MULTITHREADED + = "multithreaded"; + static String PMF_ATTRIBUTE_CONNECTION_DRIVER_NAME + = "connection-driver-name"; + static String PMF_ATTRIBUTE_CONNECTION_USER_NAME + = "connection-user-name"; + static String PMF_ATTRIBUTE_CONNECTION_PASSWORD + = "connection-password"; + static String PMF_ATTRIBUTE_CONNECTION_URL + = "connection-url"; + static String PMF_ATTRIBUTE_CONNECTION_FACTORY_NAME + = "connection-factory-name"; + static String PMF_ATTRIBUTE_CONNECTION_FACTORY2_NAME + = "connection-factory2-name"; + static String PMF_ATTRIBUTE_DETACH_ALL_ON_COMMIT + = "detach-all-on-commit"; + static String PMF_ATTRIBUTE_COPY_ON_ATTACH + = "copy-on-attach"; + static String PMF_ATTRIBUTE_MAPPING + = "mapping"; + static String PMF_ATTRIBUTE_SERVER_TIME_ZONE_ID + = "server-time-zone-id"; + static String PMF_ATTRIBUTE_DATASTORE_READ_TIMEOUT_MILLIS + = "datastore-read-timeout-millis"; + static String PMF_ATTRIBUTE_DATASTORE_WRITE_TIMEOUT_MILLIS + = "datastore-write-timeout-millis"; + static String ELEMENT_PROPERTY + = "property"; + static String PROPERTY_ATTRIBUTE_NAME + = "name"; + static String PROPERTY_ATTRIBUTE_VALUE + = "value"; + static String ELEMENT_INSTANCE_LIFECYCLE_LISTENER + = "instance-lifecycle-listener"; + static String INSTANCE_LIFECYCLE_LISTENER_ATTRIBUTE_LISTENER + = "listener"; + static String INSTANCE_LIFECYCLE_LISTENER_ATTRIBUTE_CLASSES + = "classes"; + static String OPTION_TRANSACTIONAL_TRANSIENT + = "javax.jdo.option.TransientTransactional"; + static String OPTION_NONTRANSACTIONAL_READ + = "javax.jdo.option.NontransactionalRead"; + static String OPTION_NONTRANSACTIONAL_WRITE + = "javax.jdo.option.NontransactionalWrite"; + static String OPTION_RETAIN_VALUES + = "javax.jdo.option.RetainValues"; + static String OPTION_OPTIMISTIC + = "javax.jdo.option.Optimistic"; + static String OPTION_APPLICATION_IDENTITY + = "javax.jdo.option.ApplicationIdentity"; + static String OPTION_DATASTORE_IDENTITY + = "javax.jdo.option.DatastoreIdentity"; + static String OPTION_NONDURABLE_IDENTITY + = "javax.jdo.option.NonDurableIdentity"; + static String OPTION_ARRAYLIST + = "javax.jdo.option.ArrayList"; + static String OPTION_LINKEDLIST + = "javax.jdo.option.LinkedList"; + static String OPTION_TREEMAP + = "javax.jdo.option.TreeMap"; + static String OPTION_TREESET + = "javax.jdo.option.TreeSet"; + static String OPTION_VECTOR + = "javax.jdo.option.Vector"; + static String OPTION_ARRAY + = "javax.jdo.option.Array"; + static String OPTION_NULL_COLLECTION + = "javax.jdo.option.NullCollection"; + static String OPTION_CHANGE_APPLICATION_IDENTITY + = "javax.jdo.option.ChangeApplicationIdentity"; + static String OPTION_BINARY_COMPATIBILITY + = "javax.jdo.option.BinaryCompatibility"; + static String OPTION_GET_DATASTORE_CONNECTION + = "javax.jdo.option.GetDataStoreConnection"; + static String OPTION_GET_JDBC_CONNECTION + = "javax.jdo.option.GetJDBCConnection"; + static String OPTION_DATASTORE_TIMEOUT + = "javax.jdo.option.DatastoreTimeout"; + static String OPTION_QUERY_SQL + = "javax.jdo.query.SQL"; + static String OPTION_QUERY_CANCEL + = "javax.jdo.option.QueryCancel"; + static String OPTION_UNCONSTRAINED_QUERY_VARIABLES + = "javax.jdo.option.UnconstrainedQueryVariables"; + static String OPTION_VERSION_DATETIME + = "javax.jdo.option.version.DateTime"; + static String OPTION_VERSION_STATE_IMAGE + = "javax.jdo.option.version.StateImage"; + static String OPTION_PREDIRTY_EVENT + = "javax.jdo.option.PreDirtyEvent"; + static String OPTION_MAPPING_HETEROGENEOUS_OBJECT_TYPE + = "javax.jdo.option.mapping.HeterogeneousObjectType"; + static String OPTION_MAPPING_HETEROGENEOUS_INTERFACE_TYPE + = "javax.jdo.option.mapping.HeterogeneousInterfaceType"; + static String OPTION_MAPPING_JOINED_TABLE_PER_CLASS + = "javax.jdo.option.mapping.JoinedTablePerClass"; + static String OPTION_MAPPING_JOINED_TABLE_PER_CONCRETE_CLASS + = "javax.jdo.option.mapping.JoinedTablePerConcreteClass"; + static String OPTION_MAPPING_NON_JOINED_TABLE_PER_CONCRETE_CLASS + = "javax.jdo.option.mapping.NonJoinedTablePerConcreteClass"; + static String OPTION_MAPPING_RELATION_SUBCLASS_TABLE + = "javax.jdo.option.mapping.RelationSubclassTable"; + static String PROPERTY_PERSISTENCE_MANAGER_FACTORY_CLASS + = "javax.jdo.PersistenceManagerFactoryClass"; + static String PROPERTY_OPTIMISTIC + = "javax.jdo.option.Optimistic"; + static String PROPERTY_READONLY + = "javax.jdo.option.ReadOnly"; + static String PROPERTY_RETAIN_VALUES + = "javax.jdo.option.RetainValues"; + static String PROPERTY_RESTORE_VALUES + = "javax.jdo.option.RestoreValues"; + static String PROPERTY_IGNORE_CACHE + = "javax.jdo.option.IgnoreCache"; + static String PROPERTY_NONTRANSACTIONAL_READ + = "javax.jdo.option.NontransactionalRead"; + static String PROPERTY_NONTRANSACTIONAL_WRITE + = "javax.jdo.option.NontransactionalWrite"; + static String PROPERTY_MULTITHREADED + = "javax.jdo.option.Multithreaded"; + static String PROPERTY_TRANSACTION_ISOLATION_LEVEL + = "javax.jdo.option.TransactionIsolationLevel"; + static String PROPERTY_TRANSACTION_ISOLATION_LEVEL_READ_UNCOMMITTED + = "javax.jdo.option.TransactionIsolationLevel.read-uncommitted"; + static String PROPERTY_TRANSACTION_ISOLATION_LEVEL_READ_COMMITTED + = "javax.jdo.option.TransactionIsolationLevel.read-committed"; + static String PROPERTY_TRANSACTION_ISOLATION_LEVEL_REPEATABLE_READ + = "javax.jdo.option.TransactionIsolationLevel.repeatable-read"; + static String PROPERTY_TRANSACTION_ISOLATION_LEVEL_SNAPSHOT + = "javax.jdo.option.TransactionIsolationLevel.snapshot"; + static String PROPERTY_TRANSACTION_ISOLATION_LEVEL_SERIALIZABLE + = "javax.jdo.option.TransactionIsolationLevel.serializable"; + static String PROPERTY_DETACH_ALL_ON_COMMIT + = "javax.jdo.option.DetachAllOnCommit"; + static String PROPERTY_COPY_ON_ATTACH + = "javax.jdo.option.CopyOnAttach"; + static String PROPERTY_CONNECTION_DRIVER_NAME + = "javax.jdo.option.ConnectionDriverName"; + static String PROPERTY_CONNECTION_USER_NAME + = "javax.jdo.option.ConnectionUserName"; + static String PROPERTY_CONNECTION_PASSWORD + = "javax.jdo.option.ConnectionPassword"; + static String PROPERTY_CONNECTION_URL + = "javax.jdo.option.ConnectionURL"; + static String PROPERTY_CONNECTION_FACTORY_NAME + = "javax.jdo.option.ConnectionFactoryName"; + static String PROPERTY_CONNECTION_FACTORY2_NAME + = "javax.jdo.option.ConnectionFactory2Name"; + static String PROPERTY_MAPPING + = "javax.jdo.option.Mapping"; + static String PROPERTY_NAME + = "javax.jdo.option.Name"; + static String PROPERTY_SPI_RESOURCE_NAME + = "javax.jdo.option.spi.ResourceName"; + static String PROPERTY_PERSISTENCE_UNIT_NAME + = "javax.jdo.option.PersistenceUnitName"; + static String PROPERTY_INSTANCE_LIFECYCLE_LISTENER + = "javax.jdo.listener.InstanceLifecycleListener"; + static String PROPERTY_PREFIX_INSTANCE_LIFECYCLE_LISTENER + = "javax.jdo.listener.InstanceLifecycleListener."; + static String PROPERTY_MAPPING_CATALOG + = "javax.jdo.mapping.Catalog"; + static String PROPERTY_MAPPING_SCHEMA + = "javax.jdo.mapping.Schema"; + static String PROPERTY_SERVER_TIME_ZONE_ID + = "javax.jdo.option.ServerTimeZoneID"; + static String PROPERTY_DATASTORE_READ_TIMEOUT_MILLIS + = "javax.jdo.option.DatastoreReadTimeoutMillis"; + static String PROPERTY_DATASTORE_WRITE_TIMEOUT_MILLIS + = "javax.jdo.option.DatastoreWriteTimeoutMillis"; + static String NONCONFIGURABLE_PROPERTY_VENDOR_NAME + = "VendorName"; + static String NONCONFIGURABLE_PROPERTY_VERSION_NUMBER + = "VersionNumber"; + static String JTA + = "JTA"; + static String RESOURCE_LOCAL + = "RESOURCE_LOCAL"; + static String JDOCONFIG_DTD_RESOURCE + = "javax/jdo/jdoconfig_3_0.dtd"; + static String JDOCONFIG_XSD_RESOURCE + = "javax/jdo/jdoconfig_3_0.xsd"; + static String JDO_DTD_RESOURCE + = "javax/jdo/jdo_3_0.dtd"; + static String JDO_XSD_RESOURCE + = "javax/jdo/jdo_3_0.xsd"; + static String ORM_DTD_RESOURCE + = "javax/jdo/orm_3_0.dtd"; + static String ORM_XSD_RESOURCE + = "javax/jdo/orm_3_0.xsd"; + static String JDOQUERY_DTD_RESOURCE + = "javax/jdo/jdoquery_3_0.dtd"; + static String JDOQUERY_XSD_RESOURCE + = "javax/jdo/jdoquery_3_0.xsd"; + static String ANONYMOUS_PERSISTENCE_MANAGER_FACTORY_NAME + = ""; + public static final String TX_READ_UNCOMMITTED = "read-uncommitted"; + public static final String TX_READ_COMMITTED = "read-committed"; + public static final String TX_REPEATABLE_READ = "repeatable-read"; + public static final String TX_SNAPSHOT = "snapshot"; + public static final String TX_SERIALIZABLE = "serializable"; + public static final String PROPERTY_ENHANCER_VENDOR_NAME = "VendorName"; + public static final String PROPERTY_ENHANCER_VERSION_NUMBER = "VersionNumber"; + public static final String PROPERTY_TRANSACTION_TYPE = "javax.jdo.option.TransactionType"; + public static final int ENHANCER_EXCEPTION = 1; + public static final int ENHANCER_NO_JDO_ENHANCER_FOUND = 2; + public static final int ENHANCER_USAGE_ERROR = 3; +} + +public interface javax.jdo.datastore.DataStoreCache { + public void evict(Object oid); + public void evictAll(); + public varargs void evictAll(Object[] oids); + public void evictAll(java.util.Collection oids); + public void evictAll(Class pcClass, boolean subclasses); + public void evictAll(boolean subclasses, Class pcClass); + public void pin(Object oid); + public void pinAll(java.util.Collection oids); + public varargs void pinAll(Object[] oids); + public void pinAll(Class pcClass, boolean subclasses); + public void pinAll(boolean subclasses, Class pcClass); + public void unpin(Object oid); + public void unpinAll(java.util.Collection oids); + public varargs void unpinAll(Object[] oids); + public void unpinAll(Class pcClass, boolean subclasses); + public void unpinAll(boolean subclasses, Class pcClass); +} + +public interface javax.jdo.datastore.JDOConnection { + public Object getNativeConnection(); + public void close(); +} + +public interface javax.jdo.datastore.Sequence { + public String getName(); + public Object next(); + public void allocate(int additional); + public Object current(); + public long nextValue(); + public long currentValue(); +} + +public interface javax.jdo.Extent extends java.lang.Iterable { + public java.util.Iterator iterator(); + public boolean hasSubclasses(); + public Class getCandidateClass(); + public javax.jdo.PersistenceManager getPersistenceManager(); + public void closeAll(); + public void close(java.util.Iterator it); + public javax.jdo.FetchPlan getFetchPlan(); +} + +public interface javax.jdo.FetchPlan { + public static final String DEFAULT = "default"; + public static final String ALL = "all"; + public static final int DETACH_UNLOAD_FIELDS = 2; + public static final int DETACH_LOAD_FIELDS = 1; + public static final int FETCH_SIZE_GREEDY = -1; + public static final int FETCH_SIZE_OPTIMAL = 0; + public javax.jdo.FetchPlan addGroup(String fetchGroupName); + public javax.jdo.FetchPlan removeGroup(String fetchGroupName); + public javax.jdo.FetchPlan clearGroups(); + public java.util.Set getGroups(); + public javax.jdo.FetchPlan setGroups(java.util.Collection fetchGroupNames); + public varargs javax.jdo.FetchPlan setGroups(String[]fetchGroupNames); + public javax.jdo.FetchPlan setGroup(String fetchGroupName); + public javax.jdo.FetchPlan setMaxFetchDepth(int fetchDepth); + public int getMaxFetchDepth(); + public javax.jdo.FetchPlan setDetachmentRoots(java.util.Collection roots); + public java.util.Collection getDetachmentRoots(); + public varargs javax.jdo.FetchPlan setDetachmentRootClasses(Class[] rootClasses); + public Class[] getDetachmentRootClasses(); + public javax.jdo.FetchPlan setFetchSize(int fetchSize); + public int getFetchSize(); + public javax.jdo.FetchPlan setDetachmentOptions(int options); + public int getDetachmentOptions(); +} + +public class javax.jdo.identity.ByteIdentity extends javax.jdo.identity.SingleFieldIdentity { + public ByteIdentity(Class pcClass, byte key); + public ByteIdentity(Class pcClass, Byte key); + public ByteIdentity(Class pcClass, String str); + public ByteIdentity(); + public byte getKey(); + public String toString(); + public boolean equals(Object obj); + public int compareTo(Object obj); + public void writeExternal(java.io.ObjectOutput out) throws java.io.IOException; + public void readExternal(java.io.ObjectInput in) throws java.io.IOException, ClassNotFoundException; +} + +public class javax.jdo.identity.CharIdentity extends javax.jdo.identity.SingleFieldIdentity { + public CharIdentity(Class pcClass, char key); + public CharIdentity(Class pcClass, Character key); + public CharIdentity(Class pcClass, String str); + public CharIdentity(); + public char getKey(); + public String toString(); + public boolean equals(Object obj); + public int compareTo(Object obj); + public void writeExternal(java.io.ObjectOutput out) throws java.io.IOException; + public void readExternal(java.io.ObjectInput in) throws java.io.IOException, ClassNotFoundException; +} + +public class javax.jdo.identity.IntIdentity extends javax.jdo.identity.SingleFieldIdentity { + public IntIdentity(Class pcClass, int key); + public IntIdentity(Class pcClass, Integer key); + public IntIdentity(Class pcClass, String str); + public IntIdentity(); + public int getKey(); + public String toString(); + public boolean equals(Object obj); + public int compareTo(Object obj); + public void writeExternal(java.io.ObjectOutput out) throws java.io.IOException; + public void readExternal(java.io.ObjectInput in) throws java.io.IOException, ClassNotFoundException; +} + +public class javax.jdo.identity.LongIdentity extends javax.jdo.identity.SingleFieldIdentity { + public LongIdentity(Class pcClass, long key); + public LongIdentity(Class pcClass, Long key); + public LongIdentity(Class pcClass, String str); + public LongIdentity(); + public long getKey(); + public String toString(); + public boolean equals(Object obj); + public int compareTo(Object obj); + public void writeExternal(java.io.ObjectOutput out) throws java.io.IOException; + public void readExternal(java.io.ObjectInput in) throws java.io.IOException, ClassNotFoundException; +} + +public class javax.jdo.identity.ObjectIdentity extends javax.jdo.identity.SingleFieldIdentity { + public ObjectIdentity(Class pcClass, Object param); + public ObjectIdentity(); + public Object getKey(); + public String toString(); + public boolean equals(Object obj); + public int hashCode(); + public int compareTo(Object obj); + public void writeExternal(java.io.ObjectOutput out) throws java.io.IOException; + public void readExternal(java.io.ObjectInput in) throws java.io.IOException, ClassNotFoundException; +} + +public class javax.jdo.identity.ShortIdentity extends javax.jdo.identity.SingleFieldIdentity { + public ShortIdentity(Class pcClass, short key); + public ShortIdentity(Class pcClass, Short key); + public ShortIdentity(Class pcClass, String str); + public ShortIdentity(); + public short getKey(); + public String toString(); + public boolean equals(Object obj); + public int compareTo(Object obj); + public void writeExternal(java.io.ObjectOutput out) throws java.io.IOException; + public void readExternal(java.io.ObjectInput in) throws java.io.IOException, ClassNotFoundException; +} + +public abstract class javax.jdo.identity.SingleFieldIdentity implements java.io.Externalizable, java.lang.Comparable { + public SingleFieldIdentity(); + public Class getTargetClass(); + public String getTargetClassName(); + public synchronized Object getKeyAsObject(); + public boolean equals(Object obj); + public int hashCode(); + public void writeExternal(java.io.ObjectOutput out) throws java.io.IOException; + public void readExternal(java.io.ObjectInput in) throws java.io.IOException, ClassNotFoundException; +} + +public class javax.jdo.identity.StringIdentity extends javax.jdo.identity.SingleFieldIdentity { + public StringIdentity(Class pcClass, String key); + public StringIdentity(); + public String getKey(); + public String toString(); + public boolean equals(Object obj); + public int compareTo(Object obj); + public void writeExternal(java.io.ObjectOutput out) throws java.io.IOException; + public void readExternal(java.io.ObjectInput in) throws java.io.IOException, ClassNotFoundException; +} + +public interface javax.jdo.InstanceCallbacks extends javax.jdo.listener.ClearCallback, javax.jdo.listener.DeleteCallback, javax.jdo.listener.LoadCallback, javax.jdo.listener.StoreCallback { +} + +public class javax.jdo.JDOCanRetryException extends javax.jdo.JDOException { + public JDOCanRetryException(); + public JDOCanRetryException(String msg); + public JDOCanRetryException(String msg, Throwable[] nested); + public JDOCanRetryException(String msg, Throwable nested); + public JDOCanRetryException(String msg, Object failed); + public JDOCanRetryException(String msg, Throwable[] nested, Object failed); + public JDOCanRetryException(String msg, Throwable nested, Object failed); +} + +public class javax.jdo.JDODataStoreException extends javax.jdo.JDOCanRetryException { + public JDODataStoreException(); + public JDODataStoreException(String msg); + public JDODataStoreException(String msg, Throwable[] nested); + public JDODataStoreException(String msg, Throwable nested); + public JDODataStoreException(String msg, Object failed); + public JDODataStoreException(String msg, Throwable[] nested, Object failed); + public JDODataStoreException(String msg, Throwable nested, Object failed); +} + +public class javax.jdo.JDODetachedFieldAccessException extends javax.jdo.JDOUserException { + public JDODetachedFieldAccessException(); + public JDODetachedFieldAccessException(String msg); + public JDODetachedFieldAccessException(String, Object); + public JDODetachedFieldAccessException(String msg, Throwable[] nested); + public JDODetachedFieldAccessException(String msg, Throwable nested); +} + +public class javax.jdo.JDOException extends RuntimeException { + public JDOException(); + public JDOException(String msg); + public JDOException(String msg, Throwable[] nested); + public JDOException(String msg, Throwable nested); + public JDOException(String msg, Object failed); + public JDOException(String msg, Throwable[] nested, Object failed); + public JDOException(String msg, Throwable nested, Object failed); + public Object getFailedObject(); + public Throwable[] getNestedExceptions(); + public synchronized Throwable getCause(); + public Throwable initCause(Throwable cause); + public synchronized String toString(); + public void printStackTrace(); + public synchronized void printStackTrace(java.io.PrintStream s); + public synchronized void printStackTrace(java.io.PrintWriter s); +} + +public class javax.jdo.JDOFatalDataStoreException extends javax.jdo.JDOFatalException { + public JDOFatalDataStoreException(); + public JDOFatalDataStoreException(String msg); + public JDOFatalDataStoreException(String msg, Object failed); + public JDOFatalDataStoreException(String msg, Throwable[] nested); + public JDOFatalDataStoreException(String msg, Throwable nested); + public JDOFatalDataStoreException(String msg, Throwable[] nested, Object failed); + public JDOFatalDataStoreException(String msg, Throwable nested, Object failed); +} + +public class javax.jdo.JDOFatalException extends javax.jdo.JDOException { + public JDOFatalException(); + public JDOFatalException(String msg); + public JDOFatalException(String msg, Throwable[] nested); + public JDOFatalException(String msg, Throwable nested); + public JDOFatalException(String msg, Object failed); + public JDOFatalException(String msg, Throwable[] nested, Object failed); + public JDOFatalException(String msg, Throwable nested, Object failed); +} + +public class javax.jdo.JDOFatalInternalException extends javax.jdo.JDOFatalException { + public JDOFatalInternalException(); + public JDOFatalInternalException(String msg); + public JDOFatalInternalException(String msg, Throwable[] nested); + public JDOFatalInternalException(String msg, Throwable nested); + public JDOFatalInternalException(String msg, Object failed); + public JDOFatalInternalException(String msg, Throwable[] nested, Object failed); + public JDOFatalInternalException(String msg, Throwable nested, Object failed); +} + +public class javax.jdo.JDOFatalUserException extends javax.jdo.JDOFatalException { + public JDOFatalUserException(); + public JDOFatalUserException(String msg); + public JDOFatalUserException(String msg, Throwable[] nested); + public JDOFatalUserException(String msg, Throwable nested); + public JDOFatalUserException(String msg, Object failed); + public JDOFatalUserException(String msg, Throwable[] nested, Object failed); + public JDOFatalUserException(String msg, Throwable nested, Object failed); +} + +public class javax.jdo.JDOHelper implements javax.jdo.Constants { + public JDOHelper(); + public static javax.jdo.JDOHelper getInstance(); + public static javax.jdo.PersistenceManager getPersistenceManager(Object pc); + public static void makeDirty(Object pc, String fieldName); + public static Object getObjectId(Object pc); + public static java.util.Collection getObjectIds(java.util.Collection pcs); + public static Object[] getObjectIds(Object[] pcs); + public static Object getTransactionalObjectId(Object pc); + public static Object getVersion(Object pc); + public static boolean isDirty(Object pc); + public static boolean isTransactional(Object pc); + public static boolean isPersistent(Object pc); + public static boolean isNew(Object pc); + public static boolean isDeleted(Object pc); + public static boolean isDetached(Object pc); + public static enum javax.jdo.ObjectState getObjectState(Object pc); + public static javax.jdo.PersistenceManagerFactory getPersistenceManagerFactory(); + public static javax.jdo.PersistenceManagerFactory getPersistenceManagerFactory(java.util.Map props); + public static javax.jdo.PersistenceManagerFactory getPersistenceManagerFactory(java.util.Map props, ClassLoader cl); + public static javax.jdo.PersistenceManagerFactory getPersistenceManagerFactory(java.util.Map props, java.lang.String name, ClassLoader propsloader, ClassLoader pmfloader); + public static javax.jdo.PersistenceManagerFactory getPersistenceManagerFactory(java.util.Map props, java.lang.String name, ClassLoader pmfloader); + public static javax.jdo.PersistenceManagerFactory getPersistenceManagerFactory(java.util.Map props, java.lang.String name); + public static javax.jdo.PersistenceManagerFactory getPersistenceManagerFactory(String propsResource); + public static javax.jdo.PersistenceManagerFactory getPersistenceManagerFactory(String propsResource, ClassLoader loader); + public static javax.jdo.PersistenceManagerFactory getPersistenceManagerFactory(String propsResource, ClassLoader propsLoader, ClassLoader pmfLoader); + public static javax.jdo.PersistenceManagerFactory getPersistenceManagerFactory(ClassLoader pmfLoader); + public static javax.jdo.PersistenceManagerFactory getPersistenceManagerFactory(java.io.File propsFile); + public static javax.jdo.PersistenceManagerFactory getPersistenceManagerFactory(java.io.File propsFile, ClassLoader loader); + public static javax.jdo.PersistenceManagerFactory getPersistenceManagerFactory(String jndiLocation, javax.naming.Context context); + public static javax.jdo.PersistenceManagerFactory getPersistenceManagerFactory(String jndiLocation, javax.naming.Context context, ClassLoader loader); + public static javax.jdo.PersistenceManagerFactory getPersistenceManagerFactory(java.io.InputStream stream); + public static javax.jdo.PersistenceManagerFactory getPersistenceManagerFactory(java.io.InputStream stream, ClassLoader loader); + public static javax.jdo.JDOEnhancer getEnhancer(); + public static javax.jdo.JDOEnhancer getEnhancer(ClassLoader loader); +} + +public class javax.jdo.JDONullIdentityException extends javax.jdo.JDOUserException { + public JDONullIdentityException(); + public JDONullIdentityException(String msg); + public JDONullIdentityException(String msg, Object failed); + public JDONullIdentityException(String msg, Throwable[] nested); + public JDONullIdentityException(String msg, Throwable nested); +} + +public class javax.jdo.JDOObjectNotFoundException extends javax.jdo.JDODataStoreException { + public JDOObjectNotFoundException(); + public JDOObjectNotFoundException(String msg); + public JDOObjectNotFoundException(String msg, Object failed); + public JDOObjectNotFoundException(String msg, Throwable nested); + public JDOObjectNotFoundException(String msg, Throwable nested, Object failed); + public JDOObjectNotFoundException(String msg, Throwable[] nested); + public JDOObjectNotFoundException(String msg, Throwable[] nested, Object failed); +} + +public class javax.jdo.JDOOptimisticVerificationException extends javax.jdo.JDOFatalDataStoreException { + public JDOOptimisticVerificationException(); + public JDOOptimisticVerificationException(String msg); + public JDOOptimisticVerificationException(String msg, Object failed); + public JDOOptimisticVerificationException(String msg, Throwable[] nested); + public JDOOptimisticVerificationException(String msg, Throwable nested, Object failed); + public JDOOptimisticVerificationException(String msg, Throwable[] nested, Object failed); +} + +public class javax.jdo.JDOUnsupportedOptionException extends javax.jdo.JDOUserException { + public JDOUnsupportedOptionException(); + public JDOUnsupportedOptionException(String msg); + public JDOUnsupportedOptionException(String msg, Throwable[] nested); + public JDOUnsupportedOptionException(String msg, Throwable nested); +} + +public class javax.jdo.JDOUserCallbackException extends javax.jdo.JDOUserException { + public JDOUserCallbackException(); + public JDOUserCallbackException(String msg); + public JDOUserCallbackException(String msg, Throwable[] nested); + public JDOUserCallbackException(String msg, Throwable nested); + public JDOUserCallbackException(String msg, Object failed); + public JDOUserCallbackException(String msg, Throwable[] nested, Object failed); + public JDOUserCallbackException(String msg, Throwable nested, Object failed); +} + +public class javax.jdo.JDOUserException extends javax.jdo.JDOCanRetryException { + public JDOUserException(); + public JDOUserException(String msg); + public JDOUserException(String msg, Throwable[] nested); + public JDOUserException(String msg, Throwable nested); + public JDOUserException(String msg, Object failed); + public JDOUserException(String msg, Throwable[] nested, Object failed); + public JDOUserException(String msg, Throwable nested, Object failed); +} + +public interface javax.jdo.listener.AttachCallback { + public void jdoPreAttach(); + public void jdoPostAttach(Object attached); +} + +public interface javax.jdo.listener.AttachLifecycleListener extends javax.jdo.listener.InstanceLifecycleListener { + public void preAttach(javax.jdo.listener.InstanceLifecycleEvent event); + public void postAttach(javax.jdo.listener.InstanceLifecycleEvent event); +} + +public interface javax.jdo.listener.ClearCallback { + public void jdoPreClear(); +} + +public interface javax.jdo.listener.ClearLifecycleListener extends javax.jdo.listener.InstanceLifecycleListener { + public void preClear(javax.jdo.listener.InstanceLifecycleEvent event); + public void postClear(javax.jdo.listener.InstanceLifecycleEvent event); +} + +public interface javax.jdo.listener.CreateLifecycleListener extends javax.jdo.listener.InstanceLifecycleListener { + public void postCreate(javax.jdo.listener.InstanceLifecycleEvent event); +} + +public interface javax.jdo.listener.DeleteCallback { + public void jdoPreDelete(); +} + +public interface javax.jdo.listener.DeleteLifecycleListener extends javax.jdo.listener.InstanceLifecycleListener { + public void preDelete(javax.jdo.listener.InstanceLifecycleEvent event); + public void postDelete(javax.jdo.listener.InstanceLifecycleEvent event); +} + +public interface javax.jdo.listener.DetachCallback { + public void jdoPreDetach(); + public void jdoPostDetach(Object detached); +} + +public interface javax.jdo.listener.DetachLifecycleListener extends javax.jdo.listener.InstanceLifecycleListener { + public void preDetach(javax.jdo.listener.InstanceLifecycleEvent event); + public void postDetach(javax.jdo.listener.InstanceLifecycleEvent event); +} + +public interface javax.jdo.listener.DirtyLifecycleListener extends javax.jdo.listener.InstanceLifecycleListener { + public void preDirty(javax.jdo.listener.InstanceLifecycleEvent event); + public void postDirty(javax.jdo.listener.InstanceLifecycleEvent event); +} + +public class javax.jdo.listener.InstanceLifecycleEvent extends java.util.EventObject { + public static final int CREATE = 0; + public static final int LOAD = 1; + public static final int STORE = 2; + public static final int CLEAR = 3; + public static final int DELETE = 4; + public static final int DIRTY = 5; + public static final int DETACH = 6; + public static final int ATTACH = 7; + public InstanceLifecycleEvent(Object source, int type); + public InstanceLifecycleEvent(Object source, int type, Object target); + public int getEventType(); + public Object getSource(); + public Object getTarget(); + public Object getPersistentInstance(); + public Object getDetachedInstance(); +} + +public interface javax.jdo.listener.InstanceLifecycleListener { +} + +public interface javax.jdo.listener.LoadCallback { + public void jdoPostLoad(); +} + +public interface javax.jdo.listener.LoadLifecycleListener extends javax.jdo.listener.InstanceLifecycleListener { + public void postLoad(javax.jdo.listener.InstanceLifecycleEvent event); +} + +public interface javax.jdo.listener.StoreCallback { + public void jdoPreStore(); +} + +public interface javax.jdo.listener.StoreLifecycleListener extends javax.jdo.listener.InstanceLifecycleListener { + public void preStore(javax.jdo.listener.InstanceLifecycleEvent event); + public void postStore(javax.jdo.listener.InstanceLifecycleEvent event); +} + +public interface javax.jdo.PersistenceManager { + public boolean isClosed(); + public void close(); + public javax.jdo.Transaction currentTransaction(); + public void evict(Object pc); + public varargs void evictAll(Object[] pcs); + public void evictAll(java.util.Collection pcs); + public void evictAll(boolean, Class); + public void evictAll(); + public void refresh(Object pc); + public varargs void refreshAll(Object[] pcs); + public void refreshAll(java.util.Collection pcs); + public void refreshAll(); + public void refreshAll(javax.jdo.JDOException jdoe); + public javax.jdo.Query newQuery(); + public javax.jdo.Query newQuery(Object compiled); + public javax.jdo.Query newQuery(String query); + public javax.jdo.Query newQuery(String language, Object query); + public javax.jdo.Query newQuery(Class cls); + public javax.jdo.Query newQuery(javax.jdo.Extent cln); + public javax.jdo.Query newQuery(Class cls, java.util.Collection cln); + public javax.jdo.Query newQuery(Class cls, String filter); + public javax.jdo.Query newQuery(Class cls, java.util.Collection cln, String filter); + public javax.jdo.Query newQuery(javax.jdo.Extent cln, String filter); + public javax.jdo.Query newNamedQuery(Class cls, String queryName); + public javax.jdo.Extent getExtent(Class persistenceCapableClass, boolean subclasses); + public javax.jdo.Extent getExtent(Class persistenceCapableClass); + public Object getObjectById(Object oid, boolean validate); + public Object getObjectById(Class cls, Object key); + public Object getObjectById(Object oid); + public Object getObjectId(Object pc); + public Object getTransactionalObjectId(Object pc); + public Object newObjectIdInstance(Class pcClass, Object key); + public java.util.Collection getObjectsById(java.util.Collection oids, boolean validate); + public java.util.Collection getObjectsById(java.util.Collection oids); + public Object[] getObjectsById(Object[] oids, boolean validate); + public varargs Object[] getObjectsById(boolean validate,Object[] oids); + public varargs Object[] getObjectsById(Object[] oids); + public Object makePersistent(Object pc); + public varargs Object[] makePersistentAll(Object[] pcs); + public java.util.Collection makePersistentAll(java.util.Collection pcs); + public void deletePersistent(Object pc); + public varargs void deletePersistentAll(Object[] pcs); + public void deletePersistentAll(java.util.Collection pcs); + public void makeTransient(Object pc); + public varargs void makeTransientAll(Object[] pcs); + public void makeTransientAll(java.util.Collection pcs); + public void makeTransient(Object pc, boolean useFetchPlan); + public void makeTransientAll(Object[] pcs, boolean useFetchPlan); + public varargs void makeTransientAll(boolean useFetchPlan, Object[] pcs); + public void makeTransientAll(java.util.Collection pcs, boolean useFetchPlan); + public void makeTransactional(Object pc); + public varargs void makeTransactionalAll(Object[] pcs); + public void makeTransactionalAll(java.util.Collection pcs); + public void makeNontransactional(Object pc); + public varargs void makeNontransactionalAll(Object[] pcs); + public void makeNontransactionalAll(java.util.Collection pcs); + public void retrieve(Object pc); + public void retrieve(Object pc, boolean FGOnly); + public void retrieveAll(java.util.Collection pcs); + public void retrieveAll(java.util.Collection pcs, boolean FGOnly); + public varargs void retrieveAll(Object[] pcs); + public void retrieveAll(Object[] pcs, boolean FGOnly); + public varargs void retrieveAll(boolean FGOnly, Object[] pcs); + public void setUserObject(Object o); + public Object getUserObject(); + public javax.jdo.PersistenceManagerFactory getPersistenceManagerFactory(); + public Class getObjectIdClass(Class cls); + public void setMultithreaded(boolean flag); + public boolean getMultithreaded(); + public void setIgnoreCache(boolean flag); + public boolean getIgnoreCache(); + public boolean getDetachAllOnCommit(); + public void setDetachAllOnCommit(boolean flag); + public boolean getCopyOnAttach(); + public void setCopyOnAttach(boolean flag); + public Object detachCopy(Object pc); + public java.util.Collection detachCopyAll(java.util.Collection pcs); + public varargs Object[] detachCopyAll(Object [] pcs); + public Object putUserObject(Object key, Object val); + public Object getUserObject(Object key); + public Object removeUserObject(Object key); + public void flush(); + public void checkConsistency(); + public javax.jdo.FetchPlan getFetchPlan(); + public Object newInstance(Class pcClass); + public java.util.Date getServerDate(); + public javax.jdo.datastore.Sequence getSequence(String name); + public javax.jdo.datastore.JDOConnection getDataStoreConnection(); + public varargs void addInstanceLifecycleListener(javax.jdo.listener.InstanceLifecycleListener listener, Class[] classes); + public void removeInstanceLifecycleListener(javax.jdo.listener.InstanceLifecycleListener listener); + public java.util.Set getManagedObjects(); + public java.util.Set getManagedObjects(java.util.EnumSet states); + public varargs java.util.Set getManagedObjects(Class[] classes); + public varargs java.util.Set getManagedObjects(java.util.EnumSet states, Class[] classes); + javax.jdo.FetchGroup getFetchGroup(Class cls, String name); + public void setDatastoreReadTimeoutMillis(Integer interval); + public Integer getDatastoreReadTimeoutMillis(); + public void setDatastoreWriteTimeoutMillis(Integer interval); + public Integer getDatastoreWriteTimeoutMillis(); + public void setProperty(String propertyName, Object value); + public java.util.Map getProperties(); + public java.util.Set getSupportedProperties(); +} + +public interface javax.jdo.PersistenceManagerFactory extends java.io.Serializable { + public void close(); + public boolean isClosed(); + public javax.jdo.PersistenceManager getPersistenceManager(); + public javax.jdo.PersistenceManager getPersistenceManagerProxy(); + public javax.jdo.PersistenceManager getPersistenceManager(String userid, String password); + public void setConnectionUserName(String userName); + public String getConnectionUserName(); + public void setConnectionPassword(String password); + public void setConnectionURL(String URL); + public String getConnectionURL(); + public void setConnectionDriverName(String driverName); + public String getConnectionDriverName(); + public void setConnectionFactoryName(String connectionFactoryName); + public String getConnectionFactoryName(); + public void setConnectionFactory(Object connectionFactory); + public Object getConnectionFactory(); + public void setConnectionFactory2Name(String connectionFactoryName); + public String getConnectionFactory2Name(); + public void setConnectionFactory2(Object connectionFactory); + public Object getConnectionFactory2(); + public void setMultithreaded(boolean flag); + public boolean getMultithreaded(); + public void setMapping(String mapping); + public String getMapping(); + public void setOptimistic(boolean flag); + public boolean getOptimistic(); + public void setRetainValues(boolean flag); + public boolean getRetainValues(); + public void setRestoreValues(boolean restoreValues); + public boolean getRestoreValues(); + public void setNontransactionalRead(boolean flag); + public boolean getNontransactionalRead(); + public void setNontransactionalWrite(boolean flag); + public boolean getNontransactionalWrite(); + public void setIgnoreCache(boolean flag); + public boolean getIgnoreCache(); + public boolean getDetachAllOnCommit(); + public void setDetachAllOnCommit(boolean flag); + public boolean getCopyOnAttach(); + public void setCopyOnAttach(boolean flag); + public java.lang.String getName(); + public void setName(java.lang.String); + public java.lang.String getPersistenceUnitName(); + public void setPersistenceUnitName(java.lang.String); + public java.lang.String getServerTimeZoneID(); + public void setServerTimeZoneID(java.lang.String); + public java.lang.String getTransactionType(); + public void setTransactionType(java.lang.String); + public void setReadOnly(boolean flag); + public boolean getReadOnly(); + public void setTransactionIsolationLevel(String); + public String getTransactionIsolationLevel(); + public java.util.Properties getProperties(); + public java.util.Collection supportedOptions(); + public javax.jdo.datastore.DataStoreCache getDataStoreCache(); + public void addInstanceLifecycleListener(javax.jdo.listener.InstanceLifecycleListener listener, Class[] classes); + public void removeInstanceLifecycleListener(javax.jdo.listener.InstanceLifecycleListener listener); + varargs void addFetchGroups(javax.jdo.FetchGroup[] groups); + varargs void removeFetchGroups(javax.jdo.FetchGroup[] groups); + void removeAllFetchGroups(); + javax.jdo.FetchGroup getFetchGroup(Class cls, String name); + java.util.Set getFetchGroups(); + public void registerMetadata(javax.jdo.metadata.JDOMetadata metadata); + public javax.jdo.metadata.JDOMetadata newMetadata(); + public javax.jdo.metadata.TypeMetadata getMetadata(String className); + public void setDatastoreReadTimeoutMillis(Integer interval); + public Integer getDatastoreReadTimeoutMillis(); + public void setDatastoreWriteTimeoutMillis(Integer interval); + public Integer getDatastoreWriteTimeoutMillis(); + public java.util.Collection getManagedClasses(); +} + +public interface javax.jdo.Query extends java.io.Serializable { + public static final String JDOQL = "javax.jdo.query.JDOQL"; + public static final String SQL = "javax.jdo.query.SQL"; + public void setClass(Class cls); + public void setCandidates(javax.jdo.Extent pcs); + public void setCandidates(java.util.Collection pcs); + public void setFilter(String filter); + public void declareImports(String imports); + public void declareParameters(String parameters); + public void declareVariables(String variables); + public void setOrdering(String ordering); + public void setIgnoreCache(boolean ignoreCache); + public void addSubquery(javax.jdo.Query, java.lang.String, java.lang.String); + public void addSubquery(javax.jdo.Query, java.lang.String, java.lang.String, java.lang.String); + public varargs void addSubquery(javax.jdo.Query, java.lang.String, java.lang.String, java.lang.String[]); + public void addSubquery(javax.jdo.Query, java.lang.String, java.lang.String, java.util.Map); + public boolean getIgnoreCache(); + public void compile(); + public Object execute(); + public Object execute(Object p1); + public Object execute(Object p1, Object p2); + public Object execute(Object p1, Object p2, Object p3); + public Object executeWithMap(java.util.Map parameters); + public varargs Object executeWithArray(Object[] parameters); + public javax.jdo.PersistenceManager getPersistenceManager(); + public void close(Object queryResult); + public void closeAll(); + public void setGrouping(String group); + public void setUnique(boolean unique); + public void setResult(String data); + public void setResultClass(Class cls); + public void setRange(long fromIncl, long toExcl); + public void setRange(String fromInclToExcl); + public void addExtension(String key, Object value); + public void setExtensions(java.util.Map extensions); + public javax.jdo.FetchPlan getFetchPlan(); + public varargs long deletePersistentAll(Object[] parameters); + public long deletePersistentAll(java.util.Map parameters); + public long deletePersistentAll(); + public void setUnmodifiable(); + public boolean isUnmodifiable(); + public void cancelAll(); + public void cancel(Thread); + public Boolean getSerializeRead(); + public void setSerializeRead(Boolean); + public void setDatastoreReadTimeoutMillis(Integer interval); + public Integer getDatastoreReadTimeoutMillis(); + public void setDatastoreWriteTimeoutMillis(Integer interval); + public Integer getDatastoreWriteTimeoutMillis(); +} + +public interface javax.jdo.spi.Detachable { + public void jdoReplaceDetachedState(); +} + +public class javax.jdo.spi.JDOImplHelper extends Object { + public static javax.jdo.spi.JDOImplHelper getInstance() throws SecurityException; + public String[] getFieldNames(Class pcClass); + public Class[] getFieldTypes(Class pcClass); + public byte[] getFieldFlags(Class pcClass); + public Class getPersistenceCapableSuperclass(Class pcClass); + public javax.jdo.spi.PersistenceCapable newInstance(Class pcClass, javax.jdo.spi.StateManager sm); + public javax.jdo.spi.PersistenceCapable newInstance(Class pcClass, javax.jdo.spi.StateManager sm, Object oid); + public Object newObjectIdInstance(Class pcClass); + public Object newObjectIdInstance(Class pcClass, Object obj); + public void copyKeyFieldsToObjectId(Class pcClass, javax.jdo.spi.PersistenceCapable$ObjectIdFieldSupplier fm, Object oid); + public void copyKeyFieldsFromObjectId(Class pcClass, javax.jdo.spi.PersistenceCapable$ObjectIdFieldConsumer fm, Object oid); + public static void registerClass(Class pcClass, String[] fieldNames, Class[] fieldTypes, byte[] fieldFlags, Class persistenceCapableSuperclass, javax.jdo.spi.PersistenceCapable pc); + public void unregisterClasses(ClassLoader cl); + public void unregisterClass(Class pcClass); + public void addRegisterClassListener(javax.jdo.spi.RegisterClassListener crl); + public void removeRegisterClassListener(javax.jdo.spi.RegisterClassListener crl); + public java.util.Collection getRegisteredClasses(); + public static void registerAuthorizedStateManagerClass(Class smClass) throws SecurityException; + public static void registerAuthorizedStateManagerClasses(java.util.Collection smClasses) throws SecurityException; + public static void checkAuthorizedStateManager(javax.jdo.spi.StateManager sm); + public static void checkAuthorizedStateManagerClass(Class smClass); + public Object registerStringConstructor(Class cls, javax.jdo.spi.JDOImplHelper$StringConstructor sc); + public static Object construct(String className, String keyString); + public synchronized void registerDateFormat(java.text.DateFormat df); + public synchronized void registerErrorHandler(org.xml.sax.ErrorHandler); + public static org.xml.sax.ErrorHandler getRegisteredErrorHandler(); + public synchronized void registerDocumentBuilderFactory(javax.xml.parsers.DocumentBuilderFactory); + public static javax.xml.parsers.DocumentBuilderFactory getRegisteredDocumentBuilderFactory(); + public synchronized void addStateInterrogation(javax.jdo.spi.StateInterrogation si); + public synchronized void removeStateInterrogation(javax.jdo.spi.StateInterrogation si); + public void nonBinaryCompatibleMakeDirty(Object pc, String fieldName); + public boolean nonBinaryCompatibleIs(Object pc, javax.jdo.spi.JDOImplHelper$StateInterrogationBooleanReturn sibr); + public Object nonBinaryCompatibleGet(Object pc, javax.jdo.spi.JDOImplHelper$StateInterrogationObjectReturn sibr); + public static void assertOnlyKnownStandardProperties(java.util.Map properties); + public static final java.util.Set USER_CONFIGURABLE_STANDARD_PROPERTIES; +} + +static public interface javax.jdo.spi.JDOImplHelper$StringConstructor { + public Object construct(String s); +} + +static public interface javax.jdo.spi.JDOImplHelper$StateInterrogationBooleanReturn { + public Boolean is(Object pc, javax.jdo.spi.StateInterrogation si); +} + +static public interface javax.jdo.spi.JDOImplHelper$StateInterrogationObjectReturn { + public Object get(Object pc, javax.jdo.spi.StateInterrogation si); +} + +public final class javax.jdo.spi.JDOPermission extends java.security.BasicPermission { + public JDOPermission(String name); + public JDOPermission(String name, String actions); + public static final javax.jdo.spi.JDOPermission GET_METADATA; + public static final javax.jdo.spi.JDOPermission MANAGE_METADATA; + public static final javax.jdo.spi.JDOPermission SET_STATE_MANAGER; + public static final javax.jdo.spi.JDOPermission CLOSE_PERSISTENCE_MANAGER_FACTORY; +} + +public interface javax.jdo.spi.PersistenceCapable { + public static final byte READ_WRITE_OK = 0; + public static final byte LOAD_REQUIRED = 1; + public static final byte READ_OK = -1; + public static final byte CHECK_READ = 1; + public static final byte MEDIATE_READ = 2; + public static final byte CHECK_WRITE = 4; + public static final byte MEDIATE_WRITE = 8; + public static final byte SERIALIZABLE = 16; + public javax.jdo.PersistenceManager jdoGetPersistenceManager(); + public void jdoReplaceStateManager(javax.jdo.spi.StateManager sm) throws SecurityException; + public void jdoProvideField(int fieldNumber); + public void jdoProvideFields(int[] fieldNumbers); + public void jdoReplaceField(int fieldNumber); + public void jdoReplaceFields(int[] fieldNumbers); + public void jdoReplaceFlags(); + public void jdoCopyFields(Object other, int[] fieldNumbers); + public void jdoMakeDirty(String fieldName); + public Object jdoGetObjectId(); + public Object jdoGetTransactionalObjectId(); + public Object jdoGetVersion(); + public boolean jdoIsDirty(); + public boolean jdoIsTransactional(); + public boolean jdoIsPersistent(); + public boolean jdoIsNew(); + public boolean jdoIsDeleted(); + public boolean jdoIsDetached(); + public javax.jdo.spi.PersistenceCapable jdoNewInstance(javax.jdo.spi.StateManager sm); + public javax.jdo.spi.PersistenceCapable jdoNewInstance(javax.jdo.spi.StateManager sm, Object oid); + public Object jdoNewObjectIdInstance(); + public Object jdoNewObjectIdInstance(Object o); + public void jdoCopyKeyFieldsToObjectId(Object oid); + public void jdoCopyKeyFieldsToObjectId(javax.jdo.spi.PersistenceCapable$ObjectIdFieldSupplier fm, Object oid); + public void jdoCopyKeyFieldsFromObjectId(javax.jdo.spi.PersistenceCapable$ObjectIdFieldConsumer fm, Object oid); +} + +static public interface javax.jdo.spi.PersistenceCapable$ObjectIdFieldManager extends javax.jdo.spi.PersistenceCapable$ObjectIdFieldConsumer, javax.jdo.spi.PersistenceCapable$ObjectIdFieldSupplier { +} + +static public interface javax.jdo.spi.PersistenceCapable$ObjectIdFieldSupplier { + public boolean fetchBooleanField(int fieldNumber); + public char fetchCharField(int fieldNumber); + public byte fetchByteField(int fieldNumber); + public short fetchShortField(int fieldNumber); + public int fetchIntField(int fieldNumber); + public long fetchLongField(int fieldNumber); + public float fetchFloatField(int fieldNumber); + public double fetchDoubleField(int fieldNumber); + public String fetchStringField(int fieldNumber); + public Object fetchObjectField(int fieldNumber); +} + +static public interface javax.jdo.spi.PersistenceCapable$ObjectIdFieldConsumer { + public void storeBooleanField(int fieldNumber, boolean value); + public void storeCharField(int fieldNumber, char value); + public void storeByteField(int fieldNumber, byte value); + public void storeShortField(int fieldNumber, short value); + public void storeIntField(int fieldNumber, int value); + public void storeLongField(int fieldNumber, long value); + public void storeFloatField(int fieldNumber, float value); + public void storeDoubleField(int fieldNumber, double value); + public void storeStringField(int fieldNumber, String value); + public void storeObjectField(int fieldNumber, Object value); +} + +public class javax.jdo.spi.RegisterClassEvent extends java.util.EventObject { + public RegisterClassEvent(javax.jdo.spi.JDOImplHelper helper, Class registeredClass, String[] fieldNames, Class[] fieldTypes, byte[] fieldFlags, Class persistenceCapableSuperclass); + public Class getRegisteredClass(); + public String[] getFieldNames(); + public Class[] getFieldTypes(); + public byte[] getFieldFlags(); + public Class getPersistenceCapableSuperclass(); +} + +public interface javax.jdo.spi.RegisterClassListener extends java.util.EventListener { + public void registerClass(javax.jdo.spi.RegisterClassEvent event); +} + +public interface javax.jdo.spi.StateInterrogation { + public Boolean isPersistent(Object pc); + public Boolean isTransactional(Object pc); + public Boolean isDirty(Object pc); + public Boolean isNew(Object pc); + public Boolean isDeleted(Object pc); + public Boolean isDetached(Object pc); + public javax.jdo.PersistenceManager getPersistenceManager(Object pc); + public Object getObjectId(Object pc); + public Object getTransactionalObjectId(Object pc); + public Object getVersion(Object pc); + public boolean makeDirty(Object pc, String fieldName); +} + +public interface javax.jdo.spi.StateManager { + public byte replacingFlags(javax.jdo.spi.PersistenceCapable pc); + public javax.jdo.spi.StateManager replacingStateManager(javax.jdo.spi.PersistenceCapable pc, javax.jdo.spi.StateManager sm); + public boolean isDirty(javax.jdo.spi.PersistenceCapable pc); + public boolean isTransactional(javax.jdo.spi.PersistenceCapable pc); + public boolean isPersistent(javax.jdo.spi.PersistenceCapable pc); + public boolean isNew(javax.jdo.spi.PersistenceCapable pc); + public boolean isDeleted(javax.jdo.spi.PersistenceCapable pc); + public javax.jdo.PersistenceManager getPersistenceManager(javax.jdo.spi.PersistenceCapable pc); + public void makeDirty(javax.jdo.spi.PersistenceCapable pc, String fieldName); + public Object getObjectId(javax.jdo.spi.PersistenceCapable pc); + public Object getTransactionalObjectId(javax.jdo.spi.PersistenceCapable pc); + public Object getVersion(javax.jdo.spi.PersistenceCapable pc); + public boolean isLoaded(javax.jdo.spi.PersistenceCapable pc, int field); + public void preSerialize(javax.jdo.spi.PersistenceCapable pc); + public boolean getBooleanField(javax.jdo.spi.PersistenceCapable pc, int field, boolean currentValue); + public char getCharField(javax.jdo.spi.PersistenceCapable pc, int field, char currentValue); + public byte getByteField(javax.jdo.spi.PersistenceCapable pc, int field, byte currentValue); + public short getShortField(javax.jdo.spi.PersistenceCapable pc, int field, short currentValue); + public int getIntField(javax.jdo.spi.PersistenceCapable pc, int field, int currentValue); + public long getLongField(javax.jdo.spi.PersistenceCapable pc, int field, long currentValue); + public float getFloatField(javax.jdo.spi.PersistenceCapable pc, int field, float currentValue); + public double getDoubleField(javax.jdo.spi.PersistenceCapable pc, int field, double currentValue); + public String getStringField(javax.jdo.spi.PersistenceCapable pc, int field, String currentValue); + public Object getObjectField(javax.jdo.spi.PersistenceCapable pc, int field, Object currentValue); + public void setBooleanField(javax.jdo.spi.PersistenceCapable pc, int field, boolean currentValue, boolean newValue); + public void setCharField(javax.jdo.spi.PersistenceCapable pc, int field, char currentValue, char newValue); + public void setByteField(javax.jdo.spi.PersistenceCapable pc, int field, byte currentValue, byte newValue); + public void setShortField(javax.jdo.spi.PersistenceCapable pc, int field, short currentValue, short newValue); + public void setIntField(javax.jdo.spi.PersistenceCapable pc, int field, int currentValue, int newValue); + public void setLongField(javax.jdo.spi.PersistenceCapable pc, int field, long currentValue, long newValue); + public void setFloatField(javax.jdo.spi.PersistenceCapable pc, int field, float currentValue, float newValue); + public void setDoubleField(javax.jdo.spi.PersistenceCapable pc, int field, double currentValue, double newValue); + public void setStringField(javax.jdo.spi.PersistenceCapable pc, int field, String currentValue, String newValue); + public void setObjectField(javax.jdo.spi.PersistenceCapable pc, int field, Object currentValue, Object newValue); + public void providedBooleanField(javax.jdo.spi.PersistenceCapable pc, int field, boolean currentValue); + public void providedCharField(javax.jdo.spi.PersistenceCapable pc, int field, char currentValue); + public void providedByteField(javax.jdo.spi.PersistenceCapable pc, int field, byte currentValue); + public void providedShortField(javax.jdo.spi.PersistenceCapable pc, int field, short currentValue); + public void providedIntField(javax.jdo.spi.PersistenceCapable pc, int field, int currentValue); + public void providedLongField(javax.jdo.spi.PersistenceCapable pc, int field, long currentValue); + public void providedFloatField(javax.jdo.spi.PersistenceCapable pc, int field, float currentValue); + public void providedDoubleField(javax.jdo.spi.PersistenceCapable pc, int field, double currentValue); + public void providedStringField(javax.jdo.spi.PersistenceCapable pc, int field, String currentValue); + public void providedObjectField(javax.jdo.spi.PersistenceCapable pc, int field, Object currentValue); + public boolean replacingBooleanField(javax.jdo.spi.PersistenceCapable pc, int field); + public char replacingCharField(javax.jdo.spi.PersistenceCapable pc, int field); + public byte replacingByteField(javax.jdo.spi.PersistenceCapable pc, int field); + public short replacingShortField(javax.jdo.spi.PersistenceCapable pc, int field); + public int replacingIntField(javax.jdo.spi.PersistenceCapable pc, int field); + public long replacingLongField(javax.jdo.spi.PersistenceCapable pc, int field); + public float replacingFloatField(javax.jdo.spi.PersistenceCapable pc, int field); + public double replacingDoubleField(javax.jdo.spi.PersistenceCapable pc, int field); + public String replacingStringField(javax.jdo.spi.PersistenceCapable pc, int field); + public Object replacingObjectField(javax.jdo.spi.PersistenceCapable pc, int field); + public Object[] replacingDetachedState(javax.jdo.spi.Detachable pc, Object[] state); +} + +public interface javax.jdo.Transaction { + public void begin(); + public void commit(); + public void rollback(); + public boolean isActive(); + public boolean getRollbackOnly(); + public void setRollbackOnly(); + public void setNontransactionalRead(boolean nontransactionalRead); + public boolean getNontransactionalRead(); + public void setNontransactionalWrite(boolean nontransactionalWrite); + public boolean getNontransactionalWrite(); + public void setRetainValues(boolean retainValues); + public boolean getRetainValues(); + public void setRestoreValues(boolean restoreValues); + public boolean getRestoreValues(); + public void setOptimistic(boolean optimistic); + public boolean getOptimistic(); + void setIsolationLevel(String level); + String getIsolationLevel(); + public void setSynchronization(javax.transaction.Synchronization sync); + public javax.transaction.Synchronization getSynchronization(); + public javax.jdo.PersistenceManager getPersistenceManager(); + public Boolean getSerializeRead(); + public void setSerializeRead(Boolean); +} + +public final enum javax.jdo.ObjectState extends java.lang.Enum { + + public static final enum javax.jdo.ObjectState TRANSIENT; + public static final enum javax.jdo.ObjectState TRANSIENT_CLEAN; + public static final enum javax.jdo.ObjectState TRANSIENT_DIRTY; + public static final enum javax.jdo.ObjectState PERSISTENT_NEW; + public static final enum javax.jdo.ObjectState HOLLOW_PERSISTENT_NONTRANSACTIONAL; + public static final enum javax.jdo.ObjectState PERSISTENT_NONTRANSACTIONAL_DIRTY; + public static final enum javax.jdo.ObjectState PERSISTENT_CLEAN; + public static final enum javax.jdo.ObjectState PERSISTENT_DIRTY; + public static final enum javax.jdo.ObjectState PERSISTENT_DELETED; + public static final enum javax.jdo.ObjectState PERSISTENT_NEW_DELETED; + public static final enum javax.jdo.ObjectState DETACHED_CLEAN; + public static final enum javax.jdo.ObjectState DETACHED_DIRTY; + public static enum javax.jdo.ObjectState valueOf(java.lang.String); + public static javax.jdo.ObjectState[] values(); + public String toString(); +} + +public annotation javax.jdo.annotations.Column extends java.lang.annotation.Annotation +{ + String name() default ""; + String target() default ""; + String targetMember() default ""; + String jdbcType() default ""; + String sqlType() default ""; + int length() default -1; + int scale() default -1; + String allowsNull() default ""; + String defaultValue() default ""; + String insertValue() default ""; + javax.jdo.annotations.Extension[] extensions() default {}; + int position() default -1; +} + +public annotation javax.jdo.annotations.Columns extends java.lang.annotation.Annotation +{ + javax.jdo.annotations.Column[] value(); +} + +public annotation javax.jdo.annotations.DatastoreIdentity extends java.lang.annotation.Annotation +{ + enum javax.jdo.annotations.IdGeneratorStrategy strategy() default javax.jdo.annotations.IdGeneratorStrategy.UNSPECIFIED; + String customStrategy() default ""; + String sequence() default ""; + String column() default ""; + javax.jdo.annotations.Column[] columns() default {}; + javax.jdo.annotations.Extension[] extensions() default {}; +} + +public annotation javax.jdo.annotations.Discriminator extends java.lang.annotation.Annotation +{ + enum javax.jdo.annotations.DiscriminatorStrategy strategy() + default javax.jdo.annotations.DiscriminatorStrategy.UNSPECIFIED; + String customStrategy() default ""; + String indexed() default ""; + String column() default ""; + String value() default ""; + javax.jdo.annotations.Column[] columns() default {}; +} + +public final enum javax.jdo.annotations.DiscriminatorStrategy extends java.lang.Enum +{ + public static final enum javax.jdo.annotations.DiscriminatorStrategy UNSPECIFIED; + public static final enum javax.jdo.annotations.DiscriminatorStrategy NONE; + public static final enum javax.jdo.annotations.DiscriminatorStrategy VALUE_MAP; + public static final enum javax.jdo.annotations.DiscriminatorStrategy CLASS_NAME; + public static enum javax.jdo.annotations.DiscriminatorStrategy valueOf(java.lang.String); + public static javax.jdo.annotations.DiscriminatorStrategy[] values(); +} + +public annotation javax.jdo.annotations.Element extends java.lang.annotation.Annotation +{ + Class[] types() default {}; + String serialized() default ""; + String embedded() default ""; + javax.jdo.annotations.Embedded[] embeddedMapping() default {}; + String dependent() default ""; + String table() default ""; + String column() default ""; + enum javax.jdo.annotations.ForeignKeyAction deleteAction() default javax.jdo.annotations.ForeignKeyAction.UNSPECIFIED; + enum javax.jdo.annotations.ForeignKeyAction updateAction() default javax.jdo.annotations.ForeignKeyAction.UNSPECIFIED; + String indexed() default ""; + String index() default ""; + String unique() default ""; + String uniqueKey() default ""; + String mappedBy() default ""; + javax.jdo.annotations.Column[] columns() default {}; + String generateForeignKey() default ""; + String foreignKey() default ""; + javax.jdo.annotations.Extension[] extensions() default {}; +} + +public annotation javax.jdo.annotations.Embedded extends java.lang.annotation.Annotation +{ + String ownerMember() default ""; + String nullIndicatorColumn() default ""; + String nullIndicatorValue() default ""; + javax.jdo.annotations.Persistent[] members() default {}; + javax.jdo.annotations.Discriminator discriminatorColumnName() default @javax.jdo.annotations.Discriminator; +} + +public annotation javax.jdo.annotations.EmbeddedOnly extends java.lang.annotation.Annotation +{ +} + +public annotation javax.jdo.annotations.Extension extends java.lang.annotation.Annotation +{ + String vendorName(); + String key(); + String value(); +} + +public annotation javax.jdo.annotations.Extensions extends java.lang.annotation.Annotation +{ + javax.jdo.annotations.Extension[] value(); +} + +public annotation javax.jdo.annotations.FetchGroup extends java.lang.annotation.Annotation +{ + String name() default ""; + String postLoad() default ""; + javax.jdo.annotations.Persistent[] members(); + String[] fetchGroups() default {}; +} + +public annotation javax.jdo.annotations.FetchGroups extends java.lang.annotation.Annotation +{ + javax.jdo.annotations.FetchGroup[] value(); +} + +public annotation javax.jdo.annotations.FetchPlan extends java.lang.annotation.Annotation +{ + String name() default ""; + String[] fetchGroups() default {}; + int maxFetchDepth() default 1; + int fetchSize() default 0; +} + +public annotation javax.jdo.annotations.FetchPlans extends java.lang.annotation.Annotation +{ + javax.jdo.annotations.FetchPlan[] value(); +} + +public annotation javax.jdo.annotations.ForeignKey extends java.lang.annotation.Annotation +{ + String name() default ""; + String table() default ""; + String deferred() default ""; + String unique() default ""; + enum javax.jdo.annotations.ForeignKeyAction deleteAction() default javax.jdo.annotations.ForeignKeyAction.RESTRICT; + enum javax.jdo.annotations.ForeignKeyAction updateAction() default javax.jdo.annotations.ForeignKeyAction.RESTRICT; + String[] members() default {}; + javax.jdo.annotations.Column[] columns() default {}; + javax.jdo.annotations.Extension[] extensions() default {}; +} + +public final enum javax.jdo.annotations.ForeignKeyAction extends java.lang.Enum +{ + public static final enum javax.jdo.annotations.ForeignKeyAction UNSPECIFIED; + public static final enum javax.jdo.annotations.ForeignKeyAction RESTRICT; + public static final enum javax.jdo.annotations.ForeignKeyAction CASCADE; + public static final enum javax.jdo.annotations.ForeignKeyAction NULL; + public static final enum javax.jdo.annotations.ForeignKeyAction DEFAULT; + public static final enum javax.jdo.annotations.ForeignKeyAction NONE; + public static enum javax.jdo.annotations.ForeignKeyAction valueOf(java.lang.String); + public static javax.jdo.annotations.ForeignKeyAction[] values(); +} + +public annotation javax.jdo.annotations.ForeignKeys extends java.lang.annotation.Annotation +{ + javax.jdo.annotations.ForeignKey[] value(); +} + +public final enum javax.jdo.annotations.IdGeneratorStrategy extends java.lang.Enum +{ + public static final enum javax.jdo.annotations.IdGeneratorStrategy UNSPECIFIED; + public static final enum javax.jdo.annotations.IdGeneratorStrategy NATIVE; + public static final enum javax.jdo.annotations.IdGeneratorStrategy SEQUENCE; + public static final enum javax.jdo.annotations.IdGeneratorStrategy IDENTITY; + public static final enum javax.jdo.annotations.IdGeneratorStrategy INCREMENT; + public static final enum javax.jdo.annotations.IdGeneratorStrategy UUIDSTRING; + public static final enum javax.jdo.annotations.IdGeneratorStrategy UUIDHEX; + public static enum javax.jdo.annotations.IdGeneratorStrategy valueOf(java.lang.String); + public static javax.jdo.annotations.IdGeneratorStrategy[] values(); +} + +public final enum javax.jdo.annotations.IdentityType extends java.lang.Enum +{ + public static final enum javax.jdo.annotations.IdentityType UNSPECIFIED; + public static final enum javax.jdo.annotations.IdentityType APPLICATION; + public static final enum javax.jdo.annotations.IdentityType DATASTORE; + public static final enum javax.jdo.annotations.IdentityType NONDURABLE; + public static enum javax.jdo.annotations.IdentityType valueOf(java.lang.String); + public static javax.jdo.annotations.IdentityType[] values(); +} + +public annotation javax.jdo.annotations.Index extends java.lang.annotation.Annotation +{ + String name() default ""; + String table() default ""; + String unique() default ""; + String[] members() default {}; + javax.jdo.annotations.Column[] columns() default {}; + javax.jdo.annotations.Extension[] extensions() default {}; +} + +public annotation javax.jdo.annotations.Indices extends java.lang.annotation.Annotation +{ + javax.jdo.annotations.Index[] value(); +} + +public annotation javax.jdo.annotations.Inheritance extends java.lang.annotation.Annotation +{ + enum javax.jdo.annotations.InheritanceStrategy strategy() default javax.jdo.annotations.InheritanceStrategy.UNSPECIFIED; + String customStrategy() default ""; +} + +public final enum javax.jdo.annotations.InheritanceStrategy extends java.lang.Enum +{ + public static final enum javax.jdo.annotations.InheritanceStrategy UNSPECIFIED; + public static final enum javax.jdo.annotations.InheritanceStrategy NEW_TABLE; + public static final enum javax.jdo.annotations.InheritanceStrategy SUBCLASS_TABLE; + public static final enum javax.jdo.annotations.InheritanceStrategy SUPERCLASS_TABLE; + public static final enum javax.jdo.annotations.InheritanceStrategy COMPLETE_TABLE; + public static enum javax.jdo.annotations.InheritanceStrategy valueOf(java.lang.String); + public static javax.jdo.annotations.InheritanceStrategy[] values(); +} + +public annotation javax.jdo.annotations.Join extends java.lang.annotation.Annotation +{ + String table() default ""; + String column() default ""; + String indexed() default ""; + String index() default ""; + String unique() default ""; + String uniqueKey() default ""; + String outer() default ""; + enum javax.jdo.annotations.ForeignKeyAction deleteAction() default javax.jdo.annotations.ForeignKeyAction.UNSPECIFIED; + javax.jdo.annotations.Column[] columns() default {}; + String generatePrimaryKey() default ""; + String primaryKey() default ""; + String generateForeignKey() default ""; + String foreignKey() default ""; + javax.jdo.annotations.Extension[] extensions() default {}; +} + +public annotation javax.jdo.annotations.Joins extends java.lang.annotation.Annotation +{ + javax.jdo.annotations.Join[] value(); +} + +public annotation javax.jdo.annotations.Key extends java.lang.annotation.Annotation +{ + Class[] types() default {}; + String serialized() default ""; + String embedded() default ""; + javax.jdo.annotations.Embedded[] embeddedMapping() default {}; + String dependent() default ""; + String table() default ""; + String column() default ""; + enum javax.jdo.annotations.ForeignKeyAction deleteAction() default javax.jdo.annotations.ForeignKeyAction.UNSPECIFIED; + enum javax.jdo.annotations.ForeignKeyAction updateAction() default javax.jdo.annotations.ForeignKeyAction.UNSPECIFIED; + String indexed() default ""; + String index() default ""; + String unique() default ""; + String uniqueKey() default ""; + String mappedBy() default ""; + javax.jdo.annotations.Column[] columns() default {}; + String generateForeignKey() default ""; + String foreignKey() default ""; + javax.jdo.annotations.Extension[] extensions() default {}; +} + +public annotation javax.jdo.annotations.NotPersistent extends java.lang.annotation.Annotation +{ +} + +public final enum javax.jdo.annotations.NullValue extends java.lang.Enum +{ + public static final enum javax.jdo.annotations.NullValue NONE; + public static final enum javax.jdo.annotations.NullValue EXCEPTION; + public static final enum javax.jdo.annotations.NullValue DEFAULT; + public static enum javax.jdo.annotations.NullValue valueOf(java.lang.String); + public static javax.jdo.annotations.NullValue[] values(); +} + +public annotation javax.jdo.annotations.Order extends java.lang.annotation.Annotation +{ + String column() default ""; + String mappedBy() default ""; + javax.jdo.annotations.Column[] columns() default {}; + javax.jdo.annotations.Extension[] extensions() default {}; +} + +public annotation javax.jdo.annotations.PersistenceAware extends java.lang.annotation.Annotation +{ +} + +public annotation javax.jdo.annotations.PersistenceCapable extends java.lang.annotation.Annotation +{ + javax.jdo.annotations.Persistent[] members() default {}; + String table() default ""; + String catalog() default ""; + String schema() default ""; + String requiresExtent() default ""; + String embeddedOnly() default ""; + String detachable() default ""; + enum javax.jdo.annotations.IdentityType identityType() default javax.jdo.annotations.IdentityType.UNSPECIFIED; + Class objectIdClass() default void.class; + javax.jdo.annotations.Extension[] extensions() default {}; + String cacheable() default "true"; + String serializeRead() default "false"; +} + +public final enum javax.jdo.annotations.PersistenceModifier extends java.lang.Enum +{ + public static final enum javax.jdo.annotations.PersistenceModifier UNSPECIFIED; + public static final enum javax.jdo.annotations.PersistenceModifier PERSISTENT; + public static final enum javax.jdo.annotations.PersistenceModifier TRANSACTIONAL; + public static final enum javax.jdo.annotations.PersistenceModifier NONE; + public static enum javax.jdo.annotations.PersistenceModifier valueOf(java.lang.String); + public static javax.jdo.annotations.PersistenceModifier[] values(); +} + +public annotation javax.jdo.annotations.Persistent extends java.lang.annotation.Annotation +{ + enum javax.jdo.annotations.PersistenceModifier persistenceModifier() + default javax.jdo.annotations.PersistenceModifier.UNSPECIFIED; + String table() default ""; + String defaultFetchGroup() default ""; + enum javax.jdo.annotations.NullValue nullValue() default javax.jdo.annotations.NullValue.NONE; + String embedded() default ""; + String embeddedElement() default ""; + String embeddedKey() default ""; + String embeddedValue() default ""; + String serialized() default ""; + String serializedElement() default ""; + String serializedKey() default ""; + String serializedValue() default ""; + String dependent() default ""; + String dependentElement() default ""; + String dependentKey() default ""; + String dependentValue() default ""; + String primaryKey() default ""; + enum javax.jdo.annotations.IdGeneratorStrategy valueStrategy() default javax.jdo.annotations.IdGeneratorStrategy.UNSPECIFIED; + String customValueStrategy() default ""; + String sequence() default ""; + String loadFetchGroup() default ""; + Class[] types() default {}; + String mappedBy() default ""; + javax.jdo.annotations.Column[] columns() default {}; + String column() default ""; + String nullIndicatorColumn() default ""; + String name() default ""; + int recursionDepth() default 1; + javax.jdo.annotations.Extension[] extensions() default {}; + String cacheable() default "true"; +} + +public annotation javax.jdo.annotations.PrimaryKey extends java.lang.annotation.Annotation +{ + String name() default ""; + String column() default ""; + javax.jdo.annotations.Column[] columns() default {}; + javax.jdo.annotations.Extension[] extensions() default {}; +} + +public annotation javax.jdo.annotations.Queries extends java.lang.annotation.Annotation +{ + javax.jdo.annotations.Query[] value(); +} + +public annotation javax.jdo.annotations.Query extends java.lang.annotation.Annotation +{ + String name(); + String value(); + String language() default "JDOQL"; + String unmodifiable() default ""; + String unique() default ""; + Class resultClass() default void.class; + String fetchPlan() default ""; + javax.jdo.annotations.Extension[] extensions() default {}; +} + +public annotation javax.jdo.annotations.Sequence extends java.lang.annotation.Annotation +{ + String name(); + enum javax.jdo.annotations.SequenceStrategy strategy(); + String datastoreSequence() default ""; + Class factoryClass() default void.class; + javax.jdo.annotations.Extension[] extensions() default {}; + int initialValue() default 1; + int allocationSize() default 50; +} + +public final enum javax.jdo.annotations.SequenceStrategy extends java.lang.Enum +{ + public static final enum javax.jdo.annotations.SequenceStrategy NONTRANSACTIONAL; + public static final enum javax.jdo.annotations.SequenceStrategy CONTIGUOUS; + public static final enum javax.jdo.annotations.SequenceStrategy NONCONTIGUOUS; + public static enum javax.jdo.annotations.SequenceStrategy valueOf(java.lang.String); + public static javax.jdo.annotations.SequenceStrategy[] values(); +} + +public annotation javax.jdo.annotations.Serialized extends java.lang.annotation.Annotation +{ +} + +public annotation javax.jdo.annotations.Transactional extends java.lang.annotation.Annotation +{ +} + +public annotation javax.jdo.annotations.Unique extends java.lang.annotation.Annotation +{ + String name() default ""; + String table() default ""; + String deferred() default ""; + String[] members() default {}; + javax.jdo.annotations.Column[] columns() default {}; + javax.jdo.annotations.Extension[] extensions() default {}; +} + +public annotation javax.jdo.annotations.Uniques extends java.lang.annotation.Annotation +{ + javax.jdo.annotations.Unique[] value(); +} + +public annotation javax.jdo.annotations.Value extends java.lang.annotation.Annotation +{ + Class[] types() default {}; + String serialized() default ""; + String embedded() default ""; + javax.jdo.annotations.Embedded[] embeddedMapping() default {}; + String dependent() default ""; + String table() default ""; + String column() default ""; + enum javax.jdo.annotations.ForeignKeyAction deleteAction() default javax.jdo.annotations.ForeignKeyAction.UNSPECIFIED; + enum javax.jdo.annotations.ForeignKeyAction updateAction() default javax.jdo.annotations.ForeignKeyAction.UNSPECIFIED; + String indexed() default ""; + String index() default ""; + String unique() default ""; + String uniqueKey() default ""; + String mappedBy() default ""; + javax.jdo.annotations.Column[] columns() default {}; + String generateForeignKey() default ""; + String foreignKey() default ""; + javax.jdo.annotations.Extension[] extensions() default {}; +} + +public annotation javax.jdo.annotations.Version extends java.lang.annotation.Annotation +{ + enum javax.jdo.annotations.VersionStrategy strategy() default javax.jdo.annotations.VersionStrategy.UNSPECIFIED; + String customStrategy() default ""; + String column() default ""; + String indexed() default ""; + javax.jdo.annotations.Column[] columns() default {}; + javax.jdo.annotations.Extension[] extensions() default {}; +} + +public final enum javax.jdo.annotations.VersionStrategy extends java.lang.Enum +{ + public static final enum javax.jdo.annotations.VersionStrategy UNSPECIFIED; + public static final enum javax.jdo.annotations.VersionStrategy NONE; + public static final enum javax.jdo.annotations.VersionStrategy STATE_IMAGE; + public static final enum javax.jdo.annotations.VersionStrategy DATE_TIME; + public static final enum javax.jdo.annotations.VersionStrategy VERSION_NUMBER; + public static enum javax.jdo.annotations.VersionStrategy valueOf(java.lang.String); + public static javax.jdo.annotations.VersionStrategy[] values(); +} + +public annotation javax.jdo.annotations.Cacheable extends java.lang.annotation.Annotation +{ + String value() default "true"; +} + +public interface javax.jdo.FetchGroup { + public static final String DEFAULT = "default"; + public static final String RELATIONSHIP = "relationship"; + public static final String MULTIVALUED = "multivalued"; + public static final String BASIC = "basic"; + public static final String ALL = "all"; + String getName(); + Class getType(); + boolean getPostLoad(); + javax.jdo.FetchGroup setPostLoad(boolean postLoad); + javax.jdo.FetchGroup addMember(String memberName); + varargs javax.jdo.FetchGroup addMembers(String[] memberNames); + javax.jdo.FetchGroup removeMember(String memberName); + varargs javax.jdo.FetchGroup removeMembers(String[] memberNames); + javax.jdo.FetchGroup addCategory(String categoryName); + javax.jdo.FetchGroup removeCategory(String categoryName); + javax.jdo.FetchGroup setRecursionDepth(String memberName, int recursionDepth); + int getRecursionDepth(String memberName); + java.util.Set getMembers(); + javax.jdo.FetchGroup setUnmodifiable(); + boolean isUnmodifiable(); + int hashCode(); + boolean equals(Object other); +} + +/*** This causes some NPE in SignatureTest whatever that means ***/ +/* +public interface JDOEnhancer extends java.lang.instrument.ClassFileTransformer { + java.util.Properties getProperties(); + javax.jdo.JDOEnhancer setVerbose(boolean flag); + javax.jdo.JDOEnhancer setOutputDirectory(String dirName); + javax.jdo.JDOEnhancer setClassLoader(ClassLoader loader); + javax.jdo.JDOEnhancer addPersistenceUnit(String persistenceUnit); + javax.jdo.JDOEnhancer addClass(String className, byte[] bytes); + javax.jdo.JDOEnhancer addClasses(String... classNames); + javax.jdo.JDOEnhancer addFiles(String... metadataFiles); + javax.jdo.JDOEnhancer addJar(String jarFileName); + int enhance(); + int validate(); + byte[] getEnhancedBytes(String className); + void registerMetadata(javax.jdo.metadata.JDOMetadata metadata); + javax.jdo.metadata.JDOMetadata newMetadata(); +} */ Propchange: db/jdo/trunk/tck/src/conf/jdo-signatures.txt ------------------------------------------------------------------------------ svn:eol-style = native