All perguntas(coding)

Estou tentando criar um aplicativo MAUI para Android, para ser depurado em um tablet conectado localmente. Estou tentando armazenar a localização do keystore na caixa de texto do projeto, mas o VS2022 se recusa a aceitar a string. Agora, adicionei-a manualmente ao csproj, mas ainda não aparece e não está assinando.

Esta é uma parte do meu arquivo CSPROJ:

<PropertyGroup Condition="'$(Configuration)|$(TargetFramework)|$(Platform)'=='Debug|net9.0-android35.0|AnyCPU'">
  <AndroidKeyStore>True</AndroidKeyStore>
    <AndroidSigningKeyStore>c:\clients\android.keystore</AndroidSigningKeyStore>
    <AndroidSigningStorePass>thePassword</AndroidSigningStorePass>
    <AndroidSigningKeyAlias>android</AndroidSigningKeyAlias>
    <AndroidSigningKeyPass>android</AndroidSigningKeyPass>
    <AndroidApkSignerAdditionalArguments></AndroidApkSignerAdditionalArguments>
  </PropertyGroup>

Esta é a saída de erro que recebo:

1>Deployment failed to Acer B3-A40.
1>Deploy failed
========== Deploy: 0 succeeded, 1 failed, 0 skipped ==========
========== Deploy completed at 11:47 and took 05.605 seconds ==========
LastWriteTime of `C:\Users\eric\source\repos\MauiApp3\MauiApp3\bin\Debug\net9.0-android35.0\com.companyname.mauiapp3-Signed.apk`: 2025-04-09 15:45:25
DEBUG RunShellCommand 719014592815 pm install -d "/data/local/tmp/com.companyname.mauiapp3-Signed.apk" [1837ms]
DEBUG RunShellCommand 719014592815 rm "/data/local/tmp/com.companyname.mauiapp3-Signed.apk" [1657ms]
FastDeploy
target.prop.ro.product.build.version.sdk: 24
target.prop.ro.product.cpu.abilist: arm64-v8a;armeabi-v7a;armeabi
target.prop.ro.product.manufacturer: Acer
target.prop.ro.product.model: B3-A40
target.prop.ro.product.cpu.abi: arm64-v8a
deploy.error.code: ADB0010
deploy.tool: xamarin.sync
deploy.result: Failed
deploy.supports.fastdev: True
deploy.systemapp: False
deploy.duration.ms: 0
pii.deploy.error: Mono.AndroidTools.InstallFailedException: The package was not properly signed (NO_CERTIFICATES).
at Mono.AndroidTools.Internal.AdbOutputParsing.CheckInstallSuccess(String output, String packageName) in /Users/runner/work/1/s/xamarin-android/external/android-platform-support/src/Mono.AndroidTools/Internal/AdbOutputParsing.cs:line 315
at System.Threading.Tasks.Task.Execute()

Criei o keystore com os seguintes comandos na caixa DOS do administrador:

cd "c:\program files\Android\jdk\jdk-8.0.302.8-hotspot\jdk8u302-b08\jre\bin\"
keytool -genkey -v -keystore c:\clients\android.keystore -storepass thePassword -alias android -keypass android -keyalg RSA -keysize 2048 -validity 10000 -dname "cn=MyName, ou=MyGroup, o=MyCompany, c=Canada" -storetype pkcs12
keytool -genkey -v -keystore c:\clients\android.keystore -storepass thePassword -alias other -keypass other!5 -keyalg RSA -keysize 2048 -validity 10000 -dname "cn=MyName, ou=MyGroup, o=MyCompany, c=Canada" -storetype pkcs12

Meu VS2022 está atualizado (v17.13.6). Qual é o segredo para fazer com que ele assine o aplicativo?

data Zero = Zero 
data Succ x = Succ x 

class NatToPeano a b | a -> b where 
    toPean :: b
instance NatToPeano 0 Zero where toPean = Zero 
instance (NatToPeano (x-1) a) => NatToPeano x (Succ a) where
     toPean = Succ (toPean @(x-1))

Isso produz o erro:

 Functional dependencies conflict between instance declarations:
  instance NatToPeano 0 Zero -- Defined at parsejava.hs:26:10
  instance NatToPeano (x - 1) a => NatToPeano x (Succ a)
    -- Defined at parsejava.hs:28:10

 26 | instance NatToPeano 0 Zero where

Tenho uma GPU AMD. Estou usando pyopencl. Tenho um contexto e uma fila. Então criei um array:

import pyopencl
import pyopencl.array
ctx = pyopencl.create_some_context(interactive=False)
queue = pyopencl.CommandQueue(ctx)
array = pyopencl.array.empty(queue, [10], dtype=float)
print(array)

A instrução print está exibindo alguns conteúdos. O pyopencl transferiu dados da memória da GPU para imprimir esses valores? Se não, de onde eles vêm?

Estou tentando abrir um arquivo de texto via Sharepoint para ler, mas continuo recebendo uma mensagem de erro (Tempo de execução 52 Nome ou número inválido).

Recebo o erro de depuração na linha strFile: Abrir strFile para entrada como #1

Dim FileToOpen as Variant
Dim sh as Worksheet
Dim strFile As String
    
    '-------Open Text file -------------
Set FileToOpen = Application.FileDialog(msoFileDialogFilePicker)

With FileToOpen
        .Filters.Clear
        .Filters.Add "Text Files", "*.tx*"
        .Title = "Browse to text File"
        .AllowMultiSelect = False
        .InitialFileName = "https:\\my.sharepoint.com\sites\THALI01\"
        If .Show = True Then
            strFile = .SelectedItems(1)
        End If
    End With

   '''-----reading lines on text file-----

 Open strFile For Input As #1
    Do Until Left(Oneline, 42) = "Mapping Definition Name: "
      Line Input #1, Oneline
      DoEvents
    Loop
    
        Acq = Trim(Mid(Oneline, 42, 30))
        sh.Range("B8") = Acq
 
End Sub

Procurei por todo lugar e não consigo encontrar uma resposta definitiva (atual) para essa pergunta.

Tenho um UILabel configurado para usar dimensionamento dinâmico de fontes por questões de acessibilidade. Funcionou muito bem com esta linha de código:

attributes[.font] = UIFont.preferredFont(forTextStyle: .body)

No entanto, a fonte padrão não funciona para mim do ponto de vista do design.

Quando tento usar uma fonte personalizada, faço isso:

attributes[.font] = UIFont(name: "Futura-Medium", size: 17)

Isso me força a definir o tamanho, o que acredito que anula a capacidade de alterar a fonte dinamicamente.

Eu adoraria descobrir uma de duas soluções...

Ou defina a preferredFont universalmente como a fonte da minha escolha. Ou uma linha de código melhor na qual eu possa selecionar uma fonte personalizada e ainda ajustá-la dinamicamente.

Para recapitular... Atualmente, meu resultado é dimensionar o texto corretamente, mas uma fonte genérica com este código:

var attributes = [NSAttributedString.Key: Any]()
attributes[.font] = UIFont.preferredFont(forTextStyle: .body)
attributes[.foregroundColor] = UIColor.black

Ou é uma fonte mais adequada, mas não escala nada com este código:

var attributes = [NSAttributedString.Key: Any]()
attributes[.font] = UIFont(name: "Futura-Medium", size: 17)
attributes[.foregroundColor] = UIColor.black

Tenho uma classe modelo que contém uma tupla.

template <class... SomeTypes>
class Foo
{ ... };

Como posso aplicar uma restrição aos tipos contidos no pacote de parâmetros SomeTypes? Por exemplo, se eu quisesse garantir que todos os tipos se encaixassem no std::movableconceito?

E se SomeTypestambém houvesse modelos?

template < template<typename> class... SomeTypes>
class Bar
{ ... };

Aqui está um caso mais específico do que estou procurando. O código não deveria (e não compila) porque FooBnão é copiável.

Infelizmente, o compilador não exibe as melhores mensagens de erro quando isso acontece (no código com o qual estou lidando, os tipos são mais complexos e isso resulta em listas de erros gigantescas). Espero poder adicionar algum tipo de requirescláusula FooContainerque gere um erro muito mais claro.

#include <tuple>
#include <concepts>

template <typename ContainerType>
class Foo
{
};

template <typename ContainerType>
class FooA : public Foo<ContainerType>
{
    public:
    int some_data {0};

    void DoSomething()
    {
        some_data++;
    }
};

template <typename ContainerType>
class FooB : public Foo<ContainerType>
{
    public:
    // non-copyable object
    FooB() = default;
    FooB( const FooB& ) = delete;
    FooB& operator=( const FooB& ) = delete;
    ~FooB() = default;

    int some_data {0};

    void DoSomething()
    {
        some_data++;
    }
};


template < template<typename> class... SomeTypes>
// requires (std::copyable<SomeTypes...>) ???
class FooContainer
{
    public:
    std::tuple<SomeTypes<FooContainer>...> my_tuple;

    template <std::size_t I = 0, std::enable_if_t<I == sizeof...(SomeTypes)>* = nullptr>
    void DoAllThings()
    {
    }

    template <std::size_t I = 0, std::enable_if_t<I < sizeof...(SomeTypes)>* = nullptr>
    void DoAllThings()
    {
        std::get<I>(my_tuple).DoSomething();
        DoAllThings<I + 1>();
    }
};


using MyContainer = FooContainer<FooA, FooB>;

int main()
{
    MyContainer my_bar;
    my_bar.DoAllThings();
    MyContainer my_bar2 = my_bar;
}

--Edição 2--

Então, depois de brincar com algumas das sugestões aqui, o mais próximo que cheguei do que eu queria foi usar uma função estática externa para fazer a verificação.

template <typename FooType>
requires (std::copyable<FooType>)
constexpr bool FooTypeCheck()
{
    return true;
}

static_assert(FooTypeCheck<FooA<int>>());

Isso me dá a verificação que eu quero (se a classe Foo derivada é copiável) e, portanto, a saída do compilador mais fácil de ler se a verificação falhar. Para fins de verificação de tipo, o ContainerType não importa, então eu apenas passo um int. Infelizmente, isso também significa que preciso adicionar o static_assert para cada classe Foo derivada, e o int que eu passo para ContainerType é um pouco estranho.

--Edição Final (Resposta)-- Dei os créditos a @Ted Lyngmo pela resposta, pois estava próxima do que eu precisava. Como o parâmetro ContainerType é apenas parte do CRTP, ele realmente não importa para os propósitos da restrição, e posso usar apenas int, e a solução é um pouco mais simples.

template <template <typename> class FooType>
concept FooTypeCheck = std::copyable<FooType<int>>;

template < template<typename> class... SomeTypes>
requires (... && FooTypeCheck<SomeTypes>)
class FooContainer
{ ... };

Estou construindo trait-types (semelhantes a std::type_identity) para representar templates de diferentes tipos. Templates de valores variádicos de tipos mistos são um caso especial, e só consigo pensar em criá-los por meio de structs aninhadas, como mostrado abaixo.

O clang aceita isso, o gcc não.

template <typename ... Ts>
struct variadic_value_metatemplate_builder
    {
        template <template <Ts ... tt_Vs> typename TT>
        struct build
            {
                template <Ts ... Vs>
                using type = TT<Vs ...>;
            };
    };

( link compilador-explorador )

O erro do gcc é:

<source>:8:39: error: expansion pattern 'tt_Vs' contains no parameter packs [-Wtemplate-body]
    8 |                 using type = TT<Vs ...>;

quem está certo?

A formulação do erro do gcc parece incorreta, mas acho que está relacionada à exigência de que Vs ...e Ts ... tenham o mesmo tamanho, o que Vs ...não o torna livremente variável. Mas, pelo que sei, todos ainda são pacotes de parâmetros .

EDITAR: À PARTE: Por que isso pode ser útil?

Na verdade, é bem difícil criar um caso de uso prático (para esse tipo específico de modelo-modelo), mas aqui está minha tentativa rápida (altamente implausível, não muito boa).

Você está escrevendo uma rotina de teste para um grupo de operações gráficas de modelo. Algumas são do formato <int DIMENSION> , outras são <int DIMENSION, bool UNDO>, etc... Você quer escrever uma rotina de teste genérica para todos os formatos , que recebe um parâmetro de formulário, um conjunto de operações gráficas correspondentes e um conjunto de valores de teste constexpr para os parâmetros. Você pode então fazer algo como:

generic_graphics_test<metabuilder_DIMENSION_UNDO, variadic_auto_constants<2, false>, variadic_auto_constants<3, true>, [etc...]>::test<gfx_translate, gfx_scale, [etc...]>();

para testar de alguma forma as variedades 2D e 3D reversíveis de gfx_translatee gfx_scale. (onde test()recebe instâncias de build(acima) como parâmetros de modelo, que aqui representam as operações de modelo de translação e escala (brutas e não resolvidas) (como functores ou algo assim)).

(... isso é como meta-aninhamento-nível-4 ou algo assim :)

((Espero que pelo menos 17% disso seja semi-compreensível :))

Infelizmente, ainda não existe uma palavra-chave genérica "parâmetro-de-modelo-de-tipo-ou-valor-possivelmente-variádico" (seria muito bom, mas provavelmente seria muito difícil escrever código de compilador para ela), que permitiria que cada tipo possível de modelo-modelo fosse representado por um único modelo de característica.

Espero que alguém possa ajudar.

Herdei um projeto que utiliza um banco de dados Atlas Mongo. Fui solicitado a obter dados de uma coleção. Suponha que os documentos estejam estruturados na coleção da seguinte forma:

{ _id: 'Parent1', kids: [ { _id: 'Test1', grandkids: [ { name: 'Blah' } ] } ] },
{ _id: 'Parent2', kids: [ { _id: 'Test1', grandkids: [ { name: 'Bloh' } ] } ] },
{ _id: 'Parent3', kids: [ { _id: 'Test2', grandkids: [ { name: 'Bloh' } ] } ] }

Preciso obter o neto com o nome 'Bloh' quando o _id da criança for 'Teste 1', o que deve retornar dados do 2º documento.

Usando a interface web do Cloud MongoDb, tentei consultar assim, só para ver se conseguia obter o segundo documento de volta:

{
    '$and': [
        { 'kids._id': ObjectId('Test 1') },
        { 'kids.grandkids.name': 'Bloh' }
    ]
}

Mas não obtive nenhum resultado. Suspeito que possa ser porque o _id em kids não é único.

Supondo que eu consiga o segundo documento de volta, como faço para obter o neto correspondente de volta?

Desde já, obrigado!

Editar:

Usando o playground MongoDb, isso pode ser um problema:

Consulta inválida:

Linha 3: ObjectId inválido: o hash deve ter 24 caracteres

Infelizmente, kid._id não só é duplicado, como também nem sempre tem 24 caracteres.

O ConcurrentDictionarycódigo-fonte menciona a possibilidade de usar TAlternateKey, que é uma estrutura de referência. https://github.com/dotnet/runtime/blob/main/src/libraries/System.Collections.Concurrent/src/System/Collections/Concurrent/ConcurrentDictionary.cs

Além disso, depois de alguma pesquisa, encontrei outros exemplos interessantes. Como aqui: https://github.com/dotnet/runtime/blob/main/src/libraries/Microsoft.Extensions.Caching.Memory/src/MemoryCache.cs

#if NET9_0_OR_GREATER
            private readonly ConcurrentDictionary<string, CacheEntry>.AlternateLookup<ReadOnlySpan<char>> _stringAltLookup;

            public CoherentState()
            {
                _stringAltLookup = _stringEntries.GetAlternateLookup<ReadOnlySpan<char>>();
            }
#endif
//...
#if NET9_0_OR_GREATER
            internal bool TryGetValue(ReadOnlySpan<char> key, [NotNullWhen(true)] out CacheEntry? entry)
                => _stringAltLookup.TryGetValue(key, out entry);
#endif

#if NET9_0_OR_GREATER
            private readonly ConcurrentDictionary<string, CacheEntry>.AlternateLookup<ReadOnlySpan<char>> _stringAltLookup;

            public CoherentState()
            {
                _stringAltLookup = _stringEntries.GetAlternateLookup<ReadOnlySpan<char>>();
            }
#endif

Devo usar ReadOnlySpan<char>como chave em ConcurrentDictionaryvez de stringpara melhor desempenho?

Escrevi uma classe de filtro IIR com um estado de filtro interno e uma função elemento a elemento float filter(float x). Naturalmente, devido ao estado de filtro interno, ela filter()só pode ser chamada nas amostras na ordem em que estão organizadas na sequência.

Se eu agora aplicar essa função a um Eigen Array, como

input.unaryExpr(filter);

a ordem de execução será unaryExpr()sempre estritamente na ordem dos valores no array, ou pode ocorrer execução fora de ordem ou até mesmo paralelização?

Seria mais seguro escrever o loop explicitamente para garantir que a ordem seja sempre a esperada?

No momento, parece estar funcionando corretamente, mas não consigo encontrar nenhuma documentação explícita sobre seu comportamento.