Retrieve policies by their identifier
@param {Array} identifiers - an array of policy identifiers
@return {Promise<[Policy]>} - promise of an array of policies
545970
function findPolicies(identifiers) {
  return loadPolicies()
  .then((policies) => {
    return _.filter(policies, (policy) => { return identifiers.indexOf(policy.name) !== -1; });
  });
}
1269532
public static function extractIdentifierInObjectList(array $identifiers, array &$objects)
    {
        $searchIds = [];

        foreach ($identifiers as $identifier) {
            if (\is_object($identifier)) {
                $objects[] = $identifier;

                continue;
            }
            $searchIds[] = $identifier;
        }

        return $searchIds;
    }
932090
function marshallCustomIdentifiers(request, shape) {
  var identifiers = {};
  marshallCustomIdentifiersHelper(identifiers, request.params, shape);
  return identifiers;
}
638894
function containsOnlyIdentifiers(node) {
            if (node.type === "Identifier") {
                return true;
            }

            if (node.type === "MemberExpression") {
                if (node.object.type === "Identifier") {
                    return true;
                }
                if (node.object.type === "MemberExpression") {
                    return containsOnlyIdentifiers(node.object);
                }
            }

            return false;
        }
181121
function (identifier)  {
    var path;
    if (identifier) {
      path = this.constructPath(constants.CHANNELS, identifier);
      return this.Core.DELETE(path);
    } else {
      return this.rejectRequest('Bad Request: A channel identifier is required.');
    }
  }
282572
def get_job_definitions(self, identifier):
        
        result = []
        env = self.get_job_definition_by_arn(identifier)
        if env is not None:
            result.append(env)
        else:
            for value in self._job_definitions.values():
                if value.name == identifier:
                    result.append(value)

        return result
1238397
def get_user_from_identifier(settings, identifier):
    """"""
    providers = list(auth.strip() for auth in settings.get('authenticators').split(','))
    identities = Identity.find_all(Identity.provider.in_(providers), Identity.identifier == identifier)
    if identities:
        return sorted(identities, key=lambda x: providers.index(x.provider))[0].user
    for provider in providers:
        try:
            identity_info = multipass.get_identity(provider, identifier)
        except IdentityRetrievalFailed:
            continue
        if identity_info is None:
            continue
        if not identity_info.provider.settings.get('trusted_email'):
            continue
        emails = {email.lower() for email in identity_info.data.getlist('email') if email}
        if not emails:
            continue
        user = User.find_first(~User.is_deleted, User.all_emails.in_(list(emails)))
        if user:
            return user
952483
public function loadContentTypeGroupsByIdentifiers(array $identifiers)
    {
        $contentTypeGroups = array_map(
            function ($identifier) {
                try {
                    return $this->contentTypeService->loadContentTypeGroupByIdentifier($identifier);
                } catch (NotFoundException $notFoundException) {
                    return $this->createContentTypeGroupByIdentifier($identifier);
                }
            },
            $identifiers
        );

        return $contentTypeGroups;
    }
856272
protected function getDependencies(array $identifiers): array
    {
        $dependencies = [];

        foreach ($identifiers as $index => $identifier) {
            $dependencies[$index] = !$identifier->optional || $this->container->has($identifier->key)
                ? $this->container->get($identifier->key)
                : null;
        };

        return $dependencies;
    }
1127754
@Override
    public Identifiable[] checkIds(Identifiable... items) {
        for (Identifiable item : items) {
            checkId(item);
        }
        return items;
    }
1363237
def get_objects(self, ids, **args):
        
        args["ids"] = ",".join(ids)
        return self.request(self.version + "/", args)
250843
function (identifier) {
            var self = this;

            return this.findByIdentifier(identifier).then(function (record) {
                if (!record) {
                    throw new Errors.NotFoundError(
                        'Could not find %s with identifier %s'.format(
                            pluralize.singular(self.identity),
                            identifier
                        ), {
                            identifier: identifier,
                            collection: self.identity
                        });
                }

                return record;
            });
        }
351769
function getDataRegistry(identifier) {
  assert(!identifier || (typeof identifier === 'string'), `Invalid identifier specified: ${identifier}`);

  if (!window.__private__) window.__private__ = {};
  if (window.__private__.dataRegistry === undefined) window.__private__.dataRegistry = {};

  if (identifier)
    return namespace(identifier, window.__private__.dataRegistry);
  else if (identifier === null)
    return null
  else
    return window.__private__.dataRegistry;
}
134825
function collectDependenciesIds(ast) {
	var ids = [];

	visitRequireArgument(ast, function(argument) {
		ids.push(argument.value);
	});

	return ids;
}
460971
def query_ids(self, ids):
        

        results = self._get_repo_filter(Layer.objects).filter(uuid__in=ids).all()

        if len(results) == 0:  # try services
            results = self._get_repo_filter(Service.objects).filter(uuid__in=ids).all()

        return results
143535
function (identifier)  {
    var path;
    if (identifier) {
      path = this.constructPath(constants.LOCATIONS, identifier);
      return this.Core.DELETE(path);
    } else {
      return this.rejectRequest('Bad Request: A location identifier is required.');
    }
  }
1110708
function getChoices() {
    return {
      roleIdentifiers: () => {
        return plugin.loadRoles()
        .then(roles => {
          // Build the list of available roles for input verification and interactive selection
          return _.map(roles, role => {
            return {
              value: role.name,
              name: role.name + (role.description ? ' - ' + role.description : '')
            };
          });
        });
      }
    };
  }