All perguntas(coding)

Tenho um dataframe com três colunas: "a", "b" e "target".

Eu aplico uma função ("spreadcalc") em todo o dataframe que você pode ver abaixo no código. O que eu gostaria de fazer é minimizar o resultado da função para cada linha do dataframe alterando os valores nas colunas "a" e "b". Eu ficaria grato se você pudesse me ajudar. Muito obrigado.

Aqui está o código:

import numpy as np
from scipy.optimize import fsolve
import scipy.optimize as optimize

def spreadcalc(df):
    avrg = (df['a'] + df['b'])/2
    spr = (df['b'] - df['a'])/ avrg
    diff = df['target'] - spr
    return diff

optimize.minimize(spreadcalc) 

Como eu escrevo algo assim? No momento, usar dois pontos parece quebrar tudo. Existe um equivalente?

run-name: Something Running ${{  (inputs.cache-retain  == 'true') ? '(with forced cache-retain)' : ''}}

por exemplo

• se verdadeiro:'Something running (with forced cache-retain)'
• se falso:'Something running'

é o que estou procurando.

Estou tendo problemas em algumas condições nas minhas regras do firestore. No meu caso de uso, tenho 2 tipos de usuários com diferentes declarações personalizadas:

• Um usuário tem customerId e sites (matriz)
• Outro usuário tem customerIds

Meu plano é dar os seguintes acessos:

• Permitir consultas para Customers/{customerId} e coleções aninhadas se:

  • O usuário tem reivindicações personalizadas customerId == customerId (request.auth.token.customerId == customerId)
  • As declarações personalizadas do usuário customerIds contêm customerId (request.auth.token.customerIds.hasAny([customerId])

• Permitir consultas para Sites/{siteId} e coleções aninhadas se:

  • Os sites de declarações personalizadas do usuário contêm {siteId} e a variável do documento Sites⁄{sites} permissionsToView (matriz) deve conter o customerId das declarações personalizadas do usuário.
  • A variável do documento Sites⁄{sites} permissionsToView (array) deve conter as declarações personalizadas do usuário customerId.

Para a primeira permissão estabeleci as seguintes condições:

match /Customers/{customerId}/{document=**} {
      allow read, write: if isCustomerAccessible(customerId);
    }
function isCustomerAccessible(customerId) {
      return 
        request.auth.token.customerIds.hasAny([customerId]) ||
        request.auth.token.customerId == customerId ||
        request.auth.token.isSuper;
    }

Obter o documento específico permitido do lado do cliente é possível, mas fazer uma consulta que vai recuperar documentos permitidos retorna "permissão negada". O objetivo é permitir a coleta independente da consulta que está sendo executada.

Para a segunda condição fiz o seguinte:

match /Sites/{site}/{document=**} {
      allow read: if isSiteAccessibleView(site);
      allow write: if isSiteAccessibleEdit(site);
    }

function isSiteAccessibleView(site) {
      return request.auth != null && (
        request.auth.token.isSuper ||
        hasSiteViewPermission(site) ||
        hasSitePermissionThroughCustomerIds(site)
      );
    }
    
    function isSiteAccessibleEdit(site) {
      return request.auth != null && (
        request.auth.token.isSuper ||
        hasSiteEditPermission(site) ||
        hasSitePermissionThroughCustomerIds(site)
      );
    }

    function hasSiteViewPermission(site) {
      let siteDoc = get(/databases/$(database)/documents/Sites/$(site));
      let permissionValue = siteDoc.data.permissionsToView;
      return permissionValue.hasAny([request.auth.token.customerId]);
    }
    
    function hasSiteEditPermission(site) {
      let siteDoc = get(/databases/$(database)/documents/Sites/$(site));
      let permissionValue = siteDoc.data.permissionsToEdit;
      let sites = request.auth.token.sites;
      return permissionValue.hasAny([request.auth.token.customerId]) && sites.hasAny([site]);
    }

    function hasSitePermissionThroughCustomerIds(site) {
      let siteDoc = get(/databases/$(database)/documents/Sites/$(site));
      let permissionValue = siteDoc.data.permissionsToEdit;
      return request.auth.token.customerIds.hasAny(permissionValue);
    }

Ambas as condições devem dar acesso a todos os documentos das coleções aninhadas, porém não é permitido obter a coleção Customer/{customerId}/People com um usuário que tenha o customerId correto.

Para reproduzir use as seguintes regras:

rules_version = '2';
service cloud.firestore {
  match /databases/{database}/documents {
    match /Customers/{customerId}/{document=**} {
      allow read, write: if isCustomerAccessible(customerId);
    }
        function isCustomerAccessible(customerId) {
      return 
        request.auth.token.customerIds.hasAny([customerId]) ||
        request.auth.token.customerId == customerId ||
        request.auth.token.isSuper;
    }
  }
}

use um lado do cliente e faça login com um usuário. Este usuário deve ter a variável customerId dentro. Ao fazer uma consulta à coleção Customers (que retornará apenas documentos permitidos), ele retornará permissões negadas

const customersCollection = collection(db, "Customers")
    const customersQuery = query(
        customersCollection,
        where("tenantID", "==", tenantID)
    )
    const docs = await getDocs(customersQuery)

Eu uso redux toolkithá alguns anos e estou bem familiarizado com ele. Estou passando e tentando atualizar o código antigo usando a RTK Queryestratégia mais nova para substituir alguns dos meus antigos slicese thunks.

Se entendi a documentação corretamente, parece que o RTK Query foi criado para substituir amplamente a maneira antiga de fazer as coisas e, em vez de manter o estado "manualmente" em seus slices, você deixa o RTK Query cuidar do gerenciamento/armazenamento em cache e apenas solicita novamente os dados do slice da API que foi definido pelo RTK Query, e ele faz o resto automaticamente.

Supondo que isso esteja correto, como você seleciona dados que foram adicionados ao cache por uma mutação?

Especificamente, estou usando uma mutação para autenticar um usuário (este é o cenário de teste mais simples, então não há realmente nenhuma autenticação, nenhum token, etc.)

Parece que:

    loginUser: builder.mutation<UserServiceResult, UserCredentials>({
        query: ({ userName, password }) => ({
            url: '/authenticate',
            method: 'POST',
            body: { UserName: userName, Password: password },
        }),
    }),

No formulário de login, isso é usado assim:

    const [loginUser, { isLoading: isUpdating }] = useLoginUserMutation();
    loginUser(credentials).unwrap().then((userServiceResult) => {
        if (userServiceResult.isSuccessful) {
            console.log("Successfully logged in", userServiceResult);
            toast.success("User authenticated.", {position: "top-right"});
        } else {
            toast.error("User authentication failed.", {position: "top-right"});
        }
    })

Tudo isso está funcionando bem. Mas o layout principal está usando um seletor redux para verificar se o usuário existe na loja para mostrar o menu "logado" vs. o menu "convidado". Parece com isso:

const user = useAppSelector(selectUser); // then do stuff if user is not null

Qual é a estratégia para manter os dados contidos nas mutações da API?

Estou usando a versão mais recente do Visual Studio 17.13.5 e trabalhando com meu projeto está tudo bem, de repente me deparei com este erro:

O que eu fiz para tentar resolver esse problema:

1-Delete obj+bin folder and rebuild.
2-Changing   <HighDpiMode>false</HighDpiMode> in Application.myapp to true nothing helped.
3-Created a new project and copied the files and put in the new one.

Nada me ajudou! Mas também recebi alguns erros: Erro de ferramenta personalizada: Falha ao gerar arquivo: Há um erro no documento XML (11, 35).

Então estou confuso e não consigo encontrar nenhuma solução!

Há uma pergunta semelhante aqui no stackoverflow sobre como fazer isso quando todos são do mesmo tamanho, mas não quando são de tamanhos diferentes. Tenho 4 visualizações em um HStack que quero espaçar uniformemente, mas como o Picker é maior do que os outros 3, é impossível fazer isso usando o Spacer e, como agora são 4 em vez de 3, também não posso mais usar o alinhamento. Qual é a solução para garantir que todos sejam espaçados uniformemente?

import SwiftUI



    
    
    @EnvironmentObject var captureDelegate: CaptureDelegate
    let images = ["person.slash.fill", "person.fill", "person.2.fill", "person.2.fill", "person.2.fill"]
    @Binding var timerPress: Bool
    
    private var rotationAngle: Angle {
            switch captureDelegate.orientationLast {
            case .landscapeRight:
                return .degrees(90)
            case .landscapeLeft:
                return .degrees(-90)  // Fixes the upside-down issue
            default:
                return .degrees(0)
            }
        }
    
    var body: some View {
        HStack() {
            
            Image(systemName: "gearshape")
                .resizable()
                .frame(width: 25, height: 25)
                .foregroundStyle(captureDelegate.cameraPressed ? Color(white: 0.4) : .white  )
                .disabled(captureDelegate.cameraPressed)
                .rotationEffect(rotationAngle)
                .frame(maxWidth: .infinity, alignment: .leading)
                .onTapGesture {
                    if !captureDelegate.cameraPressed {
                        
                    }
                    
                }
            
            Image(systemName: "timer")
                .resizable()
                .frame(width: 25, height: 25)
                .foregroundStyle(captureDelegate.cameraPressed ? Color(white: 0.4) : .white  )
                .disabled(captureDelegate.cameraPressed)
                .rotationEffect(rotationAngle)
                .frame(maxWidth: .infinity)
                .onTapGesture {
                    if !captureDelegate.cameraPressed {
                        timerPress.toggle()
                    }
                    
                }
            

            
            Image(systemName: "timer")
                .resizable()
                .frame(width: 25, height: 25)
                .foregroundStyle(captureDelegate.cameraPressed ? Color(white: 0.4) : .white  )
                .disabled(captureDelegate.cameraPressed)
                .rotationEffect(rotationAngle)
                .frame(maxWidth: .infinity)
                .onTapGesture {
                    if !captureDelegate.cameraPressed {
                        timerPress.toggle()
                    }
                    
                }
            
              


            Picker("Pick a number of people", selection: $captureDelegate.userSelectedNumber) {
                    ForEach(0...4, id: \.self) { i in
                        HStack(spacing: 70) {
                            Image(systemName: self.images[i])
                                .resizable()
                                .frame(width: 20, height: 20)
                                .rotationEffect(rotationAngle)
 
                            Text("\(i)")
                                .font(.system(size: 42))
                                .rotationEffect(rotationAngle)
                            
                        }.tag(i)
                            .rotationEffect(rotationAngle)
                        
                    }
                    
                }
                .tint(.white)
                .clipped()
                .foregroundStyle(captureDelegate.cameraPressed ? Color(white: 0.4) : .white  )
                .disabled(captureDelegate.cameraPressed)
                .rotationEffect(rotationAngle)
                .animation(.easeInOut(duration: 0.5), value: rotationAngle)
                .frame(maxWidth: .infinity, alignment: .trailing)

        }
        .font(.system(size: 24))
        .padding([.leading,.trailing], 15)
    }
}

Tentei usar o espaçador, mas não funciona porque eles não são todos do mesmo tamanho. Quando eu tinha 3 visualizações, obtive sucesso usando o alinhamento à esquerda no centro e à direita, mas agora que há 4 visualizações, não funciona mais.

Aqui tentei usar um ZStack para posicioná-los, colocando as duas vistas centrais no mesmo HStack:

 ZStack {
            
            HStack {
                Image(systemName: "gearshape")
                    .resizable()
                    .frame(width: 25, height: 25)
                    .foregroundStyle(captureDelegate.cameraPressed ? Color(white: 0.4) : .white  )
                    .disabled(captureDelegate.cameraPressed)
                    .rotationEffect(rotationAngle)
                    .frame(maxWidth: .infinity, alignment: .leading)
                    .onTapGesture {
                        if !captureDelegate.cameraPressed {
                            
                        }
                        
                    }
                
                
                
                Picker("Pick a number of people", selection: $captureDelegate.userSelectedNumber) {
                    ForEach(0...4, id: \.self) { i in
                        HStack(spacing: 70) {
                            Image(systemName: self.images[i])
                                .resizable()
                                .frame(width: 20, height: 20)
                                .rotationEffect(rotationAngle)
                            
                            Text("\(i)")
                                .font(.system(size: 42))
                                .rotationEffect(rotationAngle)
                            
                        }.tag(i)
                            .rotationEffect(rotationAngle)
                        
                    }
                    
                }
                .tint(.white)
                .clipped()
                .foregroundStyle(captureDelegate.cameraPressed ? Color(white: 0.4) : .white  )
                .disabled(captureDelegate.cameraPressed)
                .rotationEffect(rotationAngle)
                .animation(.easeInOut(duration: 0.5), value: rotationAngle)
                .frame(maxWidth: .infinity, alignment: .trailing)
            }
            
            HStack {
               
                Text("\(captureDelegate.totalPhotosToTake)")
                    .font(.system(size: 15))
                    .foregroundStyle(.white)
                    .fontWeight(.bold)
                    .padding(.horizontal, 9)
                    .padding(.vertical, 5)
                    .overlay(
                        RoundedRectangle(cornerRadius: 5).stroke(.white, lineWidth: 2)
                    )
                    .frame(maxWidth: .infinity, alignment: .center)
                
                Image(systemName: "timer")
                    .resizable()
                    .frame(width: 25, height: 25)
                    .foregroundStyle(captureDelegate.cameraPressed ? Color(white: 0.4) : .white  )
                    .disabled(captureDelegate.cameraPressed)
                    .rotationEffect(rotationAngle)
                    .onTapGesture {
                        if !captureDelegate.cameraPressed {
                            timerPress.toggle()
                        }
                        
                    }
                    .frame(maxWidth: .infinity, alignment: .center)

              
            }
        
        }
        .font(.system(size: 24))
        .padding([.leading,.trailing], 15)

E mudar os alinhamentos das duas vistas centrais de central para teste e entrelinha produz este efeito:

org 0x7c00

BOOTDRIVE equ 0x9000

flatcode equ 0x0008                             
                                                
flatdata equ 0x0010                                 
                                                
flatstack equ 0x0010                                

[bits 16]

section .text

bspstart:
    
    xor ax,ax       ;some BIOS required
    
    mov ds,ax
    mov byte [BOOTDRIVE],dl
    
    mov ax,0x8000
    mov ss,ax
    mov sp,0

    mov cx,2000 ;80x25*2
    xor si,si
    mov di,1
    mov ax,0xb800
    mov ds,ax
    
cleanscreen:

    mov byte [ds:si],0x0
    add si,2
    mov byte [ds:di],0xf
    add di,2
    
    loop cleanscreen
    
    xor ax,ax
    mov ds,ax       ;restore ax to load GDTR
    
Read_Disk_INT0x13:  ;Read/Write Harddisk/Floppy provided by BIOS INT 0x13   ;cannot use in 32bits mode and 64bits mode
    
    mov ah,0x2  ;function ID 0x2 read_sector; 0x3 write_sector
    mov al,0x2  ;count of read/write sector
    mov ch,0x0  ;location(cylider)
    mov dh,0x0  ;location()
    mov cl,0x2  ;location(sector)
    mov byte dl,[BOOTDRIVE] ;type of drive(0x0~0x7f floppy drive;0x80~0xff hard drive)
    
    mov bx,0x0
    mov es,bx   ;es:bx target memory area 
    mov bx,0x7e00
    
    int 13h
    
    cli             ;after int 0x13 inst execute, the IF bit was enabled. we must to disable it.
    
    jc Read_Disk_Error
    
Read_Disk_OK:
    
    lgdt [GDT_PROP]
    
    in al,0x92
    or al,2
    out 0x92,al
    
    mov eax,0x1
    mov cr0,eax
    
    jmp dword flatcode:bsp_protected_mode_init_segreg

[bits 32]

bsp_protected_mode_init_segreg:

    mov ax,flatdata
    mov ds,ax
    mov ax,flatstack
    mov ss,ax
    
    mov esp,0x00200000
    
loadpage:

    mov eax,flatdata
    mov ds,eax
    mov es,eax
    mov esi,temp_pt
    mov edi,0x00100000
    mov ecx,temp_pt_end - temp_pt
    cld
    rep movsb
    
    mov esi,temp_pdt
    mov edi,0x00101000
    mov ecx,temp_pdt_end - temp_pdt
    cld
    rep movsb
    
    mov esi,temp_pdpt
    mov edi,0x00102000
    mov ecx,temp_pdpt_end - temp_pdpt
    cld
    rep movsb
    
    mov esi,temp_pml4
    mov edi,0x00103000
    mov ecx,temp_pml4_end - temp_pml4
    cld
    rep movsb

bsp_init_long_mode:
    
    call checkcpuid
    
    call checkia32e
    
    mov ax,flatdata
    mov ds,ax
    
    mov eax,0x20
    mov cr4,eax
    
    mov eax,0x00103000      ;pml4
    mov cr3,eax
    
    mov ecx,0xc0000080
    rdmsr
    or eax,1 << 8
    wrmsr
    
    cli
    
    mov eax,0x80000001
    mov cr0,eax
    
    jmp dword flatcode:bsp_long_mode
    
temp_pt:

    dq 0x00000000000b8001
    dq 0x00000000000b8001
    dq 0x0000000000000001
    dq 0x0000000000000001
    dq 0x0000000000000001
    dq 0x0000000000000001
    dq 0x0000000000104001   ;stack at 0x00104000
    dq 0x0000000000007001   ;bootloader
    
temp_pt_end:
    
temp_pdt:

    dq 0x0000000000100001
    
temp_pdt_end:
    
temp_pdpt:
    
    dq 0x0000000000101001
    
temp_pdpt_end:

temp_pml4:

    dq 0x0000000000102001
    
temp_pml4_end:

GDT_PROP:
    
    dw GDT_TABLE_32_END - GDT_TABLE_ENTRY_32 - 1
    dd GDT_TABLE_ENTRY_32
    
GDT_TABLE_ENTRY_32:

    dq 0x0000000000000000   ;Empty Entry
    
    dq 0x00cf9a000000ffff   ;code
    
    dq 0x00cf92000000ffff   ;data&stack
    
GDT_TABLE_32_END:

GDT_PROP_64:
    
    dw GDT_TABLE_64_END - GDT_TABLE_ENTRY_64 - 1
    dq GDT_TABLE_ENTRY_64

GDT_TABLE_ENTRY_64:

    dq 0x0000000000000000
    
    dq 0x00af9a000000ffff
    
    dq 0x00af92000000ffff
    
GDT_TABLE_64_END:


    
[bits 16]

BIOS_13H_ERROR:

    db 'PizzaLoader:(0x0) Disk Error! System Halted.'

Read_Disk_Error:
    
    mov ax,0x0
    mov ds,ax
    
    xor si,si
    
    mov bx,BIOS_13H_ERROR
    
    mov cx,44
    
Print_Disk_Error:
    
    mov dx,0x0
    mov ds,dx
    
    mov byte al,[ds:bx]         ;read BIOS_13H_ERROR
    add bx,1
    
    mov dx,0xb800
    mov ds,dx
    
    mov byte [ds:si],al         ;write 0xb8000
    add si,2
                     
    loop Print_Disk_Error
    
    jmp cpuhlt
    
cpuhlt:

    hlt
    
    
times 510 - ($ - $$) db  0x0

db 0x55, 0xaa

[bits 32]

NO_CPUID_ERROR:

    db 'PizzaLoader:(0x1)The Processor does not support CPUID instruction, System Halted.'

checkcpuid:
    
    pushfd
    pop eax
    
    mov ecx,eax
    
    xor eax,1<<21
    
    push eax
    popfd
    
    pushfd
    pop eax
    
    push ecx
    popfd
    
    xor eax,ecx
    jz nocpuid
    
    ret

nocpuid:
    
    mov ax,flatdata
    mov ds,ax
    
    mov esi,0x000b8000
    
    mov ebx,NO_CPUID_ERROR
    
    mov ecx,81
    
Print_no_CPUID_Error:
    
    mov byte al,[ebx]           ;read NO_CPUID_ERROR
    add ebx,1
    
    mov byte [esi],al           ;write 0xb8000
    add esi,2
                     
    loop Print_no_CPUID_Error
    
    hlt
    
NO_IA32E_ERROR:

    db 'PizzaLoader:(0x2)The Processor does not support 64-bits mode, System Halted.'
    
checkia32e:

    mov eax, 0x80000000    ; Set the A-register to 0x80000000.
    cpuid                  ; CPU identification.
    cmp eax, 0x80000001    ; Compare the A-register with 0x80000001.
    jb noia32e             ; It is less, there is no long mode.
    ret
    
noia32e:

    mov ax,flatdata
    mov ds,ax
    
    mov esi,0x000b8000
    
    mov ebx,NO_IA32E_ERROR
    
    mov ecx,76
    
Print_no_IA32E_Error:
    
    mov byte al,[ebx]           ;read NO_CPUID_ERROR
    add ebx,1
    
    mov byte [esi],al           ;write 0xb8000
    add esi,2
                     
    loop Print_no_IA32E_Error
    
    hlt

[bits 64]

bsp_long_mode:
    
    lgdt [GDT_PROP_64]
    
    mov rax,flatdata
    mov ds,rax
    mov ss,rax
    mov sp,0x00006000
    
    call Load_Kernel
    
    hlt
    
Load_Kernel:
    
    mov rsi,0x00000000
    
    mov rbx,loading_kernel_Message
    
    mov rcx,21
    
Print_Loading_Kernel_Message:
    
    mov byte al,[rbx]           ;read message
    
    add rbx,1
    
    mov byte [rsi],al           ;write 0x000b8000
    add rsi,2
                     
    loop Print_Loading_Kernel_Message

    ret
    
loading_kernel_Message:

    db 'Loading Mio Kernel...'
    
[bits 64]

restart:
    
    mov dx,0xcf9
    mov al,0xe
    out dx,al

Aqui estão meus códigos completos e o resultado final é este:

Kn’chmf?Lhn?Jdqmdk———

A saída de texto tem códigos ASCII 1 abaixo do que deveriam estar, então, 1 letra antes no alfabeto. Deve ser "Carregando..."

Olá, tenho uma implementação de classe de pilha na linguagem C++ usando uma lista encadeada simples. O código também contém operações como construtor, destrutor, pop, push, top, exibindo as pilhas e verificando se uma pilha está vazia ou não. Além disso, há uma parte para exibir interseção, união e diferença de duas pilhas usando essas operações listadas. Embora as partes de interseção e união funcionem bem no código e forneçam a saída desejada, há um problema com a exibição da diferença de duas pilhas que não consegui descobrir. Para esta parte, quero exibir elementos que S1 tem e S2 não tem. Eu agradeceria se você pudesse me ajudar.

Aqui estão minhas duas pilhas:

S1 = {maçã, banana, cereja}

S2 = {banana, cereja, tâmara}

Saída esperada para diferença:

S5 (Diferença) = {maçã}

Mas em vez disso, estou recebendo esta saída:

S5 (Diferença) = {maçã, banana, cereja}

#include <iostream>
#include <string>
using namespace std;

// Node structure for singly linked list
struct Node {
    string data;
    Node* next;
};

// Stack class implementation using singly linked list
class Stack {
private:
    Node* top;

public:
    // Constructor
    Stack() : top(nullptr) {}

    // Destructor
    ~Stack() {
        while (!isEmpty()) {
            pop();
        }
    }

    // Push operation
    void push(const string& data) {
        Node* newNode = new Node{data, top};
        top = newNode;
    }

    // Pop operation
    string pop() {
        if (isEmpty()) {
            cout << "Stack is empty!" << endl;
            return "";
        }
        string data = top->data;
        Node* temp = top;
        top = top->next;
        delete temp;
        return data;
    }

    // Top operation
    string getTop() const {
        if (isEmpty()) {
            return "";
        }
        return top->data;
    }

    // Display all elements in the stack
    void displayStack() const {
        Node* current = top;
        while (current) {
            cout << current->data << " ";
            current = current->next;
        }
        cout << endl;
    }

    // Check if stack is empty
    bool isEmpty() const {
        return top == nullptr;
    }

    // Find operation
    bool find(const string& data) const {
        Node* current = top;
        while (current) {
            if (current->data == data) {
                return true;
            }
            current = current->next;
        }
        return false;
    }
};

// Function to compute intersection of two stacks
Stack intersection(Stack& s1, Stack& s2) {
    Stack result;
    Stack temp;  // Temporary stack to preserve s1 during traversal

    while (!s1.isEmpty()) {
        string element = s1.pop();
        temp.push(element);
        if (s2.find(element)) {
            result.push(element);
        }
    }

    // Restore original stack s1
    while (!temp.isEmpty()) {
        s1.push(temp.pop());
    }

    return result;
}

// Function to compute union of two stacks
Stack unionStacks(Stack& s1, Stack& s2) {
    Stack result;

    Stack temp;  // Temporary stack to preserve s1 during traversal

    while (!s1.isEmpty()) {
        string element = s1.pop();
        temp.push(element);
        result.push(element);
    }

    // Restore original stack s1
    while (!temp.isEmpty()) {
        s1.push(temp.pop());
    }

    while (!s2.isEmpty()) {
        string element = s2.pop();
        if (!result.find(element)) {  // Avoid duplicate entries
            result.push(element);
        }
    }

    return result;
}

Stack difference(Stack& s1, Stack& s2) {
    Stack result;

    Stack temp;  // Temporary stack to preserve s1 during traversal

    while (!s1.isEmpty()) {
        string element = s1.pop();
        temp.push(element);
        if (s2.find(element)) {
            continue;
        }
        else {
            result.push(element);
        }
    }

    // Restore original stack s1
    while (!temp.isEmpty()) {
        s1.push(temp.pop());
    }

    return result;
}

// Main function to test functionality
int main() {
    Stack s1, s2;

    // Push elements into stacks S1 and S2
    s1.push("apple");
    s1.push("banana");
    s1.push("cherry");

    s2.push("banana");
    s2.push("cherry");
    s2.push("date");

    cout << "Stack S1: ";
    s1.displayStack();

    cout << "Stack S2: ";
    s2.displayStack();

    // Intersection of S1 and S2
    Stack s3 = intersection(s1, s2);
    cout << "Intersection (S3): ";
    s3.displayStack();

    // Union of S1 and S2
    Stack s4 = unionStacks(s1, s2);
    cout << "Union (S4): ";
    s4.displayStack();
    
    // Difference of S1 and S2
    Stack s5 = difference(s1, s2);
    cout << "Difference (S5): ";
    s5.displayStack();

    return 0;
}

Para encontrar os elementos que S1 tem e S2 não (é isso que estou tentando fazer), tentei colocar os elementos em outra pilha.

Ao usar @EntityScantodas as entidades no basePackages especificado, elas são selecionadas pelo scan. Por certos motivos , gostaríamos de evitar isso.

Tivemos a ideia de substituir a @EntityScananotação pela configuração manual para incluir apenas classes de entidade específicas, em vez de todas as entidades do pacote, chamando factoryBean.setManagedTypes(managedTypes).

Há uma postagem de baeldung que vai nessa direção, mas o foco não está na configuração de managedTypes únicos.

Na verdade, ficamos surpresos por não termos encontrado nenhuma postagem de blog, pergunta do stackoverflow, etc. que tratasse da questão "É possível configurar o @EntityScan ou uma alternativa para rastrear apenas classes únicas, não pacotes completos?".

Há algum problema ou desvantagem em fazer isso em um aplicativo Spring Boot?

O javadoc de LocalContainerEntityManagerFactoryBean.setManagedTypeseven diz:

Defina o PersistenceManagedTypes a ser usado para criar a lista de tipos gerenciados como uma alternativa à varredura de entidades. -- https://docs.spring.io...orm/jpa/LocalContainerEntityManagerFactoryBean

Criei um projeto de exemplo para demonstrar a ideia: https://github.com/frankkriegl-zero/jpa-managed-types-sample/tree/stackoverflow-question-79541611

Da classe de configuração JpaConfig :

@Configuration
public class JpaConfig {

List<String> sharedManagedEntityClassNames = Stream.of(
            external.model.Book.class // located in a 'remote' package, outside of org.example.bookstore
    ).map(Class::getName).toList();

List<String> managedEntityPackages = List.of(
            "org.example.bookstore.model"
    );

@Bean(name = "persistenceManagedTypes")
PersistenceManagedTypes persistenceManagedTypes(ResourceLoader resourceLoader) {
    var scanResult = new PersistenceManagedTypesScanner(resourceLoader)
            .scan(managedEntityPackages.toArray(new String[0]));

    // merge the shared managed entity class names with the scanned ones
    List<String> managedClassNames = new ArrayList<>();
    managedClassNames.addAll(sharedManagedEntityClassNames);
    managedClassNames.addAll(scanResult.getManagedClassNames());

    return PersistenceManagedTypes.of(managedClassNames, Collections.emptyList());
}

// entityManagerFactoryBean

}

É assim que substituímos o bean entityManagerFactory:

@Bean(name = "entityManagerFactory")
public EntityManagerFactory entityManagerFactory(DataSource dataSource,
                                                 PersistenceManagedTypes managedTypes) {
    LocalContainerEntityManagerFactoryBean factoryBean = new LocalContainerEntityManagerFactoryBean();
    factoryBean.setDataSource(dataSource);
    factoryBean.setJpaVendorAdapter(new HibernateJpaVendorAdapter());

    factoryBean.setManagedTypes(managedTypes); // alternative to @EntityScan and @EnableJpaRepositories

    factoryBean.afterPropertiesSet();
    return factoryBean.getObject();
}

Não nos sentimos muito confiantes em criar nosso próprio bean emFactory, pois este é a espinha dorsal de toda lógica relacionada ao JPA em um aplicativo baseado em JPA:

1. Não temos certeza se isso poderia criar um esforço de manutenção adicional caso as implementações do framework (Spring Boot ou Hibernate) mudassem aqui.
2. Como esse é um componente crítico com configurações bastante complexas, temos um certo medo de ignorar algo e quebrar a camada de persistência do aplicativo.

Algum conselho ou experiência com o uso setManagedTypes(PersistenceManagedTypes)em vez de @EntityScan?

Obrigado!

Estou tentando implementar um scrubber discreto com marcações de texto no SwiftUI da seguinte forma. Meu problema é que não consigo determinar a altura do HStackinterior do ScrollViewapriori, então tentei usar onGeometryChangeo modificador, mas não funciona (ou seja, o texto de sobreposição é truncado). Uma maneira de consertar é usando GeometryReadere atribuindo a altura de HStackcom base no proxy de geometria, mas quero saber se há outra maneira de sair sem usar GeometryReader.

struct ScrollScrubber: View {
    var config:ScrubberConfig
    
    @State var viewSize:CGSize?
    
    var body: some View {
        let horizontalPadding = (viewSize?.width ?? 0)/2
        
        ScrollView(.horizontal) {
            HStack(spacing:config.spacing) {
                let totalSteps = config.steps * config.count
                
                ForEach(0...totalSteps, id: \.self) { index in
                    let remainder = index % config.steps
                    Divider()
                        .background( remainder == 0 ? Color.primary : Color.gray)
                        .frame(width: 0, height: remainder == 0 ? 20 : 10, alignment: .center)
                        .frame(maxHeight: 20, alignment: .bottom)
                        .overlay(alignment: .bottom) {
                            if remainder == 0 {
                                Text("\(index / config.steps)")
                                    .font(.caption)
                                    .fontWeight(.semibold)
                                    .textScale(.secondary)
                                    .fixedSize()
                                    .offset(y:20)
                            }
                        }
                    
                }
            }
            .frame(height:viewSize?.height)
            
        }
        .scrollIndicators(.hidden)
        .safeAreaPadding(.horizontal, horizontalPadding)
        .onGeometryChange(for: CGSize.self) { proxy in
            proxy.size
        } action: { newValue in
            viewSize = newValue
            print("View Size \(newValue)")
        }


    }
}

struct ScrubberConfig:Equatable {
    var count:Int
    var steps:Int
    var spacing:CGFloat
}

#Preview {
    ScrollScrubber(config: .init(count: 100, steps: 5, spacing: 5.0))
        .frame(height:60)
}