Calls base constructor feeding defaults from Map and IPropertyLookup params

@param propfile       File containing property data
@param defaults       Map of default properties
@param defaultsLookup IPropertyLookup of default properties
@return lookup
503894
public static PropertyLookup create(final File propfile, final Map defaults, final IPropertyLookup defaultsLookup) {
        return new PropertyLookup(propfile, defaults, defaultsLookup);
    }
476628
function findPropsWithoutDefaultValue (propsNode) {
      return propsNode.value.properties
        .filter(prop => prop.type === 'Property')
        .filter(prop => {
          if (prop.value.type !== 'ObjectExpression') {
            return true
          }

          return !propIsRequired(prop) && !propHasDefault(prop)
        })
    }
78882
@SuppressWarnings("unchecked")
    public <T> T getProperty(String propName, T defaultValue) {
        String propValue = props.getProperty(propName);
        if (propValue == null)
            return defaultValue;
        return ReflectionUtil.<T>getObjectInstance(propValue);
    }
246736
function defaultsDeep(config, defaults) {
              if (_.isPlainObject(config)) {
                return _.mapValues(_.defaults(config, defaults), function(val, index) {
                  return defaultsDeep(_.get(config, index), _.get(defaults, index));
                });
              }

              return config || defaults;
            }
61773
public static IRI getDefaultProfile(final RDFSyntax syntax, final IRI identifier,
            final String defaultJsonLdProfile) {
        if (RDFA.equals(syntax)) {
            return identifier;
        } else if (defaultJsonLdProfile != null) {
            return rdf.createIRI(defaultJsonLdProfile);
        }
        return compacted;
    }
754322
public void createResourceFieldMap(Props props)
   {
      byte[] fieldMapData = null;
      for (Integer key : RESOURCE_KEYS)
      {
         fieldMapData = props.getByteArray(key);
         if (fieldMapData != null)
         {
            break;
         }
      }

      if (fieldMapData == null)
      {
         populateDefaultData(getDefaultResourceData());
      }
      else
      {
         createFieldMap(fieldMapData);
      }
   }
252289
public static Properties loadDefaultProperties(final JarFile jf) throws IOException {
	final ZipEntry ze = jf.getEntry("default.properties");
	if (ze == null) throw new IOException("the Lucee core has no default.properties file!");

	final Properties prop = new Properties();
	InputStream is = null;
	try {
	    is = jf.getInputStream(ze);
	    prop.load(is);
	}
	finally {
	    CFMLEngineFactorySupport.closeEL(is);
	}
	return prop;
    }
55005
private static Properties loadProperties(String defaultsName, String propertiesName) throws IOException {
        Properties bundle = new Properties();
        ClassLoader loader = SecurityActions.getContextClassLoader();
        URL defaultUrl = null;
        URL url = null;
        // First check for local visibility via a URLClassLoader.findResource
        if (loader instanceof URLClassLoader) {
            URLClassLoader ucl = (URLClassLoader) loader;
            defaultUrl = SecurityActions.findResource(ucl, defaultsName);
            url = SecurityActions.findResource(ucl, propertiesName);
            PicketBoxLogger.LOGGER.traceAttemptToLoadResource(propertiesName);
        }
        // Do a general resource search
        if (defaultUrl == null) {
            defaultUrl = loader.getResource(defaultsName);
            if (defaultUrl == null) {
                try {
                    defaultUrl = new URL(defaultsName);
                } catch (MalformedURLException mue) {
                    PicketBoxLogger.LOGGER.debugFailureToOpenPropertiesFromURL(mue);
                    File tmp = new File(defaultsName);
                    if (tmp.exists()) {
                        defaultUrl = tmp.toURI().toURL();
                    }
                }
            }
        }
        if (url == null) {
            url = loader.getResource(propertiesName);
            if (url == null) {
                try {
                    url = new URL(propertiesName);
                } catch (MalformedURLException mue) {
                    PicketBoxLogger.LOGGER.debugFailureToOpenPropertiesFromURL(mue);
                    File tmp = new File(propertiesName);
                    if (tmp.exists()) {
                        url = tmp.toURI().toURL();
                    }
                }
            }
        }
        if (url == null && defaultUrl == null) {

            String propertiesFiles = propertiesName + "/" + defaultsName;
            throw PicketBoxMessages.MESSAGES.unableToFindPropertiesFile(propertiesFiles);
        }

        if (url != null) {
            InputStream is = null;
            try {
                is = SecurityActions.openStream(url);
            } catch (PrivilegedActionException e) {
                throw new IOException(e.getLocalizedMessage());
            }
            if (is != null) {
                try {
                    bundle.load(is);
                } finally {
                    safeClose(is);
                }
            } else {
                throw PicketBoxMessages.MESSAGES.unableToLoadPropertiesFile(propertiesName);
            }
            PicketBoxLogger.LOGGER.tracePropertiesFileLoaded(propertiesName, bundle.keySet());
        } else {
            InputStream is = null;
            try {
                is = defaultUrl.openStream();
                bundle.load(is);
                PicketBoxLogger.LOGGER.tracePropertiesFileLoaded(defaultsName, bundle.keySet());
            } catch (Throwable e) {
                PicketBoxLogger.LOGGER.debugFailureToLoadPropertiesFile(defaultsName, e);
            } finally {
                safeClose(is);
            }
        }
        return bundle;
    }
1195946
def _fill_lookup_prop(self, requirements_properties):
        """"""
        if not self._lookup_prop:
            raise Dump2PolarionException("Failed to set the 'polarion-lookup-method' property")

        etree.SubElement(
            requirements_properties,
            "property",
            {"name": "lookup-method", "value": self._lookup_prop},
        )
1025589
public static Map<String, Object> mapDescribedProperties(final PropertyResolver resolver,
                                                             final Description description) {
        //use a default scope of InstanceOnly if the Property doesn't specify it
        //use property default value if otherwise not resolved
        return mapDescribedProperties(resolver, description, null);
    }
441908
@Nonnull
	private static Properties findDefaultProperties() {
		final InputStream in = SourceCodeFormatter.class.getClassLoader().getResourceAsStream(DEFAULT_PROPERTIES_PATH);
		final Properties p = new Properties();
		try {
			p.load(in);
		} catch (final IOException e) {
			throw new RuntimeException(String.format("Can not load resource %s", DEFAULT_PROPERTIES_PATH));
		}
		return p;
	}
213611
function addAsyncPropsToPropPrototype(defaultProps, propTypes) {
  const defaultValues = {};

  const descriptors = {
    // Default "resolved" values for async props, returned if value not yet resolved/set.
    _asyncPropDefaultValues: {
      enumerable: false,
      value: defaultValues
    },
    // Shadowed object, just to make sure "early indexing" into the instance does not fail
    _asyncPropOriginalValues: {
      enumerable: false,
      value: {}
    }
  };

  // Move async props into shadow values
  for (const propName in propTypes) {
    const propType = propTypes[propName];
    const {name, value} = propType;

    // Note: async is ES7 keyword, can't destructure
    if (propType.async) {
      defaultValues[name] = value;
      descriptors[name] = getDescriptorForAsyncProp(name, value);
    }
  }

  Object.defineProperties(defaultProps, descriptors);
}
342521
private void loadProperties(File propFile) {
		if (propFile == null) {
			return;
		}
		try {
			loadProperties(new FileInputStream(propFile), propFile.getAbsolutePath());
		}
		catch (FileNotFoundException e) {
			Console.warn("Unable to find properties file ["+propFile.getAbsolutePath()+"].");
		}
	}
1086597
public static <K, V> Map<K, V> defaults(final Map<K, V> object, final Map<K, V> defaults) {
        final Map<K, V> result = newLinkedHashMap();
        for (final Map.Entry<K, V> entry : defaults.entrySet()) {
            result.put(entry.getKey(), entry.getValue());
        }
        for (final Map.Entry<K, V> entry : object.entrySet()) {
            result.put(entry.getKey(), entry.getValue());
        }
        return result;
    }
966835
public String getProperty(String key,String defaultValue)
    {
        //get property value
        return this.PROPERTIES.getProperty(key,defaultValue);
    }
1078709
private static Properties loadProperties(String propertiesFile) {
    Properties properties = new Properties();
    try (InputStream is = new FileInputStream(propertiesFile)) {
      properties.load(is);
    } catch (IOException e) {
      throw new RuntimeException("failed to load properties", e);
    }
    return properties;
  }
732337
public String getProperty(String propName, String defaultValue) {
        return props.getProperty(propName, defaultValue);
    }