fromArray example

new AppCollection([$installedApp])
        );

        static::assertInstanceOf(ExtensionCollection::class, $extensions);
        static::assertEquals([
            'German',
            'British English',
        ], $extensions->first()->getLanguages());

        static::assertSame($installedApp->getUpdatedAt(), $extensions->first()->getUpdatedAt());
        static::assertEquals(new PermissionCollection([
            PermissionStruct::fromArray(['entity' => 'product', 'operation' => 'create']),
            PermissionStruct::fromArray(['entity' => 'product', 'operation' => 'read']),
            PermissionStruct::fromArray(['entity' => 'additional_privileges', 'operation' => 'additional:privilege']),
        ]), $extensions->first()->getPermissions());

        foreach ($extensions as $extension) {
            static::assertEquals(ExtensionStruct::EXTENSION_TYPE_APP, $extension->getType());
        }
    }

    private function getInstalledApp(): AppEntity
    {
        

            'webhooks' => [
                [
                    'name' => 'hook1',
                    'eventName' => CustomerLoginEvent::EVENT_NAME,
                    'url' => 'https://test.com',
                ],
            ],
        ]], Context::createDefaultContext());

        $permissionPersister = $this->getContainer()->get(PermissionPersister::class);
        $permissions = Permissions::fromArray([
            'customer' => ['read'],
        ]);

        $permissionPersister->updatePrivileges($permissions, $aclRoleId);

        $this->appendNewResponse(new Response(200));

        $customerId = Uuid::randomHex();
        $this->createCustomer($customerId);

        $customer = $this->getContainer()->get('customer.repository')->search(new Criteria([$customerId]), Context::createDefaultContext())->get($customerId);
        

    public function saveSystemConfiguration($data)
    {
        $settings = $this->getSystemConfiguration(AbstractQuery::HYDRATE_OBJECT);

        if (!$settings instanceof Settings) {
            $settings = new Settings();
            $this->entityManager->persist($settings);
        }
        $settings->fromArray($data);
        $this->entityManager->flush();
    }

    /** * This function returns the nested configuration layout * and translate the element and container snippets. * If a shop instance passed, the function selects additionally the * element values of the passed shop. * * @return array */
    

  protected $sections;

  /** * TestSectionList constructor. */
  public function __construct(array $sections) {
    // Loop through each section and reconstruct it to ensure that all default     // values are present.     foreach ($sections as $section) {
      $this->sections[] = Section::fromArray($section->toArray());
    }
  }

  /** * {@inheritdoc} */
  protected function setSections(array $sections) {
    $this->sections = array_values($sections);
    return $sections;
  }

  

        if (isset($data['arrayStore']) && \is_array($data['arrayStore'])) {
            $data['arrayStore'] = json_encode($data['arrayStore']);
        }

        if (!$model) {
            $model = new Configuration();
            $this->entityManager->persist($model);
        }

        $model->fromArray($data);
        $this->entityManager->flush($model);
    }

    /** * @param string|int|float|null $defaultValue */
    private function schemaChanged(ConfigurationStruct $config, string $name, string $type, $defaultValue = null): bool
    {
        return $config->getColumnType() !== $type
            || $config->getColumnName() !== $name
            || $config->getDefaultValue() != $defaultValue
        ;

  protected function getGuzzleCookieJar() {
    // @todo Add xdebug cookie.     $cookies = $this->extractCookiesFromRequest(\Drupal::request());
    foreach ($cookies as $cookie_name => $values) {
      $cookies[$cookie_name] = $values[0];
    }
    return CookieJar::fromArray($cookies, $this->baseUrl);
  }

  /** * Gets the form build ID for the user login form. * * @return string * The form build ID for the user login form. */
  protected function getUserLoginFormBuildId() {
    $this->drupalGet('user/login');
    return (string) $this->getSession()->getPage()->findField('form_build_id');
  }

$data = $this->Request()->getParams();
        $id = \is_null($this->Request()->getParam('id')) ? null : (int) $this->Request()->getParam('id');

        $filter = null;
        if (\is_int($id)) {
            $filter = $this->getMultiEditRepository()->find($id);
        }
        if (!$filter instanceof Filter) {
            $filter = new Filter();
        }

        $filter->fromArray($data);

        $this->get('models')->persist($filter);
        $this->get('models')->flush();

        $this->View()->assign(
            [
                'success' => true,
            ]
        );
    }

    

protected $queries;

    protected string $operator;

    /** * @param array<string, mixed> $data */
    public static function fromArray(array $data): FilterStruct
    {
        $queries = $data['queries'];

        $data['queries'] = array_map(fn (array $query): FilterStruct => FilterStruct::fromArray($query), $queries);

        $filter = new MultiFilterStruct();
        $filter->assign($data);

        return $filter;
    }

    /** * @return array<string, string> */
    public function getQueryParameter(): array
    {

'content-type' => TRUE,
      ];
      if (str_starts_with($key, 'http-')) {
        $headers[substr($key, 5)] = $val;
      }
      // CONTENT_* are not prefixed with HTTP_       elseif (isset($content_headers[$key])) {
        $headers[$key] = $val;
      }
    }

    $cookies = CookieJar::fromArray(
      $this->getCookieJar()->allRawValues($request->getUri()),
      parse_url($request->getUri(), PHP_URL_HOST)
    );

    $request_options = [
      'cookies' => $cookies,
      'allow_redirects' => FALSE,
    ];

    if (!\in_array($request->getMethod(), ['GET', 'HEAD'], TRUE)) {
      if (NULL !== $content = $request->getContent()) {
        

public function testDefaultValues(): void
    {
        $stock = new StockData('12345', 10, true);

        static::assertNull($stock->minPurchase);
        static::assertNull($stock->maxPurchase);
        static::assertNull($stock->isCloseout);
    }

    public function testFromArray(): void
    {
        $stock = StockData::fromArray([
            'productId' => '12345',
            'stock' => 10,
            'available' => true,
            'minPurchase' => 2,
            'maxPurchase' => 5,
            'isCloseout' => true,
        ]);

        static::assertEquals('12345', $stock->productId);
        static::assertEquals(10, $stock->stock);
        static::assertTrue($stock->available);
        

'defaultValue' => '',
            'displayField' => '',
            'valueField' => '',
            'allowBlank' => false,
            'translatable' => false,
            'position' => $this->getMaxPositionValue(),
        ];

        $this->maxFieldPositionValue = max($data['position'], $this->maxFieldPositionValue) + 1;

        $field = new Field();
        $field->fromArray($data);

        $field->setComponent($this);
        $this->fields->add($field);

        return $field;
    }

    /** * Creates a checkbox field for the passed emotion component widget. * * Creates a Ext.form.field.Checkbox element. * http://docs.sencha.com/extjs/4.2.2/#!/api/Ext.form.field.Checkbox * * options { * string $name Required; Logical name of the component field * string $fieldLabel optional; Ext JS form field label * string $allowBlank Optional; Defines if the value can contain null * } * * @param array{name: string, fieldLabel?: string, allowBlank?: bool} $options * * @return Field */

        return substr_count($privilege, ':') === 1;
    }

    private function makeCategorizedPermissions(array $privilegesDelta): array
    {
        $permissions = $this->makePermissions($privilegesDelta);

        $permissionCollection = new PermissionCollection();

        foreach ($permissions as $permission) {
            $permissionCollection->add(PermissionStruct::fromArray([
                'entity' => $permission['entity'],
                'operation' => $permission['operation'],
            ]));
        }

        return $permissionCollection->getCategorizedPermissions();
    }
}

$decoded = parent::decode($field, $value);
        if (!\is_array($decoded)) {
            return null;
        }

        if (!\array_key_exists('type', $decoded)) {
            throw new InvalidPriceFieldTypeException('none');
        }

        switch ($decoded['type']) {
            case QuantityPriceDefinition::TYPE:
                return QuantityPriceDefinition::fromArray($decoded);
            case AbsolutePriceDefinition::TYPE:
                $rules = (\array_key_exists('filter', $decoded) && $decoded['filter'] !== null) ? $this->decodeRule($decoded['filter']) : null;

                return new AbsolutePriceDefinition($decoded['price'], $rules);
            case CurrencyPriceDefinition::TYPE:
                $rules = (\array_key_exists('filter', $decoded) && $decoded['filter'] !== null) ? $this->decodeRule($decoded['filter']) : null;

                $collection = new PriceCollection();
                foreach ($decoded['price'] as $price) {
                    $collection->add(new Price($price['currencyId'], (float) $price['net'], (float) $price['gross'], (bool) $price['linked']));
                }

                

$carry6 = ($h[6] + (1 << 25)) >> 26;
        $h[7] += $carry6;
        $h[6] -= $carry6 << 26;
        /** @var int $carry8 */
        $carry8 = ($h[8] + (1 << 25)) >> 26;
        $h[9] += $carry8;
        $h[8] -= $carry8 << 26;

        foreach ($h as $i => $value) {
            $h[$i] = (int) $value;
        }
        return ParagonIE_Sodium_Core_Curve25519_Fe::fromArray($h);
    }

    /** * @internal You should not use this directly from another application * * Inline comments preceded by # are from libsodium's ref10 code. * * @param string $n * @param string $p * @return string * @throws SodiumException * @throws TypeError */

if (!$template instanceof Template) {
                $template = new Template();

                if ($plugin) {
                    $template->setPlugin($plugin);
                }

                $this->entityManager->persist($template);
            }

            $template->fromArray($data);
            if (!$template->getId() || $settings->getReloadSnippets()) {
                $this->synchronizeSnippets($template);
            }

            $this->entityManager->flush($template);

            $themes[] = $theme;
        }

        return $themes;
    }