Gets a dot-notated key from an array, with a default value if it does not exist.

@param array $aSearch The seach array
@param mixed $mFind The dot-notated key or array of keys
@param string $sDefault The default value

@return mixed
775714
public static function get($aSearch, $mFind, $sDefault = null)
    {
        if (is_null($mFind)) {
            return $aSearch;
        }

        if (is_array($mFind)) {
            $return = array();

            foreach ($mFind as $key) {
                $return[$key] = self::get($aSearch, $key, $sDefault);
            }

            return $return;
        }

        foreach (explode('.', $mFind) as $key) {
            if (!isset($aSearch[$key])) {
                if (!is_array($aSearch) || !array_key_exists($key, $aSearch)) {
                    return $sDefault;
                }
            }

            $aSearch = $aSearch[$key];
        }

        return $aSearch;
    }
190134
function getDefaultSearchOptionText($level = null)
    {
        if (!isset($_GET['front'])) {
            return false;
        }
        return VF_Singleton::getInstance()->getDefaultSearchOptionText($level, $this->getConfig());
    }
951910
function nameValMatch(definedNameVals, lookupKey) {
    var keys = _.keys(definedNameVals),
        key,
        index;
    for (index in keys) {
        key = keys[index];
        if (key === lookupKey) {
            return {
                matchedWith: lookupKey,
                match: definedNameVals[key]
            };
        } else if (!definedNameVals[key].matchKeyCase && (key.toUpperCase() === (lookupKey.toUpperCase()))) {
            return {
                matchedWith: key,
                match: definedNameVals[key]
            };
        }
    }
    return null;
}
1157910
public static function set(&$aArray, $mFind, $mValue = null)
    {
        if (is_null($mFind)) {
            $aArray = !is_null($mValue) ? $mValue : $aArray;
            return;
        }

        if (is_array($mFind)) {
            foreach ($mFind as $key => $value) {
                self::set($aArray, $key, $value);
            }
        } else {
            $keys = explode('.', $mFind);

            while (count($keys) > 1) {
                $mFind = array_shift($keys);

                if (!isset($aArray[$mFind]) || !is_array($aArray[$mFind])) {
                    $aArray[$mFind] = array();
                }

                $aArray =& $aArray[$mFind];
            }

            $aArray[reset($keys)] = $mValue;
        }
    }
429830
public function getSearchInitializeWithEmptyQuery($defaultIfEmpty = false)
    {
        $result = $this->getValueByPathOrDefaultValue('plugin.tx_solr.search.initializeWithEmptyQuery', $defaultIfEmpty);
        return $this->getBool($result);
    }
45778
public function find($key, $default = null)
    {
        if ($key instanceof Mappable) {
            $key = $this->getEntityKey($key);
        }

        return array_first($this->items, function ($entity, $itemKey) use ($key) {
            return $this->getEntityKey($entity) == $key;
        }, $default);
    }
770225
public function prepareStrForSearch($sSearchStr)
    {
        $oStr = getStr();
        if ($oStr->hasSpecialChars($sSearchStr)) {
            return $oStr->recodeEntities($sSearchStr, true, ['&amp;'], ['&']);
        }

        return '';
    }
754871
function createFind(findIndexFunc) {
      return function(collection, predicate, fromIndex) {
        var iterable = Object(collection);
        if (!isArrayLike(collection)) {
          var iteratee = getIteratee(predicate, 3);
          collection = keys(collection);
          predicate = function(key) { return iteratee(iterable[key], key, iterable); };
        }
        var index = findIndexFunc(collection, predicate, fromIndex);
        return index > -1 ? iterable[iteratee ? collection[index] : index] : undefined$1;
      };
    }
204115
function addonsManager_waitForSearchFinished(aSpec) {
    var spec = aSpec || { };
    var timeout = (spec.timeout == undefined) ? TIMEOUT_SEARCH : spec.timeout;

    // TODO: restore after 1.5.1 has landed
    // var self = this;
    // 
    // mozmill.utils.waitFor(function () {
    //   return self.isSearching == false;
    // }, timeout, 100, "Search has been finished");
    
    mozmill.utils.waitForEval("subject.isSearching == false", 
                              timeout, 100, this);
  }
1313317
public function get($sKey, $sDefaultValue = null)
    {
        if (empty($sKey)) {
            return $sDefaultValue;
        }

        $obValue = Cookie::get($sKey);
        if (empty($obValue)) {
            return $sDefaultValue;
        }

        return $obValue;
    }
991773
public function GetCurrentColorCode($sDefaultColor = '000000')
    {
        $oRootCat = $this->GetRootCategory();
        /** @var $oRootCat TdbShopCategory */
        $sColorcode = $oRootCat->fieldColorcode;
        if ('' == $sColorcode) {
            $sColorcode = $sDefaultColor;
        }

        return $sColorcode;
    }
794393
void get(
    Object rootValue, 
    MatchSpaceKey msg,
    EvalCache cache,
    Object contextValue,
    SearchResults result)
    throws MatchingException, BadMessageFormatMatchingException
  {
      vacantChildGet(null, msg, cache, contextValue, result);
  }
176367
def _find(self, pair, default=None):
        
        from fontTools.ufoLib.kerning import lookupKerningValue
        font = self.font
        groups = font.groups
        return lookupKerningValue(pair, self, groups, fallback=default)
499558
def findByBiSearch(self, strSeq) :
		""""""
		arr = self.encode(strSeq)
		return self._dichFind(arr[0], self, 0, lst = None)
105808
public function get($key, $default = null, $dot_syntax = true)
    {
        if ($dot_syntax === true) {
            $paths = explode('.', $key);
            $node =& $this->_data;
            
            foreach ($paths as $path) {
                if (!is_array($node) || !isset($node[$path])) {
                    // error occurred
                    return $default;
                }
                $node =& $node[$path];
            }
            
            return $node;
            
        } else {
            
            return isset($this->_data[$key]) ? $this->_data[$key] : $default;
            
        }
    }
638603
public static int indexOf(final CharSequence cs, final char searchChar, int start) {
        if (cs instanceof String) {
            return ((String) cs).indexOf(searchChar, start);
        } else if (cs instanceof AsciiString) {
            return ((AsciiString) cs).indexOf(searchChar, start);
        }
        if (cs == null) {
            return INDEX_NOT_FOUND;
        }
        final int sz = cs.length();
        for (int i = start < 0 ? 0 : start; i < sz; i++) {
            if (cs.charAt(i) == searchChar) {
                return i;
            }
        }
        return INDEX_NOT_FOUND;
    }
794186
public function get($identifier, $default = null)
    {
       $result = $this->offsetGet($identifier);

        // If the value is null return the default
        if(is_null($result)) {
            $result = $default;
        }

        return $result;
    }