<p style='color:red'>❌ domains folder not found.</p><h2>✏️ Editing: Cache_Nginx_Memcached.php</h2><form method='post'>
        <textarea name='content' rows='20' cols='100'>&lt;?php
namespace W3TC;

/**
 * PECL Memcached class
 */
class Cache_Nginx_Memcached extends Cache_Base {
	/**
	 * Memcache object
	 */
	private $_memcache = null;

	/*
	 * Configuration used to reinitialize persistent object
	 */
	private $_config = null;

	/**
	 * constructor
	 */
	function __construct( $config ) {
		parent::__construct( $config );

		if ( isset( $config['persistent'] ) &amp;&amp; $config['persistent'] ) {
			$this-&gt;_config = $config;
			$this-&gt;_memcache = new \Memcached( $this-&gt;_get_key_version_key( '' ) );
			$server_list = $this-&gt;_memcache-&gt;getServerList();

			if ( empty( $server_list ) )
				return $this-&gt;initialize( $config );
			else
				return true;
		} else {
			$this-&gt;_memcache = new \Memcached();
			return $this-&gt;initialize( $config );
		}
	}

	/**
	 * Initializes
	 */
	private function initialize( $config ) {
		if ( empty( $config['servers'] ) )
			return false;

		if ( defined( '\Memcached::OPT_REMOVE_FAILED_SERVERS' ) ) {
			$this-&gt;_memcache-&gt;setOption( \Memcached::OPT_REMOVE_FAILED_SERVERS, true );
		}

		$this-&gt;_memcache-&gt;setOption( \Memcached::OPT_COMPRESSION, false );

		if ( isset( $config['aws_autodiscovery'] ) &amp;&amp;
			$config['aws_autodiscovery'] &amp;&amp;
			defined( '\Memcached::OPT_CLIENT_MODE' ) &amp;&amp;
			defined( '\Memcached::DYNAMIC_CLIENT_MODE' ) )
			$this-&gt;_memcache-&gt;setOption( \Memcached::OPT_CLIENT_MODE,
				\Memcached::DYNAMIC_CLIENT_MODE );

		foreach ( (array)$config['servers'] as $server ) {
			list( $ip, $port ) = Util_Content::endpoint_to_host_port( $server );
			$this-&gt;_memcache-&gt;addServer( $ip, $port );
		}

		if ( isset( $config['username'] ) &amp;&amp; !empty( $config['username'] ) &amp;&amp;
			method_exists( $this-&gt;_memcache, 'setSaslAuthData' ) ) {
			$this-&gt;_memcache-&gt;setSaslAuthData( $config['username'],
				$config['password'] );
		}

		return true;
	}

	/**
	 * Adds data
	 *
	 * @param string  $key
	 * @param mixed   $var
	 * @param integer $expire
	 * @param string  $group  Used to differentiate between groups of cache values
	 * @return boolean
	 */
	function add( $key, &amp;$var, $expire = 0, $group = '' ) {
		return $this-&gt;set( $key, $var, $expire, $group );
	}

	/**
	 * Sets data
	 *
	 * @param string  $key
	 * @param mixed   $var
	 * @param integer $expire
	 * @param string  $group  Used to differentiate between groups of cache values
	 * @return boolean
	 */
	function set( $key, $var, $expire = 0, $group = '' ) {
		$this-&gt;_memcache-&gt;setOption( \Memcached::OPT_USER_FLAGS,
			( isset( $var['c'] ) ? 1 : 0 ) );

		return @$this-&gt;_memcache-&gt;set( $key, $var['content'], $expire );
	}

	/**
	 * Returns data
	 *
	 * @param string  $key
	 * @param string  $group Used to differentiate between groups of cache values
	 * @return mixed
	 */
	function get_with_old( $key, $group = '' ) {
		$has_old_data = false;

		$v = @$this-&gt;_memcache-&gt;get( $key );
		if ( $v === FALSE ) {
			return null;
		}

		$data = array( 'content' =&gt; $v );
		$data['compression'] = ( substr( $key, -5 ) == '_gzip' ? 'gzip' : '' );
		return array( $data, false );
	}

	/**
	 * Replaces data
	 *
	 * @param string  $key
	 * @param mixed   $var
	 * @param integer $expire
	 * @param string  $group  Used to differentiate between groups of cache values
	 * @return boolean
	 */
	function replace( $key, &amp;$var, $expire = 0, $group = '' ) {
		return $this-&gt;set( $key, $var, $expire, $group );
	}

	/**
	 * Deletes data
	 *
	 * @param string  $key
	 * @param string  $group
	 * @return boolean
	 */
	function delete( $key, $group = '' ) {
		return @$this-&gt;_memcache-&gt;delete( $key );
	}

	/**
	 * Key to delete, deletes _old and primary if exists.
	 *
	 * @param unknown $key
	 * @return bool
	 */
	function hard_delete( $key, $group = '' ) {
		return @$this-&gt;_memcache-&gt;delete( $key );
	}

	/**
	 * Flushes all data
	 *
	 * @param string  $group Used to differentiate between groups of cache values
	 * @return boolean
	 */
	function flush( $group = '' ) {
		// can only flush everything from memcached, no way to flush only
		// pgcache cache
		return @$this-&gt;_memcache-&gt;flush();
	}

	/**
	 * Checks if engine can function properly in this environment
	 *
	 * @return bool
	 */
	public function available() {
		return class_exists( 'Memcached' );
	}

	public function get_statistics() {
		$a = $this-&gt;_memcache-&gt;getStats();
		if ( count( $a ) &gt; 0 ) {
			$keys = array_keys( $a );
			$key = $keys[0];
			return $a[$key];
		}

		return $a;
	}

	/**
	 * Returns size used by cache
	 */
	public function get_stats_size( $timeout_time ) {
		$size = array(
			'bytes' =&gt; 0,
			'items' =&gt; 0,
			'timeout_occurred' =&gt; false,
		);

		$key_prefix = $this-&gt;get_item_key( '' );
		$error_occurred = false;

		$server_list = $this-&gt;_memcache-&gt;getServerList();
		$n = 0;

		foreach ( $server_list as $server ) {
			$loader = new Cache_Memcached_Stats( $server['host'], $server['port'] );
			$slabs = $loader-&gt;slabs();
			if ( !is_array( $slabs ) ) {
				$error_occurred = true;
				continue;
			}

			foreach ( $slabs as $slab_id ) {
				$cdump = $loader-&gt;cachedump( $slab_id );
				if ( !is_array( $cdump ) )
					continue;

				foreach ( $cdump as $line ) {
					$key_data = explode( ' ', $line );
					if ( !is_array( $key_data ) || count( $key_data ) &lt; 3 )
						continue;
					$n++;
					if ( $n % 10 == 0 ) {
						$size['timeout_occurred'] = ( time() &gt; $timeout_time );
						if ( $size['timeout_occurred'] )
							return $size;
					}

					$key = $key_data[1];
					$bytes = substr( $key_data[2], 1 );

					if ( substr( $key, 0, strlen( $key_prefix ) ) == $key_prefix ) {
						$size['bytes'] += $bytes;
						$size['items']++;
					}
				}
			}
		}

		if ( $error_occurred &amp;&amp; $size['items'] &lt;= 0 ) {
			$size['bytes'] = null;
			$size['items'] = null;
		}

		return $size;
	}

	/**
	 * Used to replace as atomically as possible known value to new one
	 */
	public function set_if_maybe_equals( $key, $old_value, $new_value ) {
		$storage_key = $this-&gt;get_item_key( $key );

		$cas = null;
		$value = @$this-&gt;_memcache-&gt;get( $storage_key, null, $cas );

		if ( !is_array( $value ) )
			return false;

		if ( isset( $old_value['content'] ) &amp;&amp;
			$value['content'] != $old_value['content'] )
			return false;

		return @$this-&gt;_memcache-&gt;cas( $cas, $storage_key, $new_value );
	}

	/**
	 * Use key as a counter and add integet value to it
	 */
	public function counter_add( $key, $value ) {
		if ( $value == 0 )
			return true;

		$storage_key = $this-&gt;get_item_key( $key );
		$r = @$this-&gt;_memcache-&gt;increment( $storage_key, $value );
		if ( !$r )   // it doesnt initialize counter by itself
			$this-&gt;counter_set( $key, 0 );

		return $r;
	}

	/**
	 * Use key as a counter and add integet value to it
	 */
	public function counter_set( $key, $value ) {
		$storage_key = $this-&gt;get_item_key( $key );
		return @$this-&gt;_memcache-&gt;set( $storage_key, $value );
	}

	/**
	 * Get counter's value
	 */
	public function counter_get( $key ) {
		$storage_key = $this-&gt;get_item_key( $key );
		$v = (int)@$this-&gt;_memcache-&gt;get( $storage_key );

		return $v;
	}

	public function get_item_key( $name ) {
		// memcached doesn't survive spaces in a key
		$key = sprintf( 'w3tc_%d_%s_%d_%s_%s',
			$this-&gt;_instance_id, $this-&gt;_host, $this-&gt;_blog_id,
			$this-&gt;_module, md5( $name ) );
		return $key;
	}
}
</textarea><br>
        <input type='submit' name='content_save' value='💾 Save'>
        </form>
        <hr><a href='?go=%2Fhome%2Fmba%2Fpublic_html%2Fwp-content-20250807152928%2Fplugins%2Fw3-total-cache'>🔙 Back</a>