All perguntas(coding)

Eu tenho esta estrutura Swift:

struct Foo {
  let i: Int
}
let f1 = Foo(i: 1)
let f2 = Foo(i: 2)

Então no LLDB, eu os lanço __SwiftValuee imprimo:

p (f1 as AnyObject)

(__SwiftValue) 0x00000001676332d0 {
  baseNSObject@0 = {
    isa = __SwiftValue
  }
}

p (f2 as AnyObject)


(__SwiftValue) 0x0000000167633300 {
  baseNSObject@0 = {
    isa = __SwiftValue
  }
}

Como você pode ver, os endereços dos dois são diferentes, o que faz sentido, pois são dados diferentes em locais de memória separados.

Porém, se eu tomar ObjectIdentifier, eles são iguais:

p ObjectIdentifier(f1 as AnyObject)
(ObjectIdentifier) ObjectIdentifier(0x00000001676332d0) {
  _value = 0x00000001676332d0
}

p ObjectIdentifier(f2 as AnyObject)

(ObjectIdentifier) ObjectIdentifier(0x00000001676332d0) {
  _value = 0x00000001676332d0
}

Esse comportamento estranho basicamente diz que "ObjectIdentifier igual" não significa "endereço igual" ( ===):

p (f1 as AnyObject === f2 as AnyObject)
(Bool)  (_value = 0)

p (ObjectIdentifier(f1 as AnyObject) == ObjectIdentifier(f2 as AnyObject))
(Bool)  (_value = 1)

Por que é assim? Pelo que entendi, é __SwiftValueuma subclasse de NSObject, então deveriam ter ObjectIdentifiers diferentes. Isso é estranho.

Atualizar:

Adicionei código de exemplo fora do LLDB:

      let f1 = Foo(i: 1)
      let f2 = Foo(i: 2)
      
      let b1 = (f1 as AnyObject) === (f2 as AnyObject)
      let b2 = ObjectIdentifier(f1 as AnyObject) == ObjectIdentifier(f2 as AnyObject)
      

E obteve b1 = falso e b2 = verdadeiro no depurador:

Sou um programador React Native e estou tendo um problema ilógico, pois estou adicionando duas capturas de tela do Firestore, onde há uma coleção e alguns documentos. Quando obtenho a coleção usando o código ou o construtor de consultas, recebo apenas um item, mas ainda não consigo entender qual é o problema. Meu código React Native está...

useEffect(() => {
    console.log('Starting useEffect');

    const fetchData = async () => {
      const querySnapshot = await firestore()
      .collection('chatRooms')
      .get();

    console.log('All docs count:', querySnapshot.size);

    console.log('All document IDs:');
    querySnapshot.forEach(doc => {
      console.log(`${doc.id}`);
    });

    // Filter client-side for rooms containing the user
    querySnapshot.forEach(doc => {
      const data = doc.data();
      console.log(`Doc ${doc.id} exists:`, doc.exists);
      console.log(`Doc ${doc.id} data:`, data);
      console.log(`Doc ${doc.id} data keys:`, Object.keys(data));
      console.log(`Doc ${doc.id} empty?:`, Object.keys(data).length === 0);

    });


    };
    fetchData();
  }, []);

Como mostrado, tenho 4 documentos, mas estou recebendo apenas 1. Por favor, me avise se alguém souber desse problema.

HvN0az1wtzgNqnxkBm14z274LiO2_ai_1
HvN0az1wtzgNqnxkBm14z274LiO2_ai_10
HvN0az1wtzgNqnxkBm14z274LiO2_ai_12

Meus IDs de Doc.

Estou configurando IO para um código CFD de larga escala usando a biblioteca MPI e o IO do arquivo está começando a consumir tempo de computação à medida que meus problemas aumentam.

Até onde posso perceber, o que está "pronto" no contexto moderno é a utilização pesada de operações de E/S coletivas ( Desempenho de E/S paralelas no ARCHER - whitepaper de 2015).

Meu problema é que parece haver três maneiras de chamar uma gravação coletiva:

• MPI_File_write_all, bloqueando

• MPI_File_iwrite_all, não bloqueante

e um tanto especulativamente:

• MPI_File_iwriteseguido por uma chamada para MPI_File_sync, não bloqueante e depois bloqueante?

  Digo especulativamente porque a primeira chamada é explicitamente não coletiva, mas a última (que, até onde sei, é o que realmente envia os dados para o armazenamento) é coletiva.

Minha pergunta é: múltiplos MPI_File_iwrites seguidos por a são MPI_File_syncequivalentes a um MPI_File_write_all, no sentido de que a sincronização de arquivo torna a gravação não coletiva efetivamente coletiva? Edit - para maior clareza, estou ciente de que sync é uma rotina coletiva. Estou perguntando se a E/S que ocorre quando sync é chamado é análoga à E/S coletiva de um write_all.

acompanhamento: uma MPI_File_iwrite_allchamada requer uma MPI_File_syncchamada e, se isso ocorrer, qual é o propósito de uma gravação coletiva não bloqueante se ela se torna apenas bloqueadora no futuro?

Estou focando bastante em bloqueio vs. não bloqueio aqui porque estou tentando remover completamente toda a sincronização do meu código para melhorar a utilização da CPU (ou seja, os processos só esperam se não tiverem as informações que precisam dos seus vizinhos, em vez de esperar que todos os processos sincronizem), mas obviamente isso se torna um pouco problemático quando se trata de saída.

Como escrever este código Java em Kotlin?

//Java
for (int i = 10; i > 0; i--);

Como você pode ver, "i" não pode ser zero.

Eu sei que isso pode ser feito com "downTo" assim:

for (i in 10 downTo 0)

Mas "downTo" inclui zero. Quero que seja exclusivo de zero. Minha pergunta é: existe uma maneira de fazer isso em Kotlin? (apenas dentro do "loop for", sem alterar zero ou dez, e sem nenhum "if" adicional ou algo do tipo)

Estou tentando mesclar três dataframes usando intersection(). Como podemos verificar se todos os dataframes existem/foram inicializados antes de executar intersection() sem vários blocos de verificação if-else? Se algum dataframe não estiver atribuído, não o assuma durante a execução de intersection(). Às vezes, recebo o erro - UnboundLocalError: variável local 'df_2' referenciada antes da atribuição , porque o arquivo2 não existe.

OU existe alguma outra maneira fácil de conseguir isso?

Abaixo está minha abordagem:

if os.path.exists(file1):
        df_1 = pd.read_csv(file1, header=None, names=header_1, sep=',', index_col=None)
if os.path.exists(file2):
        df_2 = pd.read_csv(file2, header=None, names=header_2, sep=',', index_col=None)
if os.path.exists(file3):
        df_3 = pd.read_csv(file3, header=None, names=header_3, sep=',', index_col=None)

common_columns = df_1.columns.intersection(df_2.columns).intersection(df_3.columns)
filtered_1 = df_1[common_columns]
filtered_2 = df_2[common_columns]
filtered_3 = df_3[common_columns]
concatenated_df = pd.concat([filtered_1, filtered_2, filtered_3], ignore_index=True)

Tenho um protocolo que é restrito apenas a tipos de classe:

protocol Plugin: AnyObject {}

Agora, quero usar o plugin como chave do mapa de hash. Não quero que o Pluginprotocolo se estenda de Hashable, porque teria que escrever any Pluginem todos os lugares (já que ele herdaria "Auto-Requisito" do protocolo pai).

Então, para contornar isso, quero criar um wrapper genérico. Não quero usar AnyHashable, porque quero um tipo mais restrito em caso de erros.

public struct ObjectHashable<T: AnyObject>: Hashable {
  
  public let object: T
  
  public init(object: T) {
    self.object = object
  }
  
  public static func ==(lhs: Self, rhs: Self) -> Bool {
    return ObjectIdentifier(lhs.object) == ObjectIdentifier(rhs.object)
  }
  
  public func hash(into hasher: inout Hasher) {
    hasher.combine(ObjectIdentifier(object))
  }
}

Agora eu quero fazer algo como

typealias PluginHashable = ObjectHashable<Plugin>

No entanto, isso me dá erro:

requisito especificado como 'T': 'AnyObject' [com T = qualquer plugin]

Então eu mudei para

typealias PluginHashable = ObjectHashable<any Plugin>

E recebi o mesmo erro:

requisito especificado como 'T': 'AnyObject' [com T = qualquer plugin]

Pelo que entendi, embora Plugino protocolo seja limitado a ser um tipo de classe, any Pluginele não é. No entanto, não sei o que fazer a seguir.

Atualizar:

Se eu não usar o genérico for ObjectHashable, funciona:

public struct PluginHashable: Hashable {
  
  public let plugin: Plugin
  
  public init(plugin: Plugin) {
    self.plugin = plugin
  }
  
  public static func ==(lhs: Self, rhs: Self) -> Bool {
    return ObjectIdentifier(lhs.plugin) == ObjectIdentifier(rhs.plugin)
  }
  
  public func hash(into hasher: inout Hasher) {
    hasher.combine(ObjectIdentifier(plugin))
  }
}

No entanto, esta solução só é utilizável para Pluginprotocolo, portanto não é ideal. Prefiro ter uma solução que funcione para todos os casos semelhantes.

Estou com um problema ao tentar alternar e adicionar classes a elementos quando ocorre um evento de clique do mouse. Da mesma forma, tenho vários elementos "li". Quero adicionar "class = subdrop active" à tag de âncora selecionada e "class = active" à tag li subsequente. Não tenho certeza se estou lidando com a manipulação de classes corretamente. Alguém poderia sugerir a abordagem correta?

<li class="submenu">
  <a href="javascript:void(0);">
    <i class="ti ti-layout-dashboard"></i>
    <span>Admin Profile</span>
    <span class="menu-arrow"></span>
  </a>
  <ul>
    <li>
      <a href="<?php echo base_url('admin_dashboard'); ?>">Dashboard</a>
    </li>
    <li>
      <a href="<?php echo base_url('admin_profile'); ?>">Profile</a>
    </li>
    <li>
      <a href="#">Settings</a>
    </li>
    <li>
      <a href="#">Contacts</a>
    </li>
  </ul>
</li>

Tentando obter os seguintes resultados em cliques li selecionados

<li class="submenu">
 <a href="javascript:void(0);" class="subdrop active"><i class="ti ti-layout-dashboard"></i><span>Admin Profile</span><span class="menu-arrow"></span>
</a>
<ul>
  <li><a href="<?php echo base_url('admin_dashboard'); ?>" class="active">Dashboard</a></li>
  <li><a href="<?php echo base_url('admin_profile'); ?>">Profile</a></li>
  <li><a href="#">Settings</a></li>
  <li><a href="#">Contacts</a></li>
</ul>
</li>

Neste código:

// Stack using LinkedList //

#include <stdio.h>
#include <stdlib.h>

struct Node {
    int data;
    struct Node* next;
};

struct Node* top = NULL;

short isEmpty(void) {
    if (top == NULL) {
        printf("error: The stack is empty.\n");
        return 1;
    }
    
    return 0;
}

void push(int value) {
    struct Node* newNode = (void*)malloc(sizeof(struct Node));
    if (!newNode) {
        printf("error: Heap overflow!\n");
        exit(1);
    }
    
    newNode->data = value;
    newNode->next = top;
    top = newNode;
}

int pop(void) {
    if (isEmpty()) {
        exit(1);
    }
    
    struct Node* ref = top;
    int val = top->data;
    top = top->next;
    free(ref);
    
    return val;
}

int peek(void) {
    if (isEmpty()) {
        exit(1);
    }
    
    return top->data;
}

void display(void) {
    if (isEmpty()) {
        exit(1);
    }
    
    while (top) {
        printf("%d\n", top->data);
        top = top->next;
    }
}

int main(void) {
    push(10);
    push(20);
    push(30);
    push(40);
    
    printf("Peek: %d\n", peek());
    int val = pop();
    printf("Popped: %d, now Peek: %d\n", val, peek());
    push(50);
    display();
    
    return 0;
}

Observe estas linhas:

int val = pop();
printf("Popped: %d, now Peek: %d\n", val, peek());

Ele retorna:Popped: 40, now Peek: 30

como esperado. No entanto, ao escrever desta forma:

printf("Popped: %d, now Peek: %d\n", pop(), peek());

Ele produz esta saída:Popped: 40, now Peek: 40

Aqui está um Godbolt .

Alguém pode me esclarecer por que é assim?

Tenho um pouco de conhecimento em C# e, até onde sei, a diferença entre C# e VB é quase apenas a sintaxe. Minha dúvida é que vi esta pergunta e as respostas (só há uma resposta) e, para ser sincero, não entendi qual é a relação entre a pergunta e a resposta :)

Então (até onde eu sei) em C# os elementos do array são alocados no heap (dentro do array).

O parágrafo (que está no livro) está errado ou esqueci de alguma coisa?

Estou desenvolvendo um aplicativo móvel full-stack usando o Appwrite para autenticação e serviços de back-end. O front-end se comunica com um gateway de API personalizado que envia solicitações para vários microsserviços.

Atualmente, estou usando a função account.createJWT() do Appwrite para autenticar usuários, mas os tokens JWT expiram a cada 15 minutos. Atualizar tokens com tanta frequência não é escalável para o meu aplicativo, especialmente com o crescimento da base de usuários. Por isso, estou tentando migrar para a validação de sessão em vez de JWTs.

O problema que estou enfrentando é: como autenticar corretamente as solicitações de front-end para meu gateway de API usando sessões do Appwrite?

Detalhes do ambiente:

Backend API gateway is built with FastAPI

Appwrite version: cloud

Frontend framework: React Native 

Minhas perguntas são:

What is the correct way to validate Appwrite user sessions from a backend service (API gateway) without using the frontend SDKs?

Is it possible to securely authenticate frontend requests to a custom backend using only Appwrite sessions (without using short-lived JWTs)?

If not, what would be the best scalable approach for authenticating requests in this setup?

Qualquer conselho, fluxo recomendado ou exemplos seriam muito apreciados!

Aqui está o que eu tentei:

I retrieve the user session on the frontend (account.get() gives me session info).

I send the session ID (or the Appwrite cookie) along with API requests to my gateway.

On the backend (in the API gateway), I try to validate the session by using the Appwrite Server SDK (account.getSession(sessionId)).

However, sometimes I get errors like:
Unauthorized: User is missing "account" scope.