returns the Endpoint with the identifier passed as argument if not found
returns null

@param identifier
@return Endpoint
504825
public Endpoint getEndpoint(ModuleIdentifier identifier) {
		for (Endpoint endpoint : getEndpoints()) {
			if (endpoint.getIdentifier().equals(identifier)) {
				return endpoint;
			}
		}
		return null;
	}
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;
}
1249070
public TokenRequestBuilder getTokenEndPoint() {
    for(Authentication auth : getAuthentications().values()) {
      if (auth instanceof OAuth) {
        OAuth oauth = (OAuth) auth;
        return oauth.getTokenRequestBuilder();
      }
    }
    return null;
  }
697847
public final UserManagedCacheBuilder<K, V, T> identifier(String identifier) {
    UserManagedCacheBuilder<K, V, T> otherBuilder = new UserManagedCacheBuilder<>(this);
    otherBuilder.id = identifier;
    return otherBuilder;
  }
548496
def mount(self, identifier):
        

        driver = self.client.info()['Driver']
        driver_mount_fn = getattr(self, "_mount_" + driver,
                                  self._unsupported_backend)
        cid = driver_mount_fn(identifier)

        # Return mount path so it can be later unmounted by path
        return self.mountpoint, cid
690984
def get(self, identifier):
        """"""
        for provider in self._providers:
            if provider.identifier == identifier:
                return provider
        return None
758676
public static Tag getTag(int identifier) {
    Tag t = null;
    try {
      if (instance == null)
        getTiffTags();
    } catch (ReadTagsIOException e) {
      /*Nothing to be shown*/
    }
    if (tagMap.containsKey(identifier))
      t = tagMap.get(identifier);
    return t;
  }
178093
public static function get($identifier, $default = null)
    {
        $value = self::getInternal($identifier);

        if (is_null($value)) {
            return $default;
        }

        return $value;
    }
1180061
public IDrawerItem getDrawerItem(long identifier) {
        Pair<IDrawerItem, Integer> res = getAdapter().getItemById(identifier);
        if (res != null) {
            return res.first;
        } else {
            return null;
        }
    }
1227929
public String getEndpoint() {
    try {
      String endpointString = uri.getPath().split("/")[3];
      if (!endpointString.equals(ENDPOINT_IN) && !endpointString.equals(ENDPOINT_OUT)) {
        throw new IllegalArgumentException(endpointString + " is not a valid context endpoint");
      }
      return endpointString;
    } catch (IndexOutOfBoundsException e) {
      return null;
    }
  }
381384
public static String quote(String identifier) {
        if (StringUtils.isEmpty(identifier)) {
            return identifier;
        }

        String res = identifier.trim();

        if (!res.startsWith("\"")) {
            res = "\"" + res;
        }

        if (!res.endsWith("\"")) {
            res = res + "\"";
        }

        return res;

    }
131898
@Pure
	<CT extends RoadConnection> CT getEndPoint(Class<CT> connectionClass) {
		final StandardRoadConnection connection = this.lastConnection;
		if (connection == null) {
			return null;
		}
		if (connectionClass.isAssignableFrom(StandardRoadConnection.class)) {
			return connectionClass.cast(connection);
		}
		if (connectionClass.isAssignableFrom(RoadConnectionWithArrivalSegment.class)) {
			return connectionClass.cast(new RoadConnectionWithArrivalSegment(connection, this, false));
		}
		throw new IllegalArgumentException("unsupported RoadConnection class");  //$NON-NLS-1$
	}
265967
@Override
  public List<NameAssignment> lookup(final Iterable<Identifier> identifiers) {
    LOG.log(Level.FINE, "identifiers");
    final List<NameAssignment> nas = new ArrayList<>();
    for (final Identifier id : identifiers) {
      final InetSocketAddress addr = idToAddrMap.get(id);
      LOG.log(Level.FINEST, "id : {0} addr: {1}", new Object[]{id, addr});
      if (addr != null) {
        nas.add(new NameAssignmentTuple(id, addr));
      }
    }
    return nas;
  }
753649
public static MockMethodDispatcher get(String identifier, Object instance) {
        if (instance == INSTANCE) {
            // Avoid endless loop if ConcurrentHashMap was redefined to check for being a mock.
            return null;
        } else {
            return INSTANCE.get(identifier);
        }
    }
974378
private Endpoint getEndpoint(String serviceName) {
        Endpoint cachedEndpoint = endpointCache.get(serviceName);

        if (cachedEndpoint == null) {
            cachedEndpoint = computeEndpoint(serviceName);
            if (cachedEndpoint == null) {
                return null;
            }
        }

        endpointCache.put(serviceName, cachedEndpoint);
        return cachedEndpoint;
    }
1081999
public static boolean isCertificateOperationIdentifier(String identifier) {
        identifier = verifyNonEmpty(identifier, "identifier");

        URI baseUri;
        try {
            baseUri = new URI(identifier);
        } catch (URISyntaxException e) {
            return false;
        }

        // Path is of the form "/certificates/[name]/pending"
        String[] segments = baseUri.getPath().split("/");
        if (segments.length != 4) {
            return false;
        }

        if (!(segments[1]).equals("certificates")) {
            return false;
        }

        if (!(segments[3]).equals("pending")) {
            return false;
        }

        return true;
    }
806841
public function get($identifier)
    {
        $identifier = (string) $identifier;

        if($this->offsetExists($identifier)) {
            $result = $this->offsetGet($identifier);
        } else {
            $result = null;
        }

        return $result;
    }