CodeExplorer

getIndex example

$translation_manager,
        $comment_manager,
        $entity_field_manager,
      ])
      ->getMock();

    $manager->expects($this->once())
      ->method('getChildren')
      ->willReturn([]);

    // Get the index once.     $index1 = $manager->getIndex();

    // Get it again. This should not return the previously generated index. If     // it does not, then the test will fail as the mocked methods will be called     // more than once.     $index2 = $manager->getIndex();

    $this->assertEquals($index1, $index2);
  }

}

/** * Sorts items by descending quality. */
    private function sort(): void
    {
        if (!$this->sorted) {
            uasort($this->items, function DAcceptHeaderItem $a, AcceptHeaderItem $b) {
                $qA = $a->getQuality();
                $qB = $b->getQuality();

                if ($qA === $qB) {
                    return $a->getIndex() > $b->getIndex() ? 1 : -1;
                }

                return $qA > $qB ? -1 : 1;
            });

            $this->sorted = true;
        }
    }
}

/** * Returns a serializable version of the object * * @return array */
    #[\ReturnTypeWillChange]     public function jsonSerialize()
    {
        return array(
            "line" => $this->getLine(),
            "column" => $this->getColumn(),
            "index" => $this->getIndex()
        );
    }
}

        throw new ElasticsearchIndexingException([\sprintf('Indexer for name %s not found', $name)]);
    }

    public function updateMappings(): void
    {
        foreach ($this->indexer as $indexer) {
            $mapping = $this->buildMapping($indexer);

            $this->client->indices()->putMapping([
                'index' => $this->adminEsHelper->getIndex($indexer->getName()),
                'body' => $mapping,
            ]);
        }
    }

    private function isIndexedEntityWritten(EntityWrittenContainerEvent $event): bool
    {
        foreach ($this->indexer as $indexer) {
            $ids = $event->getPrimaryKeys($indexer->getEntity());

            if (!empty($ids)) {

return $this->build($taxonomy_term->forums, $taxonomy_term, $topics, $taxonomy_term->parents, $header);
  }

  /** * Returns forum index page. * * @return array * A render array. */
  public function forumIndex() {
    $vocabulary = $this->vocabularyStorage->load($this->config('forum.settings')->get('vocabulary'));
    $index = $this->forumManager->getIndex();
    $build = $this->build($index->forums, $index);
    if (empty($index->forums)) {
      // Root of empty forum.       $build['#title'] = $this->t('No forums defined');
    }
    else {
      // Set the page title to forum's vocabulary name.       $build['#title'] = $vocabulary->label();
      $this->renderer->addCacheableDependency($build, $vocabulary);
    }
    return $build;
  }

$renderer = new Renderer();
      $renderer->setFormatter(new CompactFormatter());
      return $renderer->render($ast);
    }
    catch (\Exception $exception) {
      if ($exception instanceof PeastSyntaxException) {
        $position = $exception->getPosition();
        Error::logException($this->logger, $exception, 'Syntax error: @message, File: @asset_file, Line: @asset_line, Column: @asset_column, Index: @asset_index', [
          '@asset_file' => $js_asset['data'],
          '@asset_line' => $position->getLine(),
          '@asset_column' => $position->getColumn(),
          '@asset_index' => $position->getIndex(),
        ]);
      }
      else {
        Error::logException($this->logger, $exception);
      }
      return $data;
    }
  }

  /** * Processes the contents of a javascript asset for cleanup. * * @param string $contents * The contents of the javascript asset. * * @return string * Contents of the javascript asset. */

            }
        }
    }

    private function handleIndexingMessage(ElasticsearchIndexingMessage $message): void
    {
        $task = $message->getData();

        $ids = $task->getIds();

        $index = $task->getIndex();

        $this->connection->executeStatement('UPDATE elasticsearch_index_task SET `doc_count` = `doc_count` - :idCount WHERE `index` = :index', [
            'idCount' => \count($ids),
            'index' => $index,
        ]);

        if (!$this->client->indices()->exists(['index' => $index])) {
            return;
        }

        $entity = $task->getEntity();

"next" => null,
                    "comments" => array()
                );
            }
            //Add the comment token to the buffer             $this->buffer["comments"][] = $token;
        } else {

            if ($token) {
                $loc = $token->location;
                //Store the token end position                 $this->lastTokenIndex = $loc->end->getIndex();
                if ($this->buffer) {
                    //Fill the "next" key on the comments buffer with the token                     //start position                     $this->buffer["next"] = $loc->start->getIndex();
                }
            }

            //If there is an open comment buffer, close it and move it to the             //registry             if ($buffer = $this->buffer) {
                //Use the location as key to add the group of comments to the

    /** * @dataProvider searchHelperProvider */
    public function testSearchHelper(bool $adminEsEnabled, bool $refreshIndices, string $adminIndexPrefix): void
    {
        $searchHelper = new AdminElasticsearchHelper($adminEsEnabled, $refreshIndices, $adminIndexPrefix);

        static::assertEquals($adminEsEnabled, $searchHelper->getEnabled());
        static::assertEquals($refreshIndices, $searchHelper->getRefreshIndices());
        static::assertEquals($adminIndexPrefix, $searchHelper->getPrefix());
        static::assertEquals($adminIndexPrefix . '-promotion-listing', $searchHelper->getIndex('promotion-listing'));
    }

    public function testSetEnable(): void
    {
        $searchHelper = new AdminElasticsearchHelper(false, false, 'sw-admin');

        static::assertFalse($searchHelper->getEnabled());
        static::assertFalse($searchHelper->getRefreshIndices());
        static::assertEquals('sw-admin', $searchHelper->getPrefix());
        static::assertEquals('sw-admin-promotion-listing', $searchHelper->getIndex('promotion-listing'));

$index = [];
        $term = (string) mb_eregi_replace('\s(or)\s', '|', $term);
        $term = (string) mb_eregi_replace('\s(and)\s', ' + ', $term);
        $term = (string) mb_eregi_replace('\s(not)\s', ' -', $term);

        foreach ($entities as $entityName) {
            if (!$context->isAllowed($entityName . ':' . AclRoleDefinition::PRIVILEGE_READ)) {
                continue;
            }

            $indexer = $this->registry->getIndexer($entityName);
            $alias = $this->adminEsHelper->getIndex($indexer->getName());
            $index[] = ['index' => $alias];
            $query = $indexer->globalCriteria($term, $this->buildSearch($term, $limit))->toArray();
            $query['timeout'] = $this->timeout;

            $index[] = $query;
        }

        $responses = $this->client->msearch(['body' => $index]);

        $result = [];
        foreach ($responses['responses'] as $response) {

/** * Sets the current scan position at the given one * * @param Position $position Position at which the scan position will be set * * @return $this */
    public function setScanPosition(Position $position = null)
    {
        $this->line = $position->getLine();
        $this->column = $position->getColumn();
        $this->index = $position->getIndex();
        return $this;
    }

    /** * Return the character at the given index in the source code or null if the * end is reached. * * @param int $index Index, if not given it will use the current index * * @return string|null */