Esta página lista as versões "centrais" do ActiveMQ Artemis JMS Client (de 1.0 a 2.40) e esta página contém links para as notas de versão de cada uma dessas versões.
A página mvnrepository.com também lista "JBoss Releases":
Onde estão as notas de lançamento das versões do JBoss? Qual versão do WildFly/JBoss está relacionada a qual versão "Central"?
Fiz alguns modelos que supostamente
O (1) test_sumdentro static_assertcompila, então acho que é constexpr.
Eu queria evitar duplicar os cálculos, então tentei colocar a declaração diretamente dentro da função (2) que calcula a soma. No entanto, a declaração sempre falha, independentemente da condição, em todas as versões abaixo. Isso pode ser resolvido de alguma forma?
#include <limits>
#include <stdexcept>
#include <type_traits>
template<typename T>
constexpr bool add(T& a, T b)
{
static_assert(std::is_integral<T>::value, "Only integral types are supported");
if ((b > 0) && (a > std::numeric_limits<T>::max() - b))
return false;
if ((b < 0) && (a < std::numeric_limits<T>::min() - b))
return false;
a += b;
return true;
}
//
template<typename T>
constexpr bool sum_impl(T& result)
{
return true;
}
template<typename T, typename... Rest>
constexpr bool sum_impl(T& result, T value, Rest... rest)
{
if (!add(result, value))
return false;
return sum_impl(result, rest...);
}
//
template<typename T, typename... Rest>
constexpr bool test_sum(T value, Rest... rest) // (1)
{
return sum_impl(value, rest...);
}
template<typename T, typename... Rest>
T sum(T value, Rest... rest) // (2) regular
{
if (!sum_impl(value, rest...))
throw std::overflow_error("Overflow in checked::sum");
return value;
}
template<typename T, typename... Rest>
constexpr T sum_cexpr(T value, Rest... rest) // (2) constexpr
{
// if (!sum_impl(value, rest...))
// static_assert(false, "Overflow"); // fail
// static_assert(sum_impl(value, rest...), "Overflow"); // fail
// if (!sum_impl(value, rest...))
// delegated_assert<false>(); // fail
return value;
}
template<bool B>
constexpr void delegated_assert()
{
if constexpr (!B)
static_assert(B);
}
//////
int main()
{
static_assert(test_sum(1, 2)); // (1) works
constexpr int a = sum_cexpr(10, 20, 30); // fails to compile
return 0;
}
Estou brincando com a resposta desta questão: Como testar se uma variável genérica é do tipo AnyObject
Essa solução parece não funcionar mais. Tenho este código:
public struct ObjectHashable<T>: Hashable {
public let object: T
public init(object: T) {
let t1 = type(of: object)
let b1 = t1 is AnyClass
print(t1) // Plugin
print(b1) // false
let t2 = T.self
let b2 = t2 is AnyClass
print(t2) // Plugin
print(b2) // false
let t3 = Mirror(reflecting: object).subjectType
let b3 = t3 is AnyClass
print(t3) // P
print(b3) // true
self.object = object
}
public static func ==(lhs: Self, rhs: Self) -> Bool {
return true
}
public func hash(into hasher: inout Hasher) {
}
}
protocol Plugin: AnyObject {}
class P: Plugin {}
typealias PluginHashable = ObjectHashable<Plugin>
PluginHashable(object: P())
Esse é um comportamento surpreendente.
1.
let t1 = type(of: object)
type(of:)deveria retornar o tipo dinâmico, que é P, não Plugin. Mas obtive "Plugin" impresso.
2.
let b1 = t1 is AnyClass
Não deveria ser verdade, já que t1 é um tipo de referência? (com base na resposta aqui: Como testar se uma variável genérica é do tipo AnyObject )
3.
let t2 = T.self
Isso imprime Plugin, o que faz sentido, porque eu Plugincoloquei<>
4.
let b2 = t2 is AnyClass
Isso é falso, mas acho que deveria ser verdade pelo mesmo motivo
5.
let t3 = Mirror(reflecting: object).subjectType // P
Isso imprime P, o que faz sentido
6.
let b3 = t3 is AnyClass // true
Isso é verdade, o que faz sentido. Mas por que é diferente dos outros dois casos?
Estou usando o Firestore. Ele requer regras de segurança.
Aqui está a consulta real que estou executando no grupo de coleta:
const db = getFirestore(app);
const MainCollection = collectionGroup(db, "list");
const searchQuery = query(
MainCollection,
where("destination", "==", itinerary.destination),
);
O caminho da coleta é
/maincollection/{userId}/list/{documents=**}.
As regras do Firebase sugeridas pelo CoPilot:
match /maincollection/{userId} {
allow read: if request.auth != null;
match /list/{document=**} {
allow read: if request.auth != null;
}
}
match /maincollection/{doc}/list/{itin} {
allow read: if request.auth != null;
}
match /maincollection/{doc}/list/{document=**} {
allow read: if request.auth != null;
}
match /maincollection/{document=**} {
allow read, write: if request.auth != null;
}
todos eles estão me dando o seguinte erro:
Erro ao pesquisar itinerários: FirebaseError: Permissões ausentes ou insuficientes.
Estou tentando filtrar uma Lista de Itens do SharePoint para obter apenas aqueles que foram modificados no último dia. De acordo com os seguintes documentos da API do Graph, eu deveria conseguir usar a função
$filter=lastModifiedDateTime ge {24 horas atrás}
parâmetro de consulta
https://learn.microsoft.com/en-us/graph/api/listitem-list?view=graph-rest-1.0
https://learn.microsoft.com/en-us/graph/api/resources/listitem?view=graph-rest-1.0
Um exemplo de URL que estou usando é:
https://graph.microsoft.com/v1.0/sites/{site-id}/lists/{list-id}/items?$filter=lastModifiedDateTime em 2025-04-28T00:00:00Z
Estou recebendo uma "Solicitação inválida" da Microsoft sem nenhum motivo real.
Se eu não adicionar um filtro, posso devolver todos os itens sem problemas.
Meu script gera um gráfico composto, composto por dezenas de linhas e segmentos de linha. Estou tentando adicionar uma legenda personalizada ao gráfico, que contém apenas 3 dessas linhas, mas não consigo controlar o estilo das linhas e marcadores nessa legenda.
O enredo é assim:
Na lenda, quero que Line1o estilo seja 'b.-', Line2o estilo seja 'r-o'e Line3o estilo seja 'g-o'.
Existe uma maneira de definir uma legenda com um número definido de rótulos e estilos de linha específicos?
Olá... estou tentando adicionar um parâmetro à minha consulta, mas recebo este erro:
"errorMessage": "{'S': 'ERROR', 'V': 'ERROR', 'C': '42601', 'M': 'syntax error at or near \”$2\"', 'P': '3793', 'F': 'scan.l', 'L': '1146', 'R': 'scanner_yyerror'}"
Isso funciona:
import pg8000
account_id = 1234
sql = “”"
SELECT *
FROM samples
WHERE account_id = %s
AND delete_date IS NULL
ORDER BY date DESC
“”"
cursor.execute(sql, (account_id,))
Mas isso não:
import pg8000
account_id = 1234
start_date = query_string_params['start-date'] if 'start-date' in query_string_params else None
// start_date format is: '2025-02-04'
filters = “"
if start_date is not None:
filters = filters + f" AND DATE(sample_date) >= '{start_date}'"
sql = “”"
SELECT *
FROM samples
WHERE account_id = %s
AND delete_date IS NULL
%s
ORDER BY date DESC
“”"
cursor.execute(sql, (account_id, filters))
Alguém tem ideia do que estou fazendo errado?
Enquanto trabalhava no LeetCode 675 , me deparei com um comportamento estranho PriorityQueue Comparatorque não consigo explicar.
Para resumir, vou apresentar a essência da declaração do problema; os interessados podem lê-la em detalhes no LeetCode.
Dada uma matriz mxn chamada
forest, algumas células são designadas comotrees. O desafio é encontrar o número mínimo de passos para visitar (cortar) todas as células da árvore, em ordem crescente de altura da árvore.
Para resolver isso, encontro todas as árvores e as ordeno em ordem crescente de altura. Em seguida, calculo a distância mínima de cada árvore até a próxima executando uma busca A* usando a função heurística:distance from source + Manhattan distance from the goal
O número mínimo de passos para cortar todas as árvores é a soma de todas as distâncias A*. Se em algum momento a busca A* não retornar um caminho, eu aborto.
class Solution {
private final int[][] dx = new int[][] {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};
public int cutOffTree(List<List<Integer>> forest) {
int[] curr = new int[] {0, 0};
int dist = 0;
for (int[] next : getTreesSortedByHeight(forest)) {
int d = minDist(forest, curr, next);
if (d < 0) {
return -1;
}
curr = next;
dist += d;
}
return dist;
}
private List<int[]> getTreesSortedByHeight(List<List<Integer>> forest) {
List<int[]> trees = new ArrayList<>();
for (int row = 0; row < forest.size(); row++) {
for (int col = 0; col < forest.get(0).size(); col++) {
if (forest.get(row).get(col) > 1) {
trees.add(new int[] {row, col});
}
}
}
trees.sort(Comparator.comparingInt(a -> forest.get(a[0]).get(a[1])));
return trees;
}
int minDist(List<List<Integer>> forest, int[] start, int[] goal) {
int m = forest.size();
int n = forest.get(0).size();
Map<Integer, Integer> costs = new HashMap<>();
costs.put(start[0] * n + start[1], manhattanDist(start[0], start[1], goal));
// GOTCHA: Fetching the distance from the cost map using the coordinates doesn't work!
Queue<int[]> heap = new PriorityQueue<>(Comparator.comparingInt(a -> a[0]));
heap.offer(new int[] {0, 0, start[0], start[1]}); // [cost, distance, row, column]
while (!heap.isEmpty()) {
int[] curr = heap.poll();
int dist = curr[1];
int row = curr[2];
int col = curr[3];
if (row == goal[0] && col == goal[1]) {
return dist;
}
for (int[] d : dx) {
int r = row + d[0];
int c = col + d[1];
if (r >= 0 && r < m && c >= 0 && c < n && forest.get(r).get(c) > 0) {
int cost = dist + 1 + manhattanDist(r, c, goal);
if (cost < costs.getOrDefault(r * n + c, Integer.MAX_VALUE)) {
costs.put(r * n + c, cost);
heap.offer(new int[] {cost, dist + 1, r, c});
}
}
}
}
return -1;
}
private int manhattanDist(int row, int col, int[] goal) {
return Math.abs(goal[0] - row) + Math.abs(goal[1] - col);
}
}
Observe que cada entrada de heap contém o custo heurístico . Logicamente, isso é desnecessário , pois a entrada também contém as coordenadas da célula (linha e coluna), com as quais podemos obter a distância do costsmapa da seguinte maneira:
Queue<int[]> heap = new PriorityQueue<>(Comparator.comparingInt(a -> costs.get(a[1] * n + a[2]);
Mas isso não funciona e falha em um dos casos de teste. O caso de teste é enorme, então não vejo sentido em colá-lo aqui, pois é improvável que alguém tenha tempo para depurá-lo.
O que eu gostaria de saber é o porquê dessa estranheza.
Editar: código completo adicionado conforme solicitado em um comentário.
Eu tenho este exemplo de Polars DataFrame:
import polars as pl
df = pl.DataFrame({
"id": [1, 2, 3, 4, 5],
"variable1": [15, None, 5, 10, 20],
"variable2": [40, 30, 50, 10, None],
})
Estou tentando filtrar todas as colunas do meu dataframe usando o método pl.all(), e também tentei usar pl.any_horizontal() == Condition. No entanto, estou recebendo o seguinte erro:
ComputeError: The predicate passed to 'LazyFrame.filter' expanded to multiple expressions:
col("id").is_not_null(),
col("variable1").is_not_null(),
col("variable2").is_not_null(),
This is ambiguous. Try to combine the predicates with the 'all' or `any' expression.
Aqui estão minhas tentativas de enfrentar isso.
# Attempt 1:
(
df
.filter(
pl.all().is_not_null()
)
)
# Attempt 2:
(
df
.filter(
pl.any_horizontal().is_not_null()
)
)
Saída desejada, mas não é escalável para DataFrames maiores:
(
df
.filter(
pl.col("variable1").is_not_null(),
pl.col("variable2").is_not_null()
)
)
Como posso filtrar todas as colunas de forma escalável sem especificar cada coluna individualmente?
Estou tentando gravar um arquivo em um diretório existente, usando node, path e fs.
throw new Error(`Error writing: ${err.message}`);
^
Error: Error writing: ENOENT: no such file or directory, open 'C:\Users\username\test\cheerio\output\55-207-0-228_2025-04-29_15:27:51.txt'
at C:\Users\username\test\cheerio\components\WriteFile.js:31:11
at node:fs:2385:7
at FSReqCallback.oncomplete (node:fs:188:23)
Estou trabalhando neste repositório . A função que manipula o arquivo de gravação node:fs encontra-se em /component/WriteFile.js ; ela está sendo invocada aqui, nestas linhas .
Esta é a estrutura do projeto:
project-root/
├── components/
├── node_modules/
├── output/ // Target for file write.
├── .gitignore
├── index.js
├── LICENSE
├── package-lock.json
├── package.json
└── README.md
Publicando código relevante aqui para sua conveniência. WriteFile.js
const fs = require('node:fs');
const path = require('path');
const makeFile = async (fileName, { contentString, ip }) => {
const now = new Date();
const dateString =
now.getFullYear() +
'-' +
String(now.getMonth() + 1).padStart(2, '0') +
'-' +
String(now.getDate()).padStart(2, '0') +
'_' +
String(now.getHours()).padStart(2, '0') +
':' +
String(now.getMinutes()).padStart(2, '0') +
':' +
String(now.getSeconds()).padStart(2, '0');
contentString = `DATE: ${dateString}\nFor ip: ${ip}\n${contentString}`;
const filepath = path.join(
__dirname,
'..',
'output',
`${fileName}_${dateString}.txt`
);
try {
await fs.writeFile(filepath, contentString, 'utf16le', (err) => {
if (err) {
throw new Error(`Error writing: ${err.message}`);
}
});
return 'Success';
} catch (error) {
console.error('\nError:\n', error.message, '\n');
} finally {
// Code that will run regardless of try/catch result
// Remember, don't have a return in finally.
console.log('Final completed.');
}
};
module.exports = { makeFile };
Que está sendo chamado de:
async function main() {
let start = performance.now();
let elapse;
i = 0;
for (const ip of ipList) {
i++;
if (i > 3) {
break;
}
const sleep = (ms) =>
new Promise((resolve) => {
setTimeout(resolve, ms);
});
await sleep(500);
await makeFile(ip.replaceAll('.', '-'), {
contentString: 'Mockdata',
ip: ip
});
}
elapse = performance.now() - start;
console.log('Total time elapsed: ', elapse / 1000);
}