Adds inner hit into search.

@param NestedInnerHit $innerHit

@return $this
435454
public function addInnerHit(NestedInnerHit $innerHit)
    {
        $this->getEndpoint(InnerHitsEndpoint::NAME)->add($innerHit, $innerHit->getName());

        return $this;
    }
24064
public function newFromElasticResults(Array $hit)
    {
        $instance = $this->newInstance(array(), true);

        $attributes = $hit['_source'];

        $instance->isDocument = true;

        if (isset($hit['_score'])) {
            $instance->documentScore = $hit['_score'];
        }

        if (isset($hit['_version'])) {
            $instance->documentVersion = $hit['_version'];
        }

        if (isset($hit['highlight'])) {
            foreach ($hit['highlight'] as $field => $value) {
                $instance->highlighted[$field] = $value[0];
            }
        }

        $instance->setRawAttributes($attributes, true);

        return $instance;
    }
242591
public function rules($ruleset)
    {
        if (! is_array($ruleset)) {
            $ruleset = [static::GLOBAL_KEY => $ruleset];
        }

        foreach ($ruleset as $key => $rules) {
            $this->addRule($key, $rules);
        }

        return $this;
    }
1109537
public static function set_Inet( $inet )
    {
        if( $inet instanceof Inet ) {
            return $inet;
        }
        try {
            $inet = new Inet( $inet );
            return $inet;
        } catch ( \InvalidArgumentException $e ) {
            return null;
        }
    }
1146982
public function visited()
    {
        $this->hits++;

        $this->newQuery()
            ->toBase()
            ->where($this->getKeyName(), $this->getKey())
            ->increment('hits');

        return $this;
    }
351843
public function innerJoinOnTo($source, $table, $on)
    {
        $this->join('INNER', $source, $table, $on);

        return $this;
    }
445582
public function setIsNot($isNot)
    {
        if (is_bool($isNot)) {
            $this->isNot = $isNot;

            return $this;
        } else {
            throw new \InvalidArgumentException(
                "Invalid type '" . gettype($isNot). "' for argument 'isNot' given."
            );
        }
    }
838784
public function set($index, $newValue) {
        if (!$this->offsetSet($index, $newValue)) {
            $this->append($newValue);
        }

        return $this;
    }
451517
public function remainingHits()
	{
		$remaining = null;
		foreach ($this->limits as $limit)
		{
			$hitsLeft = $limit->remaining();
			if (is_null($remaining) ||
				$hitsLeft < $remaining
			)
			{
				$remaining = $hitsLeft;
			}
		}

		return $remaining;
	}
131072
public function setMatches($matches)
    {
        foreach ($matches as $key => $dtoData) {
            $this->matches[$key] = new MatchReferenceDto($dtoData);
        }
    
        return $this;
    }
415522
public function setSearch($search)
    {
        $this->_search = $search;
        $this->_queryBuilder->setSearch($search);
        return $this;
    }
635582
func (s *SearchSource) InnerHit(name string, innerHit *InnerHit) *SearchSource {
	s.innerHits[name] = innerHit
	return s
}
97726
public function inner_where($value = false)
    {
        if ($value !== false)
        {
            $this->inner_value = $value;
        }
        // nested table connection
        if ($this->is_inner && $this->inner_where)
        {
            $field = reset($this->inner_where);
            $this->where_pri($field, $this->inner_value, 'AND', 'nstd_tbl');
            $this->pass_default($field, $this->inner_value);
        }
    }
113448
public function in($haystack, $identical = false)
    {
        $this->addCondition(__METHOD__, [$haystack, $identical]);

        return $this;
    }
1334496
public static function inner(string $fromAlias, string $to, string $toAlias, string $condition): Join
    {
        return new self(self::MODE_INNER, $fromAlias, $to, $toAlias, $condition);
    }
548699
func (q *ParentIdQuery) InnerHit(innerHit *InnerHit) *ParentIdQuery {
	q.innerHit = innerHit
	return q
}
1209049
public function addInnerJoinOn($table, $where)
    {
        //argument test
        Argument::i()
            //Argument 1 must be a string
            ->test(1, 'string')
            //Argument 2 must be a string
            ->test(2, 'string');
        
        $where = func_get_args();
        $table = array_shift($where);
        
        $this->join[] = array(self::INNER, $table, $where, false);
        
        return $this;
    }