Examples of Key

Keys are generally obtained through key generators, certificates, or various Identity classes used to manage keys. Keys may also be obtained from key specifications (transparent representations of the underlying key material) through the use of a key factory (see {@link KeyFactory}).

A Key should use KeyRep as its serialized representation. Note that a serialized Key may contain sensitive information which should not be exposed in untrusted environments. See the Security Appendix of the Serialization Specification for more information. @see PublicKey @see PrivateKey @see KeyPair @see KeyPairGenerator @see KeyFactory @see KeyRep @see java.security.spec.KeySpec @see Identity @see Signer @version 1.57 06/04/21 @author Benjamin Renaud

  • javax.xml.registry.infomodel.Key
    @version $Revision$ $Date$
  • net.karneim.pojobuilder.model.PropertyListM.Key
  • nexj.core.meta.persistence.Key
    Interface representing a multi-part key.
  • nl.topicus.onderwijs.dashboard.keys.Key
  • oracle.kv.Key
  • org.aeonbits.owner.Config.Key
  • org.apache.accumulo.core.data.Key
  • org.apache.accumulo.proxy.thrift.Key
  • org.apache.camel.avro.generated.Key
  • org.apache.deltacloud.client.Key
    @author Andre Dietisheim
  • org.apache.flink.runtime.operators.testutils.TestData.Key
  • org.apache.flink.types.Key
    This interface has to be implemented by all data types that act as key. Keys are used to establish relationships between values. A key must always be {@link java.lang.Comparable} to other keys ofthe same type. In addition, keys must implement a correct {@link java.lang.Object#hashCode()} methodand {@link java.lang.Object#equals(Object)} method to ensure that grouping on keys works properly.

    This interface extends {@link org.apache.flink.types.Value} and requires to implementthe serialization of its value. @see org.apache.flink.types.Value @see org.apache.flink.core.io.IOReadableWritable @see java.lang.Comparable

  • org.apache.hadoop.fs.FileSystem.Cache.Key
  • org.apache.hadoop.hbase.migration.nineteen.onelab.filter.Key
    The general behavior of a key that must be stored in a filter.
  • org.apache.hadoop.util.bloom.Key
    The general behavior of a key that must be stored in a filter. @see Filter The general behavior of a filter
  • org.apache.jackrabbit.core.nodetype.EffectiveNodeTypeCache.Key
  • org.apache.jackrabbit.oak.plugins.document.UpdateOp.Key
  • org.apache.jackrabbit.oak.plugins.mongomk.UpdateOp.Key
  • org.apache.olingo.odata2.api.edm.provider.Key
    Objects of this class represent a key for an entity type
  • org.apache.tuscany.das.rdb.Key
    A key instance is used to describe a Table key definition. This is used primarily for compound keys since simple keys are described with a name.
  • org.apache.wicket.protocol.http.mock.Cookies.Key
  • org.apache.wicket.request.resource.ResourceReference.Key
  • org.apache.xerces.validators.schema.identity.Key
    Schema key identity constraint. @author Andy Clark, IBM @version $Id: Key.java,v 1.3 2001/02/20 06:12:28 andyc Exp $
  • org.apache.xindice.core.data.Key
    Key extends Value by providing a hash value for the Key.
  • org.ardverk.dht.rsrc.Key
    A {@link Key} is an unique identifier of a {@link Value}.
  • org.chaidb.db.index.Key
    This interface defines different IDBIndex key types, and methods to compare two keys.
  • org.crosswire.jsword.passage.Key
  • org.cruxframework.crux.core.client.db.annotation.Store.Key
  • org.eclipse.php.internal.ui.preferences.util.Key
  • org.exolab.castor.xml.schema.Key
    A class that represents the XML Schema Identity Constraint: Key. @author Keith Visco @version $Revision: 6230 $ $Date: 2006-04-14 04:14:43 -0600 (Fri, 14 Apr 2006) $
  • org.filsa.nikujaga.pong.Keys.Key
  • org.hdiv.cipher.Key
    Stored Session related data in the cipher section @author Roberto Velasco
  • org.hibernate.ogm.grid.Key
    The key of an entity, association or row.

    Note that exposing the state of instances through arrays is a deliberate decision for the sake of performance. The contents of these arrays must not be modified by the caller. @author Gunnar Morling

  • org.hypertable.thriftgen.Key
  • org.infinispan.test.data.Key
  • org.jayasoft.woj.common.model.security.Key
  • org.jboss.aesh.terminal.Key
  • org.jboss.dna.graph.query.validate.Schemata.Key
  • org.jboss.remoting3.HandleableCloseable.Key
    The VersionedConnectionFactory to negotiate the version on the client side and return an appropriate VersionedConnection for the negotiated version.

    As the only entry point to this class is the create method and as that method creates a new instance for each call it is guaranteed there will not be concurrent negotiations occurring. @author Darran Lofthouse

  • org.jboss.repository.spi.Key
    @author Scott.Stark@jboss.org @version $Revision: 42147 $
  • org.jboss.shrinkwrap.resolver.impl.maven.archive.plugins.ConfigurationUtils.Key
  • org.jboss.test.hibernate.timers.interfaces.Key
    Example ejb key associated with a timer. @author Scott.Stark@jboss.org @version $Revision: 81036 $
  • org.jclouds.ibm.smartcloud.domain.Key
    The current state of a public or private key. @author Adrian Cole
  • org.jclouds.joyent.cloudapi.v6_5.domain.Key
    oyent.com/sdcapidoc/cloudapi/index.html#ListKeys" >docs
  • org.jf.dexlib2.writer.pool.ProtoPool.Key
  • org.jitterbit.crypto.pgp.Key
    Interface defining a public key for PGP encryption. @author Torgil Zethson @since 2.0.0
  • org.jitterbit.integration.client.ui.project.trashcan.InspectionUtils.Key
  • org.jnode.driver.input.Key
    @author Martin Husted Hartvig @since 0.1.6
  • org.kite9.diagram.adl.Key
  • org.kitesdk.data.Key

    A key for retrieving entities from a {@link RandomAccessDataset}.

    @since 0.9.0
  • org.modeshape.jcr.query.validate.Schemata.Key
  • org.mongodb.morphia.Key

    The key object; this class is take from the app-engine datastore (mostly) implementation. It is also Serializable and GWT-safe, enabling your entity objects to be used for GWT RPC should you so desire.

    You may use normal DBRef objects as relationships in your entities if you desire neither type safety nor GWT-ability.

    @author Jeff Schnitzer (from Objectify codebase) @author Scott Hernandez (adapted to morphia/mongodb)
  • org.nfctools.mf.classic.Key
  • org.objectstyle.wolips.eomodeler.core.kvc.Key
  • org.onelab.filter.Key
    The general behavior of a key that must be stored in a filter. @see org.onelab.filter.Filter The general behavior of a filter
  • org.openstreetmap.josm.gui.tagging.TaggingPresetItems.Key
  • org.quartz.utils.Key

    Object representing a job or trigger key.

    @author Jeffrey Wescott
  • org.raml.parser.annotation.Key
  • org.sdnplatform.sync.internal.store.Key
    Represent a key in the sync system. Keys consist of a namespace and a key name. Namespaces should be dot-separated such as "com.bigswitch.device" @author readams
  • org.ugate.resources.RS.KEY
  • org.woped.quantana.graph.Key
  • org.xdams.xw.utility.Key
    @author sandroPer modificare il modello associato al commento di questo tipo generato, aprire Finestra>Preferenze>Java>Generazione codice>Codice e commenti
  • railo.runtime.type.Collection.Key
  • se.unlogic.standardutils.dao.annotations.Key
  • sprites.io.Key
  • uk.org.ogsadai.config.Key
  • water.Key
    Keys This class defines: - A Key's bytes (name) & hash - Known Disk & memory replicas. - A cache of somewhat expensive to compute stuff related to the current Cloud, plus a byte of the desired replication factor. Keys are expected to be a high-count item, hence the care about size. Keys are *interned* in the local K/V store, a non-blocking hash set and are kept pointer equivalent (via the interning) for cheap compares. The interning only happens after a successful insert in the local H2O.STORE via H2O.put_if_later. @author @version 1.0
  • winterwell.utils.Key
    For doing type-safe multi-class maps. Can be sorted by key name. @see Properties @see IProperties @author daniel
  • xbird.storage.index.Key
    Key extends Value by providing a hash value for the Key.
    @author Makoto YUI (yuin405+xbird@gmail.com)

  • Examples of org.jclouds.joyent.cloudapi.v6_5.domain.Key

                return keyPair;

          KeyApi keyApi = createMock(KeyApi.class);
          Key key = Key.builder().name("group-foo").key(keyPair.get("public")).build();


    View Full Code Here

    Examples of org.jf.dexlib2.writer.pool.ProtoPool.Key


        public void intern(@Nonnull MethodReference method) {
            // We can't use method directly, because it is likely a full MethodReference. We use a wrapper that computes
            // hashCode and equals based only on the prototype fields
            Key key = new Key(method);
            Integer prev = internedItems.put(key, 0);
            if (prev == null) {
    View Full Code Here

    Examples of org.jitterbit.crypto.pgp.Key


        private static void signAndEncrypt() throws Exception {
            FileEncryptor enc = new FileEncryptor(BouncyCastlePgpProvider.getInstance().getEncryptor());
            Key encryptionKey = new FileBasedKey(new File(root, "receiver\\pubring.gpg"),
                            "Receiver <receiver@jitterbit.com>");
            Key signatureKey = new FileBasedKey(new File(root, "sender\\secring.gpg"));
            enc.signAndEncrypt(clearTextMessage, signedAndEncryptedMessage, encryptionKey, signatureKey,
    View Full Code Here

    Examples of org.jitterbit.integration.client.ui.project.trashcan.InspectionUtils.Key

                    parent = parent.getParent();

            private void process(IntegrationEntity e) {
                required.add(new Key(e));
    View Full Code Here

    Examples of org.jnode.driver.input.Key


    public class KeyboardInterpreter_DK extends AbstractKeyboardInterpreter {

        protected void initKeys(Keys keys) {
            Key key;

            keys.setKey(1, new Key('\u00bd', '\u00a7'));
            keys.setKey(2, new Key('1', KeyEvent.VK_1, '!', KeyEvent.VK_EXCLAMATION_MARK));
            keys.setKey(3, new Key('2', KeyEvent.VK_2, '"', KeyEvent.VK_QUOTEDBL, '@', KeyEvent.VK_AT));
            keys.setKey(4, new Key('3', KeyEvent.VK_3, '#', KeyEvent.VK_NUMBER_SIGN, '\u00a3', KeyEvent.VK_3));
            keys.setKey(5, new Key('4', KeyEvent.VK_4, '\u00a4', KeyEvent.VK_4, '$', KeyEvent.VK_DOLLAR));
            keys.setKey(6, new Key('5', KeyEvent.VK_5, '%', KeyEvent.VK_UNDEFINED, '\u20ac', KeyEvent.VK_EURO_SIGN));
            keys.setKey(7, new Key('6', '&', KeyEvent.VK_6));
            keys.setKey(8, new Key('7', KeyEvent.VK_7, '/', KeyEvent.VK_SLASH, '{', KeyEvent.VK_BRACELEFT));
            keys.setKey(9, new Key('8', KeyEvent.VK_8, '(', KeyEvent.VK_LEFT_PARENTHESIS, '[', KeyEvent.VK_OPEN_BRACKET));
                new Key('9', KeyEvent.VK_9, ')', KeyEvent.VK_RIGHT_PARENTHESIS, ']', KeyEvent.VK_CLOSE_BRACKET));
            keys.setKey(11, new Key('0', KeyEvent.VK_0, '=', KeyEvent.VK_EQUALS, '}', KeyEvent.VK_BRACERIGHT));
            keys.setKey(12, new Key('+', '?', KeyEvent.VK_PLUS));

            key = new Key();
            keys.setKey(13, key);

            keys.setKey(14, new Key('\b', KeyEvent.VK_BACK_SPACE));
            keys.setKey(15, new Key('\t', KeyEvent.VK_TAB));
            keys.setKey(16, new Key('q', 'Q', KeyEvent.VK_Q));
            keys.setKey(17, new Key('w', 'W', KeyEvent.VK_W));

            keys.setKey(18, new Key('e', KeyEvent.VK_E, 'E', KeyEvent.VK_E, '\u20ac', KeyEvent.VK_EURO_SIGN));
            key = keys.getKey(18);
            key.addDeadKeyChar(KeyEvent.VK_DEAD_ACUTE, new char[]{'\u00e9', '\u00c9'});
            key.addDeadKeyChar(KeyEvent.VK_DEAD_GRAVE, new char[]{'\u00e8', '\u00c8'});
            key.addDeadKeyChar(KeyEvent.VK_DEAD_DIAERESIS, new char[]{'\u00eb', '\u00cb'});
            key.addDeadKeyChar(KeyEvent.VK_DEAD_CIRCUMFLEX, new char[]{'\u00ea', '\u00ca'});

            keys.setKey(19, new Key('r', 'R', KeyEvent.VK_R));
            keys.setKey(20, new Key('t', 'T', KeyEvent.VK_T));

            keys.setKey(21, new Key('y', 'Y', KeyEvent.VK_Y));
            key = keys.getKey(21);
            key.addDeadKeyChar(KeyEvent.VK_DEAD_ACUTE, new char[]{'\u00fd', '\u00dd'});
            key.addDeadKeyChar(KeyEvent.VK_DEAD_DIAERESIS, new char[]{'\u00ff'});

            keys.setKey(22, new Key('u', 'U', KeyEvent.VK_U));
            key = keys.getKey(22);
            key.addDeadKeyChar(KeyEvent.VK_DEAD_ACUTE, new char[]{'\u00fa', '\u00da'});
            key.addDeadKeyChar(KeyEvent.VK_DEAD_GRAVE, new char[]{'\u00f9', '\u00d9'});
            key.addDeadKeyChar(KeyEvent.VK_DEAD_DIAERESIS, new char[]{'\u00fc', '\u00dc'});
            key.addDeadKeyChar(KeyEvent.VK_DEAD_CIRCUMFLEX, new char[]{'\u00fb', '\u00db'});

            keys.setKey(23, new Key('i', 'I', KeyEvent.VK_I));
            key = keys.getKey(23);
            key.addDeadKeyChar(KeyEvent.VK_DEAD_ACUTE, new char[]{'\u00ed', '\u00cd'});
            key.addDeadKeyChar(KeyEvent.VK_DEAD_GRAVE, new char[]{'\u00ec', '\u00cc'});
            key.addDeadKeyChar(KeyEvent.VK_DEAD_DIAERESIS, new char[]{'\u00ef', '\u00cf'});
            key.addDeadKeyChar(KeyEvent.VK_DEAD_CIRCUMFLEX, new char[]{'\u00ee', '\u00ce'});

            keys.setKey(24, new Key('o', 'O', KeyEvent.VK_O));
            key = keys.getKey(24);
            key.addDeadKeyChar(KeyEvent.VK_DEAD_ACUTE, new char[]{'\u00f3', '\u00d3'});
            key.addDeadKeyChar(KeyEvent.VK_DEAD_GRAVE, new char[]{'\u00f2', '\u00d2'});
            key.addDeadKeyChar(KeyEvent.VK_DEAD_DIAERESIS, new char[]{'\u00f6', '\u00d6'});
            key.addDeadKeyChar(KeyEvent.VK_DEAD_CIRCUMFLEX, new char[]{'\u00f4', '\u00d4'});
            key.addDeadKeyChar(KeyEvent.VK_DEAD_TILDE, new char[]{'\u00f5', '\u00d5'});

            keys.setKey(25, new Key('p', 'P', KeyEvent.VK_P));
            keys.setKey(26, new Key('\u00e5', '\u00c5', KeyEvent.VK_UNDEFINED));

            key = new Key();
            keys.setKey(27, key);

            keys.setKey(28, new Key('\n', KeyEvent.VK_ENTER));
            keys.setKey(29, new Key((char) 0, KeyEvent.VK_CONTROL));

            keys.setKey(30, new Key('a', 'A', KeyEvent.VK_A));
            key = keys.getKey(30);
            key.addDeadKeyChar(KeyEvent.VK_DEAD_ACUTE, new char[]{'\u00e1', '\u00c1'});
            key.addDeadKeyChar(KeyEvent.VK_DEAD_GRAVE, new char[]{'\u00e0', '\u00c0'});
            key.addDeadKeyChar(KeyEvent.VK_DEAD_DIAERESIS, new char[]{'\u00e4', '\u00c4'});
            key.addDeadKeyChar(KeyEvent.VK_DEAD_CIRCUMFLEX, new char[]{'\u00e2', '\u00c2'});
            key.addDeadKeyChar(KeyEvent.VK_DEAD_TILDE, new char[]{'\u00e3', '\u00c3'});

            keys.setKey(31, new Key('s', 'S', KeyEvent.VK_S));
            keys.setKey(32, new Key('d', 'D', KeyEvent.VK_D));
            keys.setKey(33, new Key('f', 'F', KeyEvent.VK_F));
            keys.setKey(34, new Key('g', 'G', KeyEvent.VK_G));
            keys.setKey(35, new Key('h', 'H', KeyEvent.VK_H));
            keys.setKey(36, new Key('j', 'J', KeyEvent.VK_J));
            keys.setKey(37, new Key('k', 'K', KeyEvent.VK_K));
            keys.setKey(38, new Key('l', 'L', KeyEvent.VK_L));
            keys.setKey(39, new Key('\u00e6', '\u00c6', KeyEvent.VK_UNDEFINED));
            keys.setKey(40, new Key('\u00f8', '\u00d8', KeyEvent.VK_UNDEFINED));
            keys.setKey(43, new Key("'".charAt(0), KeyEvent.VK_QUOTE, '*', KeyEvent.VK_MULTIPLY));
            keys.setKey(44, new Key('z', 'Z', KeyEvent.VK_Z));
            keys.setKey(45, new Key('x', 'X', KeyEvent.VK_X));
            keys.setKey(46, new Key('c', 'C', KeyEvent.VK_C));
            keys.setKey(47, new Key('v', 'V', KeyEvent.VK_V));
            keys.setKey(48, new Key('b', 'B', KeyEvent.VK_B));

            keys.setKey(49, new Key('n', 'N', KeyEvent.VK_N));
            key = keys.getKey(49);
            key.addDeadKeyChar(KeyEvent.VK_DEAD_TILDE, new char[]{'\u00f1', '\u00d1'});

            keys.setKey(50, new Key('m', 'M', KeyEvent.VK_M));
            keys.setKey(51, new Key(',', KeyEvent.VK_COMMA, ';', KeyEvent.VK_SEMICOLON));
            keys.setKey(52, new Key('.', KeyEvent.VK_PERIOD, ':', KeyEvent.VK_COLON));
            keys.setKey(53, new Key('-', KeyEvent.VK_MINUS, '_', KeyEvent.VK_UNDERSCORE));

            keys.setKey(55, new Key('*', KeyEvent.VK_MULTIPLY));

            keys.setKey(57, new Key(' ', KeyEvent.VK_SPACE));
            key = keys.getKey(57);
            key.addDeadKeyChar(KeyEvent.VK_DEAD_ACUTE, new char[]{'\u00b4'});
            key.addDeadKeyChar(KeyEvent.VK_DEAD_GRAVE, new char[]{'`'});
            key.addDeadKeyChar(KeyEvent.VK_DEAD_DIAERESIS, new char[]{'\u00a8'});
            key.addDeadKeyChar(KeyEvent.VK_DEAD_CIRCUMFLEX, new char[]{'^'});
            key.addDeadKeyChar(KeyEvent.VK_DEAD_TILDE, new char[]{'~'});

            keys.setKey(71, new Key('7', KeyEvent.VK_NUMPAD7));
            keys.setKey(72, new Key('8', KeyEvent.VK_NUMPAD8));
            keys.setKey(73, new Key('9', KeyEvent.VK_NUMPAD9));
            keys.setKey(74, new Key('-', KeyEvent.VK_SUBTRACT));
            keys.setKey(75, new Key('4', KeyEvent.VK_NUMPAD4));
            keys.setKey(76, new Key('5', KeyEvent.VK_NUMPAD5));
            keys.setKey(77, new Key('6', KeyEvent.VK_NUMPAD6));
            keys.setKey(78, new Key('+', KeyEvent.VK_ADD));
            keys.setKey(79, new Key('1', KeyEvent.VK_NUMPAD1));
            keys.setKey(80, new Key('2', KeyEvent.VK_NUMPAD2));
            keys.setKey(81, new Key('3', KeyEvent.VK_NUMPAD3));
            keys.setKey(82, new Key('0', KeyEvent.VK_NUMPAD0));
            keys.setKey(83, new Key(',', KeyEvent.VK_DECIMAL));
            keys.setKey(86, new Key('<', KeyEvent.VK_LESS, '>', KeyEvent.VK_GREATER, '\\', KeyEvent.VK_BACK_SLASH));

            keys.setKey(42, new Key(KeyEvent.VK_SHIFT));
            keys.setKey(54, new Key(KeyEvent.VK_SHIFT));
            keys.setKey(56, new Key(KeyEvent.VK_ALT));
            keys.setKey(58, new Key(KeyEvent.VK_CAPS_LOCK));
            keys.setKey(59, new Key(KeyEvent.VK_F1));
            keys.setKey(60, new Key(KeyEvent.VK_F2));
            keys.setKey(61, new Key(KeyEvent.VK_F3));
            keys.setKey(62, new Key(KeyEvent.VK_F4));
            keys.setKey(63, new Key(KeyEvent.VK_F5));
            keys.setKey(64, new Key(KeyEvent.VK_F6));
            keys.setKey(65, new Key(KeyEvent.VK_F7));
            keys.setKey(66, new Key(KeyEvent.VK_F8));
            keys.setKey(67, new Key(KeyEvent.VK_F9));
            keys.setKey(68, new Key(KeyEvent.VK_F10));
            keys.setKey(69, new Key(KeyEvent.VK_NUM_LOCK));
            keys.setKey(70, new Key(KeyEvent.VK_SCROLL_LOCK));
            keys.setKey(87, new Key(KeyEvent.VK_F11));
            keys.setKey(88, new Key(KeyEvent.VK_F12));
            keys.setKey(96, new Key(KeyEvent.VK_INSERT));
            keys.setKey(97, new Key(KeyEvent.VK_HOME));
            keys.setKey(98, new Key(KeyEvent.VK_PAGE_UP));
            keys.setKey(99, new Key(KeyEvent.VK_DIVIDE));
            keys.setKey(100, new Key(KeyEvent.VK_PRINTSCREEN));
            keys.setKey(101, new Key(KeyEvent.VK_DELETE));
            keys.setKey(102, new Key(KeyEvent.VK_END));
            keys.setKey(103, new Key(KeyEvent.VK_PAGE_DOWN));
            keys.setKey(104, new Key(KeyEvent.VK_UP));
            keys.setKey(105, new Key(KeyEvent.VK_SEPARATOR));
            keys.setKey(110, new Key(KeyEvent.VK_ESCAPE));
            keys.setKey(111, new Key(KeyEvent.VK_FINAL));
            keys.setKey(112, new Key(KeyEvent.VK_CONTROL));
            keys.setKey(113, new Key(KeyEvent.VK_LEFT));
            keys.setKey(114, new Key(KeyEvent.VK_DOWN));
            keys.setKey(115, new Key(KeyEvent.VK_RIGHT));
            keys.setKey(116, new Key(KeyEvent.VK_PAUSE));
    View Full Code Here

    Examples of org.kite9.diagram.adl.Key

      public Diagram simpleDiagramWithSymbolsAndTextLines() {
        Symbol s = new Symbol("Brother of Tony Scott", 'T', SymbolShape.CIRCLE);
        Glyph rs = new Glyph("Director", "Ridley Scott", createList(new TextLine("Directed: Thelma & Louise"), new TextLine("Directed: Gladiator")),
        Diagram d1 = new Diagram("my_diagram", listOf(rs), new Key("Big Movies", "", createList(s)));
        return d1;
    View Full Code Here

    Examples of org.kitesdk.data.Key

        ds = (DaoDataset) repo.load("default", datasetName);

        // ensure the new entities are what we expect with get operations
        for (int i = 0; i < 10; ++i) {
          String iStr = Long.toString(i);
          Key key = new Key.Builder(ds)
              .add("part1", new Utf8("part1_" + iStr))
              .add("part2", new Utf8("part2_" + iStr)).build();
          compareEntitiesWithUtf8(i, ds.get(key));

        // ensure the new entities are what we expect with scan operations
        int cnt = 0;
        DatasetReader<GenericRecord> reader = ds.newReader();
        assertTrue("Reader should be open initially", reader.isOpen());
        try {
          for (GenericRecord entity : reader) {
            compareEntitiesWithUtf8(cnt, entity);
          assertEquals(10, cnt);
        } finally {
          assertFalse("Reader should be closed after calling close", reader.isOpen());

        // test a partial scan
        cnt = 3;
        reader = new DaoView<GenericRecord>(ds, GenericRecord.class)
            .from("part1", new Utf8("part1_3")).from("part2", new Utf8("part2_3"))
            .to("part1", new Utf8("part1_7")).to("part2", new Utf8("part2_7"))
        try {
          for (GenericRecord entity : reader) {
            compareEntitiesWithUtf8(cnt, entity);
          assertEquals(8, cnt);
        } finally {

        Key key = new Key.Builder(ds)
            .add("part1", new Utf8("part1_5"))
            .add("part2", new Utf8("part2_5")).build();

        // test delete
    View Full Code Here

    Examples of org.modeshape.jcr.query.validate.Schemata.Key

            // Define the keys ...
            if (keyColumns != null) {
                Set<Key> keys = new HashSet<Key>();
                for (Iterable<Column> keyColumnSet : keyColumns) {
                    if (keyColumnSet != null) {
                        Key key = new ImmutableKey(keyColumnSet);
                this.keys = Collections.unmodifiableSet(keys);
            } else {
    View Full Code Here

    Examples of org.mongodb.morphia.Key

            // check the history key (a key is the namespace + id)

            if (dbObject.containsField(ID_KEY) && getMappedClass(entity).getIdField() != null
                && getMappedClass(entity).getEntityAnnotation() != null) {
                final Key<T> key = new Key(entity.getClass(), dbObject.get(ID_KEY));
                final T cachedInstance = cache.getEntity(key);
                if (cachedInstance != null) {
                    return cachedInstance;
                } else {
                    cache.putEntity(key, entity); // to avoid stackOverflow in recursive refs

            final MappedClass mc = getMappedClass(entity);

            final DBObject updated = mc.callLifecycleMethods(PreLoad.class, entity, dbObject, this);
            try {
                for (final MappedField mf : mc.getPersistenceFields()) {
                    readMappedField(updated, mf, entity, cache);
            } catch (final MappingException e) {
                Object id = dbObject.get(ID_KEY);
                String entityName = entity.getClass().getName();
                throw new MappingException(format("Could not map %s with ID: %s", entityName, id), e);

            if (updated.containsField(ID_KEY) && getMappedClass(entity).getIdField() != null) {
                final Key key = new Key(entity.getClass(), updated.get(ID_KEY));
                cache.putEntity(key, entity);
            mc.callLifecycleMethods(PostLoad.class, entity, updated, this);
            return entity;
    View Full Code Here

    Examples of org.nfctools.mf.classic.Key

        MemoryLayout memoryLayout = readerWriter.getMemoryLayout();

        for (int sectorId = 0; sectorId < memoryLayout.getSectors(); sectorId++) {
          TrailerBlock trailerBlock = readTrailerBlock(readerWriter, sectorId);
          if (trailerBlock != null) {
            Key keyToWrite = trailerBlock.isKeyBReadable() ? Key.A : Key.B;
            for (byte[] key : knownKeys) {
              try {
                initTransportConfig(readerWriter, sectorId, new KeyValue(keyToWrite, key));
                for (int blockId = 0; blockId < memoryLayout.getBlocksPerSector(sectorId); blockId++) {
                  if (!memoryLayout.isTrailerBlock(sectorId, blockId) && !(blockId == 0 && sectorId == 0)) {
    View Full Code Here
    Copyright © 2018 www.massapi.com. All rights reserved.
    All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.