Alcinoe Component Library di Zeus64 è una libreria open source di componenti visivi e non visivi per Delphi.
Lettore video OpenGL completo, wrapper Delphi per WebRTC, controllo nativo TEdit per iOS/Android, controlli FireMonkey migliorati, messaggistica cloud Firebase, login con SDK Facebook per Android/iOS, parser Json/Bson, wrapper ImageMagick, client MongoDB.
Alcinoe è compatibile con Delphi Rio 10.3.3 e Delphi Sydney 10.4.2.
https://github.com/Zeus64/alcinoe
Con Delphi Alexandria 11.1, ora supporta il download di MOD (rimosso).
Alcinoe è ora completamente compatibile con Delphi Athens 12.3..
Installa Alcinoe.
Se non hai intenzione di utilizzare alcun componente visivo di Alcinoe durante la progettazione, non è necessario installare nulla, semplicemente aggiungi {alcinoe_rootdir}\source al percorso di ricerca del tuo progetto.
Se hai intenzione di utilizzare componenti visivi durante la progettazione, devi installare il BPL. Avvia Delphi e vai in Componente > Installa pacchetti... e scegli il file BPL che si trova in {alcinoe_rootdir}\lib\bpl\alcinoe\Win32\sydney\Alcinoe_sydney.bpl (se utilizzi Delphi Sydney, altrimenti scegli la directory corrispondente alla tua versione di Delphi). Devi comunque aggiungere {alcinoe_rootdir}\source al percorso di ricerca del tuo progetto.
Alcinoe migliora anche leggermente il codice sorgente originale di Delphi. In questo modo, devi andare in {alcinoe_rootdir}\embarcadero\sydney\10_4_2 ed eseguire update.bat per recuperare e applicare le patch al codice sorgente originale di Delphi. Il file batch presuppone che il codice sorgente originale sia situato in "c:\Program Files (x86)\Embarcadero\Studio\21.0\source" e che tu abbia GIT nel tuo percorso. Dopo che il file batch è stato eseguito, il codice sorgente di Delphi dovrà includere questo codice sorgente nel percorso di ricerca del tuo progetto.
Per utilizzare appieno le librerie che sfruttano le funzionalità di Java 1.8 (come webRTC, exoplayer, ecc.), è necessario eseguire la "desugaring" (la desugaring consente di utilizzare queste funzionalità su dispositivi più vecchi sostituendo i nuovi bytecode e le API del linguaggio con versioni precedenti durante il processo di build). Con d8.bat (sostituzione di dx.bat), la desugaring è abilitata per impostazione predefinita. Pertanto, ora puoi utilizzare la maggior parte delle ultime modifiche del linguaggio pur puntando a dispositivi più vecchi. In attesa che Embarcadero sostituisca dx.bat con d8.bat, dobbiamo rendere DX.bat un "proxy" per D8.bat. Per farlo, sostituisci il tuo file DX.bat originale (il mio si trova in c:\SDKs\android\build-tools\30.0.3\d8.bat) con quello che si trova in {alcinoe_rootdir}\tools\D8Proxy\dx.bat. Ulteriori dettagli sono disponibili qui: https://quality.embarcadero.com/browse/RSP-24155
Lettore video OpenGL completo per FireMonkey.
ALVideoPlayer renderizzerà un video su una TEXTURE. Questo è molto importante perché puoi integrare completamente il video nel form di Delphi e puoi posizionare qualsiasi controllo sopra di esso, poiché supporta l'ordine Z. I lettori video ufficiali di Delphi sono semplicemente finestre native del lettore video sopra il form e quindi non supportano l'ordine Z.
Su Android, utilizzo ExoPlayer. ExoPlayer supporta funzionalità come lo streaming adattivo dinamico su HTTP (DASH), HLS, SmoothStreaming e la crittografia comune, che non sono supportate da MediaPlayer. È progettato per essere facile da personalizzare ed estendere. Su iOS, utilizzo AVPlayer con supporto HLS come ExoPlayer.
lettore video per FireMonkey lettore video per FireMonkey lettore video per FireMonkey
wrapper Delphi per WebRTC
WebRTC (Web Real-Time Communications) è una tecnologia che consente alle applicazioni e ai siti web di acquisire e, facoltativamente, trasmettere audio e/o video, nonché di scambiare dati arbitrari tra browser e applicazioni mobili senza la necessità di un intermediario. L'insieme di standard che comprende WebRTC consente di condividere dati ed effettuare teleconferenze peer-to-peer, senza che l'utente debba installare plug-in o altri software di terze parti.
il componente TALWebRTC semplifica l'aggiunta di chat video e audio alle tue applicazioni, aprendo un mondo completamente nuovo di interattività.
wrapper Delphi per WebRTC
controlli nativi iOS/Android TEdit e TMemo per FireMonkey
L'idea è quella di combinare i controlli FireMonkey con i controlli nativi della piattaforma quando l'implementazione di determinate funzionalità in tali controlli diventa molto complessa (come webbrowser, edit, memo, datepicker, ecc.). Tuttavia, non si tratta di creare form distinti per diverse piattaforme, come ad esempio offre http://www.turbococoa.com/ (ma questa opzione è anch'essa una buona alternativa, dipende da te).
In Delphi (berlin), esiste già un controllo per la piattaforma iOS che è stato implementato in modo abbastanza buono, ma quasi nessun controllo per la piattaforma Android, quindi ho iniziato a creare controlli nativi per Android/iOS come TEdit/TMemo. Questi controlli funzionano principalmente come finestre posizionate sopra il form (quindi, ovviamente, senza l'ordine z con i controlli FireMonkey).
Disegno.
Disegno.
Controlli FireMonkey con buffering rapido/doppio e rendering nativo.
Rettangolo.
Cerchio.
Testo (Può anche disegnare testo HTML su iOS/Android/Windows/macOS).
Glifo.
ecc.
TALRectangle
TALRectangle
Il fatto
La pittura dei controlli FireMonkey a volte può essere lenta, o, per dirla diversamente, non sufficientemente veloce per uno scorrimento fluido. Ad esempio, se si considera un semplice TRectangle con angoli arrotondati, la procedura di pittura può richiedere circa 3ms! Quindi, se si hanno circa 20 TRectangle visibili sullo schermo, il tempo necessario per ridisegnare l'intero schermo è di circa 60ms (e normalmente non si hanno solo TRectangle, ma anche TLabel, TCheckbox, ecc.). Dopo, è solo una questione di matematica: impiega 100ms per ridisegnare lo schermo, quindi si possono ottenere solo circa 10 fotogrammi al secondo (in realtà, si avranno molti meno), quindi lo scorrimento non può essere fluido 🙁
La soluzione
Non volevo ricostruire i controlli FireMonkey, è un lavoro troppo grande per me, e invece ho cercato una soluzione intermedia. L'ho trovata aggiungendo una proprietà "double-buffered" ai controlli FireMonkey. Invece di ridisegnare e ridisegnare (e ridisegnare) i controlli per ogni singolo pixel di movimento della scrollbox, prima dipingo il controllo su un "buffer" che memorizzo direttamente nella memoria della GPU (tramite TTexture), e quando il sistema mi chiede di ridisegnare i controlli, invece di richiamare nuovamente l'algoritmo di pittura, semplicemente ridisegno il buffer TTexture.
I risultati
Come ho detto prima, impiegava 3ms per dipingere un semplice TRectangle con angoli arrotondati. Con la mia proprietà double-buffered, ora impiega circa 0.1ms! Quindi, ora lo scorrimento sembra molto più fluido!
OpenGL draw => Sostituito dal rendering nativo di iOS/Android.
La maggior parte delle forme di base (come TRectangle, TCircle, ecc.) utilizzano OpenGL per il disegno, il che non è molto efficiente; ad esempio, per disegnare un cerchio con OpenGL, in realtà si disegnano 50 triangoli. Questo spesso si traduce in una qualità scadente: https://quality.embarcadero.com/browse/RSP-15206. Per i rettangoli arrotondati è ancora peggio perché è necessario prima calcolare il percorso e poi disegnarlo (molto più lento di TCircle).
Un altro problema è che tutti questi disegni dipendono da Form.quality. Se imposti form.quality su highquality, tutto ciò che fai sulla tela sarà multisample, ad esempio disegnare un'immagine, e questo potrebbe essere problematico perché l'immagine avrà un anti-aliasing. Se imposti form.quality su highperformance, il disegno sarà molto grezzo (senza anti-aliasing).
Per risolvere questo problema, ho creato il buffer del mio controllo utilizzando le API NATIVE ANDROID/IOS. In questo modo, avremo un rendering di alta qualità con un'alta velocità, senza dipendere da form.quality.
TALCircle
Controlli FireMonkey migliorati.
ScrollBox
TabControl
RangeTrackBar
RangeTrackBar
lettore video per FireMonkey lettore video per FireMonkey lettore video per FireMonkey
Animazione di confetti che cadono
ALConfetti è una libreria Delphi semplice per creare un'animazione di confetti che cade, configurabile e ad alte prestazioni.
coriandoli
messaggistica cloud di Firebase
Un metodo multipiattaforma per utilizzare Firebase Cloud Messaging (FCM) per ricevere notifiche push. Con FCM, è possibile informare un'app client che sono disponibili nuove email o altri dati da sincronizzare. È possibile inviare messaggi di notifica per incentivare il coinvolgimento e la fidelizzazione degli utenti. Per casi d'uso come la messaggistica istantanea, un messaggio può trasferire un payload fino a 4 KB a un'app client.
Login tramite SDK di VKontakte/Facebook per Android/iOS.
L'SDK di VKontakte/Facebook per Android consente agli utenti di accedere alla tua app utilizzando l'accesso tramite VKontakte/Facebook. Quando gli utenti accedono alla tua app tramite VKontakte/Facebook, possono concedere autorizzazioni alla tua app per recuperare informazioni o eseguire azioni su VKontakte/Facebook per loro conto.
Filtri per l'editor di foto per Android/iOS.
Con TALColorAdjustEffect, puoi creare splendidi filtri fotografici con una semplice funzione di miglioramento automatico, rendendo le tue foto belle ed espressive in pochi minuti!
Lettore video per FireMonkey.
Parser JSON.
TALJsonDocument è un parser/writer in Delphi per il formato di dati JSON / BSON. Supporta i parser DOM e SAX (si potrebbe usare un nome migliore come SAJ per Simple API for JSON invece di SAX per Simple API for XML, ma dato che il concetto di SAX è ben noto, mantengo questo nome), supporta il formato BSON e utilizza una sintassi simile a TALXMLDocument / TXMLDocument. TALJsonDocument può anche esportare dati Json / Bson in TALStringList.
Quando si tratta di analizzare alcuni contenuti (testuali), di solito si prevedono due direzioni. Nel mondo JSON, di solito è necessario scegliere tra:
Un parser DOM, che crea una struttura ad albero in memoria di oggetti che mappa il contenuto JSON;
Un parser SAX, che legge il contenuto JSON e quindi richiama eventi predefiniti per ogni elemento del contenuto JSON.
In realtà, i parser DOM utilizzano internamente un parser SAX per leggere il contenuto JSON. Pertanto, a causa del sovraccarico della creazione degli oggetti e dell'inizializzazione delle loro proprietà, i parser DOM sono tipicamente da tre a cinque volte più lenti dei parser SAX (e utilizzano molta più memoria per memorizzare tutti i nodi). Tuttavia, i parser DOM sono molto più potenti per la gestione dei dati: non appena i dati sono mappati in oggetti nativi, il codice può accedere a qualsiasi nodo in qualsiasi momento, mentre un accesso basato su SAX dovrà leggere nuovamente l'intero contenuto JSON.
La maggior parte dei parser JSON disponibili in Delphi utilizza un approccio simile al DOM. Ad esempio, l'unità DBXJSON inclusa a partire da Delphi 2010 o la libreria SuperObject creano un'istanza di classe che mappa ogni nodo JSON. Per ottenere le migliori prestazioni, TALJsonDocument implementa sia un parser DOM che un parser SAX.
TALJsonDocument può anche supportare commenti all'interno della sorgente JSON, che è un'estensione delle specifiche JSON.
La sintassi di TALJsonDocument è molto simile a quella di TALXMLDocument / TXMLDocument.
TALJsonDocument è disponibile in 2 varianti: TALJsonDocument, che si basa su ansiString (quindi UTF-8), e TALJsonDocumentU, che si basa su una stringa Unicode (quindi UTF-16).
Esempio:
{
_id: 1, // comments
name: { first: “John”, last: “Backus” },
birth: new Date('1999-10-21T21:04:54.234Z'),
contribs: [ “Fortran”, “ALGOL”, “Backus-Naur Form”, “FP” ],
awards: [
{ award: “National Medal of Science”,
year: 1975,
by: “National Science Foundation” },
{ award: “Turing Award”,
year: 1977,
by: “ACM” }
],
spouse: “”,
address: {},
phones: []
}
Per accedere ai nodi del documento:
MyJsonDoc.loadFromJson(AJsonStr, False);
MyJsonDoc.ParseOptions := [poAllowComments]; // per consentire l'inclusione di commenti all'interno della sorgente JSON.
MyJsonDoc.childnodes['_id'].int32;
MyJsonDoc.childnodes['name'].childnodes['first'].text;
MyJsonDoc.childnodes['name'].childnodes['last'].text;
MyJsonDoc.childnodes['birth'].datetime;
for i := 0 to MyJsonDoc.childnodes['contribs'].ChildNodes.count – 1 do
MyJsonDoc.childnodes['contribs'].childnodes[i].text;
for i := 0 to MyJsonDoc.childnodes['awards'].ChildNodes.count – 1 do begin
MyJsonDoc.childnodes['awards'].childnodes[i].childnodes['award'].text;
MyJsonDoc.childnodes['awards'].childnodes[i].childnodes['year'].text;
MyJsonDoc.childnodes['awards'].childnodes[i].childnodes['by'].text;
end;
Oppure, se non si è sicuri dell'esistenza dei nodi prima di accedervi o non si desidera verificarlo, è possibile utilizzare:
MyJsonDoc.GetChildNodeValueInt32('_id', 0{valore predefinito se il nodo non esiste});
MyJsonDoc.GetChildNodeValueText(['name', 'first'], ""{valore predefinito se il nodo non esiste});
MyJsonDoc.GetChildNodeValueDateTime('birth', Now{valore predefinito se il nodo non esiste});
Per creare i nodi del documento:
MyJsonDoc.addchild('_id').int32 := 1;
with MyJsonDoc.addchild('name', ntObject) do begin
addchild('first').text := 'John';
addchild('last').text := 'Backus';
end;
MyJsonDoc.addchild('birth').dateTime := Now;
with MyJsonDoc.addchild('contribs', ntArray) do begin
addchild.text := ‘Fortran’;
addchild.text := ‘ALGOL’;
addchild.text := ‘Backus-Naur Form’;
addchild.text := ‘FP’;
end;
with MyJsonDoc.addchild(‘awards’, ntArray) do begin
with addchild(ntObject) do begin
addchild(‘award’).text := ‘National Medal of Science’;
addchild('year').int32 := 1975;
addchild('by').text := 'National Science Foundation';
end;
with addchild(ntObject) do begin
addchild('award').text := 'Turing Award';
addchild('year').int32 := 1977;
addchild('by').text := 'ACM';
end;
end;
MyJsonDoc.addchild('spouse');
MyJsonDoc.addchild('address', ntObject);
MyJsonDoc.addchild('phones', ntArray);
È possibile anche creare/aggiornare nodi in questo modo:
MyJsonDoc.SetChildNodeValueInt32('_id', 0);
MyJsonDoc.SetChildNodeValueText(['name', 'first'], 'John');
MyJsonDoc.SetChildNodeValueDateTime('birth', Now);
Per caricare e salvare da BSON:
MyJsonDoc.LoadFromFile(aBSONFileName, False{saxMode}, True{BSON});
MyJsonDoc.SaveToFile(aBSONFileName, False{saxMode}, True{BSON});
Per analizzare un documento JSON in modalità SAX:
MyJsonDoc.onParseText := procedure (Sender: TObject;
const Path: AnsiString;
const name: AnsiString;
const Args: array of const;
NodeSubType: TALJSONNodeSubType) -> NodeSubType: TALJSONNodeSubType)
begin
case NodeSubType of -> caso NodeSubType di
nstFloat: Writeln(Path + ‘=’ + ALFloatToStr(Args[0].VExtended^, ALDefaultFormatSettings)); -> nstFloat: Writeln(Path + ‘=’ + ALFloatToStr(Args[0].VExtended^, ALDefaultFormatSettings));
nstText: Writeln(Path + ‘=’ + ansiString(Args[0].VAnsiString)); -> nstText: Writeln(Path + ‘=’ + ansiString(Args[0].VAnsiString));
nstObjectID: Writeln(Path + ‘=’ + ‘ObjectId(“‘+ALBinToHex(ansiString(Args[0].VAnsiString))+'”)’); -> nstObjectID: Writeln(Path + ‘=’ + ‘ObjectId(“‘+ALBinToHex(ansiString(Args[0].VAnsiString))+'”)’);
nstBoolean: Writeln(Path + ‘=’ + ALBoolToStr(Args[0].VBoolean,’true’,’false’)); -> nstBoolean: Writeln(Path + ‘=’ + ALBoolToStr(Args[0].VBoolean,’true’,’false’));
nstDateTime: Writeln(Path + ‘=’ + ALFormatDateTime(”’ISODate(“”yyyy”-”mm”-”dd”T”hh”:”nn”:”ss”.”zzz”Z”)”’, Args[0].VExtended^, ALDefaultFormatSettings)); -> nstDateTime: Writeln(Path + ‘=’ + ALFormatDateTime(”’ISODate(“”yyyy”-”mm”-”dd”T”hh”:”nn”:”ss”.”zzz”Z”)”’, Args[0].VExtended^, ALDefaultFormatSettings));
nstNull: Writeln(Path + ‘=’ + ‘null’);
nstRegEx: Writeln(Path + ‘=’ + ansiString(Args[0].VAnsiString));
nstBinary: Writeln(Path + ‘=’ + ‘BinData(‘+inttostr(Args[1].VInteger)+’, “‘+ansiString(ALBase64EncodeStringNoCRLF(ansiString(Args[0].VAnsiString)))+'”)’);
nstJavascript: Writeln(Path + ‘=’ + ansiString(Args[0].VAnsiString));
nstInt32: Writeln(Path + ‘=’ + ‘NumberInt(‘+inttostr(Args[0].VInteger)+’)’);
nstTimestamp: Writeln(Path + ‘=’ + ‘Timestamp(‘+inttostr(int64(cardinal(Args[0].VInteger)))+’, ‘+inttostr(int64(cardinal(Args[1].VInteger)))+’)’);
nstInt64: Writeln(Path + ‘=’ + ‘NumberLong(‘+inttostr(Args[0].VInt64^)+’)’);
end;
end;
MyJsonDoc.LoadFromJSON(AJsonStr, true{saxMode});
Wrapper di ImageMagick per Delphi.
Utilizzare ImageMagick® per creare, modificare, comporre o convertire immagini bitmap. Può leggere e scrivere immagini in una varietà di formati (oltre 200), tra cui PNG, JPEG, GIF, HEIC, TIFF, DPX, EXR, WebP, Postscript, PDF e SVG. Utilizzare ImageMagick per ridimensionare, ruotare, specchiare, distorcere, inclinare e trasformare immagini, regolare i colori delle immagini, applicare vari effetti speciali o disegnare testo, linee, poligoni, ellissi e curve di Bézier.
Esempio:
var aWand: PMagickWand;
begin
//Crea la libreria ImageMagick.
alCreateImageMagickLibrary({alcinoe_rootdir} + ‘\lib\dll\imagemagick\win32\imagemagick’, min(2, System.CPUCount){aThreadLimit});
try
//crea il puntatore wand
aWand := ALImageMagickLib.NewMagickWand;
try
//carica l'immagine
if ALImageMagickLib.MagickReadImage(aWand, pansiChar(aInputFilename)) <> MagickTrue then RaiseLastMagickWandError(aWand);
//imposta la qualità di compressione
se ALImageMagickLib.MagickSetImageCompressionQuality(aWand, 80) <> MagickTrue allora RaiseLastMagickWandError(aWand);
//regola automaticamente le dimensioni dell'immagine
se ALImageMagickLib.MagickAutoOrientImage(aWand) <> MagickTrue allora RaiseLastMagickWandError(aWand);
//Ridimensiona l'immagine utilizzando il filtro Lanczos
se ALImageMagickLib.MagickResizeImage(aWand, 640, 480, LanczosFilter) <> MagickTrue allora RaiseLastMagickWandError(aWand);
//salva l'immagine
ALImageMagickLib.MagickWriteImage(aWand, pansiChar(aOutputFilename));
finally
ALImageMagickLib.DestroyMagickWand(aWand);
end;
finally
alFreeImageMagickLibrary;
end;
end;
Client MongoDB
Client Delphi per il database MongoDB. Un driver Delphi (con pool di connessioni) per accedere a un server mongoDB. Un pool di connessioni è una cache di connessioni al database mantenuta in modo che le connessioni possano essere riutilizzate quando sono richieste connessioni future al database. Nel pool di connessioni, dopo che una connessione è stata creata, viene inserita nel pool e viene riutilizzata in modo che non sia necessario stabilire una nuova connessione. Se tutte le connessioni sono in uso, viene creata una nuova connessione e viene aggiunta al pool. Il pool di connessioni riduce anche il tempo che un utente deve attendere per stabilire una connessione al database.
Esempio:
aJSONDoc := TALJSONDocument.create;
aMongoDBClient := TAlMongoDBClient.create;
try
aMongoDBClient.Connect("", 0);
aMongoDBClient.SelectData('test.exemple',
'{fieldA:123}', // la query
‘{fieldA:1, fieldB:1}’, // i campi da restituire
aJSONDoc.node);
aMongoDBClient.disconnect;
for i := 0 to aJSONDoc.node.childnodes.count – 1 do
with aJSONDoc.node.childnodes[i] do
writeln(aJSONDoc.node.childnodes[i].nodename + ‘=’ + aJSONDoc.node.childnodes[i].text)
finally
aMongoDBClient.free;
aJSONDoc.free;
end;
Esempio con connection pool:
aMongoDBConnectionPoolClient := TAlMongoDBConnectionPoolClient.create(aDBHost, aDBPort);
try
::Thread1::
aMongoDBConnectionPoolClient.SelectData('test.example',
'{fieldA:123}', // la query
‘{fieldA:1, fieldB:1}’, // i campi da restituire
aLocalVarJSONDOC.node);
::Thread2::
aMongoDBConnectionPoolClient.SelectData('test.example',
'{fieldA:999}', // la query
‘{fieldA:1, fieldB:1}’, // i campi da restituire
aLocalVarJSONDOC.node);
finally
aMongoDBClient.free;
end;
Esempio di monitoraggio dei log:
aMongoDBTailMonitoringThread := TAlMongoDBTailMonitoringThread.Create(
aDBHost,
aDBPort,
‘test.cappedCollectionExemple’
‘{}’, // la query
‘{fieldA:1, fieldB:1}’, // i campi da restituire
Procedura (Sender: TObject; JSONRowData: TALJSONNode)
begin
writeln('Nuovo elemento aggiunto in cappedCollectionExemple: ' + JSONRowData.childnodes['fieldA'].text);
end,
procedura (Sender: TObject; Error: Exception)
begin
writeln(Error.message);
end);
….
aMongoDBTailMonitoringThread.free;
Client WebSocket
Client WebSocket per Delphi implementato su WinHTTP. WebSocket è un protocollo di comunicazione che consente di aprire una sessione di comunicazione interattiva bidirezionale tra il browser dell'utente e un server. Con questo, è possibile inviare messaggi a un server e ricevere risposte guidate da eventi senza dover interrogare il server per una risposta.
Fast TStringList
TALStringList funziona come TStringList di Delphi, tranne per il fatto che consente di cercare un nome=valore utilizzando un algoritmo di ordinamento rapido quando la lista è ordinata. Inoltre, TALStringList utilizza un algoritmo indipendente dalla lingua (basato sul valore ordinale a 8 bit di ogni carattere) invece di AnsiCompareText e AnsiCompareStr utilizzati da TStringList di Delphi. Infine, l'ordinamento in TALStringList è fino a 10 volte più veloce rispetto a TStringList di Delphi. Inoltre, TALStringList non è una TStringList Unicode, ma una TStringList ANSI al 100%.
TALNVStringList (NV per NameValue) è simile a TALStringList (utilizza anche un algoritmo di ordinamento rapido), tranne per il fatto che l'ottimizzazione è orientata a una lista di coppie nome/valore anziché a una lista di stringhe.
TALHashedStringList TALHashedStringList è simile a TALStringList, tranne per il fatto che utilizza una tabella hash interna invece di un algoritmo di ordinamento rapido. Utilizzando TALHashedStringList invece di TALStringList, è possibile migliorare le prestazioni quando la lista contiene un gran numero di stringhe (altrimenti, se la lista non contiene molte stringhe, le prestazioni sono inferiori rispetto a TALStringList a causa del costo di calcolo dell'hash).
PHP runner
ALPHPRunnerEngine è un componente semplice ma utile per utilizzare facilmente PHP (qualsiasi versione) come linguaggio di scripting nelle applicazioni Delphi. ALPHPRunnerEngine consente di eseguire script PHP all'interno del programma Delphi senza un WebServer. ALPHPRunnerEngine utilizza l'interfaccia CGI/FastCGI di PHP per comunicare con il motore PHP.
Client Memcached
Client Delphi per il database memcached.
Cos'è Memcached? È un sistema di caching di oggetti in memoria distribuito, gratuito e open source, di natura generica, ma progettato per velocizzare le applicazioni web dinamiche riducendo il carico sul database.
Memcached è un archivio chiave-valore in memoria per piccoli blocchi di dati arbitrari (stringhe, oggetti) provenienti da chiamate a database, API o rendering di pagine.
Memcached è semplice ma potente. Il suo design semplice promuove una rapida implementazione, facilità di sviluppo e risolve molti problemi che si verificano con le grandi cache di dati.
Componente GSM
Il componente TAlGSMComm implementa l'invio di SMS tramite l'interfaccia in modalità testo definita nella specifica tecnica GSM 07.05, versione 5.1.0, datata dicembre 1996. Esistono diverse varianti di questa specifica, utilizzate in vari modelli Nokia, Siemens, Ericsson, ecc. Abbiamo testato internamente il Nokia 6230, ma i modelli Nokia 7190, 8890, 6210 e 9110 dovrebbero funzionare altrettanto bene. Anche i telefoni di altri produttori funzioneranno, purché implementino l'interfaccia in modalità testo. Circa 1/4 dei telefoni attuali possono essere collegati a un PC (tramite IR o cavo seriale), circa 1/3 di questi sono solo in modalità testo, 1/3 sono solo in modalità PDU e l'altro 1/3 supporta sia la modalità testo che la modalità PDU. Alcuni telefoni (come il Nokia 5190) supportano gli SMS, ma utilizzano un protocollo proprietario, che TALGSMComm non supporta.
Per testare il telefono, connetti il telefono al PC tramite il cavo seriale o il dispositivo IR (consulta la documentazione del telefono per i dettagli su come connettersi). Inserisci "AT" in una finestra del terminale per verificare che la connessione sia stabilita (dovresti ricevere "OK" dal telefono), quindi inserisci "AT+CMGF=?". La risposta dovrebbe contenere un "1", indicando che supporta la modalità testo. Se entrambi questi test passano, allora il tuo telefono soddisfa i requisiti di base.
Client SQLite3
Interroga il database SQLite3 e ottieni il risultato in formato XML o in formato JSON/BSON.
E molto altro.
Runner CGI
Client HTTP (WinInet/WinHTTP)
Client MySQL
Client NNTP
Client POP3
Client SMTP
Parser XML
WIN64
Sfortunatamente, in win64 abbiamo perso tutta l'eredità di FastCode (che era principalmente basata su ASM). Ciò significa che la maggior parte delle funzioni sarà da 2 a 10 volte più lenta. Puoi provare ad eseguire /demo/ALStringBenchMark/ in win64 e Win32 per vedere la differenza di velocità.