Set the trace specification of the service to the input value.

@param spec New string trace specification
@return new TraceSpecification, or null if unchanged
171285
synchronized static TraceSpecification setTraceSpec(String spec) {
        // If logger is used & configured by logger properties, 
        // we're done as far as trace string processing is concerned
        if (WsLogManager.isConfiguredByLoggingProperties()) {
            return null;
        }

        // If the specified string is null, or it is equal to a string,
        // or the sensitive flag has not been toggled,
        // we've already parsed, skip it.
        if ((spec == null || spec.equals(traceString)) && Tr.activeTraceSpec.isSensitiveTraceSuppressed() == suppressSensitiveTrace) {
            return null;
        }

        traceString = spec;

        // Parse the trace specification string, this will gather
        // exceptions that occur for different elements of the string
        TraceSpecification newTs = new TraceSpecification(spec, safeLevelsIndex, suppressSensitiveTrace);
        TraceSpecificationException tex = newTs.getExceptions();

        if (tex != null) {
            do {
                tex.warning(loggingConfig.get() != null);
                tex = tex.getPreviousException();
            } while (tex != null);
        }

        Tr.setTraceSpec(newTs);

        // Return the new/updated TraceSpecification to the caller. The caller can
        // then determine whether or not all elements of the TraceSpecification 
        // were known to the system or not.
        return newTs;
    }
1062818
static Proxy parseProxySettings(String spec) {

        try {
            if (spec == null || spec.length() == 0) {
                return null;
            }
            return new Proxy(spec);
        } catch (URISyntaxException e) {
            return null;
        }
    }
102398
public static String toJavaIdentifierForm( String name )
    {
        if (isBlank(name)) {
            throw new IllegalArgumentException("The specification mapping can't be null or empty");
        }
        return removeNonJavaIdentifierCharacters( removeDiacritics( toLowerCamelCase( name ) ) );
    }
685115
@Reference(name = REFERENCE_BEANVALIDATION_SERVICE, service = BeanValidation.class)
    protected void setBeanValidation(ServiceReference<BeanValidation> ref) {
        this.beanValidation.setReference(ref);
    }
694345
public void setReference(final Reference reference) {

        if (TraceComponent.isAnyTracingEnabled() && TRACE.isEntryEnabled()) {
            SibTr.entry(this, TRACE, "setReference", reference);
        }

        // Make sure no-one can pull the rug from beneath us.
        synchronized (_properties) {
            _properties = JmsJcaReferenceUtils.getInstance()
                            .getMapFromReference(reference, defaultJNDIProperties);
        }

        if (TraceComponent.isAnyTracingEnabled() && TRACE.isEntryEnabled()) {
            SibTr.exit(this, TRACE, "setReference");
        }

    }
329107
public static String toWindows(String spec) {
      if (spec == null) {
         return StringUtils.EMPTY;
      }
      return spec.replaceAll("/+", "\\\\");
   }
1212820
protected void setJaasLoginContextEntry(ServiceReference<?> ref) {
        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
            Tr.debug(this, tc, "setJaasLoginContextEntry", ref);
        }

        if (ref != null) {
            jaasLoginContextEntryName = (String) ref.getProperty("name");
        }
    }
318081
@Reference(policy = ReferencePolicy.DYNAMIC, cardinality = ReferenceCardinality.MULTIPLE)
    protected Map<String, Object> setAuthentication(ServiceReference<AuthenticationService> ref) {
        if (hasPropertiesFromFile(ref)) {
            String id = (String) ref.getProperty(KEY_ID);
            if (id != null) {
                authentication.putReference(id, ref);
            } else {
                Tr.error(tc, "SECURITY_SERVICE_REQUIRED_SERVICE_WITHOUT_ID", KEY_AUTHENTICATION);
            }
        } else {
            authentication.putReference(String.valueOf(ref.getProperty(KEY_SERVICE_ID)), ref);
        }

        // determine a new authentication service
        authnService.set(null);
        return getServiceProperties();
    }
338965
public void setServiceSpecificCredentials(java.util.Collection<ServiceSpecificCredentialMetadata> serviceSpecificCredentials) {
        if (serviceSpecificCredentials == null) {
            this.serviceSpecificCredentials = null;
            return;
        }

        this.serviceSpecificCredentials = new com.amazonaws.internal.SdkInternalList<ServiceSpecificCredentialMetadata>(serviceSpecificCredentials);
    }
1126970
protected void setWsTraceHandler(ServiceReference<WsTraceHandler> ref) {
    	getTraceRouter().setWsTraceHandler((String) ref.getProperty("id"), bundleContext.getService(ref));
    }
998152
@Override
  final public TraceMethod entry(String returnType, Object object, String methodSignature) {
    return null;
  }
520462
@Override
  public final void setSpecifics(final SpecificsOfItem pSpecifics) {
    this.specifics = pSpecifics;
    if (this.itsId == null) {
      this.itsId = new ServiceSpecificsId();
    }
    this.itsId.setSpecifics(this.specifics);
  }
229832
public Map<String, AddSpecResponse> put(Spec spec, boolean triggerListener) {
    Map<String, AddSpecResponse> responseMap = new HashMap<>();
    try {
      Preconditions.checkState(state() == State.RUNNING, String.format("%s is not running.", this.getClass().getName()));
      Preconditions.checkNotNull(spec);

      long startTime = System.currentTimeMillis();
      log.info(String.format("Adding FlowSpec with URI: %s and Config: %s", spec.getUri(),
          ((FlowSpec) spec).getConfigAsProperties()));
      specStore.addSpec(spec);
      metrics.updatePutSpecTime(startTime);
      if (triggerListener) {
        AddSpecResponse<CallbacksDispatcher.CallbackResults<SpecCatalogListener, AddSpecResponse>> response = this.listeners.onAddSpec(spec);
        for (Map.Entry<SpecCatalogListener, CallbackResult<AddSpecResponse>> entry: response.getValue().getSuccesses().entrySet()) {
          responseMap.put(entry.getKey().getName(), entry.getValue().getResult());
        }
      }
    } catch (IOException e) {
      throw new RuntimeException("Cannot add Spec to Spec store: " + spec, e);
    }
    return responseMap;
  }
1246957
public void setSpecifity(String v) {
    if (EventTrigger_Type.featOkTst && ((EventTrigger_Type)jcasType).casFeat_specifity == null)
      jcasType.jcas.throwFeatMissing("specifity", "de.julielab.jules.types.EventTrigger");
    jcasType.ll_cas.ll_setStringValue(addr, ((EventTrigger_Type)jcasType).casFeatCode_specifity, v);}
775013
static OcAgentTraceServiceConfigRpcHandler create(
      TraceServiceStub stub, TraceConfig traceConfig) {
    OcAgentTraceServiceConfigRpcHandler configRpcHandler =
        new OcAgentTraceServiceConfigRpcHandler(traceConfig);
    UpdatedLibraryConfigObserver updatedLibraryConfigObserver =
        new UpdatedLibraryConfigObserver(traceConfig, configRpcHandler);
    try {
      StreamObserver<CurrentLibraryConfig> currentConfigObserver =
          stub.config(updatedLibraryConfigObserver);
      configRpcHandler.setCurrentConfigObserver(currentConfigObserver);
    } catch (StatusRuntimeException e) {
      configRpcHandler.onComplete(e);
    }
    return configRpcHandler;
  }
1121191
Set<TraceeBackendProvider> getDefaultTraceeBackendProvider() {
		try {
			final ClassLoader classLoader = GetClassLoader.fromContext();
			final Class<?> slf4jTraceeBackendProviderClass = Class.forName("io.tracee.backend.slf4j.Slf4jTraceeBackendProvider", true, classLoader);
			final TraceeBackendProvider instance = (TraceeBackendProvider) slf4jTraceeBackendProviderClass.newInstance();
			updatedCache(classLoader, Collections.singleton(instance));
			return Collections.singleton(instance);
		} catch (ClassNotFoundException | InstantiationException | IllegalAccessException | ClassCastException e) {
			return Collections.emptySet();
		}
	}
121373
protected function _setSpec($spec)
    {
        if (!is_null($spec)) {
            $spec = $this->_normalizeIterable($spec);
        }

        $this->spec = $spec;
    }