Java RawType类代码示例

import com.sleepycat.persist.raw.RawType; //导入依赖的package包/类
/**
 * Returns all known versions of type information for a given class name,
 * or null if no persistent version of the class is known.
 *
 * @param className the name of the latest version of the class.
 *
 * @return an unmodifiable list of types for the given class name in order
 * from most recent to least recent.
 *
 * @throws IllegalStateException if this method is called for a model that
 * is not associated with an open store.
 */
public final List<RawType> getAllRawTypeVersions(String className) {
    if (catalog != null) {
        Format format = catalog.getLatestVersion(className);
        if (format != null) {
            List<RawType> list = new ArrayList<RawType>();
            while (format != null) {
                list.add(format);
                format = format.getPreviousVersion();
            }
            return Collections.unmodifiableList(list);
        } else {
            return null;
        }
    } else {
        throw new IllegalStateException("Store is not open");
    }
}
 

import com.sleepycat.persist.raw.RawType; //导入依赖的package包/类
/**
 * Checks that a non-entity class exists or does not exist.
 */
static void checkNonEntity(boolean exists,
                           EntityModel model,
                           Environment env,
                           String className,
                           int version) {
    if (exists) {
        ClassMetadata meta = model.getClassMetadata(className);
        TestCase.assertNotNull(meta);
        TestCase.assertEquals(version, meta.getVersion());
        TestCase.assertTrue(!meta.isEntityClass());

        RawType raw = model.getRawType(className);
        TestCase.assertNotNull(raw);
        TestCase.assertEquals(version, raw.getVersion());
    } else {
        TestCase.assertNull(model.getClassMetadata(className));
        TestCase.assertNull(model.getRawType(className));
    }

    TestCase.assertNull(model.getEntityMetadata(className));
    assertDbExists(false, env, className);
}
 

import com.sleepycat.persist.raw.RawType; //导入依赖的package包/类
/**
 * Reads a raw object and checks its superclass names and versions.
 */
private static void checkRawType(RawType type,
                                 Object... classVersionPairs) {
    TestCase.assertNotNull(type);
    TestCase.assertNotNull(classVersionPairs);
    TestCase.assertTrue(classVersionPairs.length % 2 == 0);

    for (int i = 0; i < classVersionPairs.length; i += 2) {
        String clsName = (String) classVersionPairs[i];
        int clsVersion = (Integer) classVersionPairs[i + 1];
        TestCase.assertEquals(clsName, type.getClassName());
        TestCase.assertEquals(clsVersion, type.getVersion());
        type = type.getSuperType();
    }
    TestCase.assertNull(type);
}
 

import com.sleepycat.persist.raw.RawType; //导入依赖的package包/类
@Override
void readRawObjects(RawStore store,
                    boolean expectEvolved,
                    boolean expectUpdated)
    throws DatabaseException {

    if (expectEvolved) {
        TestCase.fail();
    }

    RawType embedType = store.getModel().getRawType(NAME);
    checkRawType(embedType, NAME, 0);

    RawObject embed =
        new RawObject(embedType, makeValues("f", 123), null);

    RawObject obj = readRaw(store, 99, NAME2, 0, CASECLS, 0);
    checkRawFields(obj, "key", 99, "embed", embed);
}
 

import com.sleepycat.persist.raw.RawType; //导入依赖的package包/类
public Object convert(Object fromValue) {
    RawObject pet = (RawObject) fromValue;
    Map<String,Object> petValues = pet.getValues();
    Map<String,Object> subTypeValues = new HashMap<String,Object>();
    Boolean isCat = (Boolean) petValues.remove("isCatNotDog");
    Integer finickyLevel = (Integer) petValues.remove("finickyLevel");
    Double barkVolume = (Double) petValues.remove("barkVolume");
    RawType newSubType;
    if (isCat) {
        newSubType = catType;
        subTypeValues.put("finickyLevel", finickyLevel);
    } else {
        newSubType = dogType;
        subTypeValues.put("barkVolume", barkVolume);
    }
    RawObject newPet = new RawObject
        (newPetType, petValues, pet.getSuper());
    return new RawObject(newSubType, subTypeValues, newPet);
}