Maps a Guice scope to a Jersey scope.

@return the map
424965
public Map<Scope, ComponentScope> createScopeMap() {
        Map<Scope, ComponentScope> result = new HashMap<Scope, ComponentScope>();
        result.put(Scopes.SINGLETON, ComponentScope.Singleton);
        result.put(Scopes.NO_SCOPE, ComponentScope.PerRequest);
        result.put(ServletScopes.REQUEST, ComponentScope.PerRequest);
        return result;
    }
81704
public Map<String, Object> build() {
        final ImmutableMap.Builder<String, Object> builder = ImmutableMap.builder();
        ofNullable(remotePath).map(x -> builder.put("remotePath", x));
        ofNullable(user).map(x -> builder.put("user", x));
        ofNullable(pass).map(x -> builder.put("pass", x));
        ofNullable(method).map(x -> builder.put("method", x));
        return builder.build();
    }
2261
public <T extends Annotation> ScopeModel<T> getScopeModel(final Class<T> scope) {
        return scopes.getCastValue(scope);
    }
180005
public Scope getDefiningScope(String name) {
        for (Scope s = this; s != null; s = s.parentScope) {
            Map<String,Symbol> symbolTable = s.getSymbolTable();
            if (symbolTable != null && symbolTable.containsKey(name)) {
                return s;
            }
        }
        return null;
    }
689976
@Override
    public String getScopeToLocalQP() {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(this, tc, "getScopeToLocalQP");

        String scopeToLocalQP = (String) properties.get(SCOPE_TO_LOCAL_QP);

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(this, tc, "getScopeToLocalQP", scopeToLocalQP);
        return scopeToLocalQP;
    }
1307201
public static <T extends Model> ScopeBuilder<T> scope(String  scope) {
        return new ScopeBuilder<T>(modelClass(), new String[]{scope});
    }
815722
public static Mapping getMapping(PersistentEntity domainClass) {
        return domainClass == null ? null : MAPPING_CACHE.get(domainClass.getJavaClass());
    }
1198141
public Map<K, V> getMap() {
        if (mode == StorageMode.LIST) {
            synchronized (this) {
                if (mode == StorageMode.LIST) {
                    mapData = convertListToMap(listData);
                    mode = StorageMode.BOTH;
                }
            }
        }
        return Collections.unmodifiableMap(mapData);
    }
1288122
public static String generateGeography() {
        val clientInfo = ClientInfoHolder.getClientInfo();
        return clientInfo.getClientIpAddress().concat("@").concat(WebUtils.getHttpServletRequestUserAgentFromRequestContext());
    }
363928
public Map<String, Object> getJsonMap() {
        Map<String, Object> map = new LinkedHashMap<>();
        
        map.put("type", gComplex!=null && gComplex.isLeft()? "duration":"period");
        if (gComplex != null) {
            if (gComplex.isLeft()) {
                map.put("duration", gComplex.left().get());
            } else {
                map.put("period", gComplex.right().get());
            }
            if (origin != null) {
                map.put("origin", origin);
            }
            if (timeZone != null) {
                map.put("timeZone", timeZone);
            }
        }
        return map;
    }
782415
public TypeUsage.Builder scope(QualifiedName scope) {
    this.scope = Objects.requireNonNull(scope);
    return (TypeUsage.Builder) this;
  }
523630
private Map<Object, CacheItem> getScopeCache(String scope) throws InvalidScopeException {
        Map<Object, CacheItem> scopeCache = scopeCaches.get(scope);
        if (scopeCache == null) {
            throw new InvalidScopeException("The scope " + scope + " doesn't exist");
        } else {
            return scopeCache;
        }
    }
337513
public Map<String, SDVariable> variableMap() {
        Map<String,SDVariable> ret = new LinkedHashMap<>();
        for(Variable v : variables.values()){
            ret.put(v.getName(), v.getVariable());
        }
        return ret;
    }
708843
public String getScopes() {
        final StringBuilder sb = new StringBuilder();
        for (final Scope scope : Scope.values()) {
            sb.append(scope);
            sb.append(", ");
        }
        final String scopes = sb.toString().trim();
        return scopes.substring(0, scopes.length() - 1);
    }
649473
protected Map<String, Object> getJmxServerEnvironment() {
        final Map<String, Object> jmxEnv = new HashMap<String, Object>();

        // SSL Options
        final String enableSSL = System.getProperty(JMX_SSL_PROPERTY);
        if (Boolean.getBoolean(enableSSL)) {
            SslRMIClientSocketFactory csf = new SslRMIClientSocketFactory();
            jmxEnv.put(RMIConnectorServer.RMI_CLIENT_SOCKET_FACTORY_ATTRIBUTE, csf);

            SslRMIServerSocketFactory ssf = new SslRMIServerSocketFactory();
            jmxEnv.put(RMIConnectorServer.RMI_SERVER_SOCKET_FACTORY_ATTRIBUTE, ssf);
        }

        // Password file options
        final String passwordFile = System.getProperty(JMX_PASSWORD_FILE_PROPERTY);
        if (passwordFile != null) {
            jmxEnv.put(JMX_REMOTE_X_PASSWORD_FILE, passwordFile);
        }

        // Access file options
        final String accessFile = System.getProperty(JMX_ACCESS_FILE_PROPERTY);
        if (accessFile != null) {
            jmxEnv.put(JMX_REMOTE_X_ACCESS_FILE, accessFile);
        }

        if (this.logger.isDebugEnabled()) {
            this.logger.debug("Configured JMX Server Environment = '" + jmxEnv + "'");
        }

        return jmxEnv;
    }
252040
private final MapSubject delegate() {
    MapSubject delegate = check().that(actual());
    if (internalCustomName() != null) {
      delegate = delegate.named(internalCustomName());
    }
    return delegate;
  }
825845
public Map<String, BeanSpec> fields() {
        if (null != fields) {
            return fields;
        }
        synchronized (this) {
            if (null == fields) {
                Map<String, BeanSpec> map = new HashMap<>();
                for (BeanSpec spec : fields($.F.<Field>yes())) {
                    map.put(spec.name, spec);
                    // need to treat the alias of field name
                    if (spec.originalName != spec.name) {
                        map.put(spec.originalName, spec);
                    }
                }
                fields = Collections.unmodifiableMap(map);
            }
        }
        return fields;
    }