Safely retrieve a value from the $oSettings object

@param  string $sProperty the property to retrieve

@return mixed
196214
protected function getSetting($sProperty = null)
    {
        if (property_exists($this->oSettings, $sProperty)) {
            return $this->oSettings->{$sProperty};
        } elseif (is_null($sProperty)) {
            return $this->oSettings;
        } else {
            return null;
        }
    }
1130399
public function &options($strProperty){
		$strProperty = $this->_formatPropertyName($strProperty);
		if($this->hasProperty($strProperty)){
			if(array_key_exists($strProperty, $this->_arrOptions)){
				return $this->_arrOptions[$strProperty];
			}
		}
		return false;
	}
324959
public String getProperty(String strProperty)
    {
        if (this.getTask() != null)
            return this.getTask().getProperty(strProperty);   // Try app
        return null;
    }
871401
public function getSetting($name, SettingsOwnerInterface $owner = null, $default = null)
    {
        return $this->settingsManager->get($name, $owner, $default);
    }
349732
public function get_configdata_property(string $property) {
        $configdata = $this->field->get('configdata');
        if (!isset($configdata[$property])) {
            return null;
        }
        return $configdata[$property];
    }
427923
public function getPropertyVariants()
    {
        $arValueList = [];

        //Get and check settings array
        $arSettings = $this->settings;
        if (empty($arSettings) || !isset($arSettings['list']) || empty($arSettings['list'])) {
            return $arValueList;
        }

        //Get property value variants
        foreach ($arSettings['list'] as $arValue) {
            if (!isset($arValue['value']) || empty($arValue['value'])) {
                continue;
            }

            $arValueList[$arValue['value']] = $arValue['value'];
        }

        natsort($arValueList);

        return $arValueList;
    }
1068203
function (oControl, sPropertyName, mBindingInfos) {
			var mOldBindingInfos = oControl.getBindingInfo(sPropertyName);
			var vOldValue;

			var oMetadata = oControl.getMetadata().getPropertyLikeSetting(sPropertyName);
			if (oMetadata) {
				var sPropertyGetter = oMetadata._sGetter;
				vOldValue = oControl[sPropertyGetter]();
			}

			JsControlTreeModifier.bindProperty.apply(this, arguments);

			if (mOldBindingInfos){
				this._saveUndoOperation("bindProperty", [oControl, sPropertyName, mOldBindingInfos]);
			} else {
				this._saveUndoOperation("unbindProperty", [oControl, sPropertyName]);
			}
			if (vOldValue) {
				this._saveUndoOperation("setProperty", [oControl, sPropertyName, vOldValue]);
			}
		}
1321238
public String getProperty(String strProperty, String strParams)
    {
        String strValue = null;
        strValue = this.parseArg(strProperty, strParams);
        if (strValue == null)
            strValue = this.getRecordOwner().getProperty(strProperty);
        return strValue;
    }
425415
public function getProperty($propertyName)
    {
        $className = $className = $this->getClass()->getName();

        if ($this->hasProperty($propertyName) === true) {

            try {
                return new BeanProperty($className, $propertyName);
            } catch (BeanException $e) {
                $msg = "The bean property with name '${propertyName}' in class '${className}' could not be retrieved.";
                throw new BeanException($msg, BeanException::NO_PROPERTY, $e);
            }
        } else {
            $msg = "No bean property with name '${propertyName}' in class '${className}'.";
            throw new BeanException($msg, BeanException::NO_PROPERTY);
        }
    }
1202460
@Override
  public Object getOptProperty(final String name) throws OptionsException {
    if (useSystemwideValues) {
      return findValue(optionsRoot, makePathElements(name), -1);
    }

    return findValue(localOptionsRoot, makePathElements(name), -1);
  }
803753
public function getPropertyValuesCollection( core_kernel_classes_Property $property, $options=array())
    {
        $returnValue = new core_kernel_classes_ContainerCollection($this);
		foreach ($this->getPropertyValues($property, $options) as $value){
			$returnValue->add(common_Utils::toResource($value));
		}
        return $returnValue;
    }
756450
private function getFieldValue($propertyName)
    {
        // get type of input data (where we must look it up)
        $inputType = Str::lowerCase($this->_sendMethod);
        $filterType = 'text';
        // get declared field sources and types
        $sources = $this->sources();
        $types = $this->types();
        // validate sources for current field
        if (array_key_exists($propertyName, $sources)) {
            $inputType = Str::lowerCase($sources[$propertyName]);
        }


        // check if field is array-nested element by dots and use first element as general
        $filterField = $propertyName;
        if (array_key_exists($filterField, $types)) {
            $filterType = Str::lowerCase($types[$filterField]);
        }

        // get clear field value
        $propertyValue = $this->getRequest($propertyName, $inputType);

        // apply security filter for input data
        if ($inputType !== 'file') {
            if ($filterType === 'html') {
                $propertyValue = App::$Security->secureHtml($propertyValue);
            } elseif ($filterType !== '!secure') {
                $propertyValue = App::$Security->strip_tags($propertyValue);
            }
        }

        return $propertyValue;
    }
196102
public String getProperty(String strProperty)
    {
    	String value = super.getProperty(strProperty);
    	if (value == null)
    		if ((BaseDatabase.STARTING_ID.equalsIgnoreCase(strProperty))
				|| (BaseDatabase.ENDING_ID.equalsIgnoreCase(strProperty)))
    				value = this.getRemoteProperty(strProperty, true);
    	return value;
    }
1043963
protected function get($property) {
        $mapping = $this->dao()->getMapping();

        if (isset($mapping['properties'][$property]))
            return $this->getNonRelationValue($property);

        if (isset($mapping['relations'][$property]))
            return $this->getRelationValue($property);

        throw new RuntimeException('Not a mapped property "'.$property.'"');
    }
644298
public static String getConfigProperty(String configProperty) {
        checkArgument(configProperty != null, "Config property cannot be null");
        return getConfig().getString(configProperty);
    }
424451
public function hasProperty($strProperty){
		$strProperty = $this->_formatPropertyName($strProperty);
		if(in_array($strProperty, $this->_arrProperties)){
			return true;
		}
		return false;
	}
480445
protected function getPropertyValue($property)
    {
        $getter = sprintf('get%s', $property);
        if (!method_exists($this->object, $getter)) {
            throw new NostoException(
                sprintf(
                    'Class %s does not have getter for property %s',
                    get_class($this->object),
                    $property
                )
            );
        }

        return $this->object->$getter();
    }