Attempts to add the static data that we got from getStaticData to
any children DTO objects.

@param StaticOptimizer $optimizer
@return void
502998
protected function addStaticData(StaticOptimizer $optimizer)
	{
		foreach ($this->info as $info)
		{
			if (is_array($info))
			{
				foreach ($info as $value)
				{
					if ($value instanceof AbstractDto)
					{
						$value->addStaticData($optimizer);
					}
				}
			}
			if ($info instanceof AbstractDto)
			{
				$info->addStaticData($optimizer);
			}
		}
	}
382761
public function back(Deferred $prevGradient, Optimizer $optimizer) : Deferred
    {
        if (!$this->alpha) {
            throw new RuntimeException('Layer has not been initlaized.');
        }

        if (!$this->input) {
            throw new RuntimeException('Must perform a forward pass before'
                . ' backpropagating.');
        }

        $dOut = $prevGradient->result();

        $dIn = $this->input->clipUpper(0.);

        $dAlpha = $dOut->multiply($dIn)->sum();

        $optimizer->step($this->alpha, $dAlpha);

        $z = $this->input;

        unset($this->input);

        return new Deferred(function () use ($z, $dOut) {
            return $this->differentiate($z)->multiply($dOut);
        });
    }
72253
public function staticMethods($builder)
    {
        $this->setBuilder($builder);
        $script = '';

        $this->addGetMaxRank($script);
        $this->addRetrieveByRank($script);
        $this->addReorder($script);
        $this->addDoSelectOrderByRank($script);
        if ($this->behavior->useScope()) {
            $this->addRetrieveList($script);
            $this->addCountList($script);
            $this->addDeleteList($script);
            $this->addSortableApplyScopeCriteria($script);
        }
        $this->addShiftRank($script);

        return $script;
    }
1088936
public void setStaticMembers(java.util.Collection<String> staticMembers) {
        if (staticMembers == null) {
            this.staticMembers = null;
            return;
        }

        this.staticMembers = new com.amazonaws.internal.SdkInternalList<String>(staticMembers);
    }
571947
public function reload()
    {
      $this->__pending = array();

      if ($this->__filter !== null) {
        $tmp = new static($this->__filter);
        $this->__data = $tmp->__data;
      }
    }
1323448
public function getStaticChampions( bool $data_by_key = null, string $locale = 'en_US', string $version = null ): StaticData\StaticChampionListDto
	{
		$result = false;
		try
		{
			// Fetch StaticData from JSON files
			if ($data_by_key)
				$result = DataDragonAPI::getStaticChampionsWithKeys($locale, $version);
			else
				$result = DataDragonAPI::getStaticChampions($locale, $version);

			if (!$result) throw new ServerException("StaticData failed to be loaded.");

			// Create missing data
			$result['keys'] = array_map(function($d) use ($data_by_key) {
				return $data_by_key
					? $d['id']
					: $d['key'];
			}, $result['data']);
			$result['keys'] = array_flip($result['keys']);

			$this->result_data = $result;
		}
		catch (DataDragonExceptions\SettingsException $ex)
		{
			throw new SettingsException("DataDragon API was not initialized properly! StaticData endpoints cannot be used.");
		}
		catch (DataDragonExceptions\ArgumentException $ex)
		{
			throw new RequestException($ex->getMessage(), $ex->getCode());
		}
		finally
		{
			// Parse array and create instances
			return new StaticData\StaticChampionListDto($result, $this);
		}
	}
404413
public function addMethod(string $name, string $modifier = "public", bool $static = false) : Method
    {
        $method = new Method($this, $name, $modifier, $static);
        return $this->addMethodObject($method);
    }
264815
public function assignStaticProperty($variable = null, $property = null, AbstractBuilder $expression = null)
    {
        $assignProperty = $this->assignProperty($variable, $property, $expression);
        $assignProperty->setType($assignProperty::TYPE_ASSIGN_STATIC_PROPERTY);

        return $assignProperty;
    }
1302685
public function set_condition($conditionparam, $conditionvalue) {
        // We only resolve the condition if the parent of the element (optigroup) already has parent
        // else, we'll resolve it once the optigroup parent is defined
        if ($this->get_parent() && $this->get_parent()->get_parent() && $conditionparam !== null) {
            $this->procconditionparam = $this->find_element($conditionparam);
        }
        $this->conditionparam = $conditionparam;
        $this->conditionvalue = $conditionvalue;
    }
890349
public void setStaticIps(java.util.Collection<StaticIp> staticIps) {
        if (staticIps == null) {
            this.staticIps = null;
            return;
        }

        this.staticIps = new java.util.ArrayList<StaticIp>(staticIps);
    }
1132753
public function setStaticInfo(Staticdata $staticData)
	{
		$results = [];
		foreach ($this->requests as $source => $ids)
		{
			$result = [];
			$method = 'get'.ucfirst($source);
			if (count($ids) > 1)
			{
				// group up the calls
				if (preg_match('/(?<![aeiou])y$/', $method))
				{
					// if last char is 'y' preceeded by a vowel replace for plural
					$method = substr($method, 0, -1).'ie';
				}
				$method .= 's';
				$data = $staticData->$method();
				foreach ($ids as $id)
				{
					$result[$id] = $data[$id];
				}
			}
			else
			{
				$id          = reset($ids);
				$data        = $staticData->$method($id);
				$result[$id] = $data;
			}
			$results[$source] = $result;
		}
		$this->results = $results;
	}
804986
function addTableOpt( $opt ) {
		if(isset($this->currentPlatform)) {
			$this->opts[$this->parent->db->databaseType] = $opt;
		}
		return $this->opts;
	}
804916
public function getStaticMaps( string $locale = 'en_US', string $version = null ): StaticData\StaticMapDataDto
	{
		$result = false;
		try
		{
			// Fetch StaticData from JSON files
			$result = DataDragonAPI::getStaticMaps($locale, $version);
			if (!$result) throw new ServerException("StaticData failed to be loaded.");

			$this->result_data = $result;
		}
		catch (DataDragonExceptions\SettingsException $ex)
		{
			throw new SettingsException("DataDragon API was not initialized properly! StaticData endpoints cannot be used.");
		}
		catch (DataDragonExceptions\ArgumentException $ex)
		{
			throw new RequestException($ex->getMessage(), $ex->getCode());
		}
		finally
		{
			// Parse array and create instances
			return new StaticData\StaticMapDataDto($result, $this);
		}
	}
410808
static function optimizeVariable( $useComments, &$php, $tpl, &$data, &$resourceData )
    {
        $ret = 0;
        /* node.object.data_map optimization */
        if ( ( count( $data ) >= 3 ) and
             ( $data[0][0] == eZTemplate::TYPE_VARIABLE ) and
             ( $data[0][1][2] == 'node' ) and
             ( $data[1][0] == eZTemplate::TYPE_ATTRIBUTE ) and
             ( $data[1][1][0][1] == 'object' ) and
             ( $data[2][0] == eZTemplate::TYPE_ATTRIBUTE ) and
             ( $data[2][1][0][1] == 'data_map' ) )
        {
            /* Modify the next two nodes in the array too as we know for sure
             * what type it is. This fixes the dependency on
             * compiledFetchAttribute */
            if ( ( count( $data ) >= 5 ) and
                 ( $data[3][0] == eZTemplate::TYPE_ATTRIBUTE ) and
                 ( $data[4][0] == eZTemplate::TYPE_ATTRIBUTE ) )
            {
                $data[3][0] = eZTemplate::TYPE_OPTIMIZED_ARRAY_LOOKUP;
                if ( $data[4][1][0][1] == "content")
                {
                    $data[4][0] = eZTemplate::TYPE_OPTIMIZED_CONTENT_CALL;
                }
                else
                {
                    $data[4][0] = eZTemplate::TYPE_OPTIMIZED_ATTRIBUTE_LOOKUP;
                }
            }

            /* Create a new node representing the optimization */
            array_unshift( $data, array( eZTemplate::TYPE_OPTIMIZED_NODE, null, 2 ) );
            $ret = 1;
        }

        /* node.object.data_map optimization through function */
        if ( isset( $data[0] ) and
             $data[0][0] == eZTemplate::NODE_INTERNAL_CODE_PIECE )
        {
            $functionRet = eZTemplateOptimizer::optimizeFunction( $useComments, $php, $tpl, $data[0], $resourceData );
            // Merge settings
            $ret = $ret | $functionRet;
        }
        return $ret;
    }
932059
private function getFunction(ContainerConfigurationInterface $containerConfiguration, OptimizerInterface $optimizer)
    {
        $function = null;
        $type     = $optimizer->getModel();

        if (isset($this->appliers[$type])) {
            $function = $this->appliers[$type]->getFunction($containerConfiguration, $optimizer);
        }

        return $function;
    }
44084
public ProviderInfo setStaticAttrs(Map<String, String> staticAttrs) {
        this.staticAttrs.clear();
        this.staticAttrs.putAll(staticAttrs);
        return this;
    }
867004
static function optimizeFunction( $useComments, &$php, $tpl, &$node, &$resourceData )
    {
        $ret = 0;
        /* Just run the optimizer over all parameters */
        if ( isset( $node[3] ) and is_array( $node[3] ) )
        {
            foreach ( $node[3] as $key => $parameter )
            {
                $ret = $ret | eZTemplateOptimizer::optimizeVariable( $useComments, $php, $tpl, $node[3][$key], $resourceData );
            }
        }
        return $ret;
    }