Sets the Java class name and parameter defaults based on the PortletPublishingDefinition.
544691
public void setChannelPublishingDefinition(PortletPublishingDefinition cpd) {

        // Set appName/portletName if a descriptor is present.  If a framework
        // portlet, the applicationId is /uPortal.
        if (cpd.getPortletDescriptor() != null) {
            final PortletDescriptor pDesc = cpd.getPortletDescriptor();
            // PortletDescriptor is a class generated from XSD.  The value of
            // isIsFramework() will commonly be null.
            final boolean isFramework =
                    pDesc.isIsFramework() != null ? pDesc.isIsFramework() : false;
            applicationId = isFramework ? FRAMEWORK_PORTLET_URL : pDesc.getWebAppName();
            portletName = pDesc.getPortletName();
        }

        // set default values for all portlet parameters
        for (Step step : cpd.getSteps()) {
            if (step.getParameters() != null) {
                for (Parameter param : step.getParameters()) {
                    // if this parameter doesn't currently have a value, check
                    // for a default in the CPD
                    Attribute attribute = parameters.get(param.getName());
                    if (attribute == null
                            || attribute.getValue() == null
                            || attribute.getValue().trim().equals("")) {

                        // use the default value if one exists
                        ParameterInputType input = param.getParameterInput().getValue();
                        if (input != null) {
                            parameters.put(param.getName(), new Attribute(input.getDefault()));
                        }
                    }
                }
            }
            if (step.getPreferences() != null) {
                for (Preference pref : step.getPreferences()) {
                    // if this parameter doesn't currently have a value, check
                    // for a default in the CPD
                    if (!portletPreferences.containsKey(pref.getName())
                            || portletPreferences.get(pref.getName()).getValue().size() == 0
                            || (portletPreferences.get(pref.getName()).getValue().size() == 1
                                    && portletPreferences
                                            .get(pref.getName())
                                            .getValue()
                                            .get(0)
                                            .trim()
                                            .equals(""))) {

                        if (!portletPreferences.containsKey(pref.getName())) {
                            portletPreferences.put(pref.getName(), new StringListAttribute());
                        }

                        // use the default value if one exists
                        PreferenceInputType input = pref.getPreferenceInput().getValue();
                        if (input instanceof SingleValuedPreferenceInputType) {
                            SingleValuedPreferenceInputType singleValued =
                                    (SingleValuedPreferenceInputType) input;
                            if (singleValued.getDefault() != null) {
                                portletPreferences
                                        .get(pref.getName())
                                        .getValue()
                                        .add(singleValued.getDefault());
                            }
                        } else if (input instanceof MultiValuedPreferenceInputType) {
                            MultiValuedPreferenceInputType multiValued =
                                    (MultiValuedPreferenceInputType) input;
                            if (multiValued.getDefaults() != null) {
                                portletPreferences
                                        .get(pref.getName())
                                        .getValue()
                                        .addAll(multiValued.getDefaults());
                            }
                        }
                    }
                }
            }
        }
    }
1330098
public void setInitParameters(Map<String, String> initParameters) {
		Assert.notNull(initParameters, "InitParameters must not be null");
		this.initParameters = new LinkedHashMap<>(initParameters);
	}
1167797
public void setMethodDefaults(String method)
  {
        String defaultMethod = m_properties.getProperty(OutputKeys.METHOD);
 
        if((null == defaultMethod) || !defaultMethod.equals(method)
         // bjm - add the next condition as a hack
         // but it is because both output_xml.properties and
         // output_unknown.properties have the same method=xml
         // for their default. Otherwise we end up with
         // a ToUnknownStream wraping a ToXMLStream even
         // when the users says method="xml"
         //
         || defaultMethod.equals("xml")
         )
        {
            Properties savedProps = m_properties;
            Properties newDefaults = 
                OutputPropertiesFactory.getDefaultMethodProperties(method);
            m_properties = new Properties(newDefaults);
            copyFrom(savedProps, false);
        }
  }
667896
private void initJavaFXTaglets() {
        addStandardTaglet(new PropertyGetterTaglet());
        addStandardTaglet(new PropertySetterTaglet());
        addStandardTaglet(new SimpleTaglet("propertyDescription",
                message.getText("doclet.PropertyDescription"),
                SimpleTaglet.FIELD + SimpleTaglet.METHOD));
        addStandardTaglet(new SimpleTaglet("defaultValue", message.getText("doclet.DefaultValue"),
            SimpleTaglet.FIELD + SimpleTaglet.METHOD));
        addStandardTaglet(new SimpleTaglet("treatAsPrivate", null,
                SimpleTaglet.FIELD + SimpleTaglet.METHOD + SimpleTaglet.TYPE));
    }
863829
def set_default(cls, name):
        """"""
        if name not in cls._depots:
            raise RuntimeError('%s depot has not been configured' % (name,))
        cls._default_depot = name
624356
public void setServletName(final String servletName) {
		NullArgumentException.validateNotNull(servletName, "Servlet name");
		this.servletName = servletName;
		// sepcify filter name for Pax Web
		final WebAppInitParam initParam = new WebAppInitParam();
		initParam.setParamName("servlet-name");
		initParam.setParamValue(servletName);
		initParams.add(initParam);
	}
812597
public void setProxyClass(Class newProxyClass)
    {
        proxyClass = newProxyClass;
        if (proxyClass == null)
        {
            setProxyClassName(null);
        }
        else
        {
            proxyClassName = proxyClass.getName();
        }
    }
250277
@SuppressWarnings("unchecked")
   public void setSynonymProviderClass(String className)
   {
      try
      {
         Class<?> clazz = ClassLoading.forName(className, this);
         if (SynonymProvider.class.isAssignableFrom(clazz))
         {
            synonymProviderClass = (Class<? extends SynonymProvider>)clazz;
         }
         else
         {
            log.warn("Invalid value for synonymProviderClass, {} " + "does not implement SynonymProvider interface.",
               className);
         }
      }
      catch (ClassNotFoundException e)
      {
         log.warn("Invalid value for synonymProviderClass, class {} not found.", className);
      }
   }
479040
public void setClassLoader(ClassLoader loader) {
    this.classLoader = loader;
    // Note that this class is immutable after construction, except for the class loader
    // Thus we can pass down the loader to the owner and parameter types once now, no need to pass it down in toType()
    if (this.enclosingType != null) {
      this.enclosingType.setClassLoader(loader);
    }
    if (this.parameters != null) {
      for (TypeRepresentation param: this.parameters) {
        param.setClassLoader(loader);
      }
    }
  }
1263984
@Override
    public boolean setInitParameter(String name, String value) throws IllegalStateException, IllegalArgumentException {
        if (name == null) {
            logger.logp(Level.SEVERE, CLASS_NAME, "setInitParameter", servlet40NLS.getString("name.is.null"));
            throw new java.lang.NullPointerException(servlet40NLS.getString("name.is.null"));
        }

        return super.setInitParameter(name, value);
    }
40739
@Override
    public T setResourceAdapterXML(String resourceName) throws IllegalArgumentException {
        Validate.notNull(resourceName, "ResourceName must be specified");
        return setResourceAdapterXML(new ClassLoaderAsset(resourceName));

    }
1319553
public void setDefaultNamedOutput(OutputFormat outputFormat, Class keyClass, Class valueClass, Map<String, String> specificContext)  throws TupleMRException {
  	namedOutputs.add(new Output(true, "DEFAULT", outputFormat, keyClass, valueClass, specificContext));
  }
869411
private void setCommonParameters() {

        m_checkinBean.setPullBefore(m_pullFirst.getValue().booleanValue());
        m_checkinBean.setPullAfter(m_pullAfterCommit.getValue().booleanValue());
        m_checkinBean.setPush(m_pushAutomatically.getValue().booleanValue());
        m_checkinBean.setExcludeLibs(m_excludeLib.getValue().booleanValue());
        m_checkinBean.setCommit(m_addAndCommit.getValue().booleanValue());
        m_checkinBean.setIgnoreUnclean(m_ignoreUnclean.getValue().booleanValue());
        m_checkinBean.setCopyAndUnzip(m_copyAndUnzip.getValue().booleanValue());
        m_checkinBean.setGitUserEmail(m_emailField.getValue());
        m_checkinBean.setGitUserName(m_userField.getValue());
        String commitMessage = m_commitMessage.getValue();
        if (!CmsStringUtil.isEmptyOrWhitespaceOnly(commitMessage)) {
            m_checkinBean.setCommitMessage(commitMessage);
        }
    }
621954
public void setRuntimeInfoFactory(String className) {

        Object objectInstance;

        try {
            objectInstance = Class.forName(className).newInstance();
        } catch (Throwable t) {
            LOG.error(Messages.get().getBundle().key(Messages.LOG_CLASS_INIT_FAILURE_1, className), t);
            return;
        }

        if (objectInstance instanceof I_CmsDbContextFactory) {
            m_runtimeInfoFactory = (I_CmsDbContextFactory)objectInstance;
            if (CmsLog.INIT.isInfoEnabled()) {
                CmsLog.INIT.info(
                    Messages.get().getBundle().key(Messages.INIT_RUNTIME_INFO_FACTORY_SUCCESS_1, className));
            }
        } else {
            if (CmsLog.INIT.isFatalEnabled()) {
                CmsLog.INIT.fatal(
                    Messages.get().getBundle().key(Messages.INIT_RUNTIME_INFO_FACTORY_FAILURE_1, className));
            }
        }

    }
657717
public void setClassDefinition(String name, byte[] def) {
    classDefs.put(name, ByteBuffer.wrap(def));
  }
253778
protected void setTTEClassDefinition(String tteClass, Identification id, Attributes attr) {
	this.tteCD = ClassDefinitionImpl.toClassDefinition(tteClass, id, attr);
    }
430118
public void setPublishedName(String name) {
        //log.debug("setPublishedName: {}", name);
        // a publish name of "false" is a special case, used when stopping a stream
        if (StringUtils.isNotEmpty(name) && !"false".equals(name)) {
            this.publishedName = name;
            registerJMX();
        }
    }