Helper method to get the default property configuration for the given resource type.<p>

@param typeName the name of the resource type

@return the default property configuration for the given type
19932
protected Map<String, CmsXmlContentProperty> getDefaultPropertiesForType(String typeName) {

        Map<String, CmsXmlContentProperty> propertyConfig = new LinkedHashMap<String, CmsXmlContentProperty>();
        CmsExplorerTypeSettings explorerType = OpenCms.getWorkplaceManager().getExplorerTypeSetting(typeName);
        if (explorerType != null) {
            List<String> defaultProps = explorerType.getProperties();
            for (String propName : defaultProps) {
                CmsXmlContentProperty property = new CmsXmlContentProperty(
                    propName,
                    "string",
                    "string",
                    "",
                    "",
                    "",
                    "",
                    null,
                    "",
                    "",
                    "false");
                propertyConfig.put(propName, property);
            }
        }
        return propertyConfig;
    }
1007618
protected static String toGoodTypeName(String typeName) {
    int lastDotPosition = typeName.lastIndexOf(".");
    if(lastDotPosition == -1) {
      return typeName;
    }
    else {
      return typeName.substring(lastDotPosition + 1);
    }
  }
665833
@SuppressWarnings("unchecked")
  public Class<? extends TypedConfig<?>> getConcreteClass(AtomixRegistry registry, String typeName) {
    ConfiguredType type = registry.getType(typeClass, typeName);
    if (type == null) {
      return null;
    }
    return (Class<? extends TypedConfig<?>>) type.newConfig().getClass();
  }
842386
@Override
    public ProtocolDefaults getValue() {
        ProtocolStackConfigurator configurator = load(ProtocolDefaultsBuilder.this.resource);
        for (org.jgroups.conf.ProtocolConfiguration config: configurator.getProtocolStack()) {
            this.map.put(config.getProtocolName(), Collections.unmodifiableMap(config.getProperties()));
        }
        return this;
    }
901769
private function findByBindingType($typeName)
    {
        $matches = array();

        $expr = Expr::isInstanceOf('Puli\Discovery\Binding\ResourceBinding');

        foreach ($this->discovery->findBindings($typeName, $expr) as $binding) {
            /** @var ResourceBinding $binding */
            foreach ($binding->getResources() as $resource) {
                $matches[$resource->getPath()] = StringUtil::getShortClassName(get_class($resource));
            }
        }

        ksort($matches);

        return $matches;
    }
401336
private String getProviderName(String resourceType) {

        CmsDebugLog.consoleLog("getProviderName for " + resourceType);
        for (CmsResourceTypeBean typeBean : m_dialogBean.getTypes()) {
            if (typeBean.getType().equals(resourceType)) {
                return typeBean.getPreviewProviderName();
            }
        }
        return null;
    }
1113844
private Object createDefaultResource(String className, ResourceInfo resourceRefInfo) throws Exception {
        if (className != null) {
            String javaCompDefaultFilter = "(" + com.ibm.ws.resource.ResourceFactory.JAVA_COMP_DEFAULT_NAME + "=*)";
            String createsFilter = FilterUtils.createPropertyFilter(ResourceFactory.CREATES_OBJECT_CLASS, className);
            String filter = "(&" + javaCompDefaultFilter + createsFilter + ")";
            return createResourceWithFilter(filter, resourceRefInfo);
        }
        return null;
    }
351472
private static I_CmsResourceType getResourceType(CmsResource resource, String createType) {

        I_CmsResourceType resType = null;
        if (CmsStringUtil.isNotEmptyOrWhitespaceOnly(createType)) {
            try {
                resType = OpenCms.getResourceManager().getResourceType(createType);
            } catch (CmsLoaderException e) {
                LOG.error("Could not read resource type '" + createType + "' for resource creation.", e);
            }
        } else if (resource != null) {
            resType = OpenCms.getResourceManager().getResourceType(resource);
        }
        return resType;
    }
43114
public Configuration createFromResource(String resourceName) {
        Exceptions.nullArgument("resourceName", resourceName);

        Configuration configuration;
        try {
            InputStream stream = null;
            try {
                stream = Utils.openResourceStream(resourceName);

                if (stream != null) {
                    configuration = create(stream);
                } else {
                    throw new TextProcessorFactoryException("Can't find or open resource \"" + resourceName + "\".");
                }
            } finally {
                if (stream != null) {
                    stream.close();
                }
            }
        } catch (IOException e) {
            throw new TextProcessorFactoryException(e);
        }

        return configuration;
    }
331382
protected TypeReference<?> getBeanPropertyType(Class<?> clazz,
			String propertyName, TypeReference<?> originalType) {
		TypeReference<?> propertyDestinationType = null;
		if (beanDestinationPropertyTypeProvider != null) {
			propertyDestinationType = beanDestinationPropertyTypeProvider
					.getPropertyType(clazz, propertyName, originalType);
		}
		if (propertyDestinationType == null) {
			propertyDestinationType = originalType;
		}
		return propertyDestinationType;
	}
569672
public List<CmsResourceTypeConfig> getResourceTypes() {

        List<CmsResourceTypeConfig> result = internalGetResourceTypes(true);
        for (CmsResourceTypeConfig config : result) {
            config.initialize(getCms());
        }
        return result;
    }
1347495
public static ValueType fromConfig(String property) {
      //If the property is valid and we cannot find a "property.type" then the value of the property represents its simple type.
      if (Config.hasProperty(property) && !Config.hasProperty(property, TYPE_PROPERTY)) {
         return new SimpleValueType(Config.get(property).asClass());
      }

      if( Config.isBean(property) ){
         Object o = Config.get(property);
         return new SimpleValueType(o.getClass());
      }

      //Read in the value type parameters from the configuration using the property as the prefix
      Map<String, Class> typeInfo = Config.getMap(property, String.class, Class.class);
      //Set the type class to the type property defaulting to String if not found
      Class<?> typeClass = typeInfo.getOrDefault(TYPE_PROPERTY, String.class);


      //Check for a collection
      if (Collection.class.isAssignableFrom(typeClass)) {
         return new CollectionValueType(typeClass,
                                        typeInfo.getOrDefault(ELEMENT_TYPE_PROPERTY, String.class)
         );
      }

      //Check for a Map
      if (Map.class.isAssignableFrom(typeClass)) {
         return new MapValueType(typeClass,
                                 typeInfo.getOrDefault(KEY_TYPE_PROPERTY, String.class),
                                 typeInfo.getOrDefault(VALUE_TYPE_PROPERTY, String.class)
         );
      }

      return new SimpleValueType(typeClass);
   }
190622
public static String getDefaultFileOrDetailType(CmsObject cms, CmsResource resource) {

        String type = null;

        if (resource.isFolder()
            && !(OpenCms.getResourceManager().getResourceType(resource) instanceof CmsResourceTypeFolderExtended)
            && !CmsJspNavBuilder.isNavLevelFolder(cms, resource)) {
            try {
                CmsResource defaultFile = cms.readDefaultFile(resource, CmsResourceFilter.ONLY_VISIBLE_NO_DELETED);
                if (defaultFile != null) {
                    type = getDetailType(cms, defaultFile, resource);
                    if (type == null) {
                        type = OpenCms.getResourceManager().getResourceType(defaultFile).getTypeName();
                    }

                }
            } catch (CmsSecurityException e) {
                // ignore
            }
        } else if (CmsResourceTypeXmlContainerPage.isContainerPage(resource)) {
            type = getDetailType(cms, resource, null);

        }
        return type;

    }
854451
public static String getDefaultJdbcTypeFor(String javaType)
    {
        return _jdbcMappings.containsKey(javaType) ? (String)_jdbcMappings.get(javaType) : JDBC_DEFAULT_TYPE;
    }
1332110
@NonNull
  public static CreateTypeStart createType(@NonNull String typeName) {
    return createType(CqlIdentifier.fromCql(typeName));
  }
1261881
public String getRequiredConfigAttributeWithDefaultValue(Map<String, Object> props, String key, String defaultValue) {
        return getRequiredConfigAttributeWithDefaultValueAndConfigId(props, key, defaultValue, null);
    }
348938
public JawrConfigManagerMBean getConfigMgr(String resourceType) {

		JawrConfigManagerMBean configMgr = null;
		if (resourceType.equals(JS_TYPE)) {
			configMgr = jsMBean;
		} else if (resourceType.equals(CSS_TYPE)) {
			configMgr = cssMBean;
		} else if (resourceType.equals(BINARY_TYPE)) {
			configMgr = binaryMBean;
		}

		return configMgr;
	}