All perguntas(coding)

Estou trabalhando em um programa do Windows que adiciona valores à variável de ambiente PATH . A variável PATH é delimitada por ponto e vírgula ( ;), e qualquer caminho de pasta válido pode ser incluído. No entanto, ;é válido em caminhos de pasta, então caminhos contendo ponto e vírgula devem ser colocados entre aspas duplas ao serem adicionados ao caminho:

C:\Program Files (x86);"C:\;My Folder";C:\Program Files

Para evitar esse problema com ponto e vírgula, meu programa envolve todos os caminhos entre aspas duplas. No entanto, alguém me informou recentemente que o Powershell não funciona com valores entre aspas na variável PATH, pois ele trata as aspas como caracteres comuns:

Observei como o PowerShell manipula a variável Path (com base neste código: PowerShell/PowerShell@16176ef/src/System.Management.Automation/engine/CommandDiscovery.cs#L1187-L1240). Pelo que posso perceber, o PowerShell não remove aspas duplas - ele apenas divide os caminhos sempre que vê um ponto e vírgula.

Então, o valor PATH C:\Program Files (x86);"C:\;My Folder";C:\Program Filesé interpretado incorretamente assim (se entendi corretamente o que está acontecendo):

C:\Program Files (x86)
"C:\
My Folder"
C:\Program Files

Aqui está um vídeo demonstrando o comportamento (isso só ocorre com o Powershell, não com o cmd): https://www.mediafire.com/file/aih2ky9fz07x5w0/powershellpathwithsemicolonsbug.mp4/file

Qual é a melhor maneira para meu programa lidar com isso? E, mais urgentemente, por que o Powershell não funciona com valores PATH que têm aspas (embora o CMD faça)? Editar o valor do caminho para incluir ponto e vírgula usando o modo manual - Edit the system environment variables -> Path -> Edit- faz com que o Windows envolva automaticamente os caminhos necessários entre aspas, quebrando o Powershell. Então, isso não é um problema com meu programa ou situação - é um problema inerente com a forma como o Powershell processa o PATH.

Esse comportamento é intencional no Powershell? E há uma solução alternativa, ou terei que chegar a um acordo A. Envolvendo caminhos que contêm ponto e vírgula entre aspas e permitindo que esse comportamento de bug ocorra ou B. não permitindo ponto e vírgula em PATH?

Considere o seguinte código:

std::vector<float> foo = some_generator_function();
std::span<float> bar {foo};
/* Wrapper for C API that uses bar->data() and bar->size_bytes()
 * if bar != nullptr, guaranteed not to change any data in bar.
 * In some cases bar is constructed from a const C array.
 */
do_smth (&bar);

Este código compila e funciona bem, pois std::spanpode ser construído a partir de um std::vector.

Agora, estou tentando envolvê-lo em uma função separada:

void do_wrap (const std::vector<float>& foo) {
    std::span<float> bar (foo);
    do_smth (&bar);
}

E surge o problema:

erro: nenhuma função correspondente para chamada para 'std::span<float>::span(const std::vector<float>&)'`

Mais precisamente, const std::vector<float>&não satisfaz restrições.

Há alguma razão para isso? Estou suspeitando do constqualificador por enquanto.

Construindo como bar (foo.data(), foo.size())relatórios um erro semelhante.

Compilando com g++ 14.2.0, MinGW64.

Quero ter uma classe de estilo especial para um ComboBox que eu possa reutilizar. Por exemplo, quero criar uma classe yellowedque fornecerá um fundo amarelo. Este é meu código:

Java:

public class NewMain extends Application {

    @Override
    public void start(Stage primaryStage) {
        ComboBox<String> comboBox = new ComboBox<>();
        comboBox.getItems().addAll("Option 1", "Option 2", "Option 3");
        comboBox.getStyleClass().add("yellowed");

        VBox vbox = new VBox(comboBox);
        Scene scene = new Scene(vbox, 400, 300);
        scene.getStylesheets().add(NewMain.class.getResource("test.css").toExternalForm());
        primaryStage.setScene(scene);
        primaryStage.show();
    }

    public static void main(String[] args) {
        launch(args);
    }
}

CSS:

.combo-box.yellowed {
    -fx-background-color: yellow;
}

.combo-box-popup.yellowed > .list-view > .virtual-flow > .clipped-container > .sheet > .list-cell {
    -fx-background-color: yellow;
}

O problema é que o pop-up (do meu ComboBox com yellowedclasse de estilo) que será exibido não terá uma yellowedclasse.

Alguém poderia dizer se existe uma maneira de adicionar uma classe de estilo ao pop-up de um ComboBox específico?

Aqui está um conjunto de dados onde ANO é uma variável de agrupamento.

dat <- data.frame(YEAR = c(rep(1999,4),rep(2002,3)), VALUE = c(1,2,3,2,1,2,3))

Gostaria de adicionar uma coluna que analisa a coluna VALUE e diz "onde, dentro do ano, esse valor fica?" Estou com dificuldade para expressar isso de forma concisa, mas é praticamente o que cume_dist faz, exceto que cume_dist agrupa valores vinculados e eu os quero separados. cume_dist pega 1,2,2,3 e retorna 0,25, 0,75, 0,75, 1,00 e preciso que os vínculos sejam separados: 1,2,2,4 deve retornar 0,25, 0,50, 0,75, 1,0.

Aqui está uma linha baseada em cume_dist que funciona, exceto para os valores empatados:

dat %>% group_by(YEAR) %>% mutate(cumdist = cume_dist(VALUE))

Tentei desconstruir cume_dist (que é a classificação no grupo dividida pelo tamanho do grupo) e usar row_number, que separa empates, para o numerador e dividi-lo pelo número de linhas em cada ano. Isso me dá o numerador correto:

dat %>% group_by(YEAR) %>% mutate(rownumber = row_number(VALUE))

Mas como faço para dividir essas classificações pelo número de valores em cada ano (ou seja, dividir todas as classificações de 1999 por 4 e as classificações de 2002 por 3)?

Aqui está um exemplo mínimo do meu problema:

innerFunc([2, 4, 5]) % works fine
outerFunc(innerFunc, [2, 4, 5]) % doesn't work

function out = innerFunc(my_vec) 
    my_vec % not recogniced when called from outerFunc
    out = -1;
end

function out = outerFunc(func, my_vec) 
    out = func(my_vec);
end

Esta é a saída do código:

my_vec =

     2     4     5


ans =

    -1

Not enough input arguments.

Error in nested_funcs_bug>innerFunc (line 5)
    my_vec % not recogniced when called from outerFunc

Error in nested_funcs_bug (line 2)
outerFunc(innerFunc, [2, 4, 5]) % doesn't work

>> 

Não sei por que o erro na linha 2?

Principalmente porque "innerFunc" geralmente funciona e eu passo uma entrada para ele na função outerFunc.

Minha tabela tem 3 células: as duas primeiras contêm entradas, e a terceira tem meu contenteditable. Cada célula tem uma largura de 33.333%. Quando eu digito texto em uma entrada e ela transborda, tudo funciona bem — o texto é simplesmente escondido, como esperado para uma entrada.

No entanto, quando digito contenteditable, ele estica a célula em vez de "rolar" o texto como uma entrada faz.

* {
  box-sizing: border-box;
}

table {
  width: 100%;
}

td {
  width: 33.333333%;
}

input {
  width: 100%;
  height: 32px;
  border: 1px solid #dedede;
}

.contendeditable {
  padding-left: 10px;
  height: 32px;
  border: 1px solid red;
  width: 100%;
  white-space: nowrap;
  overflow-x: auto;
  overflow-y: hidden;
  line-height: 32px;
}

<table>
  <tr>
    <td><input type="text" /></td>
    <td><input type="text" /></td>
    <td>
      <div class="contendeditable" contenteditable="true"></div>
    </td>
  </tr>
</table>

Aqui está o jsfiddle: https://jsfiddle.net/zvm0exdc/14/

As classes base e derivadas compartilham uma tabela virtual? Quando me candidatei a um emprego, alguns entrevistadores de empresas famosas da Internet disseram que sim com certeza. Embora eu tenha dito a eles que o valor do ponteiro apontando para a tabela virtual no objeto da classe derivada é diferente do valor do ponteiro apontando para a tabela virtual no objeto da classe base, então eles não devem compartilhar a mesma tabela virtual, o entrevistador ainda disse com certeza que eles compartilham a mesma tabela virtual. Então, fiquei um pouco confuso e vim aqui para encontrar a resposta.

Digamos que eu queira obter o conteúdo java.runtime.versiondo shell do Linux.

Não quero java -versionfazer nenhum tipo de busca/envio, pois já usamos essa abordagem no passado e ela se mostrou instável.

➜  java -version
openjdk version "21" 2023-09-19 LTS
OpenJDK Runtime Environment Temurin-21+35 (build 21+35-LTS)
OpenJDK 64-Bit Server VM Temurin-21+35 (build 21+35-LTS, mixed mode)

Este exemplo contém muita saída que muda de versão para versão e também de fornecedor para fornecedor.

O que eu já tentei foi usar jshell:

Mas a saída ainda contém todos os comentários de comando que não posso desabilitar (pelo menos não sei:

➜  printf $'System.out.println(java.lang.System.getProperty("java.runtime.version"));\n/exit\n' | jshell -s
-> System.out.println(java.lang.System.getProperty("java.runtime.version"))21+35-LTS
-> %

O que eu quero neste exemplo é apenas a 21+35-LTSparte de uma forma confiável e à prova do futuro.

Estou aberto a usar ferramentas disponíveis em uma imagem base do Ubuntu Slim ou no recente Java JDK.

EDIT: Não sou contra grep/sed em geral, desde que a solução seja à prova de futuro e funcione com diferentes fornecedores Java.

Em C++, eu marco uma função como noexceptnos seguintes casos:

A função em si não gera exceções, mas seus parâmetros de tipo de valor podem gerar exceções durante a construção.

O código a seguir demonstra essa situação:

struct A {
    A(bool will_throw) {
        std::cerr << "Ctor of A\n";
        if (will_throw) throw std::runtime_error("An exception from A");
    }
    A(A&& lhs) noexcept {
        std::cerr << "Move ctor of A\n";
    }
    ~A() noexcept = default;
};

struct B {
    A mem_;

    // Exceptions are thrown during parameter passing, not inside the function
    // Thus it isn't an UB I think.
    B(A value = A(true)) noexcept : mem_{std::move(value)} {/* do nothing */}
    ~B() noexcept = default;
};

Neste código, o construtor de Bé marcado como noexcept, e o A(true)construtor padrão pode lançar uma exceção, mas acredito que isso não leva a um comportamento indefinido, pois a exceção ocorre durante a passagem de parâmetros e não dentro do corpo da função.

O programa de teste está aqui .

Minha pergunta é:

Em casos semelhantes, é seguro marcar o construtor e outras funções com noexcept? Essa prática pode ser aplicada amplamente, especialmente em casos em que a função em si não lança nenhuma exceção?

Estou com dificuldade para entender o que o U-Boot e/ou Coreboot faz que um RISC-V SBI (Supervisor Binary Interface) não faz. Entendo que a função do SBI é abstrair recursos, mas não entendo o que precisa ser inicializado que um SBI não faz. Vi alguns exemplos (slide 9) dos tipos de processos de inicialização que você pode ter, mas não entendo por que qual deles é necessário em cada caso.

O processo de inicialização poderia ser?: ZSBL (Zero-Stage bootloader) -> SBI -> Kernel

E se for esse o caso, qual é o sentido de ter Coreboot ou U-Boot? Eu entendo que um bootloader de primeiro estágio pode precisar ser carregado na RAM estática primeiro para inicializar a RAM dinâmica e então mover para um SBI, mas qual seria o sentido de ter o SBI carregado no U-Boot depois do SBI então? Só para o gerenciador de boot?

No caso teórico de o RISC-V chegar ao mercado de PCs, qual seria uma configuração de inicialização rápida ideal?