All perguntas(coding)

Quero usar um campo de apoio do EF Core .

A entidade possui:

public IReadOnlyCollection<Product> Products => _products;
private readonly List<Product> _products = default!;

Configuração EF:

builder
  .HasMany(x => x.Products)
  .WithOne()
  .HasForeignKey(x => x.ManufacturerId)
  .OnDelete(DeleteBehavior.Cascade);

builder                            // <----- problem here
  .Property(x => x.Products)
  .HasField("_products");

Isso produz:

Não foi possível criar um 'DbContext' do tipo ''. A exceção 'A propriedade ou navegação 'Produtos' não pode ser adicionada ao tipo 'Fabricante' porque uma propriedade ou navegação com o mesmo nome já existe no tipo 'Fabricante'.' foi gerada durante a tentativa de criar uma instância.

Suspeito que o código de configuração tenta adicionar a mesma navegação duas vezes. Qualquer uma delas pode ser usada, mas não simultaneamente. Eu poderia remover uma e confiar em convenções, mas não quero fazer isso, pois prefiro código de configuração explícito.

Como posso configurar explicitamente esse campo de apoio e evitar o erro?

Estou tentando criar um aplicativo de automação pessoal com alguns blocos de ação que adiciono usando um botão suspenso de ação. Aqui está este elemento:

<div class="row justify-center">
  <q-btn-dropdown v-model="menu" class="glossy" color="primary" label="++ Add Action">
    <q-card class="">
      <q-list bordered separator>
        <q-item clickable v-ripple>
          <q-item-section side>
            <q-icon color="primary" name="add_circle_outline" />
          </q-item-section>
          <q-item-section>
            <q-item-label class="q-ml-xs">Create a Contact</q-item-label>
          </q-item-section>
        </q-item>

        <q-item clickable v-ripple>
          <q-item-section side>
            <q-icon color="primary" name="update" />
          </q-item-section>
          <q-item-section>
            <q-item-label>Update Contact</q-item-label>
          </q-item-section>
        </q-item>

        <q-item clickable v-ripple>
          <q-item-section side>
            <q-icon color="primary" name="system_update_alt" />
          </q-item-section>
          <q-item-section>
            <q-item-label>Upsert Contact</q-item-label>
          </q-item-section>
        </q-item>
        <q-item clickable v-ripple>
          <q-item-section side>
            <q-icon color="primary" name="delete" />
          </q-item-section>
          <q-item-section>
            <q-item-label>Delete Contact</q-item-label>
          </q-item-section>
        </q-item>
      </q-list>
    </q-card>
  </q-btn-dropdown>
</div>

O problema é que não consigo adicionar um espaço entre o Botão de Ação e o Menu Suspenso. Tentei adicionar q-mb-sm a q-btn-dropdown e q-mt-sm a q-card, sem sucesso. Mesmo o CSS personalizado não está funcionando, sempre aparece assim:

Você pode me recomendar alguma ideia? Obrigado.

Qual é a diferença semântica entre definir e inicializar uma instância de uma estrutura e uma referência a uma estrutura? Em outras palavras, qual é a diferença entre esses dois programas em Rust?

struct SomeStruct {
    some_field: String,
}

fn main() {
    let s: SomeStruct = SomeStruct { some_field: "string".to_string() };
    println!("{} ", s.some_field);
}

struct SomeStruct {
    some_field: String,
}

fn main() {
    let s: &SomeStruct = &SomeStruct { some_field: "string".to_string() };
    println!("{} ", s.some_field);
}

Gostaria de saber como "%" funciona em uma matriz de tipo derivado.

Eu escrevi o seguinte programa onde o operador "+" foi sobrecarregado:

module my_mod

  implicit none

  type :: my_type
    real :: r1 , r2
    integer :: i1, i2
  end type my_type
  
  interface operator(+)
    module procedure add_my_type_vec, add_my_type
  end interface
  
contains
  function add_my_type_vec(a,b) result(res)
    type(my_type), dimension(:),intent(in) :: a, b
    type(my_type), dimension(size(a)) :: res

      res%r1 = a%r1 + b%r1
      res%r2 = a%r2 + b%r2
      res%i1 = a%i1 + b%i1
      res%i2 = a%i2 + b%i2
      
  end function add_my_type_vec
  
  function add_my_type(a,b) result(res)
    type(my_type), intent(in) :: a, b
    type(my_type) :: res

      res%r1 = a%r1 + b%r1
      res%r2 = a%r2 + b%r2
      res%i1 = a%i1 + b%i1
      res%i2 = a%i2 + b%i2
      
  end function add_my_type
  
end module my_mod

program my_pgm
    use my_mod
    implicit none
    
    type(my_type),allocatable, dimension(:) :: my_vec1, my_vec2, my_vec3
    
    write(*,*) "Sum on type : ", my_type(1.0, 2.0, 1, 2) + my_type(1.0, 2.0, 1, 2)

    allocate(my_vec1(1000), my_vec2(1000), my_vec3(1000))
    my_vec1 = my_type(1.0, 2.0, 1, 2)
    my_vec2 = my_type(1.0, 2.0, 1, 2)
    my_vec3 = my_vec1 + my_vec2
    
    write(*,*) "Sum on vec of type : ", my_vec3(123)
    

end program my_pgm

Na add_my_type_vecfunção, como %funciona? Por exemplo, na instrução res%r1 = a%r1 + b%r1, há a criação (ou seja, cópia de memória) de dois arrays de reais que contêm apenas a%r1e b%r1, a soma é feita nesses arrays e, em seguida, a atribuição é feita em res%r1? Acho que é mais complicado.

Em Programação Paralela e Concorrente em Haskell de Simon Marlow, a implementação de bracketé mostrada,

bracket
        :: IO a         -- ^ computation to run first (\"acquire resource\")
        -> (a -> IO b)  -- ^ computation to run last (\"release resource\")
        -> (a -> IO c)  -- ^ computation to run in-between
        -> IO c         -- returns the value from the in-between computation
bracket before after thing =
  mask $ \restore -> do
    a <- before
    r <- restore (thing a) `onException` after a
    _ <- after a
    return r

e um comentário segue. Aqui está a parte que está me intrigando

[…] É normal que beforecontenha uma operação de bloqueio; se uma exceção for gerada enquanto beforeestiver bloqueado, não haverá danos. Mas beforedeve executar apenas uma operação de bloqueio. Uma exceção gerada por uma segunda operação de bloqueio não resultaria em afterexecução. […]

Não entendi bem esse comentário, então gostaria de alguns esclarecimentos sobre ele.

Para esclarecer, não entendi nem a parte de que nenhum dano é causado : algumas páginas antes (p. 159), a seguinte tentativa falhada (segunda) de chamar takeMVar, executar uma operação dependendo de seu conteúdo e, finalmente, colocar o resultado dessa operação de volta na MVarvia putMVaré mostrada,

problem :: MVar a -> (a -> IO a) -> IO ()
problem m f = mask $ \restore -> do
  a <- takeMVar m
  r <- restore (f a) `catch`  \e -> do putMVar m a; throw e
  putMVar m r

Ao analisar este exemplo, "aceito" como um fato que takeMVarnão pode ser alterado maté que retorne; na verdade, isso foi retirado do texto:

seria seguro que exceções fossem levantadas até o ponto em que takeMVarretornasse.

e sinto que entendo o que se segue (eu acho ).

Mas voltando à implementação de bracket, e se beforeinternamente usar takeMVar, e uma exceção assíncrona ocorrer após o takeMVarretorno dela (esvaziando um MVar)? Isso não é um problema, justamente pelo motivo de estarmos usando mask+ restore, ou seja, tal exceção seria adiada até que o argumento para restore, que é thing a, comece a ser executado, momento em que o manipulador de exceções necessário está em vigor, neste caso via `onException` after a?

E o que dá errado se beforefizer outra chamada para a operação de bloqueio, digamos takeMVarnovamente para simplificar? O problema ocorre porque a exceção poderia ocorrer enquanto takeMVar o bloqueio estiver em andamento, portanto, na janela de tempo em que as exceções não são mascaradas, de modo que a exceção sairia de bracket, deixando o MVarargumento that was para o primeiro takeMVarnão vazio, mas em um estado diferente do original, dado que afternão teve a chance de ser executado?

É isso?

Além disso, a página do documento não menciona isso, ou não vejo como isso está implícito.

no VPlay adicionei este código:

<template>
    <v-app>
        <v-container>
            <v-select
                v-model="selectedState"
                :items="states"
                item-value="value"
                item-text="text"
                label="State"
                outlined
            ></v-select>
        </v-container>
    </v-app>
</template>

<script setup>
  import { ref } from 'vue'

  const selectedState = ref('')
  const states = ref([
    { value: '1', text: 'VIC' },
    { value: '2', text: 'ACT' },
  ])
</script>

O menu suspenso de seleção tem os dois objetos e não os pares valor/texto, como esperado.

Também recebo um aviso: Propriedade inválida: falha na verificação de tipo para a propriedade "título". String esperada | Número | Booleano, Objeto obtido

Sou iniciante no Vuetify. O que estou perdendo aqui? O que estou fazendo errado?

Minha intenção é obter dados do supabase via Pinia e criar um elemento select em um formulário.

Eu tenho a seguinte função de atualização de alguns objetos e arrays condicionais, mas ocorre um erro

Uncaught TypeError: (o && [{ orderId: "Ord_sdDerd124dsdcv"}]) is not iterable

Meu código

function UpdateQueryRes(e) {
  const deliveryList = {
    ...(e && { isActive: true})
  };

  const checkList = [ ...(e && [{ orderId: "Ord_sdDerd124dsdcv"}])];

  ...doint db updated

}

Simplesmente não consigo resolver isso, por que só aparece esse erro quando ese torna false.

como faço para que as teclas WASD espelhem exatamente as mesmas ações que as teclas de seta fazem?

Digamos que se eu segurar a tecla de seta para cima por alguns segundos, estou tentando fazer com que W espelhe o mesmo.

Isso é o que eu tentei até agora

   Up::
{
    Send("{Up}")
    Sleep(50)  ; Waits 50 milliseconds
    Send("w")
}

Estou tentando automatizar uma tarefa administrativa (PC local) do Excel via PowerShell; para abrir um arquivo do Excel, ler/carregar seu conteúdo/dados e, em seguida, consultar o conteúdo/dados como um banco de dados para vários cenários específicos de "consulta de banco de dados" (por exemplo, onde colA=X e colD=Y, então contar/ou fazer algo útil e, em seguida, imprimir a saída na tela do terminal).

Posso abrir um arquivo Excel no meu PC, ler as planilhas (por exemplo, nomes das guias) e seus nomes de colunas (A1:Z1).

Meu problema é tentar consultar cabeçalhos de colunas específicos, para tipos de dados e cenários específicos e imprimir em texto simples

Pelo que entendi, existem basicamente dois métodos principais para abrir um arquivo (por exemplo, myExcel.xlsx) via PowerShell:

1. Usando a abordagem moderna orientada a objetos do objeto COM

   $file_obj_handler = New-Object -ComObject Excel.Application

2. Usando a abordagem antiga e menos eficiente de import-csv

   $file_obj_handler = import-csv filepathname <extra parameters here>

Para sua informação, não sou contra nenhuma das abordagens e já tentei ambas. Mas meu problema comum é que, enquanto o array relevante é criado, seu conteúdo é codificado em algum formato simbólico estranho (parece Unicode/XML — em vez de texto simples humano).

Verifiquei o tamanho e o tipo do array usando os comandos:

$file_obj_handler.Count #my array size was 4194
$file_obj_handler.GetType() #printed System.Object[]

Tentei usar o parâmetro de comando em linha (-encoding utf8) e coisas do tipo, mas sem sucesso.

Existe uma maneira melhor, idealmente, de converter a matriz em texto simples ao abrir o manipulador de arquivo de objeto por meio de qualquer um dos métodos (1 ou 2), em vez de tentar contornar/reformatar a matriz depois que os dados do arquivo do Excel já tiverem sido lidos/carregados?

Eu sei que talvez eu precise usar um delimitador para os elementos do array (estágio 2), mas minha principal tarefa (estágio 1) é primeiro conseguir ler (o conteúdo da string em formato humano).

Eu uso as referências de arquivo aberto:

$workbook=$file_obj_handler.Workbooks.Open($excelFile)

Mas o mesmo problema ocorre sempre que faço um loop/imprimo o conteúdo do array - não imprime em texto simples/legível por humanos:

$workbook.Worksheets.Item(1)
$worksheets.Cells.Items(1,$i).Text

Estou desenvolvendo um explorador fractal em C++ usando SFML e std::threadrenderizando o conjunto de Mandelbrot na CPU com exibição progressiva. O objetivo é aproveitar múltiplos núcleos, dividindo a imagem em faixas horizontais, com cada faixa renderizada por uma thread separada. A responsividade do usuário é importante, o que significa que interações como zoom ou panorâmica devem, idealmente, interromper a renderização atual e iniciar uma nova.

Ao implementar a lógica de renderização progressiva, encontrei um artefato visual que é consistentemente reproduzível em um exemplo mínimo.

O Artefato Observado:

Durante o processo de renderização, que visa preencher a imagem faixa por faixa, a saída não mostra faixas sólidas de pixels computados. Em vez disso, dentro da região horizontal atribuída a cada thread, a estrutura fractal aparece como linhas horizontais finas e desconexas, separadas por espaços pretos.

Este não é o preenchimento suave esperado da área de trabalho horizontal. Uma captura de tela ilustrando esse artefato específico e consistente pode ser vista aqui:

https://isstatic.askoverflow.dev/82LBOVUT.png

O que considero particularmente intrigante é a consistência com que esse artefato se manifesta. Não parece ser um "rasgo" transitório ou uma condição de corrida típica; o padrão está presente de forma confiável sempre que executo o código com os mesmos parâmetros.

#include <SFML/Graphics.hpp>
#include <iostream>
#include <vector>
#include <thread>
#include <chrono>
#include <cstring>

struct render_target {
    unsigned int x_start, y_start, x_end, y_end;
    render_target(unsigned int xs, unsigned int ys, unsigned int xe, unsigned int ye)
            : x_start(xs), y_start(ys), x_end(xe), y_end(ye) {}
};

unsigned char* pixels = nullptr;

const unsigned int render_width = 800;
const unsigned int render_height = 600;

const unsigned int buffer_width = render_width;
const unsigned int buffer_height = render_height;

const double zoom_x = 240.0;
const double zoom_y = 240.0;
const double x_offset = 2.25;
const double y_offset = 1.25;
const unsigned int max_iterations = 300;

std::vector<unsigned char> thread_stop_flags; // 0: running, 1: stop requested, 2: stopped

sf::Texture texture;
sf::Sprite sprite(texture);
sf::Image image;

void cpu_render_minimal(render_target target, unsigned char* pixels, unsigned int width_param, unsigned int height_param,
                        double zoom_x, double zoom_y, double x_offset, double y_offset,
                        unsigned int max_iterations,
                        unsigned char& finish_flag)
{
    finish_flag = 0;

    for(unsigned int y = target.y_start; y < target.y_end; ++y){
        for(unsigned int x = target.x_start; x < target.x_end; ++x){
            double zr = 0.0;
            double zi = 0.0;
            double cr = x / zoom_x - x_offset;
            double ci = y / zoom_y - y_offset;

            unsigned int curr_iter = 0;
            while (curr_iter < max_iterations && zr * zr + zi * zi < 4.0) {
                double tmp_zr = zr;
                zr = zr * zr - zi * zi + cr;
                zi = 2.0 * tmp_zr * zi + ci;
                ++curr_iter;

                if(finish_flag == 1) {
                    finish_flag = 2;
                    return;
                }
            }

            unsigned char color_val;
            if (curr_iter == max_iterations) {
                color_val = 255;
            } else {
                color_val = static_cast<unsigned char>((curr_iter % 255) + 1);
            }

            const unsigned int index = (y * width_param + x) * 4;

            if (index + 3 < buffer_width * buffer_height * 4) {
                pixels[index] = color_val;
                pixels[index + 1] = color_val;
                pixels[index + 2] = color_val;
                pixels[index + 3] = 255;
            }
        }
    }
    finish_flag = 1;
}

void post_processing_minimal() {
    if (!pixels) return;

    image = sf::Image({render_width, render_height}, pixels);
    texture = sf::Texture(image, true);
    sprite = sf::Sprite(texture);
}

void start_render_job()
{
    if (pixels != nullptr) {
        delete[] pixels;
        pixels = nullptr;
    }

    pixels = new unsigned char[buffer_width * buffer_height * 4];
    if (!pixels) {
        std::cerr << "Error: Could not allocate pixel buffer!" << std::endl;
        return;
    }
    memset(pixels, 0, buffer_width * buffer_height * 4);

    unsigned int max_threads = std::thread::hardware_concurrency();
    if (max_threads == 0) max_threads = 1;
    thread_stop_flags.assign(max_threads, 0);
    std::vector<render_target> render_targets;

    unsigned int strip_height = render_height / max_threads;
    for(unsigned int i = 0; i < max_threads; ++i) {
        unsigned int x_start = 0;
        unsigned int x_end = render_width;
        unsigned int y_start = strip_height * i;
        unsigned int y_end = (i == max_threads - 1) ? render_height : strip_height * (i + 1);
        if (y_start >= y_end) continue;

        render_targets.emplace_back(x_start, y_start, x_end, y_end);
    }

    for(size_t i = 0; i < render_targets.size(); ++i) {
        std::thread t(cpu_render_minimal, render_targets[i], pixels,
                      render_width, render_height,
                      zoom_x, zoom_y, x_offset, y_offset,
                      max_iterations, std::ref(thread_stop_flags[i]));
        t.detach();
    }

    std::cout << "Started render job with " << render_targets.size() << " threads." << std::endl;
    std::cout << "Buffer dimensions: " << buffer_width << "x" << buffer_height << std::endl;
    std::cout << "Render dimensions passed to threads: " << render_width << "x" << render_height << std::endl;
}

int main() {
    sf::RenderWindow window(sf::VideoMode({render_width, render_height}), "Mandelbrot MRE");
    window.setFramerateLimit(60);

    image = sf::Image({render_width, render_height}, sf::Color::Black);
    texture = sf::Texture(image);
    sprite.setTexture(texture);

    start_render_job();

    while(window.isOpen()){
        while(const auto event = window.pollEvent()) {
            if(event->is<sf::Event::Closed>())
                window.close();
            if (event->is<sf::Event::KeyPressed>() && event->getIf<sf::Event::KeyPressed>()->scancode == sf::Keyboard::Scancode::Space) {
                std::cout << "Space pressed. Simulating render restart attempt..." << std::endl;
                start_render_job();

                if (pixels) memset(pixels, 0, buffer_width * buffer_height * 4);
            }
        }

        post_processing_minimal();

        window.clear(sf::Color::Black);
        window.draw(sprite);
        window.display();

        static bool render_finished = false;
        if (!render_finished && !thread_stop_flags.empty() &&
            std::all_of(thread_stop_flags.begin(), thread_stop_flags.end(),
                        [](unsigned char state){ return state == 1 || state == 2; }))
        {
            std::cout << "All threads finished (or stopped)." << std::endl;
            render_finished = true;
        }
    }
    if (pixels) {
        delete[] pixels;
        pixels = nullptr;
    }

    return 0;
}

CMakeLists.txt associado:

cmake_minimum_required(VERSION 3.20)
project(MandelbrotMRE LANGUAGES CXX)

set(CMAKE_CXX_STANDARD 20)
set(CMAKE_CXX_STANDARD_REQUIRED ON)

set(CMAKE_TOOLCHAIN_FILE "$ENV{HOME}/vcpkg/scripts/buildsystems/vcpkg.cmake" CACHE STRING "Vcpkg toolchain file")

find_package(SFML 3 COMPONENTS Graphics Window System REQUIRED)

if(CMAKE_CXX_COMPILER_ID MATCHES "GNU|Clang")
    add_compile_options(-Wall -Wextra -pedantic -fPIE)
elseif(MSVC)
    add_compile_options(/W4 /MP /std:c++latest)
endif()

set(CPP_SOURCES main.cpp)

add_executable(${PROJECT_NAME} ${CPP_SOURCES})

target_link_libraries(${PROJECT_NAME} PRIVATE
        SFML::Graphics
        SFML::Window
        SFML::System
)

Detalhes do ambiente:

• SO: Arch Linux
• Compilador C++: G++
• Versão SFML: 3
• Versão do CMake: 3.20+

Perguntas específicas:

• Por que esse artefato fragmentado específico e consistente aparece durante a renderização progressiva neste código de CPU multithread?

• Como esse artefato pode ser corrigido de forma confiável?