Get object ouput stream suitable for reading persistent state
associated with given key.
180380
public GZIPOutputStream getGZIPOutputStream(BeanId beanId)
                    throws CSIException
    {
        final boolean isTraceOn = TraceComponent.isAnyTracingEnabled();
        if (isTraceOn && tc.isEntryEnabled())
            Tr.entry(tc, "getOutputStream", beanId);

        final String fileName = getPortableFilename(beanId);
        final long beanTimeoutTime = getBeanTimeoutTime(beanId);
        GZIPOutputStream result = null;

        try
        {
            result = (GZIPOutputStream) AccessController.doPrivileged(new PrivilegedExceptionAction<GZIPOutputStream>()
            {
                public GZIPOutputStream run()
                                throws IOException
                {
                    File statefulBeanFile = getStatefulBeanFile(fileName, false);
                    FileOutputStream fos = EJSPlatformHelper.isZOS()
                                    ? new WSFileOutputStream(statefulBeanFile, beanTimeoutTime)
                                    : new FileOutputStream(statefulBeanFile);
                    return new GZIPOutputStream(fos); // d651126
                }
            });
        } catch (PrivilegedActionException ex2)
        {
            Exception ex = ex2.getException();
            FFDCFilter.processException(ex, CLASS_NAME + ".getOutputStream", "127", this);
            Tr.warning(tc, "IOEXCEPTION_WRITING_FILE_FOR_STATEFUL_SESSION_BEAN_CNTR0025W",
                       new Object[] { fileName, this, ex }); //p111002.3
            throw new CSIException("Unable to open output stream", ex);
        }

        if (isTraceOn && tc.isEntryEnabled())
            Tr.exit(tc, "getOutputStream");
        return result;
    }
895445
def get(self, key):
        
        group = self.get_node(key)
        if group is None:
            raise KeyError('No object named {key} in the file'.format(key=key))
        return self._read_group(group)
582335
private static Map<String, Object> readMap(StreamingInput input)
		throws IOException
	{
		boolean readEnd = false;
		if(input.peek() == Token.OBJECT_START)
		{
			// Check if the object is wrapped
			readEnd = true;
			input.next();
		}

		Token t;
		Map<String, Object> result = new HashMap<String, Object>();
		while((t = input.peek()) != Token.OBJECT_END && t != null)
		{
			// Read the key
			input.next(Token.KEY);
			String key = input.getString();

			// Read the value
			Object value = readDynamic(input);

			result.put(key, value);
		}

		if(readEnd)
		{
			input.next(Token.OBJECT_END);
		}

		return result;
	}
779424
static public Key readPut(String keyname, InputStream is) throws Exception {
    return readPut(Key.make(keyname), is);
  }
864898
public String getString(String key) {

    Object obj = get(key);

    try {
      return (String) obj;
    } catch (Exception e) {
      throw new ClassCastException("Identified object is not a String.");
    }
  }
273537
def get(type, key)

      r = lock(:read, type, key) { |f| do_get(f) }

      r == false ? nil : r
    end
1303204
private final StreamInfo getStreamInfo(String streamKey, SIBUuid12 streamId)
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.entry(tc, "getStreamInfo", new Object[]{streamKey, streamId});
    StreamInfo sinfo = streamTable.get(streamKey);
    if ((sinfo != null) && sinfo.streamId.equals(streamId))
    {
      if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(tc, "getStreamInfo", sinfo);
      return sinfo;
    }

    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(tc, "getStreamInfo", null);
    return null;
  }
1208071
public synchronized Snapshot get(String key) throws IOException {
		checkNotClosed();
		validateKey(key);
		Entry entry = lruEntries.get(key);
		if (entry == null) {
			return null;
		}

		if (!entry.readable) {
			return null;
		}

		// Open all streams eagerly to guarantee that we see a single published
		// snapshot. If we opened streams lazily then the streams could come
		// from different edits.
		File[] files = new File[valueCount];
		InputStream[] ins = new InputStream[valueCount];
		try {
			File file;
			for (int i = 0; i < valueCount; i++) {
				file = entry.getCleanFile(i);
				files[i] = file;
				ins[i] = new FileInputStream(file);
			}
		} catch (FileNotFoundException e) {
			// A file must have been deleted manually!
			for (int i = 0; i < valueCount; i++) {
				if (ins[i] != null) {
					Util.closeQuietly(ins[i]);
				} else {
					break;
				}
			}
			return null;
		}

		redundantOpCount++;
		journalWriter.append(READ + ' ' + key + '\n');
		if (journalRebuildRequired()) {
			executorService.submit(cleanupCallable);
		}

		return new Snapshot(key, entry.sequenceNumber, files, ins, entry.lengths);
	}
313701
private Stream<String> getKeysStream() {
        val cursor = client.getConnectionFactory().getConnection()
                .scan(ScanOptions.scanOptions().match(getPatternTicketRedisKey())
                .count(SCAN_COUNT)
                .build());
        return StreamSupport
            .stream(Spliterators.spliteratorUnknownSize(cursor, Spliterator.ORDERED), false)
            .map(key -> (String) client.getKeySerializer().deserialize(key))
            .collect(Collectors.toSet())
            .stream()
            .onClose(() -> {
                try {
                    cursor.close();
                } catch (final IOException e) {
                    LOGGER.error("Could not close Redis connection", e);
                }
            });
    }
65137
function(key, callback) {
	store.getBytes(key, function(err, value) {
		if (err) { throw 'could not retrieve BYTES for key: '+[key, err].join(' ') }
		callback(value)
	})
}
481979
long get(final long key) {
    final int probe = hashProbe(key);
    if (states[probe] > 0) {
      assert (keys[probe] == key);
      return values[probe];
    }
    return 0;
  }
343076
def get(self, key):
        
        if key == None or key == '':
            return None
        elif key.find('.') > 0:
            return RecursiveObjectReader.get_property(self, key)
        else:
            return super(Parameters, self).get(key)
1313015
public <T> T getOutputValue (String key, Class<T> type)
	{
		try {
			String s = mapper.writeValueAsString(_findOutputValue(key));
			return (mapper.readValue(s, type));
		}
		catch (IOException e) {
			return null;
		}
	}
272593
private void readObject(ObjectInputStream stream) throws IOException {
        try {
            decode(stream);
        } catch (InvalidKeyException e) {
            e.printStackTrace();
            throw new IOException("deserialized key is invalid: " +
                                  e.getMessage());
        }
    }
534771
public Object get(long key)
  {
    int hash = (int) (key & mask);

    while (true) {
      long mapKey = keys[hash];

      if (mapKey == key)
        return values[hash];
      else if (mapKey == DEAD_KEY) {
        if ((flags[hash] & DELETED) == 0)
          return null;
      }

      hash = (hash + 1) & mask;
    }
  }
346523
@SuppressWarnings("unchecked")
    public V get(Object key) {
        synchronized( this ) {
            //WeakReference ref;
            SoftReference ref;
            V item;
            
            if( !containsKey(key) ) {
                return null;
            }
            ref = cache.get(key);
            item = (V)ref.get();
            if( item == null ) {
                return null;
            }
            if( item instanceof CachedItem ) {
                CachedItem ci = (CachedItem)item;
                
                if( ci.isValidForCache() ) {
                    return item;
                }
                remove(key);
                return null;
            }
            return item;
        }
    }
1244573
private void readObject(java.io.ObjectInputStream s)
        throws java.io.IOException, ClassNotFoundException  {
        // Read in any hidden stuff
        s.defaultReadObject();

        // Read in size (number of Mappings)
        int size = s.readInt();
        if (size < 0)
            throw new java.io.StreamCorruptedException
                ("Illegal mappings count: " + size);
        init(capacity(size));

        // Read the keys and values, and put the mappings in the table
        for (int i=0; i<size; i++) {
            @SuppressWarnings("unchecked")
                K key = (K) s.readObject();
            @SuppressWarnings("unchecked")
                V value = (V) s.readObject();
            putForCreate(key, value);
        }
    }