converts a list of longs to a list of acls.

@param longs
the list of longs
@return a list of ACLs that map to longs
429350
public synchronized List<ACL> convertLong(Long longVal) {
        if (longVal == null)
            return null;
        if (longVal == -1L)
            return Ids.OPEN_ACL_UNSAFE;
        List<ACL> acls = longKeyMap.get(longVal);
        if (acls == null) {
            LOG.error("ERROR: ACL not available for long " + longVal);
            throw new RuntimeException("Failed to fetch acls for " + longVal);
        }
        return acls;
    }
461826
public static ULong[] ulong_a(long... values) {
        ULong[] array = new ULong[values.length];
        for (int i = 0; i < values.length; i++) {
            array[i] = ulong(values[i]);
        }
        return array;
    }
997979
public Descriptor replaceAllAcls(PSequence<ServiceAcl> acls) {
        return new Descriptor(name, calls, pathParamSerializers, messageSerializers, serializerFactory, exceptionSerializer, autoAcl, acls, headerFilter, locatableService, circuitBreaker, topicCalls);
    }
805344
static Long[] createLongs() {
        int len = LONG_UPPER_BOUND - LONG_LOWER_BOUND + 1;
        Long[] ret = new Long[len];
        long val = (long) LONG_LOWER_BOUND;
        for (int i = 0; i < len; i++, val++) {
            ret[i] = new Long(val);
        }
        return ret;
    }
1100655
public static <T extends BaseObject<Long>> Map<Long, T> convert2Map(
            List<T> enTs) {

        Map<Long, T> map = new HashMap<Long, T>();

        if (enTs == null) {
            return map;
        }

        for (T t : enTs) {

            map.put(t.getId(), t);
        }

        return map;
    }
1339452
public long[] keySetLong() {
    long[] dom = new long[size()];
    IteratorLong i=(IteratorLong)keySet().iterator();
    int j=0;
    while( j < dom.length && i.hasNext() )
      dom[j++] = i.nextLong();
    return dom;
  }
1115058
public List<Acl> listBucketAcls(String bucketName) {
    // [START listBucketAcls]
    List<Acl> acls = storage.listAcls(bucketName);
    for (Acl acl : acls) {
      // do something with ACL entry
    }
    // [END listBucketAcls]
    return acls;
  }
1050212
public List<T> list(List<Long> ids)
    {
        List<T> ret = new ArrayList<T>();

        if(ids != null)
        {
            for(Long id : ids)
            {
                T resource = get(id);
                if(resource != null)
                    ret.add(resource);
            }
        }

        return ret;
    }
370758
private final Map<String, Long> getLongMap(NamedList<Object> response, String... args) {
    Object objectItem = response.findRecursive(args);
    if (objectItem != null && objectItem instanceof Map) {
      return (Map) objectItem;
    } else {
      return null;
    }
  }
1331160
public T replaceAcl(List<AclEntry> entries) {
    boolean clearACL = false;
    for (AclEntry entry : entries) {
      /**
       * if we are only setting default ACLs, we do not need to clear access ACL entries
       * observed same behavior on linux
       */
      if (!entry.isDefault()) {
        clearACL = true;
      }
    }
    if (clearACL) {
      mAcl.clearEntries();
    }
    return setAcl(entries);
  }
594178
public static long[] copyOf(long[] longArray) {

    	long[] copy = new long[longArray.length];
        System.arraycopy(longArray, 0, copy, 0, longArray.length);
        return copy;
    }
1156621
public long[] toLongArray() {
    long[] answer = new long[bitmap.limit()];
    bitmap.rewind();
    bitmap.get(answer);
    return answer;
  }
295405
public static final long[] computeIndexOffsets(int[] sizes) {
    long[] indexOffsets = new long[sizes.length];
    for (int i = sizes.length - 1; i >= 0; i--) {
      if (i == sizes.length - 1) {
        indexOffsets[i] = 1;
      } else {
        indexOffsets[i] = indexOffsets[i + 1] * ((long) sizes[i + 1]);
      }
    }
    return indexOffsets;
  }
699272
public Descriptor withServiceAcls(ServiceAcl... acls) {
        return replaceAllAcls(this.acls.plusAll(Arrays.asList(acls)));
    }
1295686
public long[] getLongArray(final String key) {
		final String[] value = getArray(key);
		if (value != null) {
			final long[] result = new long[value.length];
			for (int i = 0; i < value.length; i++) {
				result[i] = Long.parseLong(value[i]);
			}
			return result;
		}
		return null;
	}
699032
private final Long getLong(NamedList<Object> response, String... args) {
    Object objectItem = response.findRecursive(args);
    if (objectItem != null && objectItem instanceof Long) {
      return (Long) objectItem;
    } else {
      return null;
    }
  }
1236549
public List<Long> getLongs(String name, String delimiter) {
        List<String> strings = getStrings(name, delimiter);

        List<Long> longs = new ArrayList<>(strings.size());
        for (String value : strings) {
            try {
                long i = Long.parseLong(value);
                longs.add(i);
            } catch (NumberFormatException e) {
            }
        }

        return Collections.unmodifiableList(longs);
    }