All perguntas(coding)

Estou tentando implementar o modelo usando uma função globalmente sobrecarregada para executar ações personalizadas por assinatura. Como pode haver um grupo de tipos (por exemplo, tipos numéricos) com uma implementação semelhante, tentei usar conceitos para cobri-lo, mas tropecei no problema em que o compilador não vê a definição com conceito sem instanciação explícita.

MSVC 17.13.0 (/std:c++latest)

// my.hpp
template <typename value_type>
void bar(value_type value);

template <typename value_type>
void foo(value_type value)
{
    bar<value_type>(value);
}

// my.cpp
#include "my.hpp"
#include <print>
#include <type_traits>

template<std::integral value_type>
void bar(value_type value)
{
    std::println("bar(integral[{}])", value);
}

int main()
{
    //bar(5);
    foo(6);
}

O programa acima não é compilado porque o vinculador não vê bara definição de :

símbolo externo não resolvido "void __cdecl bar(int)" (??$bar@H@@YAXH@Z) referenciado na função "void __cdecl foo(int)" (??$foo@H@@YAXH@Z)

Porém, se eu descomentar a linha bar(5);em main(), isso obviamente instanciará o modelo restrito ao conceito, e o resultado será adequado (mas com saída extra da chamada direta bar(5)):

barra(integral[5])

barra(integral[6])

Existe um padrão comum para resolver tal tarefa? Basicamente, eu quero que o template que recebe o tipo seja capaz de encontrar a definição adequada da função template em si, void bar<int>no meu caso.

Em C++, você pode herdar todos os construtores de uma classe base escrevendousing Baseclass::Baseclass

Minha Baseclass tem um construtor padrão e outro que aceita um argumento int, embora este realmente não importe neste caso.

Mas por razões que não entendo, o construtor padrão herdado de alguma forma "desaparece" no momento em que tento adicionar meu próprio construtor à classe derivada. Por que isso acontece e qual é a melhor solução para contornar isso?

Considere o seguinte trecho de código:

#include <iostream>
#include <string>
using std::cout;

struct Base
{
  Base() {};
  Base(int i)
  {
    cout << i << " was called";
  };
};

struct GoodDaughter : public Base
{
  using Base::Base;
};

struct EvilSon : public Base
{
  using Base::Base;

  EvilSon(std::string q) {}; //define ANOTHER constructor
};

void testFamily()
{
  Base b;
  GoodDaughter g1; //compiles
  EvilSon e1;      //somehow doesn't compile, complains about no default constructor existing


  GoodDaughter g2(1); //compiles
  EvilSon e2(1);      //compiles, which means that other constructor still got inherited.
}

A mensagem de erro é:

<source>(30): error C2512: 'EvilSon': no appropriate default constructor available
<source>(19): note: see declaration of 'EvilSon'

Estou usando a versão mais recente do MSVC 19. Algumas pessoas descobriram que outros compiladores, como o gcc, não davam esse erro

Estou trabalhando em um projeto antigo C# .NET 4.8 para minha empresa. Ele usa ScintillaNET 2.2.7895.17875 para criar um editor de código personalizado.

Há uma seta suspensa (destacada em vermelho na minha imagem anexada) que exibe uma lista de documentos abertos. Quando seleciono um nome de arquivo da lista, o arquivo correspondente é exibido. No entanto, às vezes essa seta não aparece até que eu redimensione a janela, depois disso ela se torna visível.

Não consigo encontrar o código responsável por esse menu suspenso e como ele recupera a lista de arquivos. Também preciso investigar por que a seta às vezes não é exibida corretamente.

Alguém tem alguma ideia de onde procurar ou como consertar esse problema? Qualquer ajuda seria muito apreciada!

Estou tentando adicionar autenticação ao meu aplicativo de funções do Azure antes de permitir que solicitações sejam processadas.

Para evitar o manuseio manual da tokenização, tentei configurar o Provedor de Identidade para meu Aplicativo de Função.

O que fiz até agora: Criei um registro de aplicativo com as seguintes configurações:

Página de autenticação:

Permissões da API:

Expor uma API

Provedor de identidade

O problema: quando tento testar ou executar minha função, recebo um erro 401 Unauthorized. Eu esperava que o Identity Provider lidasse com a autenticação automaticamente. No entanto, quando clico no domínio padrão, ele não solicita autorização. Em vez disso, uma nova janela é aberta com as seguintes telas:

Observações adicionais:

Se eu navegar manualmente até https://func-myfunc-01.azurewebsites.net/.auth/login/aad/callback, a autenticação funciona e sou autorizado com sucesso.

Meu objetivo:

Quero que os usuários sejam solicitados a autenticar antes de acessar a URL da Função. Uma vez autenticados, eles devem conseguir executar a função.

O que estou fazendo errado? Qualquer orientação seria muito apreciada.

Obrigado!

Li os documentos e muitas postagens (aqui e em outros lugares) sobre este assunto sem nenhuma alegria até agora

É um aplicativo TypeScript Electron criado com o aplicativo Electron-Vite , desenvolvido no VS Code

// package.json

"scripts": {
    "dev": "electron-vite dev -w",

Ele inicia através do seu main.tsarquivo

// main.ts

imports here...

console.log('main start');

const ipcListener = new IpcListener<IpcHandlerEvents>();
const ipcEmitter = new IpcEmitter<IpcRendererEvents>();

O main.tsarquivo cria o BrowserWindow e com um arquivo de pré-carregamento

const mainWindow = new BrowserWindow({
  show: false,
  autoHideMenuBar: true,
  webPreferences: {
    preload: join(__dirname, '../preload/preload.js'),
    sandbox: process.env.NODE_ENV !== 'test',
  },
});

E preload.tscomeça de forma semelhante amain.ts

// preload.ts

imports here...

console.log('preload start');

if (process.contextIsolated) {
    try {

O principal index.tsxno processo de renderização então começa

// index.tsx

imports here...

console.log('index start');

Que preenche o conteúdo via createRoot

createRoot(document.getElementById('root') as HTMLElement).render(
  <StrictMode>
    <RouterProvider
      router={createHashRouter(getRoutesConfig(store), {
        future: {
          v7_relativeSplatPath: true,
          v7_fetcherPersist: true,
          v7_partialHydration: true,
          v7_skipActionErrorRevalidation: true,
          v7_normalizeFormMethod: true,
        },
      })}
      future={{ v7_startTransition: true }}
    />
  </StrictMode>

Finalmente exibindo root.tsxcomo a, bem, raiz do aplicativo. Com um limite de erro

console.log('root start')

return (
  <ReduxProvider store={store}>
    <ErrorBoundary>
      <App />
    </ErrorBoundary>
  </ReduxProvider>
);

Quando um erro é lançado, o limite de erro: armazena o estado atual; então informa o processo principal

localStorage.setItem('storeToLoad', JSON.stringify(state));

window.electron.ipcRenderer.send('ERROR_IN_WINDOW', {
  error,
  errorInfo,
});

Que por sua vez tenta reiniciar o aplicativo após sair

// main.ts

ipcListener.on('ERROR_IN_WINDOW', (_, args: unknown) => {
  console.log('error in window - relaunch');
  app.relaunch();
  app.exit();
});

Então, quando alguém executa o aplicativo pela primeira vez, este log é mostrado

// in VS Code terminal
main start

// in app console
preload start
index start
root start

Mas quando um erro é lançado e o aplicativo é 'reiniciado' (cof cof), isso é o que é mostrado

// in VS Code terminal
AB C:\development\AppDir\App> (ie: the process ends) 

// in app console
preload start

E o aplicativo reiniciado é apenas um retângulo branco

Obviamente esse não é o resultado desejado. Alguma ideia de como eu poderia chegar ao resultado desejado (pls, obg)?

Eu estava tentando resolver a questão 128 do LeetCode. Maior sequência consecutiva :

Dado um array não classificado de inteiros nums, retorne o comprimento da maior sequência de elementos consecutivos .

Você deve escrever um algoritmo que seja executado no O(n)tempo.

Exemplo 1:

Entrada: nums = [100,4,200,1,3,2]
Saída: 4
Explicação: A sequência de elementos consecutivos mais longa é [1, 2, 3, 4]. Portanto, seu comprimento é 4.

Restrições:

• 0 <= nums.length <= 105
• -109 <= nums[i] <= 109

Minha primeira tentativa fez classificação seguida de contagem. Isso tem complexidade de tempo O(nlogn), mas surpreendentemente me deu 93,93% de percentil para complexidade de tempo (40ms).

Então reli a questão e percebi que a resposta deve estar em complexidade de tempo O(n). Então escrevi o seguinte código:

def longestConsecutive(self, nums: List[int]) -> int:
        s = set(nums)
        longest_streak = 0
        
        for num in nums:
            if (num - 1) not in s:
                current_streak = 1
                while (num + 1) in s:
                    num += 1
                    current_streak += 1
                longest_streak = max(longest_streak, current_streak)
            
        return longest_streak

(Eu sei, não é uma boa prática reutilizar o nome da variável num no loop aninhado, mas isso não vem ao caso. Eu testei usando uma variável separada também com o mesmo resultado abaixo)

Embora isso devesse teoricamente ter complexidade de tempo O(n), mais rápido que minha primeira solução, isso na verdade resultou em limite de tempo excedido para alguns casos e meu código foi rejeitado.

Acabei enviando uma solução de aprovação após consultar a solução

class Solution:
    def longestConsecutive(self, nums: List[int]) -> int:
        nums = set(nums)
        longest_streak = 0
        
        for num in nums:
            if (num - 1) not in nums:
                next_num = num + 1
                while next_num in nums:
                    next_num += 1
                longest_streak = max(longest_streak, next_num - num)
            
        return longest_streak

onde identifiquei 2 diferenças principais:

1. Reatribuí nums a um conjunto no local em vez de uma nova variável
2. Usei next_num em vez de manter uma variável current_streak

No entanto, ambas as mudanças não parecem ter impacto significativo no tempo de execução, o suficiente para cruzar a linha entre o limite de tempo excedido e uma solução de passagem. Para me confundir ainda mais, essa solução O(n) ainda teve um desempenho pior do que minha solução de classificação, classificando-se apenas no percentil 75,73% (46 ms).

Então minhas perguntas são:

1. Por que um algoritmo O(nlogn) tem desempenho mais rápido que O(n) na prática?
2. Por que meu primeiro algoritmo O(n) é tão lento que atingiu o limite de tempo excedido, enquanto meu segundo algoritmo com alterações mínimas conseguiu passar?

Sou novo na Biblioteca de Gramática de Recursos do GF, mas gostaria de modelar expressões temporais como "ano até a data" e suas variantes ("ano até a data", "ano até agora", "anual", etc.).

Qual parte do discurso seria "ano até a data" e como posso representar "ano até a data" no RGL do GF? "Ano até a data" deve ser um AP, Adv ou uma categoria diferente?

Esta foi minha primeira tentativa:

oper YearToDate : AP = mkAP (mkA "year-to-date") ;  

Mas o problema é que isso codifica a frase "year-to-date" como uma string. Isso significa que seus componentes não são modificáveis ​​("month to date") e não tenho certeza de como contabilizar todas as variantes.

Estou fazendo algumas simulações de física usando jax, e isso envolve uma função chamada Hamiltoniano, definida da seguinte forma:

# Constructing the Hamiltonian
@partial(jit, static_argnames=['n', 'omega'])
def hamiltonian(n: int, omega: float):
    """Construct the Hamiltonian for the system."""
    H = omega *  create(n) @ annhilate(n)
    return H 

e então uma função maior def solve_diff(n, omega, kappa, alpha0):que é definida da seguinte forma:

@partial(jit, static_argnames=['n', 'omega'])
def solve_diff(n, omega, kappa, alpha0):
    # Some functionality that uses kappa and alpha0
    
    H = hamiltonian(n, omega)

    # returns an expectation value

Quando tento calcular o gradiente desta função usando jax.grad

n = 16   
omega = 1.0   
kappa = 0.1  
alpha0 = 1.0 

# Compute gradients with respect to omega, kappa, and alpha0
grad_population = grad(solve_diff, argnums=(1, 2, 3))
grads = grad_population(n, omega, kappa, alpha0)

print(f"Gradient w.r.t. omega: {grads[0]}")
print(f"Gradient w.r.t. kappa: {grads[1]}")
print(f"Gradient w.r.t. alpha0: {grads[2]}")

ele gera o seguinte erro:

ValueError: Non-hashable static arguments are not supported. An error occurred while trying to hash an object of type <class 'jax._src.interpreters.ad.JVPTracer'>, Traced<ShapedArray(float32[], weak_type=True)>with<JVPTrace> with
  primal = 1.0
  tangent = Traced<ShapedArray(float32[], weak_type=True)>with<JaxprTrace> with
    pval = (ShapedArray(float32[], weak_type=True), None)
    recipe = LambdaBinding(). The error was:
TypeError: unhashable type: 'JVPTracer'

Porém, rodando solve_diff(16,1.0,0.1,1.0)sozinho funciona como esperado.

Agora, se eu remover omegada lista de variáveis ​​estáticas tanto a hamiltonianfunção quanto o solve_diff, o grad será gerado conforme o esperado.

Isso está me confundindo, porque não sei mais o que se qualifica como variáveis ​​estáticas ou dinâmicas, a partir da definição de que variáveis ​​estáticas não mudam entre chamadas de função, ambas ne omegasão constantes e, de fato, não devem mudar entre chamadas de função.

Tenho um bloco PL/SQL onde eu:

1. Declare e inicialize uma coleção (TABLE OF my_table.key%TYPE).
2. Use um SYS_REFCURSOR para COLETAR chaves em massa na coleção.
3. Imprima lst.COUNT, que mostra 0.
4. Execute um loop FORALL para atualizar linhas em my_table com base nas chaves coletadas.
5. Imprima SQL%ROWCOUNT, que inesperadamente mostra 1 linha atualizada.

    DECLARE  
      TYPE t_list IS TABLE OF my_table.key%TYPE;  
      lst t_list := t_list();  
      cur SYS_REFCURSOR;  
      var NUMBER; -- Holds sequence value  
    
    BEGIN  
      -- Assign sequence value  
      var := my_sequence.NEXTVAL;  
    
      -- Open and fetch cursor  
      OPEN cur FOR  
        SELECT key FROM my_table WHERE some_conditions;  
    
      FETCH cur BULK COLLECT INTO lst;  
      CLOSE cur;  
    
      -- Debug output  
      DBMS_OUTPUT.PUT_LINE('lst.COUNT: ' || lst.COUNT); -- Prints 0  
    
      -- FORALL update  
      FORALL I IN 1..lst.COUNT  
        UPDATE my_table  
        SET col = SYSDATE  
        WHERE key = lst(I)  
        AND status = 'A';  
    
      DBMS_OUTPUT.PUT_LINE('SQL%ROWCOUNT: ' || SQL%ROWCOUNT); -- Prints 1  
    
    END;

Observações e problemas:

• lst.COUNT = 0, então FORALL não deve ser executado.
• Entretanto, SQL%ROWCOUNT mostra 1 linha atualizada em vez de 0.
• Se eu remover a atribuição sequence.NEXTVAL, SQL%ROWCOUNT mostra corretamente 0.

Questões:

1. Por que SQL%ROWCOUNT mostra 1 mesmo quando FORALL não é executado?
2. sequence.NEXTVAL afeta SQL%ROWCOUNT de alguma forma?
3. Como posso garantir que SQL%ROWCOUNT reflita corretamente apenas a atualização FORALL?

Versões: faces 2.2 Biblioteca JavaScript Faces Mojarra Faces 4.0.7

Liguei Primefaces.CSP em web.xml. E gera nonce-s para js.

Encontrei alguns xhtml onde faces.js violou (unsafe-inline)

Recusou-se a executar o script inline porque ele viola a seguinte diretiva da Política de Segurança de Conteúdo: "script-src 'self'

if (!!script) {
    var scriptNode = document.createElement("script");
    scriptNode.type = "text/javascript";
    scriptNode.text = script;
    head.appendChild(scriptNode); //this violates
    head.removeChild(scriptNode)
}

Como posso usar Primefaces.CSP e faces.js juntos com segurança?