PHP ElggMemcache::load方法代码示例

 public function get($key, callable $callback = null, $default = null)
 {
     $value = $this->memcache->load($key);
     if (!isset($value)) {
         $value = $default;
     }
     if (is_callable($callback)) {
         return call_user_func($callback, $value);
     }
     return $value;
 }

 /**
  * Create an Elgg* object from a given entity row.
  *
  * Handles loading all tables into the correct class.
  *
  * @param \stdClass $row The row of the entry in the entities table.
  *
  * @return \ElggEntity|false
  * @see get_entity_as_row()
  * @see add_subtype()
  * @see get_entity()
  * @access private
  *
  * @throws \ClassException|\InstallationException
  */
 function rowToElggStar($row)
 {
     if (!$row instanceof \stdClass) {
         return $row;
     }
     if (!isset($row->guid) || !isset($row->subtype)) {
         return $row;
     }
     $new_entity = false;
     // Create a memcache cache if we can
     static $newentity_cache;
     if (!$newentity_cache && is_memcache_available()) {
         $newentity_cache = new \ElggMemcache('new_entity_cache');
     }
     if ($newentity_cache) {
         $new_entity = $newentity_cache->load($row->guid);
     }
     if ($new_entity) {
         return $new_entity;
     }
     // load class for entity if one is registered
     $classname = get_subtype_class_from_id($row->subtype);
     if ($classname != "") {
         if (class_exists($classname)) {
             $new_entity = new $classname($row);
             if (!$new_entity instanceof \ElggEntity) {
                 $msg = $classname . " is not a " . '\\ElggEntity' . ".";
                 throw new \ClassException($msg);
             }
         } else {
             error_log("Class '" . $classname . "' was not found, missing plugin?");
         }
     }
     if (!$new_entity) {
         //@todo Make this into a function
         switch ($row->type) {
             case 'object':
                 $new_entity = new \ElggObject($row);
                 break;
             case 'user':
                 $new_entity = new \ElggUser($row);
                 break;
             case 'group':
                 $new_entity = new \ElggGroup($row);
                 break;
             case 'site':
                 $new_entity = new \ElggSite($row);
                 break;
             default:
                 $msg = "Entity type " . $row->type . " is not supported.";
                 throw new \InstallationException($msg);
         }
     }
     // Cache entity if we have a cache available
     if ($newentity_cache && $new_entity) {
         $newentity_cache->save($new_entity->guid, $new_entity);
     }
     return $new_entity;
 }

/**
 * Create a standard object from a given entity row.
 *
 * @param stdClass $row The row of the entry in the entities table.
 *
 * @return ElggEntity|false
 * @link http://docs.elgg.org/DataModel/Entities
 * @see get_entity_as_row()
 * @see add_subtype()
 * @see get_entity()
 * @access private
 *
 * @throws ClassException|InstallationException
 */
function elasticsearch_entity_row_to_std($row)
{
    if (!$row instanceof stdClass) {
        return $row;
    }
    if (!isset($row->guid) || !isset($row->subtype)) {
        return $row;
    }
    $new_entity = false;
    // Create a memcache cache if we can
    static $newentity_cache;
    if (!$newentity_cache && is_memcache_available()) {
        $newentity_cache = new ElggMemcache('new_entity_cache');
    }
    if ($newentity_cache) {
        $new_entity = $newentity_cache->load($row->guid);
    }
    if ($new_entity) {
        return $new_entity;
    }
    try {
        // load class for entity if one is registered
        $classname = get_subtype_class_from_id($row->subtype);
        if ($classname != "") {
            if (class_exists($classname)) {
                $new_entity = new $classname($row);
                if (!$new_entity instanceof ElggEntity) {
                    $msg = elgg_echo('ClassException:ClassnameNotClass', array($classname, 'ElggEntity'));
                    throw new ClassException($msg);
                }
            }
        }
        if (!$new_entity) {
            switch ($row->type) {
                case 'object':
                    $new_entity = new ElggObject($row);
                    break;
                case 'user':
                    $new_entity = new ElggUser($row);
                    break;
                case 'group':
                    $new_entity = new ElggGroup($row);
                    break;
                case 'site':
                    $new_entity = new ElggSite($row);
                    break;
                default:
                    $msg = elgg_echo('InstallationException:TypeNotSupported', array($row->type));
                    throw new InstallationException($msg);
            }
        }
    } catch (IncompleteEntityException $e) {
        return false;
    }
    return $new_entity;
}

/**
 * Gets the metastring identifier for a value.
 *
 * Elgg normalizes the names and values of annotations and metadata. This function
 * provides the identifier used as the index in the metastrings table. Plugin
 * developers should only use this if denormalizing names/values for performance
 * reasons (to avoid multiple joins on the metastrings table).
 *
 * @param string $string         The value
 * @param bool   $case_sensitive Should the retrieval be case sensitive?
 *                               If not, there may be more than one result
 *
 * @return int|array metastring id or array of ids
 * @since 1.9.0
 */
function elgg_get_metastring_id($string, $case_sensitive = true)
{
    global $CONFIG, $METASTRINGS_CACHE;
    // caching doesn't work for case insensitive requests
    if ($case_sensitive) {
        $result = array_search($string, $METASTRINGS_CACHE, true);
        if ($result !== false) {
            return $result;
        }
        // Experimental memcache
        $msfc = null;
        static $metastrings_memcache;
        if (!$metastrings_memcache && is_memcache_available()) {
            $metastrings_memcache = new ElggMemcache('metastrings_memcache');
        }
        if ($metastrings_memcache) {
            $msfc = $metastrings_memcache->load($string);
        }
        if ($msfc) {
            return $msfc;
        }
    }
    $escaped_string = sanitise_string($string);
    if ($case_sensitive) {
        $query = "SELECT * FROM {$CONFIG->dbprefix}metastrings WHERE string = BINARY '{$escaped_string}' LIMIT 1";
    } else {
        $query = "SELECT * FROM {$CONFIG->dbprefix}metastrings WHERE string = '{$escaped_string}'";
    }
    $id = false;
    $results = get_data($query);
    if (is_array($results)) {
        if (!$case_sensitive) {
            $ids = array();
            foreach ($results as $result) {
                $ids[] = $result->id;
            }
            // return immediately because we don't want to cache case insensitive results
            return $ids;
        } else {
            if (isset($results[0])) {
                $id = $results[0]->id;
            }
        }
    }
    if (!$id) {
        $id = _elgg_add_metastring($string);
    }
    $METASTRINGS_CACHE[$id] = $string;
    if ($metastrings_memcache) {
        $metastrings_memcache->save($string, $id);
    }
    return $id;
}

/**
 * Return the meta string id for a given tag, or false.
 * 
 * @param string $string The value (whatever that is) to be stored
 * @param bool $case_sensitive Do we want to make the query case sensitive?
 * @return mixed Integer tag or false.
 */
function get_metastring_id($string, $case_sensitive = true)
{
    global $CONFIG, $METASTRINGS_CACHE, $METASTRINGS_DEADNAME_CACHE;
    $string = sanitise_string($string);
    $result = array_search($string, $METASTRINGS_CACHE);
    if ($result !== false) {
        if (isset($CONFIG->debug) && $CONFIG->debug) {
            error_log("** Returning id for string:{$string} from cache.");
        }
        return $result;
    }
    // See if we have previously looked for this and found nothing
    if (in_array($string, $METASTRINGS_DEADNAME_CACHE)) {
        return false;
    }
    // Experimental memcache
    $msfc = null;
    static $metastrings_memcache;
    if (!$metastrings_memcache && is_memcache_available()) {
        $metastrings_memcache = new ElggMemcache('metastrings_memcache');
    }
    if ($metastrings_memcache) {
        $msfc = $metastrings_memcache->load($string);
    }
    if ($msfc) {
        return $msfc;
    }
    // Case sensitive
    $cs = "";
    if ($case_sensitive) {
        $cs = " BINARY ";
    }
    $row = get_data_row("SELECT * from {$CONFIG->dbprefix}metastrings where string={$cs}'{$string}' limit 1");
    if ($row) {
        $METASTRINGS_CACHE[$row->id] = $row->string;
        // Cache it
        // Attempt to memcache it if memcache is available
        if ($metastrings_memcache) {
            $metastrings_memcache->save($row->string, $row->id);
        }
        if (isset($CONFIG->debug) && $CONFIG->debug) {
            error_log("** Cacheing string '{$row->string}'");
        }
        return $row->id;
    } else {
        $METASTRINGS_DEADNAME_CACHE[$string] = $string;
    }
    return false;
}

function subsite_manager_get_plugin_order()
{
    if (is_memcache_available()) {
        $memcache = new ElggMemcache('subsite_manager');
    }
    if (isset($memcache)) {
        if ($plugin_order = $memcache->load('plugin_order')) {
            return $plugin_order;
        }
    }
    $db_prefix = get_config('dbprefix');
    $priority = elgg_namespace_plugin_private_setting('internal', 'priority');
    $options = array('type' => 'object', 'subtype' => 'plugin', 'limit' => ELGG_ENTITIES_NO_VALUE, 'selects' => array('plugin_oe.*'), 'joins' => array("JOIN {$db_prefix}private_settings ps on ps.entity_guid = e.guid", "JOIN {$db_prefix}objects_entity plugin_oe on plugin_oe.guid = e.guid"), 'wheres' => array("ps.name = '{$priority}'"), 'order_by' => "CAST(ps.value as unsigned), e.guid", 'site_guids' => array(1));
    $plugins = elgg_get_entities_from_relationship($options);
    $plugin_order = array();
    foreach ($plugins as $i => $plugin) {
        $plugin_order[$plugin->title] = $i;
    }
    if (isset($memcache)) {
        $memcache->save('plugin_order', $plugin_order);
    }
    return $plugin_order;
}

/**
 * Create an Elgg* object from a given entity row.
 *
 * Handles loading all tables into the correct class.
 *
 * @param stdClass $row The row of the entry in the entities table.
 *
 * @return ElggEntity|false
 * @link http://docs.elgg.org/DataModel/Entities
 * @see get_entity_as_row()
 * @see add_subtype()
 * @see get_entity()
 * @access private
 *
 * @throws ClassException|InstallationException
 */
function entity_row_to_elggstar($row)
{
    if (!$row instanceof stdClass) {
        return $row;
    }
    if (!isset($row->guid) || !isset($row->subtype)) {
        return $row;
    }
    $new_entity = false;
    // Create a memcache cache if we can
    static $newentity_cache;
    if (!$newentity_cache && is_memcache_available()) {
        $newentity_cache = new ElggMemcache('new_entity_cache');
    }
    if ($newentity_cache) {
        $new_entity = $newentity_cache->load($row->guid);
    }
    if ($new_entity) {
        return $new_entity;
    }
    // load class for entity if one is registered
    $classname = get_subtype_class_from_id($row->subtype);
    if ($classname != "") {
        if (class_exists($classname)) {
            $new_entity = new $classname($row);
            if (!$new_entity instanceof ElggEntity) {
                $msg = elgg_echo('ClassException:ClassnameNotClass', array($classname, 'ElggEntity'));
                throw new ClassException($msg);
            }
        } else {
            error_log(elgg_echo('ClassNotFoundException:MissingClass', array($classname)));
        }
    }
    if (!$new_entity) {
        //@todo Make this into a function
        switch ($row->type) {
            case 'object':
                $new_entity = new ElggObject($row);
                break;
            case 'user':
                $new_entity = new ElggUser($row);
                break;
            case 'group':
                $new_entity = new ElggGroup($row);
                break;
            case 'site':
                $new_entity = new ElggSite($row);
                break;
            default:
                $msg = elgg_echo('InstallationException:TypeNotSupported', array($row->type));
                throw new InstallationException($msg);
        }
    }
    // Cache entity if we have a cache available
    if ($newentity_cache && $new_entity) {
        $newentity_cache->save($new_entity->guid, $new_entity);
    }
    return $new_entity;
}

/**
 * Get the value of a datalist element.
 *
 * @internal Datalists are stored in the datalist table.
 *
 * @tip Use datalists to store information common to a full installation.
 *
 * @param string $name The name of the datalist
 * @return string|null|false String if value exists, null if doesn't, false on error
 * @access private
 */
function datalist_get($name)
{
    global $CONFIG, $DATALIST_CACHE;
    $name = trim($name);
    // cannot store anything longer than 255 characters in db, so catch here
    if (elgg_strlen($name) > 255) {
        elgg_log("The name length for configuration variables cannot be greater than 255", "ERROR");
        return false;
    }
    $name = sanitise_string($name);
    if (isset($DATALIST_CACHE[$name])) {
        return $DATALIST_CACHE[$name];
    }
    // If memcache enabled then cache value in memcache
    $value = null;
    static $datalist_memcache;
    if (!$datalist_memcache && is_memcache_available()) {
        $datalist_memcache = new ElggMemcache('datalist_memcache');
    }
    if ($datalist_memcache) {
        $value = $datalist_memcache->load($name);
    }
    if ($value) {
        return $value;
    }
    // [Marcus Povey 20090217 : Now retrieving all datalist values on first
    // load as this saves about 9 queries per page]
    // This also causes OOM problems when the datalists table is large
    // @todo make a list of datalists that we want to get in one grab
    $result = get_data("SELECT * from {$CONFIG->dbprefix}datalists");
    if ($result) {
        foreach ($result as $row) {
            $DATALIST_CACHE[$row->name] = $row->value;
            // Cache it if memcache is available
            if ($datalist_memcache) {
                $datalist_memcache->save($row->name, $row->value);
            }
        }
        if (isset($DATALIST_CACHE[$name])) {
            return $DATALIST_CACHE[$name];
        }
    }
    return null;
}

<?php

$site = elgg_get_site_entity();
$key = "css_splash_" . $site->guid;
if (is_memcache_available()) {
    $cache = new ElggMemcache("rijkshuisstijl");
    $css = $cache->load($key);
    if ($css) {
        echo $css;
        return;
    }
}
$parser = new Less_Parser();
$parser->parseFile(RIJKSHUISSTIJL_LESS . "/splash.less", "/mod/rijkshuisstijl/src/assets/");
$colors = elgg_get_plugin_setting("colors", "rijkshuisstijl");
if ($colors) {
    $colors = unserialize($colors);
    foreach ($colors as $number => $value) {
        $parser->parse("@belastingdienst--{$number}: {$value};");
    }
}
$css = $parser->getCss();
echo $css;
if (is_memcache_available()) {
    $cache->save($key, $css, 0);
}

/**
 * Get the value of a datalist element.
 * 
 * Plugin authors should use elgg_get_config() and pass null for the site GUID.
 *
 * @internal Datalists are stored in the datalist table.
 *
 * @tip Use datalists to store information common to a full installation.
 *
 * @param string $name The name of the datalist
 * @return string|null|false String if value exists, null if doesn't, false on error
 * @access private
 */
function datalist_get($name)
{
    global $CONFIG, $DATALIST_CACHE;
    $name = trim($name);
    // cannot store anything longer than 255 characters in db, so catch here
    if (elgg_strlen($name) > 255) {
        elgg_log("The name length for configuration variables cannot be greater than 255", "ERROR");
        return false;
    }
    if (isset($DATALIST_CACHE[$name])) {
        return $DATALIST_CACHE[$name];
    }
    // If memcache enabled then cache value in memcache
    $value = null;
    static $datalist_memcache = null;
    if (!$datalist_memcache && is_memcache_available()) {
        $datalist_memcache = new ElggMemcache('datalist_memcache');
    }
    if ($datalist_memcache) {
        $value = $datalist_memcache->load($name);
    }
    // @todo cannot cache 0 or false?
    if ($value) {
        return $value;
    }
    // not in cache and not in memcache so check database
    $escaped_name = sanitize_string($name);
    $result = get_data_row("SELECT * FROM {$CONFIG->dbprefix}datalists WHERE name = '{$escaped_name}'");
    if ($result) {
        $DATALIST_CACHE[$result->name] = $result->value;
        // Cache it if memcache is available
        if ($datalist_memcache) {
            $datalist_memcache->save($result->name, $result->value);
        }
        return $result->value;
    }
    return null;
}

/**
 * Get the value of a particular piece of data in the datalist
 *
 * @param string $name The name of the datalist
 * @return string|false Depending on success
 */
function datalist_get($name)
{
    global $CONFIG, $DATALIST_CACHE;
    // We need this, because sometimes datalists are received before the database is created
    if (!is_db_installed()) {
        return false;
    }
    $name = sanitise_string($name);
    if (isset($DATALIST_CACHE[$name])) {
        return $DATALIST_CACHE[$name];
    }
    // If memcache enabled then cache value in memcache
    $value = null;
    static $datalist_memcache;
    if (!$datalist_memcache && is_memcache_available()) {
        $datalist_memcache = new ElggMemcache('datalist_memcache');
    }
    if ($datalist_memcache) {
        $value = $datalist_memcache->load($name);
    }
    if ($value) {
        return $value;
    }
    // [Marcus Povey 20090217 : Now retrieving all datalist values on first load as this saves about 9 queries per page]
    $result = get_data("SELECT * from {$CONFIG->dbprefix}datalists");
    if ($result) {
        foreach ($result as $row) {
            $DATALIST_CACHE[$row->name] = $row->value;
            // Cache it if memcache is available
            if ($datalist_memcache) {
                $datalist_memcache->save($name, $row->value);
            }
        }
        if (isset($DATALIST_CACHE[$name])) {
            return $DATALIST_CACHE[$name];
        }
    }
    /*if ($row = get_data_row("SELECT value from {$CONFIG->dbprefix}datalists where name = '{$name}' limit 1")) {
    			$DATALIST_CACHE[$name] = $row->value;
    			
    			// Cache it if memcache is available
    			if ($datalist_memcache) $datalist_memcache->save($name, $row->value);
    			
    			return $row->value;
    		}*/
    return false;
}

/**
 * Return the metadata values that match your query.
 * 
 * @param string $meta_name
 * @return mixed either a value, an array of ElggMetadata or false.
 */
function get_metadata_byname($entity_guid, $meta_name)
{
    global $CONFIG;
    $meta_name = get_metastring_id($meta_name);
    if (empty($meta_name)) {
        return false;
    }
    $entity_guid = (int) $entity_guid;
    $access = get_access_sql_suffix("e");
    $md_access = get_access_sql_suffix("m");
    // If memcache is available then cache this (cache only by name for now since this is the most common query)
    $meta = null;
    static $metabyname_memcache;
    if (!$metabyname_memcache && is_memcache_available()) {
        $metabyname_memcache = new ElggMemcache('metabyname_memcache');
    }
    if ($metabyname_memcache) {
        $meta = $metabyname_memcache->load("{$entity_guid}:{$meta_name}");
    }
    if ($meta) {
        return $meta;
    }
    $result = get_data("SELECT m.*, n.string as name, v.string as value from {$CONFIG->dbprefix}metadata m JOIN {$CONFIG->dbprefix}entities e ON e.guid = m.entity_guid JOIN {$CONFIG->dbprefix}metastrings v on m.value_id = v.id JOIN {$CONFIG->dbprefix}metastrings n on m.name_id = n.id where m.entity_guid={$entity_guid} and m.name_id='{$meta_name}' and {$access} and {$md_access}", "row_to_elggmetadata");
    if (!$result) {
        return false;
    }
    // Cache if memcache available
    if ($metabyname_memcache) {
        if (count($result) == 1) {
            $r = $result[0];
        } else {
            $r = $result;
        }
        $metabyname_memcache->setDefaultExpiry(3600);
        // This is a bit of a hack - we shorten the expiry on object metadata so that it'll be gone in an hour. This means that deletions and more importantly updates will filter through eventually.
        $metabyname_memcache->save("{$entity_guid}:{$meta_name}", $r);
    }
    if (count($result) == 1) {
        return $result[0];
    }
    return $result;
}

/**
 * Return an array of all private settings.
 *
 * @param int $entity_guid The entity GUID
 *
 * @return array|false
 * @see set_private_setting()
 * @see get_private_settings()
 * @see remove_private_setting()
 * @see remove_all_private_settings()
 * @link http://docs.elgg.org/DataModel/Entities/PrivateSettings
 */
function get_all_private_settings($entity_guid)
{
    global $PRIVATE_SETTINGS_CACHE;
    static $private_setting_memcache;
    $dbprefix = elgg_get_config("dbprefix");
    $entity_guid = (int) $entity_guid;
    // check if you have access to the entity
    if (!elgg_get_ignore_access() && !get_entity_as_row($entity_guid)) {
        return false;
    }
    // first check localy
    if (isset($PRIVATE_SETTINGS_CACHE[$entity_guid])) {
        return $PRIVATE_SETTINGS_CACHE[$entity_guid];
    }
    if (!isset($private_setting_memcache) && is_memcache_available()) {
        $private_setting_memcache = new ElggMemcache("private_settings");
    }
    if ($private_setting_memcache) {
        if ($settings = $private_setting_memcache->load($entity_guid)) {
            // cache localy
            $PRIVATE_SETTINGS_CACHE[$entity_guid] = $settings;
            if (!empty($settings)) {
                return $settings;
            } else {
                return false;
            }
        }
    }
    $query = "SELECT *";
    $query .= " FROM {$dbprefix}private_settings";
    $query .= " WHERE entity_guid = {$entity_guid}";
    $settings = array();
    if ($result = get_data($query)) {
        foreach ($result as $r) {
            $settings[$r->name] = $r->value;
        }
    }
    if ($private_setting_memcache) {
        $private_setting_memcache->save($entity_guid, $settings);
    }
    if (!empty($settings)) {
        // cache localy
        $PRIVATE_SETTINGS_CACHE[$entity_guid] = $settings;
        return $settings;
    }
    return false;
}

/**
 * Return the meta string id for a given tag, or false.
 *
 * @param string $string         The value to store
 * @param bool   $case_sensitive Do we want to make the query case sensitive?
 *                               If not there may be more than one result
 *
 * @return int|array|false meta   string id, array of ids or false if none found
 * @deprecated 1.9 Use elgg_get_metastring_id()
 */
function get_metastring_id($string, $case_sensitive = TRUE)
{
    elgg_deprecated_notice(__FUNCTION__ . ' is deprecated. Use elgg_get_metastring_id()', 1.9);
    global $CONFIG, $METASTRINGS_CACHE, $METASTRINGS_DEADNAME_CACHE;
    $string = sanitise_string($string);
    // caching doesn't work for case insensitive searches
    if ($case_sensitive) {
        $result = array_search($string, $METASTRINGS_CACHE, true);
        if ($result !== false) {
            return $result;
        }
        // See if we have previously looked for this and found nothing
        if (in_array($string, $METASTRINGS_DEADNAME_CACHE, true)) {
            return false;
        }
        // Experimental memcache
        $msfc = null;
        static $metastrings_memcache;
        if (!$metastrings_memcache && is_memcache_available()) {
            $metastrings_memcache = new \ElggMemcache('metastrings_memcache');
        }
        if ($metastrings_memcache) {
            $msfc = $metastrings_memcache->load($string);
        }
        if ($msfc) {
            return $msfc;
        }
    }
    // Case sensitive
    if ($case_sensitive) {
        $query = "SELECT * from {$CONFIG->dbprefix}metastrings where string= BINARY '{$string}' limit 1";
    } else {
        $query = "SELECT * from {$CONFIG->dbprefix}metastrings where string = '{$string}'";
    }
    $row = FALSE;
    $metaStrings = get_data($query);
    if (is_array($metaStrings)) {
        if (sizeof($metaStrings) > 1) {
            $ids = array();
            foreach ($metaStrings as $metaString) {
                $ids[] = $metaString->id;
            }
            return $ids;
        } else {
            if (isset($metaStrings[0])) {
                $row = $metaStrings[0];
            }
        }
    }
    if ($row) {
        $METASTRINGS_CACHE[$row->id] = $row->string;
        // Cache it
        // Attempt to memcache it if memcache is available
        if ($metastrings_memcache) {
            $metastrings_memcache->save($row->string, $row->id);
        }
        return $row->id;
    } else {
        $METASTRINGS_DEADNAME_CACHE[$string] = $string;
    }
    return false;
}

function entity_view_counter_is_counted(ElggEntity $entity)
{
    if (php_sapi_name() === 'cli') {
        return true;
    }
    if (!entity_view_counter_is_configured_entity_type($entity->getType(), $entity->getSubtype())) {
        return true;
    }
    if (isset($_SERVER["HTTP_USER_AGENT"]) && preg_match('/bot|crawl|slurp|spider/i', $_SERVER["HTTP_USER_AGENT"])) {
        return true;
    }
    $user = elgg_get_logged_in_user_entity();
    if ($user && $user->getGUID() == $entity->getOwnerGUID()) {
        return true;
    }
    if (is_memcache_available()) {
        $cache = new ElggMemcache('entity_view_counter');
        $key = "view_" . session_id() . "_" . $entity->guid;
        if ($cache->load($key)) {
            return true;
        }
    }
    if (entity_view_counter_ignore_ip()) {
        return true;
    }
    return false;
}