All perguntas(coding)

Acho que sei a resposta para isso, mas apreciaria uma verificação de sanidade.

A invalidação do iterador se aplica a std::back_insert_iterators?

#include <cassert>
#include <iterator>
#include <vector>

int main() {
    auto v = std::vector<int>{ 0, 1, 2 };
    auto iter = std::back_inserter(v);
    *iter++ = 3;
    v.clear();    // invalidates iterators, but
    *iter++ = 4;  //  back_insert_iterator is special?
    assert(v.size() == 1 && v[0] == 4);
    return 0;
}

Este código funciona para mim porque a implementação std::back_insert_iterator do meu fornecedor não contém um iterador (ou ponteiro ou referência). Ele simplesmente chama o método push_back do contêiner.

Mas o padrão exige essa implementação? O back_insert_iterator de outro fornecedor poderia manter e manter um iterador one-past-the-end para usar com uma chamada para o método de inserção do contêiner? Parece que atenderia aos requisitos. Esta diferença, claro, é que seria vulnerável à invalidação.

Eu sei que cppreference.com não é oficial, mas é mais acessível que o padrão.

[Método claro de um vetor] [i]nvalida quaisquer ... iteradores referentes aos elementos contidos. Quaisquer iteradores além do final também são invalidados. [ cppreference.com , ênfase adicionada ]

Um std::back_insert_iterator pode ser o filho-propaganda de um iterador passado.

Estou transmitindo dados usando o netcat e canalizando a saída para o gawk. Aqui está um exemplo de sequência de bytes que o gawk receberá:

=AAAA;=BBBB;;CCCC==DDDD;

Os dados incluem quase todos os caracteres arbitrários, mas nunca contêm caracteres NULL, onde =e ;são reservados para serem delimitadores. À medida que pedaços de caracteres arbitrários são escritos, cada pedaço será sempre prefixado por um dos delimitadores e sempre sufixado por um dos delimitadores, mas qualquer um dos delimitadores pode ser usado a qualquer momento: =nem sempre é o prefixo e ;nem sempre é o sufixo. Ele nunca escreverá um pedaço sem escrever também um prefixo e um sufixo apropriados. À medida que os dados são analisados, preciso distinguir qual delimitador foi usado, para que meu código downstream possa interpretar adequadamente essas informações.

Como se trata de um fluxo de rede, o stdin permanece aberto após a leitura dessa sequência, enquanto aguarda dados futuros. Eu gostaria que o gawk lesse até que qualquer delimitador fosse encontrado e, em seguida, executasse o corpo do meu script gawk com todos os dados encontrados, garantindo ao mesmo tempo que ele lida adequadamente com o fluxo contínuo de stdin. Explico isso com mais detalhes abaixo.

Até agora

Aqui está o que tentei até agora (script zsh, usando gawk, no macOS). Para este post, simplifiquei o corpo para apenas imprimir os dados - meu script gawk completo tem um corpo muito mais complicado. Também simplifiquei o fluxo do netcat para apenas catum arquivo (junto com cat'ing stdin para imitar o comportamento do fluxo).

cat example.txt - | gawk '
BEGIN {
    RS = "=|;";
}
{
    if ($0 != "") {
        print $0;
        fflush();
    }
}
'

example.txt

=AAAA;=BBBB;=CCCC;=DDDD;

Minha tentativa lida com êxito com a maioria dos dados... até o registro mais recente. Ele fica esperando por mais dados do stdin e não consegue executar o corpo do meu script para o registro mais recente, apesar de um delimitador apropriado estar claramente disponível no stdin.

Saída atual: (falha ao processar o registro mais recente de DDDD)

AAAA
BBBB
CCCC
[hang here, waiting for future data]

Resultado desejado: (processa com sucesso todos os registros, incluindo o mais recente)

AAAA
BBBB
CCCC
DDDD
[hang here, waiting for future data]

O que exatamente poderia ser a causa desse problema e como posso resolvê-lo? Reconheço que este parece ser um cenário extremo. Muito obrigado a todos pela ajuda!

Editar: consolidação de comentários, esclarecimentos diversos e várias observações/realizações

Aqui estão algumas observações diversas que encontrei durante a depuração, antes e depois de fazer esta postagem originalmente. Essas edições também esclarecem algumas dúvidas que surgiram nos comentários e consolidam as informações espalhadas por vários comentários em um único lugar. Também inclui algumas conclusões que fiz sobre como o gawk funciona internamente, com base nas informações extremamente esclarecedoras dos comentários. As informações nesta edição substituem qualquer informação potencialmente conflitante que possa ter sido discutida nos comentários.

1. Investiguei brevemente se isso poderia ser um problema de buffer de pipe imposto pelo sistema operacional. Depois de mexer na stdbufferramenta para desabilitar todo o buffer de pipe, parece que o buffer não é o problema, pelo menos não no sentido tradicional (veja o item nº 3).

2. Percebi que se o stdin estiver fechado e um regex for usado para RS, nenhum problema ocorrerá. Por outro lado, se stdin permanecer aberto e RS não for uma regex (ou seja, uma string de texto simples), também não ocorrerão problemas. O problema só ocorre se o stdin permanecer aberto e o RS for um regex. Assim, podemos razoavelmente assumir que é algo relacionado a como o regex lida com um fluxo contínuo de stdin.

3. Percebi que se meu RS com regex ( RS = "=|;";) tiver 3 caracteres... e o stdin permanecer aberto... ele para de travar depois que exatamente 3 caracteres adicionais aparecerem no stdin. Se eu ajustar o comprimento do meu regex para 5 caracteres ( RS = "(=|;)"), a quantidade de caracteres adicionais necessários para retornar do travamento será ajustada de acordo. Combinado com a discussão extremamente esclarecedora com Kaz, isso estabelece que o enforcamento é um artefato do próprio mecanismo regex. Como Kaz disse, quando o mecanismo de regex analisa RS = "=|;";, ele acaba tentando ler caracteres adicionais do stdin para ter certeza de que o regex é compatível, apesar dessa leitura adicional não ser estritamente necessária para o regex em questão, o que obviamente causa um espere no stdin. Também tentei adicionar quantificadores preguiçosos ao regex, o que em teoria significa que o mecanismo regex pode retornar imediatamente, mas infelizmente isso não acontece, pois este é um detalhe de implementação do mecanismo regex.

4. Os documentos gawk aqui e aqui afirmam que quando RS é um único caractere, ele é tratado como uma string de texto simples e faz com que RS corresponda sem invocar o mecanismo regex. Por outro lado, se RS tiver 2 ou mais caracteres, ele será tratado como uma regex e o mecanismo de regex será invocado (posteriormente colocando em jogo o problema discutido no item 3). No entanto, isso parece um pouco enganador, o que é um detalhe de implementação do gawk. Eu tentei RS = "xy";(e ajustei meus dados de acordo) e testei novamente meu experimento do nº 3. Nenhum travamento ocorreu e a saída correta foi impressa, o que deve significar que apesar de RS ter 2 caracteres, ele ainda está sendo tratado como uma string de texto simples - o mecanismo regex nunca é invocado e o problema de travamento nunca ocorre. Portanto, parece haver alguma filtragem adicional sobre se o RS é tratado como texto simples ou como regex.

5. Então... agora que descobrimos a causa raiz do problema... o que fazemos a respeito? Uma idéia óbvia seria evitar o uso do mecanismo regex... mas meu script ainda precisa corresponder a qualquer delimitador usando algum tipo de cláusula OR... então isso parece exigir a escrita de um analisador de dados personalizado como um programa C ou de outra forma. Embora eu pudesse fazer isso, e certamente resolveria o problema, mas considerando a tarefa em questão, prefiro não seguir esse caminho de ervas daninhas.

6. Isso nos leva à solução alternativa de Ed Morton, que é provavelmente o melhor caminho a seguir, ou talvez alguma pequena derivada dela. Resumindo sua abordagem abaixo:

Basicamente, use outras ferramentas CLI, ou loops de leitura de shell, ou talvez até mesmo múltiplas invocações de gawk, para fazer uma conversão antecipadamente, antes que os dados sejam fornecidos para a invocação primária do gawk. Como Ed disse, substitua cada delimitador para que todos tenham o sufixo do caractere NULL. Como isso é feito antes que o gawk veja qualquer dado, o gawk pode ser configurado para usar o caractere NULL como RS, o que seria tratado como uma string de texto simples e não como uma regex, o que significa que o problema de suspensão da regex nunca entra em jogo. A partir daí, o delimitador real e o bloco de dados podem ser decodificados e processados ​​da maneira que você desejar.

O próprio gawk pode até ser capaz de fazer conversões antecipadas... desde que cada delimitador em questão possa ser encontrado usando um RS de texto simples e não um RS regex. Tenha cuidado com delimitadores que contenham caracteres especiais para uma regex, pois isso pode fazer com que o gawk o trate como uma regex quando você não esperava.

Embora eu já tenha marcado a resposta de Ed como a solução, acho que minha solução final será um híbrido da abordagem de Ed, do insight de Kaz e de algumas realizações subsequentes que fiz graças a eles. Gostaria de poder marcar duas respostas como soluções! Obrigado a todos pela ajuda, especialmente Ed Morton e Kaz!

Em R, suponha que eu tenha um vetor como:

vector<-c("Red", "   ", "", "5", "")

Quero contar quantos elementos deste vetor são apenas strings vazias que consistem apenas em espaços ou nenhum espaço . Para este vetor muito curto, são apenas três . O segundo, terceiro e quinto elementos são apenas espaços ou nenhum espaço. Eles não possuem caracteres como letras, números, símbolos, etc.

Existe alguma função ou método que conte isso? Eu queria algo que pudesse usar em vetores maiores, em vez de apenas observar cada elemento do vetor.

Quando adiciono linhas de grade a um gráfico de log, parece que todas as linhas de grade possíveis são adicionadas automaticamente e eu gostaria de incluir apenas as linhas principais. Tentei desligar os tiques menores, mas não surtiu efeito.

Por exemplo:

loglog([0.000001,0.1],[0.000001,0.1])
grid on
gca.YAxis.MinorTick = 'off'

Como posso ter apenas linhas de grade nas marcações dos eixos rotulados?

Eu tenho um arquivo de cabeçalho C (.h):

typedef uint8_t paraFunction(uint8_t paraVal, uint8_t paraNum);
paraFunction *paraCallTable[256];

E eu tenho um arquivo fonte C (.c):

paraFunction *paraCallTable[] = {   fn1, fn2, ... fn255, fn256 };

No entanto, a matriz termina na seção de dados. Quero que esteja em código/flash porque os endereços das funções (os dados do array) são constantes. A matriz é usada por funções em outros arquivos de origem.

Como reescrevo essas declarações para tornar tudo constante? E onde eles precisam estar (.c ou .h)?

Pesquisei no Google e tentei um zilhão de maneiras diferentes e obviamente não entendi.

Estou experimentando metaprogramação em Python (CPython 3.10.13) e notei algum comportamento estranho object.__new__(bem, estranho para mim, pelo menos). Dê uma olhada no experimento a seguir (não é um código prático, apenas um experimento ) e nos comentários. Observe que object.__new__parece mudar seu comportamento com base no primeiro argumento:

# Empty class inherit __new__ and __init__ from object
class Empty:
    pass

# Confirmation of inheritance
assert Empty.__new__ is object.__new__, "Different __new__"
assert Empty.__init__ is object.__init__, "Different __init__"

empty_obj = Empty()
uinit_empty_obj = object.__new__(Empty)

assert type(empty_obj) is type(uinit_empty_obj), "Different types"

try:
    object.__new__(Empty, 10, 'hi', hello='bye')
except TypeError as e:
    # repr(e) mentioned the Empty class
    print(repr(e))

# Overwrite the object __new__ and __init__ methods
# __new__ and __init__ with the same signature
class Person:
    def __new__(cls, name, age):
        """Does nothing bassicaly. Just overwrite `object.__new__`."""
        print(f'Inside {cls.__name__}.__new__')
        return super().__new__(cls)
    
    def __init__(self, name, age):
        print(f'Inside {type(self).__name__}.__init__')
        self.name = name
        self.age = age

a_person = Person('John Doe', 25)
uinit_person = Person.__new__(Person, 'Michael', 40)

try:
    # Seems an obvious error since object() doesn't take any arguments
    another_uinit_person = object.__new__(Person, 'Ryan', 25)
except TypeError as e:
    # Indeed raises TypeError, but now there isn't a mention of the Person class in repr(e)
    print('`another_uinit_person` :', repr(e))

# Now, some weird things happen (well, weird for me).
# Inherit __new__ from object and overwrite __init__.
# __new__ and __init__ with unmatching signatures.
# A basic Python class. Works just fine like suppose to.
class Vehicle:
    def __init__(self, model):
        self.model = model

# Confirmation of __new__ inheritance.
assert Vehicle.__new__ is object.__new__, "Nop, it isn't"

a_vehicle = Vehicle('Honda')

# I would understand if CPython autogenerated a __new__ method matching __init__
# or a __new__ method that accepts all arguments.
# The following try-except-else suggests the last, but the assert statement above 
# indicates that Vehicle.__new__ is actually object.__new__.
try:
    # Doesn't raise any exceptions
    uinit_vehicle = Vehicle.__new__(Vehicle, 'Honda', 10, ('four-wheels',), hello='bye')
except Exception as e:
    print(repr(e))
else:
    print('`uinit_vehicle` : constructed just fine', uinit_vehicle)

# Now the following runs just fine
try:
    # Doesn't raise any exceptions
    another_unit_vehicle = object.__new__(Vehicle, 'Toyota')
    another_unit_vehicle = object.__new__(Vehicle, 'Toyota', 100, four_wheels=True)
except Exception as e:
    print(repr(e))
else:
    print('`another_unit_vehicle` : constructed just fine:', another_unit_vehicle)

Eu obtive a seguinte saída:

TypeError('Empty() takes no arguments')
Inside Person.__new__
Inside Person.__init__
Inside Person.__new__
`another_uinit_person` : TypeError('object.__new__() takes exactly one argument (the type to instantiate)')
`uinit_vehicle` : constructed just fine <__main__.Vehicle object at 0x00000244D15A7A90>
`another_unit_vehicle` : constructed just fine: <__main__.Vehicle object at 0x00000244D15A7A30>

Minhas perguntas:

1. Por que o primeiro TypeErrormencionou a Emptyturma e o segundo apenas object.__new__?
2. Por que object.__new__(Person, 'Ryan', 25)levantou TypeErrore object.__new__(Vehicle, 'Toyota')não object.__new__(Vehicle, 'Toyota', 100, four_wheels=True)fez?

Basicamente: o que object.__new__acontece por baixo do capô?

Parece-me que ele está realizando uma verificação um tanto estranha nos métodos do primeiro argumento __new__e/ou __init__substituição, se houver.

Estou tentando filtrar os seguintes dados com base na existência do usernamesubdicionário.

Uma solução ideal seria quando eu não precisasse mencionar todas as chaves, por exemplo agtsvcaccount, sqlsvcaccount, sapwd, porque isso deveria ser genérico em outros esquemas.

Este é um exemplo de entrada com a variável input_parameters, esta saída é de uma tarefa de depuração do Ansible.

ok: [localhost] => {
    "msg": {
        "ansible": {
            "limit": [
                "vm1234.vmdomain.com",
                "vm5678.vmdomain.com"
            ]
        },
        "mssql": {
            "edition": "standard",
            "language": "en",
            "setupconfig": {
                "action": "Install",
                "agtsvcaccount": {
                    "type": "System User",
                    "username": "SQL_Agt",
                    "vault": "credvault",
                    "visibility": false
                },
                "agtsvcstartuptype": "Automatic",
                "features": [
                    "SQLENGINE"
                ],
                "forcereboot": false,
                "instancename": "MSSQLINSTANCE",
                "npenabled": true,
                "sapwd": {
                    "type": "Database",
                    "username": "sa",
                    "vault": "credvault",
                    "visibility": false
                },
                "securitymode": "SQL",
                "sqlcollation": "SQL_Latin1_General_CP1_CI_AS",
                "sqlsvcaccount": {
                    "type": "System User",
                    "username": "SQL_Svc",
                    "vault": "credvault",
                    "visibility": false
                },
                "sqlsvcstartuptype": "Automatic",
                "sqlsysadminaccounts": [
                    "Administrator"
                ],
                "tcpenabled": true
            },
            "version": "2022"
        }
    }
}

No momento, estou usando algo assim, que não é genérico/dinâmico o suficiente, e não quero usar account_identifierspara outros esquemas, que são muito semelhantes.

- name: 'Process credentials'
  ansible.builtin.include_role:
    name: 'mycollection.generic'
    tasks_from: 'user/{{ item.value.vault }}.yml'
  loop: '{{ input_parameters.mssql.setupconfig | dict2items }}'
  when: 'item.key in account_identifiers'
  vars:
    account_identifiers: ['sapwd','sqlsvcaccount','agtsvcaccount','ftsvcaccount','rssvcaccount','assvcaccount','issvcaccount']

Alguma idéia de como fazer isso?
Tentei tirar uma ideia da documentação do Ansible, mas acho que está faltando alguma coisa.

No C++ 20, quando uso std::ranges::views::take()em a std::ranges::istream_view(), o próximo token após a istream_viewiteração da visualização take é ignorado.

Considere o seguinte trecho de código C++20:

#include <iostream>
#include <ranges>
#include <sstream>
#include <vector>
#include <algorithm>

namespace rn = std::ranges;

int main() {
    std::string input = "1 2 3 4 5 6 7 8 9 10";
    std::istringstream input_stream(input);

    std::vector<int> head;
    rn::copy(rn::istream_view<int>(input_stream) | rn::views::take(5),
             std::back_inserter(head));

    int next_int = 0;
    input_stream >> next_int;

    for(auto x : head) std::cout << x << " ";
    std::cout << next_int << std::endl;
}

Quando compilo e executo este código em g++14 ou clang++17, a seguinte saída é produzida (observe o "6" ausente):

1 2 3 4 5 7

Link Godbolt: https://godbolt.org/z/vdGvx9666

Por que isso acontece? Este é o comportamento pretendido? O que pode ser feito para contornar isso?

Eu criei o seguinte dataframe do pandas

import pandas as pd
import numpy as np

ds = {
      'col1' : 
          [
              ['U', 'U', 'U', 'U', 'U', 1, 0, 0, 0, 'U','U', None],
              [6, 5, 4, 3, 2],
              [0, 0, 0, 'U', 'U'],
              [0, 1, 'U', 'U', 'U'],
              [0, 'U', 'U', 'U', None]
              ]
      }

df = pd.DataFrame(data=ds)

O quadro de dados fica assim:

print(df)
                                      col1
0  [U, U, U, U, U, 1, 0, 0, 0, U, U, None]
1                          [6, 5, 4, 3, 2]
2                          [0, 0, 0, U, U]
3                          [0, 1, U, U, U]
4                       [0, U, U, U, None]

Para cada linha em col1, preciso verificar se cada elemento igual a Una lista é seguido (da esquerda para a direita) por qualquer valor além de Ue None: nesse caso eu criaria uma nova coluna (chamada iCount) com valor 1. Caso contrário, 0.

No exemplo acima, o dataframe resultante ficaria assim:

                                      col1 iCount
0  [U, U, U, U, U, 1, 0, 0, 0, U, U, None]      1
1                          [6, 5, 4, 3, 2]      0
2                          [0, 0, 0, U, U]      0
3                          [0, 1, U, U, U]      0
4                       [0, U, U, U, None]      0

Somente na primeira linha o valor Ué seguido por um valor que não é Unem None(é 1)

Eu tentei este código:

col5 = np.array(df['col1'])

for i in range(len(df)):
    iCount = 0

    for j in range(len(col5[i])-1):
        
        print(col5[i][j])
        
        if((col5[i][j] == "U") & ((col5[i][j+1] != None) & (col5[i][j+1] != "U"))):
            
            iCount += 1
            
        else:
            iCount = iCount
    

Mas recebo este dataframe (errado):

                                      col1  iCount
0  [U, U, U, U, U, 1, 0, 0, 0, U, U, None]       0
1                          [6, 5, 4, 3, 2]       0
2                          [0, 0, 0, U, U]       0
3                          [0, 1, U, U, U]       0
4                       [0, U, U, U, None]       0

Alguém pode me ajudar por favor?

Estou aprendendo o princípio SOLID. Ao aprender o "Princípio da Inversão de Dependência", descobri que a classe deve depender de interfaces em vez de classes concretas.

Isso significa que a composição não é permitida? Além disso, a agregação é igual ao DIP?

Composição:

    class HPDesktop {
        private BluetoothMouse bluetoothMouse;
        private BluetoothKeyboard bluetoothKeyboard;
    
        public HPDesktop(){
            bluetoothMouse = new BluetoothMouse();
            bluetoothKeyboard = new BluetoothKeyboard();
        } 
     }

DIP: (Isso parece ser uma agregação)

class HPDesktop {
    private Mouse mouse;
    private Keyboard keyboard;

    public HPDesktop(Mouse mouse, Keyboard keyboard){
        this.mouse = mouse;
        this.keyboard = keyboard;
    }
}