All perguntas(coding)

O PowerShell oferece suporte a scripts de validação para variáveis. Isso é mais comumente usado para validar parâmetros de função, mas pode ser aplicado a qualquer variável. Esses scripts de validação são executados sempre que o valor da variável é alterado.

# create a variable with a validation script
[ValidateScript({
    if (-not ($_.Length -in @(8, 16, 24))) {
        Write-Host 'Validate Failed'
        throw "Value '$_' has invalid length: $($_.Length)"
    } else {
        Write-Host 'Validate Success'
    }
    $true
})][System.String]$MyValidatedArg = "a" * 8 # prints "Validate Success"

# Each one of these will trigger the validation script
Write-Host "Several valid assignments..."
$MyValidatedArg = "b" * 8 # prints "Validate Success"
$MyValidatedArg = "b" * 8 # prints "Validate Success"
$MyValidatedArg = "b" * 16 # prints "Validate Success"
$MyValidatedArg = "b" * 24 # prints "Validate Success"

Se eu atribuísse um valor inválido à variável, isso geraria uma exceção

$MyValidatedArg = "foo" # throws an exception

Estranhamente, consigo ignorar o script de validação se eu especificar novamente a restrição de tipo durante a atribuição. Sei que "simplesmente não faça isso" é uma opção, mas o ponto principal da minha pergunta é: por que isso funciona?

[System.String]$MyValidatedArg = "123456789" # works even though this value is invalid

A princípio, pensei que fosse apenas um sombreamento de variáveis. Tipo, talvez eu estivesse criando uma segunda variável, objeto ou algo assim, especificando a restrição de tipo uma segunda vez. Tentei capturar uma referência à variável para ver se ela manteria o script de validação. Não mantém, mas não estou muito familiarizado com os detalhes internos do PowerShell para saber se este é um teste válido.

# create a reference and assign through the reference
Write-Host "Assigning through reference..."
$refToParameter = [ref] $MyValidatedArg
$refToParameter.Value = "c" * 24 # prints "Validate Success"
Write-Host " Read via variable: $MyValidatedArg"
Write-Host " Read via reference: $($refToParameter.Value)"

# the reference and the variable are linked
# Assignments to either trigger the validation script
Write-Host "Assigning through normal variable again..."
$MyValidatedArg = "d" * 24 # prints "Validate Success"
Write-Host " Read via variable: $MyValidatedArg"
Write-Host " Read via reference: $($refToParameter.Value)"

# This works, which is odd
Write-Host "Assigning with [System.String]..."
[System.String]$MyValidatedArg = "123456789" # invalid, nothing printed
Write-Host " No exceptions yet!"

# I thought this was some sort of variable shadowing thing, but the reference shows the new value too
Write-Host "The link between the variable and the reference is still there..."
$MyValidatedArg = "e" * 8 # valid, nothing printed
Write-Host " Read via variable: $MyValidatedArg"
Write-Host " Read via reference: $($refToParameter.Value)"

# and now we appear to have killed the validation script
Write-Host "Regular invalid assignment..."
$MyValidatedArg = "123456789" # invalid, nothing printed
Write-Host " It works now for some reason"

Tenho visto muitas postagens sobre esse assunto, mas nenhuma é exatamente o que estou procurando.

Quero encontrar todas as maneiras pelas quais um número inteiro positivo N maior que 1 pode ser expresso como a soma de no máximo N números inteiros de 1 a N, como de costume.

Por exemplo, na notação padrão, estas são todas as partições de 6:

[(1, 1, 1, 1, 1, 1),
 (1, 1, 1, 1, 2),
 (1, 1, 1, 2, 1),
 (1, 1, 1, 3),
 (1, 1, 2, 1, 1),
 (1, 1, 2, 2),
 (1, 1, 3, 1),
 (1, 1, 4),
 (1, 2, 1, 1, 1),
 (1, 2, 1, 2),
 (1, 2, 2, 1),
 (1, 2, 3),
 (1, 3, 1, 1),
 (1, 3, 2),
 (1, 4, 1),
 (1, 5),
 (2, 1, 1, 1, 1),
 (2, 1, 1, 2),
 (2, 1, 2, 1),
 (2, 1, 3),
 (2, 2, 1, 1),
 (2, 2, 2),
 (2, 3, 1),
 (2, 4),
 (3, 1, 1, 1),
 (3, 1, 2),
 (3, 2, 1),
 (3, 3),
 (4, 1, 1),
 (4, 2),
 (5, 1),
 (6,)]

Agora, a notação é de entropia muito baixa: primeiro, cada ocorrência do número aumenta o tamanho de uma partição específica. Isso é ineficiente e é difícil contar as ocorrências dos números quando eles se repetem muitas vezes. Quero substituir todas as ocorrências de um número por uma tupla de dois elementos, na qual o primeiro elemento é o número e o segundo é a contagem. Por exemplo, (1, 1, 1, 1, 1, 1)é equivalente a (1, 6). Ambos contêm a mesma informação, mas um é claramente muito mais conciso.

E segundo, há muitas duplicatas na saída; por exemplo, há cinco partições que contêm quatro 1s e um 2, que são contadas como cinco elementos separados. Isso também é ineficiente, já que a adição é comutativa; mudar a ordem dos números não altera o resultado, então todos são equivalentes, são todos o mesmo elemento.

Entretanto, se substituirmos todos os cinco por apenas um elemento, perdemos informações.

Em vez disso, desejo substituí-lo pelo seguinte formato:

Counter({((1, 2), (2, 2)): 6,
         ((1, 1), (2, 1), (3, 1)): 6,
         ((1, 4), (2, 1)): 5,
         ((1, 3), (3, 1)): 4,
         ((1, 2), (4, 1)): 3,
         ((1, 1), (5, 1)): 2,
         ((2, 1), (4, 1)): 2,
         ((1, 6),): 1,
         ((2, 3),): 1,
         ((3, 2),): 1,
         ((6, 1),): 1})

Então, quero que o resultado seja um Counterem que as chaves sejam as partições exclusivas e os valores sejam quantas maneiras os números podem ser organizados.

E sim, eu escrevi uma função para isso, usando força bruta e memorização. Ela se mostrou bem eficiente.

Primeiro, esta é a implementação que gera o resultado no formato padrão. Posto aqui para comparação:

def partitions(number: int) -> list[tuple[int, ...]]:
    result = []
    stack = [(number, ())]

    while stack:
        remaining, path = stack.pop()
        if not remaining:
            result.append(path)
        else:
            stack.extend((remaining - i, path + (i,)) for i in range(remaining, 0, -1))

    return result

São necessários 582 milissegundos para encontrar todas as partições de 20 no CPython e 200 milissegundos no PyPy3:

CPython

In [22]: %timeit partitions(20)
582 ms ± 4.22 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

PyPy3

In [36]: %timeit partitions(20)
199 ms ± 3.17 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

Agora, a abordagem de força bruta com memorização que gera o formato pretendido:

PARTITION_COUNTERS = {}


def partition_counter(number: int) -> Counter:
    if result := PARTITION_COUNTERS.get(number):
        return result
    
    result = Counter()
    for i in range(1, number):
        for run, count in partition_counter(number - i).items():
            new_run = []
            added = False
            for a, b in run:
                if a == i:
                    new_run.append((a, b + 1))
                    added = True
                else:
                    new_run.append((a, b))
            
            if not added:
                new_run.append((i, 1))
            
            result[tuple(sorted(new_run))] += count
    
    result[((number, 1),)] = 1
    PARTITION_COUNTERS[number] = result
    return result

CPython

In [23]: %timeit PARTITION_COUNTERS.clear(); partition_counter(20)
10.4 ms ± 72.1 μs per loop (mean ± std. dev. of 7 runs, 100 loops each)

PyPy3

In [37]: %timeit PARTITION_COUNTERS.clear(); partition_counter(20)
9.75 ms ± 58.3 μs per loop (mean ± std. dev. of 7 runs, 100 loops each)

Leva apenas 10 milissegundos para encontrar todas as partições de 20, muito, muito mais rápido que a primeira função, e o PyPy3 não o torna mais rápido.

Mas como podemos fazer melhor? Afinal, estou apenas usando força bruta. Sei que existem muitos algoritmos inteligentes para partição de números inteiros, mas nenhum deles gera saídas no formato pretendido.

Gostaria de ter linhas no meu .gitignorearquivo que ignorassem um diretório inteiro e seus subdiretórios, além de quaisquer arquivos (e suas estruturas de pastas) que terminam em .pdf

No momento eu uso;

outputs/*
!outputs/**/*.pdf

e isso exclui o diretório de saídas e então parece incluir uma seleção aleatória de subdiretórios e .csv's e .png's.

A estrutura de pastas não é fixa para os arquivos PDF (pode ter 1 ou 8 subdiretórios), mas eu quero manter os arquivos .pdf apenas nessa outputs/pasta. Para ser sincero, achei que o que eu tinha era o certo!

Estou tentando criar um modelo LSTM para prever frases em linguagem de sinais com este formato de arquivo JSON. Este arquivo JSON contém as informações de coordenadas de 21 articulações de referência da mão para cada quadro e cada mão (mão esquerda, mão direita). Aqui está uma prévia dos meus dados de série temporal JSON.

{

        "frame": 123,
        "hands": [
            {
                "hand": "Left",
                "landmarks": [
                    {
                        "x": 0.4636201858520508,
                        "y": 0.3758980929851532,
                        "z": 7.529240519943414e-08,
                        "body_part": "wrist"
                    },

   ...

                    {
                        "x": 0.4639311134815216,
                        "y": 0.2574789524078369,
                        "z": -0.013109659776091576,
                        "body_part": "pinky_tip"
                    }
                ]
            },

            {
                "hand": "Right",
                "landmarks": [
                    {
                        "x": 0.5393109321594238,
                        "y": 0.6190552711486816,
                        "z": 1.0587137921902467e-07,
                        "body_part": "wrist"
                    },
...

                    {
                        "x": 0.4721616506576538,
                        "y": 0.5990280508995056,
                        "z": -0.006831812672317028,
                        "body_part": "pinky_tip"
                    }
                ]
            }
        ]
    },

As informações de coordenadas com localizações diferentes estão sendo repetidas para cada quadro. Ainda estou corrigindo esses dados de séries temporais JSON. Portanto, ainda não comecei a programar para LSTM. No entanto, estou preocupado se conseguirei usar esses dados de séries temporais JSON para LSTM.

No código abaixo, por que tenho que repetir cy.wrap(article)em vez de encapsulá-lo uma vez e armazenar o resultado encapsulado em uma variável reutilizável, como mostrado na linha três?

verifyArticleContent(article: JQuery<HTMLElement>, expected_article: Topic) {
            // Wrapping once does not work.
            // const article2 = cy.wrap(article)

            // Title
            cy.wrap(article).find('h2 a')
                .should('have.text', expected_article.title)
                .and('have.attr', 'href', '/forum/discussion/' + expected_article.id)

            // Description
            cy.wrap(article).find('p.data-description').should('have.text', 
                expected_article.description.substring(0, 300) + ' ...')

            // Details
            cy.wrap(article).find('p.data-author-date').should('have.text',
                expected_article.user?.username + ', ' +                          // username
                Util.dateToString(expected_article.date, 'en'))                   // date
}

Mais esclarecimentos e um exemplo de como pensei que funcionaria:

verifyArticleContent(article: JQuery<HTMLElement>, expected_article: Topic) {
            // Wrapping once does not work.
            const article2 = cy.wrap(article)

            // Title
            article2.find('h2 a')
                .should('have.text', expected_article.title)
                .and('have.attr', 'href', '/forum/discussion/' + expected_article.id)

            // STOPS WORKING HERE. If I comment out this description check, it fails on the details with the same (almost) error.
            // Description
            article2.find('p.data-description').should('have.text', 
                expected_article.description.substring(0, 300) + ' ...')

            // Details
            article2.find('p.data-author-date').should('have.text',
                expected_article.user?.username + ', ' +                          // username
                Util.dateToString(expected_article.date, 'en'))                   // date
}

imagem da mensagem de erro

Estou migrando a interface Taiga UI da versão 3 para a versão 4 em um projeto Angular. Como a TuiNotification deve ser usada na versão 4, se eu quiser usá-la para constantes como TuiNotification.Warning? Isso funcionava na versão 3, mas foi descontinuado e sugeriram usar a TuiNotificationT do mesmo pacote, mas ela não existe na versão 4.

Veja um exemplo de como o código atual se parece:

...
import { TuiNotification } from '@taiga-ui/core';
...

@Injectable()
export class SomeInputService extends RxState<{
}> {
  constructor(
    private notifications: TuiAlertService
  ) {
    super();

    this.doSomething();
  }

  private doSomething() {
    if (!something) {
       return this.showNotification(
         marker('Not working'), 
         marker('Wrong file'),
         **TuiNotification.Warning**       
       );
    }
    else {
       return this.showNotification(
         marker('Some error'),
         text ?? '',
         **TuiNotification.Error**
       );
    }
  }

  private showNotification(
    title: string,
    text: string,
    status: TuiNotification
  ) {
    const label = this.transloco.translate(title);
    const message = this.transloco.translate(text);
    this.hold(
      this.notifications.open(message, { status, label, autoClose: 10000 })
    );
  }
}

O erro que recebo é Property 'Warning' does not exist on type 'typeof TuiNotification'.ts

Estou tentando provar um teorema de correção para inserção em uma fila de prioridades baseada em lista. Aqui estão a função de inserção, a propriedade indutiva e a prova com a qual estou trabalhando:

Fixpoint insert (x : nat) (l : list nat) : list nat :=
  match l with
  | [] => [x]
  | h :: t => if x <=? h then x :: h :: t else h :: insert x t
  end.

Inductive list_PQ_property : list nat -> Prop :=
| sorted_empty : list_PQ_property []
| sorted_one : forall x, list_PQ_property [x]
| sorted_add : forall x y l,
    x <= y ->
    list_PQ_property (y :: l) ->
    list_PQ_property (x :: y :: l).

Theorem insert_correctness :
  forall (pq : PQ) (x : el),
    list_PQ_property pq ->
    list_PQ_property (insert x pq).
Proof.
  intros pq x H.
  induction H as [ | y | a b l Hab IHl].
  - simpl. apply sorted_one.
  - simpl. destruct (x <=? y) eqn:E.
    + apply Nat.leb_le in E. apply sorted_add.
      * apply E.
      * apply sorted_one.
    + apply Nat.leb_gt in E.
      apply Nat.lt_le_incl in E.
      apply sorted_add.
      * apply E.
      * apply sorted_one.
  - simpl. destruct (x <=? a) eqn:E.
    + apply Nat.leb_le in E.
      apply sorted_add.
      * apply E.
      * apply sorted_add.
        -- apply Hab.
        -- apply IHl.
  + destruct (x <=? b) eqn:E'.
      * apply Nat.leb_le in E'.
      apply sorted_add.
      apply Nat.lt_le_incl.
      apply Nat.leb_gt in E. apply E.
      apply sorted_add.
        ++ apply E'.
        ++ apply IHl.
       * apply Nat.leb_gt in E'.
        apply sorted_add.
        -- apply Hab.
Admitted.

Quando comecei a prova, tudo foi simples até chegar ao terceiro caso. No início, fiquei preso no

apply sorted_add.
        ++ apply E'.
        ++ apply IHl.

em que meu objetivo era, b <= xmas minha hipótese para E' era, x <= baté que eu contornei as propriedades de transitividade aplicando um monte de funções Nat encontradas em Coq. Agora estou preso em onde minha hipótese IHIHl se parece com isso: IHIHl : list_PQ_property (insert x (b :: l)) mas meu objetivo é este: list_PQ_property (b :: insert x l).

Não tenho certeza de como consertar isso ou se estou provando isso corretamente.

Qualquer orientação será apreciada.

Para mais informações, meu objetivo completo até agora é o seguinte:

1 goal
x : el
a, b : nat
l : list nat
Hab : a <= b
IHl : list_PQ_property (b :: l)
IHIHl : list_PQ_property (insert x (b :: l))
E : (x <=? a) = false
E' : b < x
______________________________________(1/1)
list_PQ_property (b :: insert x l)

Tentei usar IHIHl, mas não adiantou. Estou um pouco perdido, pois acho que foi assim que construí minha prova.

Estou trabalhando em um projeto que espera que o Maven resolva problemas de versão e dependências, mas continua travando na fase de compilação. Primeiro, eu tinha a conhecida "referência desconhecida" para o JDK 24: [JAVAC][com.sun.tools.javac.code.TypeTag :: UNKNOWN] [24] não foi possível compilar o código.

Comecei a mexer nas dependências e adicionar manualmente as bibliotecas jar ao projeto , mas o Maven parece não conseguir mais resolver algumas dependências, como lombok: "java: pacote lombok não existe"

POM.xml atual:

 <?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
     xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 
  http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>3.2.0</version>
</parent>
<groupId>com.ttulka.samples</groupId>
<artifactId>ddd-example-ecommerce</artifactId>
<version>1.0-SNAPSHOT</version>

<dependencies>
    <dependency>
        <groupId>org.apache.maven</groupId>
        <artifactId>maven-plugin-api</artifactId>
        <version>3.9.9</version>
        <scope>provided</scope>
    </dependency>
    <dependency>
        <groupId>org.apache.maven.plugin-tools</groupId>
        <artifactId>maven-plugin-annotations</artifactId>
        <version>${maven-plugin-tools.version}</version>
        <scope>provided</scope>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-thymeleaf</artifactId>
    </dependency>
    <dependency>
        <groupId>nz.net.ultraq.thymeleaf</groupId>
        <artifactId>thymeleaf-layout-dialect</artifactId>
        <version>3.3.0</version>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-jdbc</artifactId>
    </dependency>
    <dependency>
        <groupId>com.h2database</groupId>
        <artifactId>h2</artifactId>
    </dependency>
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <version>1.18.38</version>
        <scope>provided</scope>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-devtools</artifactId>
        <scope>runtime</scope>
        <optional>true</optional>
    </dependency>

    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
    <dependency>
        <groupId>io.rest-assured</groupId>
        <artifactId>rest-assured</artifactId>
        <scope>test</scope>
    </dependency>
    <dependency>
        <groupId>com.tngtech.archunit</groupId>
        <artifactId>archunit</artifactId>
        <version>1.2.1</version>
        <scope>test</scope>
    </dependency>
</dependencies>

<build>
    <pluginManagement>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-plugin-plugin</artifactId>
                <version>${maven-plugin-tools.version}</version>
                <executions>
                    <execution>
                        <id>help-mojo</id>
                        <goals>
                            <!-- good practice is to generate help 
mojo for plugin -->
                            <goal>helpmojo</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </pluginManagement>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
        </plugin>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-compiler-plugin</artifactId>
            <configuration>
                <source>17</source>
                <target>17</target>
            </configuration>
        </plugin>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-enforcer-plugin</artifactId>
            <version>3.5.0</version>
        </plugin>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-surefire-plugin</artifactId>
            <version>3.5.3</version>
        </plugin>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-failsafe-plugin</artifactId>
            <version>3.5.3</version>
        </plugin>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-source-plugin</artifactId>
            <version>3.3.1</version>
        </plugin>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-javadoc-plugin</artifactId>
            <version>3.11.2</version>
        </plugin>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-dependency-plugin</artifactId>
            <version>3.8.1</version>
        </plugin>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-deploy-plugin</artifactId>
            <version>3.1.4</version>
        </plugin>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-release-plugin</artifactId>
            <version>3.1.1</version>
        </plugin>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-clean-plugin</artifactId>
            <version>3.4.1</version>
        </plugin>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-resources-plugin</artifactId>
            <version>3.3.1</version>
        </plugin>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-jar-plugin</artifactId>
            <version>3.4.2</version>
            <configuration>
                <skipIfEmpty>${jar.skip-if-empty}</skipIfEmpty>
            </configuration>
        </plugin>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-war-plugin</artifactId>
            <version>3.4.0</version>
        </plugin>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-ear-plugin</artifactId>
            <version>3.3.0</version>
        </plugin>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-install-plugin</artifactId>
            <version>3.1.4</version>
        </plugin>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-jxr-plugin</artifactId>
            <version>3.6.0</version>
        </plugin>
        <plugin>
            <artifactId>maven-site-plugin</artifactId>
            <version>4.0.0-M16</version>
        </plugin>
        <plugin>
            <artifactId>maven-project-info-reports- 
plugin</artifactId>
            <version>3.9.0</version>
        </plugin>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-compiler-plugin</artifactId>
            <configuration>
                <annotationProcessorPaths>
                    <path>
                        <groupId>org.projectlombok</groupId>
                        <artifactId>lombok</artifactId>
                        <version>1.18.38</version>
                    </path>
                </annotationProcessorPaths>
            </configuration>
        </plugin>
    </plugins>
</build>
</project>

Estou tentando escrever meu próprio motor de jogo. Empacotei os arquivos, como os recursos dos jogos, para que o motor pudesse lê-los com mais rapidez e facilidade. No entanto, encontrei um problema. Não consegui encontrar a origem do problema. Quando tento ler os dados do arquivo PAK que criei, há um desvio nos dados lidos. Não consigo ler os dados corretamente.

Estrutura do arquivo:

[Header]
[Index Table]
[Asset Data]

Códigos:

namespace EngineCore
{
    public class PakEntry
    {
        public string Name { get; set; }
        public byte Type { get; set; }
        public uint Offset { get; set; }
        public uint Size { get; set; }
    }
}

namespace EngineCore
{
    public interface IPakReaderBackend
    {
        byte[] Read(PakEntry entry);
        void Dispose();
    }
}

using System;
using System.IO;
using System.IO.MemoryMappedFiles;

namespace EngineCore
{
    public class MemoryMappedBackend : IPakReaderBackend, IDisposable
    {
        private readonly MemoryMappedFile mmf;
        private MemoryMappedViewAccessor accessor;

        public MemoryMappedBackend(string path)
        {
            mmf = MemoryMappedFile.CreateFromFile(path, FileMode.Open);
        }

        public byte[] Read(PakEntry entry)
        {
            using var accessor = mmf.CreateViewAccessor(entry.Offset, entry.Size, MemoryMappedFileAccess.Read);
            byte[] buffer = new byte[entry.Size];
            accessor.ReadArray(0, buffer, 0, buffer.Length);
            return buffer;
        }

        public void Dispose()
        {
            accessor?.Dispose();
            mmf?.Dispose();
            GC.SuppressFinalize(this);
        }
    }
}

using System.IO;

namespace EngineCore
{
    public class SeekAndReadBackend : IPakReaderBackend
    {
        private readonly string pakFilePath;

        public SeekAndReadBackend(string path)
        {
            pakFilePath = path;
        }

        public byte[] Read(PakEntry entry)
        {
            byte[] buffer = new byte[entry.Size];
            using (FileStream fs = new FileStream(pakFilePath, FileMode.Open, FileAccess.Read))
            {
                fs.Seek(entry.Offset, SeekOrigin.Current);
                fs.Read(buffer, 0, buffer.Length);
            }
            return buffer;
        }

        public void Dispose() { }
    }
}

using System;
using System.Collections.Generic;
using System.IO;
using System.Text;

namespace EngineCore
{
    public class PakWriter : IDisposable
    {
        private const string Magic = "TGPAK";
        private const ushort Version = 1;
        private readonly List<PakEntry> entries;
        private readonly MemoryStream dataStream;

        public PakWriter()
        {
            entries = new List<PakEntry>();
            dataStream = new MemoryStream();
        }

        public void AddFile(string filePath, byte type)
        {
            byte[] fileData = File.ReadAllBytes(filePath);
            uint offset = (uint)dataStream.Position;


            dataStream.Write(fileData, 0, fileData.Length);

            entries.Add(new PakEntry
            {
                Name = Path.GetFileName(filePath),
                Type = type,
                Offset = offset,
                Size = (uint)fileData.Length
            });
        }

        public void Save(string outputPath)
        {
            using (FileStream fs = new FileStream(outputPath, FileMode.Create, FileAccess.Write))
            {
                using (BinaryWriter bw = new BinaryWriter(fs))
                {
                    bw.Write(Encoding.ASCII.GetBytes(Magic.PadRight(6, '\0')));
                    bw.Write(Version);
                    bw.Write((uint)entries.Count);
                    long indexOffsetPos = fs.Position;
                    bw.Write((uint)0);

                    dataStream.Seek(0, SeekOrigin.Begin);
                    dataStream.CopyTo(fs);

                    long indexOffset = fs.Position;

                    foreach (var entry in entries)
                    {
                        byte[] nameBytes = Encoding.UTF8.GetBytes(entry.Name);
                        bw.Write((byte)nameBytes.Length);
                        bw.Write(nameBytes);
                        bw.Write(entry.Type);
                        bw.Write(entry.Offset);
                        bw.Write(entry.Size);
                    }

                    fs.Seek(indexOffsetPos, SeekOrigin.Begin);
                    bw.Write((uint)indexOffset);
                }
            }
        }

        public void Dispose()
        {
            entries.Clear();
            dataStream?.Dispose();
            GC.SuppressFinalize(this);
        }
    }
}

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;

namespace EngineCore
{
    public class PakReader : IDisposable
    {
        public List<PakEntry> Entries { get; private set; } = new List<PakEntry>();
        private readonly IPakReaderBackend backend;

        public PakReader(string filePath, bool useMemoryMapping = false)
        {
            using (FileStream fs = new FileStream(filePath, FileMode.Open, FileAccess.Read))
            {
                using (BinaryReader br = new BinaryReader(fs))
                {
                    string magic = Encoding.ASCII.GetString(br.ReadBytes(6)).TrimEnd('\0');
                    if (magic != "TGPAK") throw new Exception("Invalid pak");

                    ushort version = br.ReadUInt16();
                    uint entryCount = br.ReadUInt32();
                    uint indexOffset = br.ReadUInt32();

                    fs.Seek(indexOffset, SeekOrigin.Begin);
                    for (int i = 0; i < entryCount; i++)
                    {
                        byte nameLen = br.ReadByte();
                        string name = Encoding.UTF8.GetString(br.ReadBytes(nameLen));
                        byte type = br.ReadByte();
                        uint offset = br.ReadUInt32();
                        uint size = br.ReadUInt32();

                        Entries.Add(new PakEntry
                        {
                            Name = name,
                            Type = type,
                            Offset = offset,
                            Size = size
                        });
                    }
                }
            }
            backend = useMemoryMapping ? new MemoryMappedBackend(filePath) : new SeekAndReadBackend(filePath);
        }

        public byte[] Read(string name)
        {
            PakEntry entry = Entries.FirstOrDefault(e => e.Name == name);
            if (entry == null)
            {
                return null;
            }
            return backend.Read(entry);
        }

        public void Dispose()
        {
            backend.Dispose();
            GC.SuppressFinalize(this);
        }
    }
}

Teste

// Write
PakWriter pakW = new PakWriter();
pakW.AddFile("Assets/Test1.txt", 7);
pakW.AddFile("Assets/Test2.txt", 7);
pakW.AddFile("Assets/Player.fbx", 3);
pakW.AddFile("Assets/Wall.res", 5);
pakW.Save("Bin/data.pak");
pakW.Dispose();

// Read
PakReader pakR = new PakReader("Bin/data.pak");
Console.WriteLine("Assets:");
foreach (PakEntry entry in pakR.Entries)
{
    Console.WriteLine($" - {entry.Name} (Type: {entry.Type}, Size: {entry.Size} bytes)");
}
byte[] data = pakR.Read("Test2.txt");
Console.WriteLine("Test2:" + Encoding.UTF8.GetString(data));
Console.ReadLine();
pakR.Dispose();

Saída:

Assets:
 - Test1.txt (Type: 7, Size: 20 bytes)
 - Test2.txt (Type: 7, Size: 20 bytes)
 - Player.fbx (Type: 3, Size: 759512 bytes)
 - Wall.res (Type: 5, Size: 13544 bytes)
Test2:AAAAAAAAAAAAAAAABBBB

Tenho a seguinte pergunta sobre lambdas em C++: Por que a primeira captura (em pf) por referência l-value não é permitida, mas a segunda é (pf2)?

Não estou argumentando, de uma forma ou de outra, que isso &z = z * 10deveria ser permitido; quero entender a razão técnica por trás do erro do compilador afirmando que isso não é permitido ( error: cannot capture (10 * z) by reference).

Muito obrigado antecipadamente. Esta comunidade é incrível, e peço desculpas antecipadamente se houve perguntas repetidas sobre o mesmo tópico no passado. Não consegui encontrá-las.

#include <iostream>
#include <utility>

using namespace std;

int main () {   
  int z = 10;

  // not allowed   
  auto pf = [&z = 10*z](int x) {
    ++z;
    cout << "z: " << z << endl;
    return z;   };

  // allowed   
  auto pf2 = [&z = z](int x) {
    ++z;
    cout << "z: " << z << endl;
    return z;   
  };

  cout << "pf: " << pf(20) << endl;   
  cout << "pf: " << pf(20) << endl;   
  cout << "pf2: " << pf2(20) << endl;   
  cout << "pf2: " << pf2(20) << endl;   
  return 1; 
}