Alias to ZipUtil.getEntry()

@param name
name of the entry to fetch bytes from
@return byte[]
contents of the entry by given name
198189
public byte[] getEntry(String name) {
    if (src == null) {
      throw new IllegalStateException("Source is not given");
    }
    return ZipUtil.unpackEntry(src, name);
  }
1115694
public static InputStream getResourceInputStreamForZip(File zip,
            String entryName) {
        return Optional.ofNullable(zip).map(JMResources::newZipFile)
                .map(zipFile -> getResourceInputStreamForZip(zipFile,
                        entryName)).orElse(null);
    }
1337742
public static boolean isFileInZip(String name) {
		if (name == null) {
			return false;
		}

		for (String element : ZIP_EXTENSIONS) {
			if (name.toLowerCase().contains(element + ZIP_DELIMITER)) {
				return true;
			}
		}
		return false;
	}
469143
public final byte[] getClassDigest(String name) {
    byte[] digest = digestLookup.get(name);
    if (digest == null) {
      try {
        if (beginLookup(pendingDigest, name)) {
          try {
            digest = service.getClassDigest(name, jobId);
            digestLookup.put(name, digest);
          } finally {
            endLookup(pendingDigest, name);
          }
        } else {
          digest = digestLookup.get(name);
        }
      } catch (SecurityException e) {
        logger.error("Could not get class digest", e);
      } catch (RemoteException e) {
        logger.error("Could not get class digest", e);
      }
    }
    return digest;
  }
1171264
public T getGeoPackage(String name) {
		T geoPackage = null;
		PropertiesCoreExtension<T, ?, ?, ?> properties = propertiesMap
				.get(name);
		if (properties != null) {
			geoPackage = properties.getGeoPackage();
		}
		return geoPackage;
	}
297722
public ListIterator<String> getHeaders(String name) {
		String nameToSearch = getCorrectHeaderName(name);
		ArrayList<String> result = new ArrayList<String>();

		try {
			ListIterator<Header> list = this.message.getHeaders(nameToSearch);
			while (list != null && list.hasNext()) {
				Header h = list.next();
				result.add(((SIPHeader)h).getHeaderValue());
			}
		} catch (Exception e) {
			logger.fatal("Couldnt fetch headers, original name[" + name
					+ "], name searched[" + nameToSearch + "]", e);
			return result.listIterator();
		}
		return result.listIterator();
	}
841958
private byte[] getBytes(ZipEntry ze) throws IOException {
        try (InputStream is = super.getInputStream(ze)) {
            return IOUtils.readFully(is, (int)ze.getSize(), true);
        }
    }
552385
def chunk_zip_entry(zipfile, name, chunksize=_CHUNKSIZE):
    

    with open_zip_entry(zipfile, name, mode='r') as stream:
        data = stream.read(chunksize)
        while data:
            yield data
            data = stream.read(chunksize)
1039003
public InputStream[] getInputStreams(String name) 
    {
        List parts = (List)_partMap.getValues(name);
        if (parts==null)
            return null;
        InputStream[] streams = new InputStream[parts.size()];
        for (int i=0; i<streams.length; i++) {
            streams[i] = new ByteArrayInputStream(((Part)parts.get(i))._data);
        }
        return streams;
    }
1269753
public static int getCompressionMethodOfEntry(File zip, String name) {
    ZipFile zf = null;
    try {
      zf = new ZipFile(zip);
      ZipEntry zipEntry = zf.getEntry(name);
      if (zipEntry == null) {
        return -1;
      }
      return zipEntry.getMethod();
    }
    catch (IOException e) {
      throw ZipExceptionUtil.rethrow(e);
    }
    finally {
      closeQuietly(zf);
    }
  }
840272
public static ZipEntry getClassZipEntryFromZipInClassPath(String className) throws IOException {
		String fileName = StringSupport.replaceAll(className, ".", "/");
		fileName += ".class";

		Collection<String> jars = StringSupport.split(System.getProperty("java.class.path"), ";:", false);
		for(String jarFileName : jars) {
			if (jarFileName.endsWith(".jar") || jarFileName.endsWith(".zip")) {
				ZipEntry entry = getZipEntryFromZip(fileName, jarFileName);
				if (entry != null) {
					return entry;
				}
			}
		}
		return null;
	}
894832
@Nullable
  public DirectoryEntry getRoot(Name name) {
    Directory dir = roots.get(name);
    return dir == null ? null : dir.entryInParent();
  }
694438
private String getInitials(String name)
   {
      String result = null;

      if (name != null && name.length() != 0)
      {
         StringBuilder sb = new StringBuilder();
         sb.append(name.charAt(0));
         int index = 1;
         while (true)
         {
            index = name.indexOf(' ', index);
            if (index == -1)
            {
               break;
            }

            ++index;
            if (index < name.length() && name.charAt(index) != ' ')
            {
               sb.append(name.charAt(index));
            }

            ++index;
         }

         result = sb.toString();
      }

      return result;
   }
1230419
public String [] get(final String name) {
		if(has(name)) {
			List<String> values = headers.get(name).getValues();
			return values.toArray(new String [values.size()]);
		}
		else
			return null;
	}
96939
public static byte[] externalize(Name name) {
        return externalize(name.getByteArray(), name.getByteOffset(), name.getByteLength());
    }
1106575
public String getHeader(String name) {

		String nameToSearch = getCorrectHeaderName(name);
		String value = null;
		if (this.message.getHeader(nameToSearch) != null) {
			value = ((SIPHeader) this.message.getHeader(nameToSearch))
					.getValue();
		}
		if(logger.isDebugEnabled()) {
			logger.debug("getHeader "+ name+ ", value="+ value	);
		}
		return value;
	}
162100
public static Map<String, byte[]> unzipFile(final byte[] zipBytes, boolean stripZIPName) throws IOException {
        final Map<ZipEntry, byte[]> zipEntries = new HashMap<ZipEntry, byte[]>();
        final ZipInputStream zis = new ZipInputStream(new ByteArrayInputStream(zipBytes));
        ZipEntry entry = null;
        byte[] buffer = new byte[1024];
        int read;
        while ((entry = zis.getNextEntry()) != null) {
            final ByteArrayOutputStream bos = new ByteArrayOutputStream();
            while ((read = zis.read(buffer)) > 0) {
                bos.write(buffer, 0, read);
            }
            zipEntries.put(entry, bos.toByteArray());
        }

        final HashMap<String, byte[]> files = new HashMap<String, byte[]>();
        for (final Entry<ZipEntry, byte[]> mapEntry : zipEntries.entrySet()) {
            final ZipEntry zipEntry = mapEntry.getKey();
            // Ignore directories, as we only want files
            if (!zipEntry.isDirectory()) {
                if (stripZIPName) {
                    files.put(stripZipFileName(zipEntry.getName()), mapEntry.getValue());
                } else {
                    files.put(zipEntry.getName(), mapEntry.getValue());
                }
            }
        }

        return files;
    }