All perguntas(coding)

O padrão exige que isso operator->()seja definido para iteradores não contíguos do tipo past-the-end?

Fundo:

• Independentemente da categoria do iterador, é permitido operator*()exibir comportamento indefinido quando o iterador aponta para o passado-do-fim. Isso é explícito em https://en.cppreference.com/w/cpp/iterator , seção "Desreferenciabilidade e validade", que diz: "Valores de um iterador i para os quais a expressão *i é definida são chamados desreferenciáveis. A biblioteca padrão nunca assume que valores passado-do-fim são desreferenciáveis."
• EDIT: A conclusão neste tópico está errada: veja minha resposta abaixo. Para iteradores contíguos , acredito que não é permitido operator->()exibir comportamento indefinido quando o iterador aponta para o passado-do-fim. Isso pode ser inferido de duas seções em cppreference: (1) Em https://en.cppreference.com/w/cpp/iterator/contiguous_iterator , a seção "Requisitos semânticos" define o iterador não desreferenciável ce estabelece requisitos para std::to_address(c)os quais implica que std::to_address(c)não exibe comportamento indefinido. (2) em https://en.cppreference.com/w/cpp/memory/to_address, ele fornece uma "Possível implementação" onde std::to_addressdepende de operator->(). EDIT: A "possível implementação" não usa operator->()caso pointer_traitsseja definida para o iterador; se for esse o caso, parece permitido operator->()não ser definida para iteradores finais.

É menos claro se iteradores não contíguos podem implementar operator->()de forma que seu comportamento seja indefinido para iteradores que terminam no final. Aqui estão várias "evidências"/"dicas" que encontrei relacionadas a isso:

• Conceitos de iteradores C++20 não contíguos parecem não exigir que isso operator->()seja definido. Isso simplesmente não é mencionado entre todos os requisitos definidos em https://en.cppreference.com/w/cpp/iterator/random_access_iterator , ou os requisitos dos quais dependem, AFAICS.
• O conceito de iterador contíguo em C++20, std::contiguous_iterator, requer operator->(): como mencionado acima, isso pode ser inferido, pois std::to_addressdeve ser definido, e a "Possível implementação" para std::to_addressusos operator->(). E a página https://en.cppreference.com/w/cpp/memory/to_address menciona explicitamente std::contiguous_iterator. Como não menciona outros tipos de iteradores, isso não implica nada para iteradores não contíguos, se bem me lembro.
• As categorias de iteradores legados exigem que operator->()seja definido para LegacyInputIteratore mais forte (veja a tabela em https://en.cppreference.com/w/cpp/named_req/InputIterator ) e isso é qualificado pela "Pré-condição: i é desreferenciável". Em outras palavras, há uma exceção explícita que permite que iteradores que terminam no passado exibam comportamento indefinido. Não vejo essa pré-condição removida para nenhuma das categorias de iteradores legados mais fortes (a propósito, nem mesmo https://en.cppreference.com/w/cpp/named_req/ContiguousIterator , então isso parece uma diferença entre LegacyContiguousIteratore std::contiguous_iterator).
• Por outro lado, em https://en.cppreference.com/w/cpp/iterator , seção "Desreferenciabilidade e validade", menciona-se que ______ operator*()não precisa ser definido para iteradores que terminam no passado, mas não menciona _______ operator->(). Portanto, isso pode sugerir que a exceção que permite que algumas operações em iteradores que terminam no passado sejam indefinidas não se aplica necessariamente a operator->()_______.

Portanto, é fácil se confundir, e vejo bastante "evidência"/"dicas" relacionadas a iteradores não contíguos, operator->()e passado-do-fim. Mas não há nenhum requisito explícito, até onde consegui encontrar, que determine se iteradores não contíguos podem exibir comportamento indefinido quando operator->()o iterador aponta para passado-do-fim. Alguém tem uma resposta mais definitiva?

Editar : Obrigado por vários comentários úteis. Para dar um contexto, possivelmente respondendo a algumas das respostas: O lado prático, um pouco simplificado, é que eu defini wrappers de iteradores , ou seja, classes de iteradores personalizadas cuja implementação depende de um iterador existente ("encapsulado"). O tipo do iterador encapsulado é fornecido como um parâmetro de modelo e o iterador encapsulado é fornecido como um argumento do construtor. Eu, descuidadamente, presumi que poderia definir operator->()na classe encapsuladora como &*wrapped_iterator. Isso funcionou no clang, gcc, na compilação de lançamento do MSVC e até mesmo na compilação de depuração do MSVC para iteradores não contíguos. No entanto, resultou em falhas de asserção na compilação de depuração do MSVC para iteradores contíguos, em funções como std::vector::assign(first,last)onde first e last são wrappers em torno de iteradores contíguos e first e last são ambos iteradores passados ​​do fim. O motivo foi que o MSVC vector::assigninvoca std::address_of(first) even if first==last , o que eu não previ. Por sua vez, address_ofinvocado first.operator->()para o meu wrapper de iterador contíguo. Como eu havia definido operator->()como &*wrapped_iterator, ele invoca operator*o iterador encapsulado cujo comportamento sob as condições fornecidas é indefinido. Neste caso específico, resultou em uma falha de asserção, porque o modo de depuração do MSVC tem um código especial que verifica coisas como esta ( _ITERATOR_DEBUG_LEVEL).

Então, preciso alterar a implementação de operator->(). no meu wrapper de iterador. Minha primeira ideia era fazer com que ele invocasse operator->()o iterador encapsulado. No entanto, não há garantia de que isso seja definido (veja a resposta aceita). O que preciso fazer é invocar std::to_addresso iterador encapsulado.

Estou usando MenuModule o Primeng

O modelo dentro do Menu é do tipo sinal

E é retirado do serviço

Agora, quando o serviço é chamado e o modelo é preenchido, este erro é exibido

ERROR TypeError: Cannot read properties of null (reading 'offsetHeight')

//Código HTML

<h1 (click)="statusDispacherClick(213 , $event)">
    Status Click
</h1>
<p-menu #menu [model]="listStatusTypes()" [popup]="true" />

//Código TypeScript

  @ViewChild('menu') menu !: Menu;
  listStatusTypes = signal<any[]>([])

  statusDispacherClick(data, event) {
    this.service.getDashboardChangeStatusTypes(data).subscribe(dataService => {
      dataService.map(x => {
        x.label = x.title;
      })
      this.listStatusTypes.set(dataService);
      this.cdRef.detectChanges();
      this.menu.toggle(event);
    })
  }

Sou novo no Eloquent Query Builder e tenho algumas perguntas:

Objetivo: Criar uma consulta que me retornará receitas que correspondam aos parâmetros especificados dos seletores :

1. Categoria de Prato
2. Subcategoria de Pratos
3. Cozinha
4. Menu

nuance importante: em seletores você não pode selecionar uma subcategoria sem primeiro selecionar uma categoria (lógica suspensa dependente usando livewire).

Após selecionar os parâmetros nos seletores, a URL fica assim:

http://127.0.0.1:8000/recipes?dish_category=2&dish_subcategory=37&cuisine=1&menu=1

Problema:

• Notei que ainda posso remover o ID da categoria na URL e deixar apenas a subcategoria: http://127.0.0.1:8000/recipes?dish_category=&dish_subcategory=37&cuisine=1&menu=1

• Como obter um comportamento em que um usuário só pode inserir, por exemplo, "culinária" no seletor, e a consulta seleciona receitas que correspondem somente a esse parâmetro?

Código:

Atualmente, tenho este código, ele me mostra dados corretos, mas não tenho certeza se é uma maneira adequada de filtrar dados usando parâmetros de URL:

$recipes = Recipe::with('user', 'cuisine')
    ->where('dish_category_id', $request->query('dish_category'))
    ->orWhere('dish_subcategory_id', $request->query('dish_subcategory'))
    ->orWhere('cuisine_id', $request->query('cuisine'))
    ->orWhere('menu_id', $request->query('menu'))
    ->get();

dd($recipes);

e dd($recipes)me mostra isso:

Illuminate\Database\Eloquent\Collection {#1085 ▼ // app\Http\Controllers\RecipeController.php:26
  #items: array:2 [▼
    0 => 
App\Models
\
Recipe {#1116 ▶}
    1 => 
App\Models
\
Recipe {#1082 ▶}
  ]
  #escapeWhenCastingToString: false
}

(2 receitas encontradas com os parâmetros especificados pelo usuário, também, se o usuário, por exemplo, inserir apenas o parâmetro Categoria: Caldo, então o mesmo resultado será obtido)

Conclusão:

O código atual funciona, mas preciso que ele não apenas funcione, mas também seja escrito corretamente. Também preciso levar em conta os problemas descritos acima.

Ficaria grato por conselhos e ajuda.

EDITAR 01:

Eu tentei a abordagem com when()o método:

$recipes = DB::table('recipes')
    ->when($dish_category, function ($query, $dish_category){
        $query->where('dish_category_id', $dish_category);
    })
    ->when($dish_subcategory, function ($query, $dish_subcategory){
        $query->where('dish_subcategory_id', $dish_subcategory);
    })
    ->when($cuisine, function ($query, $cuisine){
        $query->where('cuisine_id', $cuisine);
    })
    ->when($menu, function ($query, $menu){
        $query->where('menu_id', $menu);
    })
    ->get();

funciona, mas ainda consigo colar dish_subcategory_ida URL (não tenho certeza se é um bom comportamento quando não permito que o usuário selecione dish_subcategorysem dish_categoryseletores)

Estou criando um jogo de parkour e me deparei com um problema. Há uma mecânica de corrida na parede, em que, se você estiver correndo na parede, a rotação do seu jogador fica travada no plano da parede. Isso funciona perfeitamente, desde que você acerte o lado esquerdo (oeste) da parede. Quando estiver no lado direito (leste) da parede, o jogador é virado na direção errada.

private void WallStick()
{
    if (leftWall) wallNormal = leftWallHit.normal.y;
    else if (rightWall) wallNormal = rightWallHit.normal.y;

    if (leftWall) playerMovement.rotationScript.yRotation = wallNormal + 90f;
    else if (rightWall) playerMovement.rotationScript.yRotation = wallNormal - 90f;
}

leftWall e rightWall são valores booleanos para ver em que direção a parede está para o jogador. Os acertos são raycasts. Todo o resto parece autoexplicativo, mas faça perguntas se necessário. Este código funciona perfeitamente como indicado, mas apenas se o jogador correr no lado oeste da parede.

Eu poderia dividir cada parede em 2 partes e atribuir uma layerMask para diferenciar qual lado o raio atinge, mas isso parece muito desajeitado e me faria redesenhar o mundo inteiro.

Alguma ideia?

Deixe-me começar com um C++código que simplifica os problemas que enfrentei na base de código real. Eu o compilei com --std=c++20e --std=c++17. O primeiro for-loop abaixo funcionou bem; o segundo for-loop, que retorna, std::optional<Container>não funcionou, para todos os contêineres que testei. Gostaria de entender o porquê:

#include <iostream>
#include <optional>
#include <string>
#include <unordered_set>

std::unordered_set<std::string> GenerateSet() {                                                                                                                                                                                                      
  std::unordered_set<std::string> names = {"a", "b"};                                                                                                                                                                                                
  return names;                                                                                                                                                                                                                                      
}

std::optional<std::unordered_set<std::string>> GenerateOptionalSet() {                                                                                                                                                                               
  std::unordered_set<std::string> names = {"a", "b"};                                                                                                                                                                                                
  return names;                                                                                                                                                                                                                                      
}

int main() {                                                                                                                                                                                                                                         
  std::cout << "When a set is returned: {";                                                                                                                                                                                                          
  for (const auto& e : GenerateSet()) {                                                                                                                                                                                                              
    std::cout << e << " ";                                                                                                                                                                                                                           
  }                                                                                                                                                                                                                                                  
  std::cout << "}" << std::endl;                                                                                                                                                                                                                     
                                                                                                                                                                                                                                                     
  std::cout << "When a optional of a set is returned: {";                                                                                                                                                                                            
  for (const auto& e : GenerateOptionalSet().value()) {                                                                                                                                                                                              
    std::cout << e << " ";                                                                                                                                                                                                                           
  }                                                                                                                                                                                                                                                  
  std::cout << "}" << std::endl;                                                                                                                                                                                                                     
                                                                                                                                                                                                                                                     
  return 0;                                                                                                                                                                                                                                          
}

O resultado foram falhas de segmentação em tempo de execução (bastante recente clang) ou nenhuma iteração no segundo for-loop (bastante antigo gccem uma máquina Linux arcaica).

Aqui está o URL ao qual me referi em relação a std::optional<T>::value(): std::optional::value() do cppreference.com

Parece haver 4 versões diferentes. Não tinha certeza de qual versão das 4 funções substituídas seria invocada e por que não funciona como eu esperava (ou seja, apenas repetindo o valor do temporary retornado std::optional<T>).

Configuração: Um clone de asteroides com bando e aves

Quero criar um clone de asteroides em Rust com o motor de jogo Bevy e o motor de física Avian. Já tenho componentes para Bullets e Astroids. Quando eles são gerados, eles também recebem um Collider.

use bevy::prelude::*;
use avian2d::prelude::*;

#[derive(Component)]
struct Bullet;

#[derive(Component)]
struct Asteroid

fn setup(

) {
    asteroid_handle =  asset_server.load("asteroid.png");
    bullet_handle = asset_server.load("bullet.png");
    commands.spawn(
        (
            Asteroid,
            Sprite::from_image(asteroid_handle),
            Collider::circle(50.),
        )
    );
    commands.spawn(
        (
            Bullet,
            Sprite::from_image(bullet_handle),
            Collider::circle(5.),
        )
    );
}

(É claro que há algum código para que eles se movam, virem, etc., mas isso não é relevante para a questão)

O Problema: Encontrar colisões entre balas e asteroides

As interações entre entidades são onde estou tendo dificuldades: quero detectar quando um asteroide é atingido por uma bala (para que eu possa fazer a bala desaparecer e destruir o asteroide, ainda não sei como). Detectar colisões é muito fácil, posso apenas ouvir os eventos de colisão.

fn print_collisions(mut collision_event_reader: EventReader<Collision>) {
    for Collision(contacts) in collision_event_reader.read() {
        println!(
            "Entities {} and {} are colliding",
            contacts.entity1,
            contacts.entity2,
        );
    }
}

Isso imprime as colisões conforme o esperado. Mas inclui colisões entre a nave e a bala, a nave e os asteroides... Aqui, tudo o que obtenho são duas entidades e nenhuma informação adicional. Como posso testar se elas têm os componentes que desejo?

O que eu quero é obter apenas aquelas colisões entre uma bala e um asteroide.

O que a IA sugeriu

Perguntei à IA e ela sugeriu algo assim:

fn print_collisions(
    mut collision_event_reader: EventReader<Collision>,
    query: Query<(Entity, Option<&Bullet>, Option<&Asteroid>)>,
) {
    for Collision(contacts) in collision_event_reader.read() {
        let (entity1, bullet1, asteroid1) = query.get(contacts.entity1).unwrap_or((contacts.entity1, None, None));
        let (entity2, bullet2, asteroid2) = query.get(contacts.entity2).unwrap_or((contacts.entity2, None, None));

        // Check if one entity is a Bullet and the other is an Asteroid
        if (bullet1.is_some() && asteroid2.is_some()) || (bullet2.is_some() && asteroid1.is_some()) {
            println!(
                "Bullet {} collided with Asteroid {}",
                if bullet1.is_some() { entity1 } else { entity2 },
                if asteroid1.is_some() { entity1 } else { entity2 },
            );
        }
    }
}

Acho que funcionaria, mas me parece muito ineficiente. Já temos as entidades no evento, então não deveria haver necessidade de consultar todas as balas e asteroides novamente para ver se estão na consulta.

O que estou procurando: uma solução simples

Sou iniciante tanto em Rust quanto em Bevy. Tenho experiência em programação (principalmente em Python) e outras engines de jogos (como Godot), e todo o código Bevy que escrevi até agora parece elegante e modular. Isso realmente me impressiona. Por isso, estou procurando uma solução simples e elegante.

Tenho um código que rola imagens em tela cheia para frente e para trás ao tocar no lado esquerdo ou direito da tela. Quando uma imagem aparece na tela, ela executa um dos seguintes tipos de animação: superior, inferior, esquerda, direita, zoom in, zoom out — cada uma dessas animações consiste em duas subanimações (a primeira animação é rápida e a segunda é em loop).

O problema é que, às vezes, ao alternar imagens, as coordenadas da animação se acumulam. Em circunstâncias normais, as animações deveriam afetar apenas X, Y ou Escala. Mas, no meu caso, às vezes acontece que as imagens se movem na diagonal (X + Y), a animação ultrapassa os limites da imagem e vejo áreas pretas na tela. Isso não deveria acontecer. Como posso corrigir isso?

Estou usando removeAllAnimationsantes de cada animação, mas não ajuda.

código completo:

class ReaderController: UIViewController, CAAnimationDelegate {
    
    var pagesData = [PageData]()
    var index = Int()
    var pageIndex: Int = -1
    
    let pageContainer: UIView = {
        let view = UIView()
        view.translatesAutoresizingMaskIntoConstraints = false
        return view
    }()
    
    let pageViews: [PageLayout] = {
        let view = [PageLayout(), PageLayout()]
        view[0].translatesAutoresizingMaskIntoConstraints = false
        view[1].translatesAutoresizingMaskIntoConstraints = false
        return view
    }()
    
    private weak var currentTransitionView: PageLayout?
        
    override func viewDidLoad() {
        super.viewDidLoad()

        setupViews()
        setupConstraints()

        pageViews[0].index = index
        pageViews[1].index = index
        pageViews[0].pageIndex = pageIndex
        pageViews[1].pageIndex = pageIndex
        
        pageTransition(animated: false, direction: "fromRight")
    }
        
    func setupViews() {
        pageContainer.addSubview(pageViews[0])
        pageContainer.addSubview(pageViews[1])
        view.addSubview(pageContainer)
    }
        
    func setupConstraints() {
        pageContainer.topAnchor.constraint(equalTo: view.topAnchor, constant: 0.0).isActive = true
        pageContainer.bottomAnchor.constraint(equalTo: view.bottomAnchor, constant: 0.0).isActive = true
        pageContainer.leadingAnchor.constraint(equalTo: view.leadingAnchor, constant: 0.0).isActive = true
        pageContainer.trailingAnchor.constraint(equalTo: view.trailingAnchor, constant: 0.0).isActive = true

        pageViews[0].topAnchor.constraint(equalTo: pageContainer.topAnchor).isActive = true
        pageViews[0].bottomAnchor.constraint(equalTo: pageContainer.bottomAnchor).isActive = true
        pageViews[0].leadingAnchor.constraint(equalTo: pageContainer.leadingAnchor).isActive = true
        pageViews[0].trailingAnchor.constraint(equalTo: pageContainer.trailingAnchor).isActive = true

        pageViews[1].topAnchor.constraint(equalTo: pageContainer.topAnchor).isActive = true
        pageViews[1].bottomAnchor.constraint(equalTo: pageContainer.bottomAnchor).isActive = true
        pageViews[1].leadingAnchor.constraint(equalTo: pageContainer.leadingAnchor).isActive = true
        pageViews[1].trailingAnchor.constraint(equalTo: pageContainer.trailingAnchor).isActive = true
    }
        
    func loadData(fileName: Any) -> PagesData {
        var url = NSURL()
        url = Bundle.main.url(forResource: "text", withExtension: "json")! as NSURL
        let data = try! Data(contentsOf: url as URL)
        let person = try! JSONDecoder().decode(PagesData.self, from: data)
        return person
    }
    
    override func touchesBegan(_ touches: Set<UITouch>, with event: UIEvent?) {
        for touch in touches {
            let location = touch.location(in: view.self)

            if view.safeAreaInsets.left > 30 {
                if (location.x > self.view.frame.size.width - (view.safeAreaInsets.left * 1.5)) {
                    pageTransition(animated: true, direction: "fromRight")
                } else if (location.x < (view.safeAreaInsets.left * 1.5)) {
                    pageTransition(animated: true, direction: "fromLeft")
                }
            }

            else {
                if (location.x > self.view.frame.size.width - 40) {
                    pageTransition(animated: true, direction: "fromRight")
                } else if (location.x < 40) {
                    pageTransition(animated: true, direction: "fromLeft")
                }
            }
        }
        
    }
    
    func pageTransition(animated: Bool, direction: String) {
        let result = loadData(fileName: pagesData)
        
        switch direction {
        case "fromRight":
            pageIndex += 1
        case "fromLeft":
            pageIndex -= 1
        default: break
        }
        
        pageViews[0].pageIndex = pageIndex
        pageViews[1].pageIndex = pageIndex
        
        guard pageIndex >= 0 && pageIndex < result.pagesData.count else {
            pageIndex = max(0, min(pageIndex, result.pagesData.count - 1))
            return
        }
        
        let fromView = pageViews[0].isHidden ? pageViews[1] : pageViews[0]
        let toView = pageViews[0].isHidden ? pageViews[0] : pageViews[1]
        toView.imageView.layer.removeAllAnimations()
        toView.imageView.transform = .identity
        toView.configure(theData: result.pagesData[pageIndex])
        if animated {
            fromView.isHidden = true
            toView.isHidden = false
        } else {
            fromView.isHidden = true
            toView.isHidden = false
        }
    }
    
}

class PageLayout: UIView {
            
    var index = Int()
    var pageIndex = Int()
    
    let imageView: UIImageView = {
        let image = UIImageView()
        image.contentMode = .scaleAspectFill
        image.translatesAutoresizingMaskIntoConstraints = false
        return image
    }()

    var imageViewTopConstraint = NSLayoutConstraint()
    var imageViewBottomConstraint = NSLayoutConstraint()
    var imageViewLeadingConstraint = NSLayoutConstraint()
    var imageViewTrailingConstraint = NSLayoutConstraint()
    
    var imagePosition = ""
    
    override init(frame: CGRect) {
        super.init(frame: frame)
        addSubview(imageView)
        setupConstraints()
    }
    
    func setupConstraints() {
        
        imageView.layer.removeAllAnimations()
        imageView.transform = .identity
        
        removeConstraints([imageViewTopConstraint, imageViewBottomConstraint, imageViewLeadingConstraint,
                           imageViewTrailingConstraint])
        
        switch imagePosition {
            
        case "top":
            
            imageView.transform = .identity
            
            imageViewTopConstraint = imageView.topAnchor.constraint(equalTo: topAnchor, constant: -40.0)
            imageViewBottomConstraint = imageView.bottomAnchor.constraint(equalTo: bottomAnchor, constant: 0.0)
            imageViewLeadingConstraint = imageView.leadingAnchor.constraint(equalTo: leadingAnchor, constant: 0.0)
            imageViewTrailingConstraint = imageView.trailingAnchor.constraint(equalTo: trailingAnchor, constant: 0.0)
            
            addConstraints([imageViewTopConstraint, imageViewBottomConstraint, imageViewLeadingConstraint, imageViewTrailingConstraint])
            
            UIView.animate(withDuration: 2.0, delay: 0, options: [.curveEaseOut, .allowUserInteraction, .beginFromCurrentState], animations: {
                self.imageView.transform = CGAffineTransform(translationX: 0, y: 40.0)
            }, completion: { _ in
                UIView.animate(withDuration: 6.0, delay: 0, options: [.curveLinear, .autoreverse, .repeat, .beginFromCurrentState, .allowUserInteraction], animations: {
                    self.imageView.transform = self.imageView.transform.translatedBy(x: 0, y: -40.0)
                }, completion: nil)
            })
            
        case "bottom":
            
            imageView.transform = .identity
            
            imageViewTopConstraint = imageView.topAnchor.constraint(equalTo: topAnchor, constant: 0.0)
            imageViewBottomConstraint = imageView.bottomAnchor.constraint(equalTo: bottomAnchor, constant: 40.0)
            imageViewLeadingConstraint = imageView.leadingAnchor.constraint(equalTo: leadingAnchor, constant: 0.0)
            imageViewTrailingConstraint = imageView.trailingAnchor.constraint(equalTo: trailingAnchor, constant: 0.0)
            
            addConstraints([imageViewTopConstraint, imageViewBottomConstraint, imageViewLeadingConstraint, imageViewTrailingConstraint])
            
            UIView.animate(withDuration: 2.0, delay: 0, options: [.curveEaseOut, .allowUserInteraction, .beginFromCurrentState], animations: {
                self.imageView.transform = CGAffineTransform(translationX: 0, y: -40)
            }, completion: { _ in
                UIView.animate(withDuration: 6.0, delay: 0, options: [.curveLinear, .autoreverse, .repeat, .beginFromCurrentState, .allowUserInteraction], animations: {
                    self.imageView.transform = self.imageView.transform.translatedBy(x: 0, y: 40)
                }, completion: nil)
            })
            
        case "left":
            
            imageView.transform = .identity
            
            imageViewTopConstraint = imageView.topAnchor.constraint(equalTo: topAnchor, constant: 0.0)
            imageViewBottomConstraint = imageView.bottomAnchor.constraint(equalTo: bottomAnchor, constant: 0.0)
            imageViewLeadingConstraint = imageView.leadingAnchor.constraint(equalTo: leadingAnchor, constant: -40.0)
            imageViewTrailingConstraint = imageView.trailingAnchor.constraint(equalTo: trailingAnchor, constant: 0.0)
            
            addConstraints([imageViewTopConstraint, imageViewBottomConstraint, imageViewLeadingConstraint, imageViewTrailingConstraint])
            
            UIView.animate(withDuration: 2.0, delay: 0, options: [.curveEaseOut, .allowUserInteraction, .beginFromCurrentState], animations: {
                self.imageView.transform = CGAffineTransform(translationX: 40, y: 0)
            }, completion: { _ in
                UIView.animate(withDuration: 6.0, delay: 0, options: [.curveLinear, .autoreverse, .repeat, .beginFromCurrentState, .allowUserInteraction], animations: {
                    self.imageView.transform = self.imageView.transform.translatedBy(x: -40, y: 0)
                }, completion: nil)
            })
            
        case "right":
            
            imageView.transform = .identity
            
            imageViewTopConstraint = imageView.topAnchor.constraint(equalTo: topAnchor, constant: 0.0)
            imageViewBottomConstraint = imageView.bottomAnchor.constraint(equalTo: bottomAnchor, constant: 0.0)
            imageViewLeadingConstraint = imageView.leadingAnchor.constraint(equalTo: leadingAnchor, constant: 0.0)
            imageViewTrailingConstraint = imageView.trailingAnchor.constraint(equalTo: trailingAnchor, constant: 40.0)
            
            addConstraints([imageViewTopConstraint, imageViewBottomConstraint, imageViewLeadingConstraint, imageViewTrailingConstraint])
            
            UIView.animate(withDuration: 2.0, delay: 0, options: [.curveEaseOut, .allowUserInteraction, .beginFromCurrentState], animations: {
                self.imageView.transform = CGAffineTransform(translationX: -40, y: 0)
            }, completion: { _ in
                UIView.animate(withDuration: 6.0, delay: 0, options: [.curveLinear, .autoreverse, .repeat, .beginFromCurrentState, .allowUserInteraction], animations: {
                    self.imageView.transform = self.imageView.transform.translatedBy(x: 40, y: 0)
                }, completion: nil)
            })
            
        case "zoomin":
            
            imageView.transform = CGAffineTransformScale(.identity, 1.0, 1.0)
            
            imageViewTopConstraint = imageView.topAnchor.constraint(equalTo: topAnchor, constant: 0.0)
            imageViewBottomConstraint = imageView.bottomAnchor.constraint(equalTo: bottomAnchor, constant: 0.0)
            imageViewLeadingConstraint = imageView.leadingAnchor.constraint(equalTo: leadingAnchor, constant: 0.0)
            imageViewTrailingConstraint = imageView.trailingAnchor.constraint(equalTo: trailingAnchor, constant: 0.0)
            
            addConstraints([imageViewTopConstraint, imageViewBottomConstraint, imageViewLeadingConstraint, imageViewTrailingConstraint])
            
            UIView.animate(withDuration: 2.0, delay: 0, options: [.curveEaseOut, .allowUserInteraction, .beginFromCurrentState], animations: {
                self.imageView.transform = CGAffineTransform(scaleX: 1.1, y: 1.1)
            }, completion: { _ in
                UIView.animate(withDuration: 6.0, delay: 0, options: [.curveLinear, .autoreverse, .repeat, .beginFromCurrentState, .allowUserInteraction], animations: {
                    self.imageView.transform = .identity
                }, completion: nil)
            })
            
        case "zoomout":
            
            imageView.transform = CGAffineTransformScale(.identity, 1.1, 1.1)
            
            imageViewTopConstraint = imageView.topAnchor.constraint(equalTo: topAnchor, constant: 0.0)
            imageViewBottomConstraint = imageView.bottomAnchor.constraint(equalTo: bottomAnchor, constant: 0.0)
            imageViewLeadingConstraint = imageView.leadingAnchor.constraint(equalTo: leadingAnchor, constant: 0.0)
            imageViewTrailingConstraint = imageView.trailingAnchor.constraint(equalTo: trailingAnchor, constant: 0.0)
            
            addConstraints([imageViewTopConstraint, imageViewBottomConstraint, imageViewLeadingConstraint, imageViewTrailingConstraint])
            
            UIView.animate(withDuration: 2.0, delay: 0, options: [.curveEaseOut, .allowUserInteraction, .beginFromCurrentState], animations: {
                self.imageView.transform = CGAffineTransform(scaleX: 1.0, y: 1.0)
            }, completion: { _ in
                UIView.animate(withDuration: 6.0, delay: 0, options: [.curveLinear, .autoreverse, .repeat, .beginFromCurrentState, .allowUserInteraction], animations: {
                    self.imageView.transform = self.imageView.transform.scaledBy(x: 1.1, y: 1.1)
                }, completion: nil)
            })
            
        default:
            
            imageView.transform = .identity
            
            imageViewTopConstraint = imageView.topAnchor.constraint(equalTo: topAnchor, constant: 0.0)
            imageViewBottomConstraint = imageView.bottomAnchor.constraint(equalTo: bottomAnchor, constant: 0.0)
            imageViewLeadingConstraint = imageView.leadingAnchor.constraint(equalTo: leadingAnchor, constant: 0.0)
            imageViewTrailingConstraint = imageView.trailingAnchor.constraint(equalTo: trailingAnchor, constant: 0.0)
            
            addConstraints([imageViewTopConstraint, imageViewBottomConstraint, imageViewLeadingConstraint, imageViewTrailingConstraint])
        }
    }
        
    func configure(theData: PageData) {
        imageView.image = UIImage(named: "page\(pageIndex+1)")
        imagePosition = theData.imagePosition
        setupConstraints()
    }
    
    required init?(coder: NSCoder) {
        fatalError("Not happening")
    }
    
}

struct PagesData: Decodable {
    var pagesData: [PageData]
}

struct PageData: Decodable {
    let textData, textPosition, textColor, shadowColor, textAlignment, imagePosition: String
}

JSON:

{
    "pagesData" : [
        
        {
            "textData" : "",
            "textPosition" : "topLeft",
            "textColor" : "FFFFFF",
            "shadowColor" : "000000",
            "textAlignment" : "left",
            "imagePosition" : "left",
        },
        
        {
            "textData" : "",
            "textPosition" : "bottomLeft",
            "textColor" : "FFFFFF",
            "shadowColor" : "000000",
            "textAlignment" : "left",
            "imagePosition" : "bottom",
        },
        
        {
            "textData" : "",
            "textPosition" : "zoomin",
            "textColor" : "FFFFFF",
            "shadowColor" : "000000",
            "textAlignment" : "left",
            "imagePosition" : "right",
        },
        
        {
            "textData" : "",
            "textPosition" : "bottomCenter",
            "textColor" : "FFFFFF",
            "shadowColor" : "000000",
            "textAlignment" : "left",
            "imagePosition" : "zoomout",
        },
        
        {
            "textData" : "",
            "textPosition" : "topLeft",
            "textColor" : "FFFFFF",
            "shadowColor" : "000000",
            "textAlignment" : "left",
            "imagePosition" : "left",
        },
        
    ]
}

De uma pergunta anterior, sei que ao chamar ~base()uma classe derivada, ela primeiro constrói um objeto base temporário, depois invoca a base temporária operator~()no objeto temporário e, finalmente, destrói o objeto temporário.

Entretanto, quando a classe base não tem um operator~, chamar base::~base()a classe derivada ainda pode invocar o destruidor da classe base.

Por que ocorre um erro quando a classe base tem um operator~?

#include <iostream>
using namespace std;
class base
{
public:
    base(){cout << "constructor base \n";}
    ~base(){cout << "destructor base \n";}
    void operator~(){cout << "operator ~ \n";}
};

class derived : public base
{
public:
    derived(){cout << "constructor derived \n";}
    ~derived(){base::~base();cout << "destructor derived \n";}
};

Informações sobre a versão do compilador:

g++.exe (x86_64-posix-seh-rev0, Built by MinGW-W64 project) 8.1.0
Copyright (C) 2018 Free Software Foundation, Inc.
This is free software; see the source for copying conditions.  There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

Erro:

cmd /c chcp 65001>nul && C:\mingw64\bin\g++.exe -fdiagnostics-color=always -g "D:\Valkyrie-text\simple text\text.cpp" -o "D:\Valkyrie-text\simple text\text.exe"
D:\Valkyrie-text\simple text\text.cpp: In destructor 'derived::~derived()':
D:\Valkyrie-text\simple text\text.cpp:15:28: error: no matching function for call to 'derived::~derived()'
     ~derived(){base::~base();cout << "destructor derived \n";}
                            ^
D:\Valkyrie-text\simple text\text.cpp:7:5: note: candidate: 'base::~base()'
     ~base(){cout << "destructor base \n";}
     ^
D:\Valkyrie-text\simple text\text.cpp:7:5: note:   candidate expects 1 argument, 0 provided

Gostaria de exibir o número de documentos que correspondem a uma consulta específica. A consulta é um valor booleano, portanto, exiba o número de documentos que possuem o valor "true". Encontrei várias perguntas relacionadas a isso no Stack Overflow, mas apenas o código a seguir atende às minhas necessidades.

O código a seguir imprime o número correto no console, mas preciso de ajuda para exibi-lo na tela.

final Future<void> activityDone = FirebaseFirestore
      .instance
      .collection('user')
      .doc(FirebaseAuth.instance.currentUser!.uid)
      .collection('list')
      .doc(widget.docId).collection('activity').where("status", isEqualTo: true)
      .count().get().then(
        (res) => print(res.count),
    onError: (e) => print("Error completing: $e"),
  );

Não consigo fazer esse código de contagem funcionar.

String count = activityDone.toString();

Gostaria de usar o código de contagem em um texto como este

Text("Activities done = $count"),

Código completo

child: StreamBuilder(
  stream: FirebaseFirestore.instance
          .collection('user')
        .doc(FirebaseAuth.instance.currentUser!.uid)
          .collection('list')
          .doc(widget.docId).collection('activity').orderBy('xTimeStamp', descending: false)
        .snapshots(),
  ),
  builder: (context, snapshot) {

    final xSnapshot = snapshot.data?.docs;

    final Future<void> activityDone = FirebaseFirestore
      .instance
      .collection('user')
      .doc(FirebaseAuth.instance.currentUser!.uid)
      .collection('list')
      .doc(widget.docId).collection('activity')
      .where("status", isEqualTo: true)
      .count()
      .get().then(
        (res) => print(res.count),
        onError: (e) => print("Error completing: $e"),
    );

    String count = activityDone.toString();

    if (xSnapshot == null) {
      // Error
    }, else {
      Text("Activities done = $count"),
    }    
}

Erros

Após mover de quarkus-websocketpara quarkus-websockets-next, qualquer HTTP GET para um @WebSocketcaminho agora apresenta erros com

"Connection" header must be "Upgrade"

Isso ocorre porque a nova extensão intercepta todas as solicitações correspondentes e as trata como um handshake WebSocket.

No quarkus-websocketmodelo antigo, @ServerEndpointapenas atualizações verdadeiras do WebSocket eram processadas; GETs simples para o mesmo URL caíam nos recursos JAX-RS.

Com quarkus-websockets-next, @WebSocket(path="/…")instala um único manipulador Vert.x para todos os métodos HTTP naquele caminho. Um GET padrão — sem o cabeçalho Connection: Upgrade necessário — é detectado e rejeitado antes que qualquer lógica REST possa ser executada.

Abaixo está um projeto mínimo do Quarkus mostrando:

1. Legado ( quarkus-websockets):

   • Um @GET /chatponto de extremidade REST
   • Um JSR-356 WebSocket @ServerEndpoint("/chat")
     → GET funciona ( 200 OK), WS funciona

2. Próximo ( quarkus-websockets-next):

   • Mesmo recurso REST
   • Novo @WebSocket(path = "/chat")
     → Qualquer GET /chat falha agora com

"Connection" header must be "Upgrade"

Reprodução de amostra usando:

<dependency>
  <groupId>io.quarkus</groupId>
  <artifactId>quarkus-websockets</artifactId>
</dependency>

ChatResource.java:

@Path("/chat")
@ApplicationScoped
public class ChatResource {
    @GET
    public String hello() {
        return "Hello from REST!";
    }
}

ChatEndpoint.java:

@ServerEndpoint("/chat")
@ApplicationScoped
public class ChatEndpoint {
    @OnOpen
    public void onOpen(Session session) { /*...*/ }

    @OnMessage
    public void onMessage(Session session, String msg) {
        session.getAsyncRemote().sendText("Echo:" + msg);
    }
}

Comportamento

OBTER http://localhost:8080/chat → 200 OK com “Olá do REST!”

ws://localhost:8080/chat → O handshake do WebSocket foi bem-sucedido

Com o novo quarkus-websockets-next:

<dependency>
  <groupId>io.quarkus</groupId>
  <artifactId>quarkus-websockets-next</artifactId>
</dependency>

ChatResource.java (unchanged):

@Path("/chat")
@ApplicationScoped
public class ChatResource {
    @GET
    public String hello() {
        return "Hello from REST!";
    }
}

ChatSocket.java:

@WebSocket(path = "/chat")
@ApplicationScoped
public class ChatSocket {
    @OnOpen
    public void onOpen(WebSocketConnection conn) { /*...*/ }

    @OnMessage
    public void onMessage(WebSocketConnection conn, String msg) {
        conn.sendText("Echo:" + msg).subscribe().with(r -> {}, t -> {});
    }
}

Comportamento

GET http://localhost:8080/chat → falha com

"Connection" header must be "Upgrade"

ws://localhost:8080/chat → O handshake do WebSocket foi bem-sucedido

Isso é esperado quarkus-websockets-nextou é um bug? Porque estou implementando alguns endpoints para uma especificação padrão, onde posso ter endpoints mais ou menos assim:

/queries/{queryName}/events

De acordo com a especificação, ele deve fazer o seguinte:

Returns all events that match the query or creates a new Websocket subscription.

Isso estava funcionando com o quarkus-websocketse agora está falhando na solicitação GET, o que é quarkus-websockets-nextum pouco confuso se esse é um problema que precisa ser corrigido.