Voici les unités que contient Spring4D :
| Nom | Description |
|---|---|
| Base/Collections/Spring.Collections.Base | Cette unité contient les définitions de base pour les collections génériques utilisées dans le cadre d'application Spring4D. |
| Base/Collections/Spring.Collections.Dictionaries | Cette unité permet d'implémenter des structures de données de type dictionnaire (ou tables de hachage), permettant d'entreposer des paires clef-valeur. Ces dictionnaires sont souvent utilisés pour un accès rapide aux éléments à l'aide de clefs uniques. |
| Base/Collections/Spring.Collections.Events | Cette unité permet de gérer les événements associés aux collections. Cela peut inclure des mécanismes pour observer les changements dans une collection, comme l'ajout, la suppression ou la modification d'éléments, en fournissant des événements permettant de réagir à ces actions. |
| Base/Collections/Spring.Collections.Extensions | Cette unité permet de fournir des méthodes d'extension pour enrichir les collections avec des fonctionnalités supplémentaires, comme des filtres, des projections, ou des fonctions de transformation, similaires aux extensions LINQ en C#. |
| Base/Collections/Spring.Collections.LinkedLists | Cette unité permet d'implémenter des listes chaînées, une structure de données où chaque élément est lié au suivant. Cela permet une insertion et une suppression plus efficaces par rapport à des tableaux statiques, mais peut être plus coûteux en termes d'accès aléatoire. |
| Base/Collections/Spring.Collections.Lists | Cette unité contient l'implémentation des listes génériques. Une liste est une collection ordonnée permettant d'accéder aux éléments par leur index, d'ajouter et de supprimer des éléments de manière dynamique. |
| Base/Collections/Spring.Collections.MultiMaps | Cette unité contient un MultiMap, soit une variante du dictionnaire où plusieurs valeurs peuvent être associées à une seule clef. Cette unité permet de gérer des collections où chaque clef peut correspondre à plusieurs valeurs. |
| Base/Collections/Spring.Collections.MultiSets | Cette unité contient un MultiSet (ou ensemble avec doublons), soit une collection où les éléments peuvent apparaître plus d'une fois. Contrairement aux ensembles traditionnels, ne contenant que des éléments uniques, un MultiSet conserve la multiplicité des éléments. |
| Base/Collections/Spring.Collections.Queues | Cette unité permet d'implémenter des files d'attente (queues), une structure de données suivant le principe FIFO (First In, First Out), où les éléments sont ajoutés à une extrémité et supprimés de l'autre. |
| Base/Collections/Spring.Collections.Sets | Cette unité permet de gérer des ensembles (sets), une structure de données entreposant des éléments uniques, c'est-à-dire sans doublons. Les ensembles sont souvent utilisés pour tester l'appartenance ou effectuer des opérations ensemblistes comme l'union ou l'intersection. |
| Base/Collections/Spring.Collections.Stacks | Cette unité permet d'implémenter des piles, une structure de données suivant le principe LIFO (Last In, First Out), où le dernier élément ajouté est le premier à être retiré. |
| Base/Collections/Spring.Collections.Trees | Cette unité permet d'implémenter des arbres, une structure de données hiérarchique où chaque élément (ou noeud) a des enfants. Les arbres sont utilisés pour organiser des données de manière hiérarchique et permettre des opérations efficaces comme la recherche ou l'insertion. |
| Base/Collections/Spring.Collections | Cette unité permet de regrouper les autres collections et servir de point d'entrée général aux différentes implémentations de collections dans le cadre d'application Spring4D. |
| Base/Logging/Spring.Logging.Appenders.Base | Cette unité permet de fournir une base pour les classes d'appenders (ajouteurs). Les appenders définissent comment les journaux de bord sont envoyés ou enregistrés (exemple : dans un fichier, une console,...). |
| Base/Logging/Spring.Logging.Appenders.CodeSite | Cette unité contient un appender permettant d'intégrer CodeSite, un outil tiers de journalisation et de débogage visuel. Cet appender envoie les journaux de bord directement à CodeSite. |
| Base/Logging/Spring.Logging.Appenders.SmartInspect | Cette unité contient un appender permettant d'intégrer SmartInspect, un autre outil de journalisation et de débogage. Cet appender permet de lier les journaux de bord à SmartInspect pour des analyses plus détaillées. |
| Base/Logging/Spring.Logging.Appenders | Cette unité contient l'enregistrement des appenders standards, centralisant probablement la gestion de plusieurs appenders dans l'architecture du système de journal de bord. |
| Base/Logging/Spring.Logging.Controller | Cette unité permet de contrôler et de gérer les enregistreurs de journaux de bord. |
| Base/Logging/Spring.Logging.Extensions | Cette unité contient des extensions ou des fonctionnalités supplémentaires pour la journalisation, peut-être des méthodes utilitaires ou des extensions de classes existantes pour faciliter l'intégration. |
| Base/Logging/Spring.Logging.Loggers | Cette unité permet d'implémenter différentes classes de journaux de bord (enregistreurs). Les journaux de bord sont responsables de la création des entrées de journal en fonction du niveau de sévérité, des messages,... |
| Base/Logging/Spring.Logging.NullLogger | Cette unité contient un journal de bord ne faisant rien (un journal de bord "nul"). Il est souvent utilisé comme objet par défaut lorsque l'on ne souhaite pas réellement enregistrer de journal de bord. |
| Base/Logging/Spring.Logging.ResourceStrings | Cette unité contient les chaînes de caractères utilisées par le système de journalisation, probablement pour la gestion des messages d'erreurs, des descriptions de niveaux de journaux de bord,... |
| Base/Logging/Spring.Logging.Serializers | Cette unité permet de fournir des mécanismes pour sérialiser (convertir en chaîne de caractères) les messages de journaux de bord ou les objets avant qu'ils ne soient envoyés aux appenders. |
| Base/Logging/Spring.Logging | Cette unité contient le coeur du système de journalisation. Cette unité rassemble les composantes clefs et probablement les interfaces définissant le comportement du système de journaux de bord dans Spring4D. |
| Base/Patches/Spring.Patches.GetInvokeInfo | Cette unité contient un correctif ou une amélioration pour la récupération des informations d'appel dans Delphi, pour des méthodes dynamiques ou des appels à des méthodes RTTI. |
| Base/Patches/Spring.Patches.QC107219 | Cette unité contient un correctif pour résoudre un problème signalé dans le système QualityCentral (QC) de Delphi sous le numéro 107219. Il est lié à un problème spécifique à Delphi que Spring4D corrige pour améliorer la stabilité ou le comportement. |
| Base/Patches/Spring.Patches.QC93646 | Cette unité contient un correctif s'adresse à un autre problème (93646) connu dans Delphi, potentiellement lié à la gestion de la mémoire ou à d'autres comportements anormaux. |
| Base/Patches/Spring.Patches.QC98671 | Cette unité contient un correctif pour résoudre un bogue référencé sous le numéro 98671, apportant des solutions à un problème dans Delphi pouvant affecter Spring4D ou ses utilisateurs. |
| Base/Patches/Spring.Patches.RSP13163 | Cette unité permet de corriger un problème signalé dans RAD Studio Platform (RSP) sous le numéro 13163. Il apporte une correction liée au fonctionnement du compilateur ou de la bibliothèque standard de Delphi. |
| Base/Patches/Spring.Patches.RSP13589 | Cette unité contient un correctif pour résoudre un autre bogue dans RAD Studio sous le numéro 13589. |
| Base/Patterns/Spring.Patterns.Specification | Cette unité permet d'implémenter le pattern Specification (Spécification), un patron de conception utilisé pour encapsuler des règles de logique métier dans des objets. Il permet de combiner des critères de validation ou de filtrage de manière flexible. |
| Base/Spring.Comparers | Cette unité contient des implémentations de compareurs pour comparer des objets. Ces compareurs peuvent être utilisés pour ordonner des collections ou pour déterminer l'égalité entre des objets, facilitant ainsi le tri et la recherche. |
| Base/Spring.DesignPatterns | Cette unité permet de regrouper les implémentations de divers patrons de conception (design patterns) utilisés dans la bibliothèque, permettant de structurer le code de manière flexible et réutilisable. Cela peut inclure des patterns comme Singleton, Factory,... |
| Base/Spring.Events.Base | Cette unité permet de fournir les bases pour le système d'événements de Spring4D. Cela inclut des classes et des interfaces pour définir et gérer des événements de manière efficace, permettant aux objets de communiquer entre eux. |
| Base/Spring.Events | Cette unité permet d'étendre les fonctionnalités du système d'événements, probablement en ajoutant des fonctionnalités supplémentaires pour la gestion des événements, comme des événements désynchronisées ou des gestionnaires d'événements. |
| Base/Spring.Hash | Cette unité permet d'implémenter des fonctions de hachage pour générer des valeurs de hachage à partir d'objets. Cela est souvent utilisé pour des structures de données telles que les tables de hachage, permettant une recherche rapide. |
| Base/Spring.HashTable | Cette unité contient l'implémentation de tables de hachage, une structure de données utilisant des fonctions de hachage pour organiser des données et permettre un accès rapide. Elle peut inclure des fonctionnalités comme la gestion des collisions. |
| Base/Spring.HazardEra | Cette unité permet d'impliquer des techniques pour gérer la mémoire en toute sécurité, notamment dans les contextes multi-processus léger. Cela peut inclure des mécanismes pour gérer les accès concurrents et éviter les erreurs liées à la gestion de la mémoire. |
| Base/Spring.Helpers | Cette unité contient une collection de fonctions utilitaires ou d'aides facilitant certaines tâches courantes dans le développement, comme la manipulation de chaînes, le traitement des dates,... |
| Base/Spring.MethodIntercept | Cette unité permet de fournir des mécanismes pour intercepter les appels de méthodes, permettant d'ajouter des fonctionnalités telles que la journalisation, la validation ou le contrôle d'accès à certaines méthodes. |
| Base/Spring.Reflection | Cette unité permet d'implémenter des fonctionnalités de réflexion, permettant aux développeurs d'inspecter et de manipuler des types et des membres d'objets à l'exécution. Cela inclut l'accès aux propriétés, méthodes,..., sans connaître leur type à l'avance. |
| Base/Spring.ResourceStrings | Cette unité contient des chaînes de ressources utilisées dans la bibliothèque, souvent pour la gestion des messages d'erreur, des descriptions et d'autres chaînes de caractères internationalisées. |
| Base/Spring.SystemUtils | Cette unité contient des utilitaires pour interagir avec le système sous-jacent, incluant des fonctions pour obtenir des informations sur l'environnement d'exécution, la gestion des fichiers, et d'autres opérations système. |
| Base/Spring.Times | Cette unité permet de fournir des fonctionnalités pour la gestion et la manipulation des dates et des heures. Cela inclut des méthodes pour le calcul des durées, la conversion de formats,... |
| Base/Spring.ValueConverters | Cette unité contient des implémentations de convertisseurs de valeurs permettant de transformer des données d'un type à un autre, souvent utilisé dans des contextes de liaison de données ou de conversion de types. |
| Base/Spring.VirtualClass | Cette unité contient la définition de classes virtuelles pouvant être étendues sans avoir besoin d'une hiérarchie de classes complexes. Cela favorise la flexibilité et la réutilisation du code. |
| Base/Spring.VirtualInterface | Cette unité permet de créer des interfaces virtuelles, ce qui permet de définir des contrats d'interface pouvant être implémentés par différentes classes sans dépendre directement d'une implémentation spécifique. |
| Base/Spring | Cette unité contient la base regroupant les fonctionnalités clefs et les interfaces de base de la bibliothèque, agissant comme un point d'entrée pour accéder aux autres unités. |
| Core/Container/Spring.Container.ActivatorExtension | Cette unité permet d'implémenter une extension pour le conteneur d'inversion de contrôle (IoC), permettant de personnaliser ou d'étendre la manière dont les composants sont activés (créés ou initialisés) au sein du conteneur IoC. |
| Core/Container/Spring.Container.AutoMockExtension | Cette unité permet de fournir une extension pour le conteneur IoC permettant la génération automatique de mocks (objets simulés) dans le cadre des tests unitaires. Cela permet de simuler des dépendances pour des composantes durant les tests sans avoir besoin de les créer manuellement. |
| Core/Container/Spring.Container.Builder | Cette unité permet de gérer le processus de construction des dépendances dans le conteneur IoC, configurant les relations entre les interfaces et leurs implémentations, ainsi que la manière dont ces objets sont créés et injectés. |
| Core/Container/Spring.Container.Common | Cette unité contient des structures de données et des fonctionnalités communes utilisées par le conteneur IoC, centralisant les types et utilitaires nécessaires au bon fonctionnement des autres unités du conteneur. |
| Core/Container/Spring.Container.ComponentActivator | Cette unité permet de gérer l'activation des composantes dans le conteneur IoC, en s'assurant que les objets sont correctement initialisés et que leurs dépendances sont résolues lors de leur création. |
| Core/Container/Spring.Container.Core | Cette unité contient les fonctionnalités principales du conteneur, y compris la gestion des résolutions de dépendances et l'enregistrement des services. |
| Core/Container/Spring.Container.CreationContext | Cette unité permet de définir le contexte de création pour chaque instance de composante, permettant de suivre l'état et les informations relatives à la création et l'injection des dépendances. |
| Core/Container/Spring.Container.Extensions | Cette unité permet de gérer le système d'extensions pour le conteneur IoC, permettant aux développeurs d'ajouter des fonctionnalités supplémentaires au conteneur, comme des comportements personnalisés ou des gestionnaires spécifiques pour certaines situations. |
| Core/Container/Spring.Container.Injection | Cette unité permet d'implémenter les mécanismes d'injection de dépendances dans le conteneur IoC, permettant d'injecter des dépendances dans des composants via différentes méthodes, telles que l'injection par constructeur, par propriété ou par méthode. |
| Core/Container/Spring.Container.LifetimeManager | Cette unité permet de gérer le cycle de vie des objets dans le conteneur IoC, définissant si les instances doivent être créées une seule fois (singleton) ou à chaque demande (transitoire), ainsi que d'autres stratégies de gestion du cycle de vie. |
| Core/Container/Spring.Container.Pool | Cette unité permet d'implémenter un bassin d'objets, permettant la réutilisation d'instances pour améliorer les performances. Les objets sont entreposés et réutilisés lorsqu'ils ne sont plus nécessaires, évitant ainsi leur recréation. |
| Core/Container/Spring.Container.ProxyFactory | Cette unité permet de gérer la création de proxies dynamiques dans le conteneur IoC. Ces proxies permettent de créer des objets pouvant intercepter les appels de méthodes et ajouter des fonctionnalités supplémentaires comme la journalisation ou la sécurité. |
| Core/Container/Spring.Container.Registration | Cette unité permet d'enregistrer les composantes et leurs dépendances dans le conteneur IoC, en configurant les services, interfaces, et implémentations pour qu'ils puissent être résolus et injectés dans d'autres parties de l'application. |
| Core/Container/Spring.Container.Resolvers | Cette unité contient les résolveurs de dépendances étant responsables de la recherche et de la résolution des instances à injecter. Ils analysent les enregistrements et retournent les objets correspondants. |
| Core/Container/Spring.Container.ResourceStrings | Cette unité contient les chaînes de ressources spécifiques au conteneur IoC, généralement utilisées pour la gestion des messages d'erreurs et des avertissements au sein du conteneur. |
| Core/Container/Spring.Container | Cette unité pcontient la base du conteneur IoC de Spring4D. Elle regroupe toutes les fonctionnalités nécessaires pour créer, gérer et injecter des dépendances dans une application Delphi, centralisant l'infrastructure du conteneur. |
| Core/Interception/Spring.Interception.AbstractInvocation | Cette unité permet de définir l'appel abstraite utilisée dans le cadre de l'interception de méthodes. Elle sert de classe de base pour les implémentations concrètes manipulant l'interception des appels de méthode, permettant de modifier le comportement de ces appels. |
| Core/Interception/Spring.Interception.ClassProxy | Cette unité permet de gérer la création d'un proxy pour une classe. Les proxies sont utilisés pour intercepter les appels de méthodes et ajouter des fonctionnalités supplémentaires comme la journalisation, la sécurité ou la gestion de transactions. |
| Core/Interception/Spring.Interception.CustomProxy | Cette unité permet la création de proxies personnalisés, offrant plus de flexibilité pour intercepter et modifier les comportements des objets, au-delà de la simple création de proxies pour les interfaces ou classes. |
| Core/Interception/Spring.Interception.InterfaceProxy | Cette unité permet de gérer la création de proxies pour des interfaces, facilitant l'interception des appels de méthodes implémentées via des interfaces. Ces proxies permettent d'ajouter des comportements dynamiques au moment de l'exécution. |
| Core/Interception/Spring.Interception.ResourceStrings | Cette unité contient les chaînes de ressources utilisées dans le module d'interception, notamment pour les messages d'erreurs ou d'avertissement relatifs à l'interception d'appels de méthode. |
| Core/Interception/Spring.Interception | Cette unité contient la principale regroupant les fonctionnalités d'interception dans Spring4D. Elle centralise la création et la gestion des proxies, ainsi que les comportements associés à l'interception d'appels de méthode. |
| Core/Logging/Spring.Logging.Configuration.Builder | Cette unité permet de gérer la configuration du système de journalisation en construisant des options et des stratégies de journalisation selon les besoins de l'application. Ce module permet de configurer facilement la manière dont les journaux sont gérés. |
| Core/Logging/Spring.Logging.Configuration | Cette unité permet de définir la configuration globale du système de journalisation dans Spring4D, incluant les paramètres pour les appenders, les journaux de bord, et les niveaux de journalisation. |
| Core/Logging/Spring.Logging.Container | Cette unité permet d'intégrer le conteneur IoC avec le système de journalisation, permettant d'enregistrer et de gérer automatiquement les instances de journaux de bord dans le conteneur. Cela facilite l'injection de journaux de bord dans les services ou les composantes. |
| Core/Mocking/Spring.Mocking.Core | Cette unité permet d'implémenter les fonctionnalités de base du module de mocking (simulation d'objets), permettant de créer des objets simulés pour les tests unitaires. Cette unité gère la création de mocks ainsi que les interactions de base entre les objets simulés et les tests. |
| Core/Mocking/Spring.Mocking.Interceptor | Cette unité permet d'utiliser l'interception pour les objets simulés. Cette unité permet d'intercepter les appels de méthode sur les objets simulés afin de définir des comportements personnalisés ou d'enregistrer les interactions pour validation dans les tests unitaires. |
| Core/Mocking/Spring.Mocking.Matching | Cette unité permet de gérer les mécanismes de correspondance utilisés pour valider les appels de méthodes dans les objets simulés. Cela permet de vérifier si les arguments passés à une méthode sont conformes à certains critères dans les tests. |
| Core/Mocking/Spring.Mocking | Cette unité contient la base du module de mocking dans Spring4D. Elle centralise les fonctionnalités de création de mocks, l'interception des appels et les mécanismes de validation utilisés dans les tests unitaires. |
| Core/Services/Spring.Services.Logging | Cette unité permet d'implémenter des services de journalisation basés sur le cadre d'application Spring4D, permettant d'intégrer facilement la journalisation dans les applications via l'infrastructure IoC. |
| Core/Services/Spring.Services | Cette unité contient la base pour la gestion des services dans Spring4D. Elle permet d'enregistrer, de configurer et de gérer divers services au sein du conteneur IoC, facilitant leur injection et leur gestion dans les applications. |
| Data/ObjectDataSet/Spring.Data.ActiveX | Cette unité permet de gérer les interopérabilités ActiveX dans le contexte de la gestion de données dans Spring4D. Elle est utilisée pour permettre aux objets ActiveX de fonctionner avec les ensembles de données. |
| Data/ObjectDataSet/Spring.Data.ExpressionParser.Functions | Cette unité contient des fonctions supplémentaires pour le module d'analyse d'expressions. Elle permet d'ajouter des fonctions personnalisées aux expressions utilisées pour filtrer ou manipuler les données dans un ensemble de données. |
| Data/ObjectDataSet/Spring.Data.ExpressionParser | Cette unité contient un analyseur d'expressions permettant de manipuler des expressions complexes sur des ensembles de données. Il analyse les expressions en fonction des champs ou des propriétés d'objets pour filtrer ou manipuler les données. |
| Data/ObjectDataSet/Spring.Data.IndexList | Cette unité permet de gérer une liste d'index pour les ensembles de données. Elle permet de créer et de gérer des index sur les champs d'un ensemble de données pour améliorer les performances de recherche. |
| Data/ObjectDataSet/Spring.Data.ObjectDataSet | Cette unité permet d'implémenter un ensemble de données basé sur des objets. Cela permet de travailler avec des collections d'objets en tant que source de données dans des applications compatibles avec les ensembles de données, comme les applications Delphi. |
| Data/ObjectDataSet/Spring.Data.Registration | Cette unité permet d'enregistrer des composantes liés aux ensembles de données dans le conteneur de dépendance. Cela facilite la gestion et l'injection de dépendances pour ces composantes. |
| Data/ObjectDataSet/Spring.Data.ValueConverters | Cette unité permet de fournir des convertisseurs de valeurs pour convertir les types de données dans les ensembles de données. Par exemple, convertir un type de données spécifique en un autre lors de l'affichage ou du traitement. |
| Data/ObjectDataSet/Spring.Data.VirtualDataSet | Cette unité permet d'implémenter un ensemble de données virtuel, permettant de travailler avec des données n'étant pas nécessairement chargées en mémoire mais sont accessibles dynamiquement, comme lors de la lecture depuis des fichiers ou des sources à distances. |
| Extensions/Cryptography/Spring.Cryptography.Base | Cette unité permet de définir les structures de base pour les algorithmes cryptographiques dans Spring4D. Elle est à la base des autres algorithmes de chiffrement ou de hachage fournis. |
| Extensions/Cryptography/Spring.Cryptography.CRC | Cette unité permet d'implémenter les algorithmes de CRC (Cyclic Redundancy Check), étant utilisés pour vérifier l'intégrité des données. |
| Extensions/Cryptography/Spring.Cryptography.DES | Cette unité permet d'implémenter l'algorithme de chiffrement DES (Data Encryption Standard). C'est un algorithme symétrique utilisé pour le chiffrement de données. |
| Extensions/Cryptography/Spring.Cryptography.MD5 | Cette unité permet d'implémenter l'algorithme de hachage MD5, générant une empreinte unique de 128 bits pour une chaîne de caractères ou un fichier. C'est un algorithme de hachage utilisé pour vérifier l'intégrité des données. |
| Extensions/Cryptography/Spring.Cryptography.SHA | Cette unité permet d'implémenter les algorithmes de hachage SHA (Secure Hash Algorithm), tels que SHA-1 et SHA-256, produisant des empreintes uniques utilisées pour vérifier les intégrités des données. |
| Extensions/Cryptography/Spring.Cryptography.Utils | Cette unité permet de fournir des utilitaires pour les opérations cryptographiques, comme des fonctions d'aide pour manipuler les octets et les blocs de données pendant les opérations de cryptage et de hachage. |
| Extensions/Cryptography/Spring.Cryptography | Cette unité contient la base pour gérer les opérations cryptographiques dans Spring4D. Elle regroupe les fonctionnalités des différents algorithmes de chiffrement et de hachage. |
| Extensions/Utils/Spring.Utils.IO | Cette unité permet de fournir des utilitaires d'entrée/sortie pour travailler avec les fichiers et les flux de données. Elle simplifie les opérations liées aux fichiers, comme la lecture et l'écriture de fichiers. |
| Extensions/Utils/Spring.Utils.WinApi | Cette unité contient des utilitaires spécifiques à l'API Windows. Ces fonctions facilitent les interactions avec l'API Windows pour gérer les processus, les fichiers, ou d'autres ressources du système. |
| Extensions/Utils/Spring.Utils | Cette unité permet de regrouper divers utilitaires génériques ne se limitant pas à une fonction particulière. Cela inclut des assistants pour les manipulations de chaînes de caractères, de tableaux ou de types de données. |
| Persistence/Adapters/Spring.Persistence.Adapters.ADO | Cette unité permet de fournir un adaptateur pour ADO (ActiveX Data Objects), permettant à Spring4D de fonctionner avec les bases de données via ADO. Cela permet de connecter des bases de données compatibles ADO dans les applications Delphi. |
| Persistence/Adapters/Spring.Persistence.Adapters.ASA | Cette unité permet d'implémenter un adaptateur pour ASA (Adaptive Server Anywhere), une base de données de Sybase. Cet adaptateur permet d'utiliser ASA comme source de données dans une application Spring4D. |
| Persistence/Adapters/Spring.Persistence.Adapters.DBX | Cette unité permet de fournir un adaptateur pour DBExpress, un ensemble de composantes pour l'accès rapide aux bases de données. Ce module permet de se connecter à différentes bases de données via DBExpress. |
| Persistence/Adapters/Spring.Persistence.Adapters.FieldCache | Cette unité permet de gérer le cache des champs pour les adaptateurs de persistance, optimisant l'accès aux données en réduisant le nombre de requêtes nécessaires pour récupérer les champs dans une base de données. |
| Persistence/Adapters/Spring.Persistence.Adapters.FireDAC | Cette unité permet d'implémenter un adaptateur pour FireDAC, un cadre d'application d'accès universel aux bases de données pour Delphi. Il permet d'utiliser FireDAC pour se connecter à plusieurs types de bases de données via Spring4D. |
| Persistence/Adapters/Spring.Persistence.Adapters.MSSQL | Cette unité permet de fournir un adaptateur pour Microsoft SQL Server, permettant de travailler avec SQL Server comme source de données via le cadre d'application de persistance de Spring4D. |
| Persistence/Adapters/Spring.Persistence.Adapters.MongoDB | Cette unité permet d'implémenter un adaptateur pour MongoDB, une base de données NoSQL populaire. Cet adaptateur permet d'interagir avec MongoDB à l'aide de Spring4D. |
| Persistence/Adapters/Spring.Persistence.Adapters.Oracle | Cette unité permet de fournir un adaptateur pour Oracle, permettant de connecter et de manipuler des bases de données Oracle via le cadre d'application Spring4D. |
| Persistence/Adapters/Spring.Persistence.Adapters.SQLite | Cette unité permet de fournir un adaptateur pour SQLite, une base de données légère embarquée. Cet adaptateur permet d'utiliser SQLite comme source de données dans une application Delphi avec Spring4D. |
| Persistence/Adapters/Spring.Persistence.Adapters.UIB | Cette unité permet d'implémenter un adaptateur pour UIB (Unified InterBase), facilitant l'intégration avec InterBase et d'autres bases de données compatibles UIB dans Spring4D. |
| Persistence/Adapters/Spring.Persistence.Adapters.UniDAC | Cette unité permet de fournir un adaptateur pour UniDAC (Universal Data Access Components), un ensemble de composantes permettant un accès rapide et natif à plusieurs bases de données via Delphi. |
| Persistence/Adapters/Spring.Persistence.Adapters.Zeos | Cette unité permet de fournir un adaptateur pour Zeos, une bibliothèque open-source pour l'accès aux bases de données. Cet adaptateur permet de connecter Spring4D aux bases de données via Zeos. |
| Persistence/Core/Spring.Persistence.Core.AbstractSession | Cette unité permet de déclarer une classe abstraite pour une session de persistance. Une session gère le cycle de vie des entités et coordonne les transactions pour l'accès aux données via la persistance. |
| Persistence/Core/Spring.Persistence.Core.Base | Cette unité contient des classes et des fonctionnalités de base pour le cadre d'application de persistance. C'est un point central pour les fonctionnalités partagées entre différents modules de persistance. |
| Persistence/Core/Spring.Persistence.Core.ConnectionFactory | Cette unité permet de définir une usine de connexions créant des connexions aux bases de données. Elle gère l'initialisation et la création de connexions pour différentes bases de données. |
| Persistence/Core/Spring.Persistence.Core.DatabaseManager | Cette unité permet de fournir un gestionnaire de base de données facilitant les opérations sur la base de données, telles que la création, la gestion des tables, ou encore la maintenance des connexions. |
| Persistence/Core/Spring.Persistence.Core.DetachedSession | Cette unité permet d'implémenter une session détachée permettant de déconnecter des entités de la base de données tout en maintenant un suivi de leurs modifications. Cela permet une synchronisation ultérieure des entités avec la base de données. |
| Persistence/Core/Spring.Persistence.Core.EmbeddedEntity | Cette unité permet de gérer des entités embarquées, c'est-à-dire des objets ayant directement inclus dans une autre entité plutôt que d'exister séparément dans la base de données. |
| Persistence/Core/Spring.Persistence.Core.EntityCache | Cette unité permet d'implémenter un cache d'entités optimisant les performances en gardant en mémoire les entités déjà chargées depuis la base de données pour éviter des requêtes répétées. |
| Persistence/Core/Spring.Persistence.Core.EntityMap | Cette unité permet de gérer la correspondance des entités entre les objets Delphi et les tables de la base de données, en définissant comment chaque entité est cartographiée aux colonnes et tables. |
| Persistence/Core/Spring.Persistence.Core.EntityWrapper | Cette unité permet de fournir un enveloppe d'entités encapsulant des entités et offre des méthodes supplémentaires pour interagir avec elles, notamment pour suivre leur état ou appliquer des conversions de données. |
| Persistence/Core/Spring.Persistence.Core.Exceptions | Cette unité contient des exceptions spécifiques au cadre d'application de persistance, gérant les erreurs rencontrées lors des opérations de persistance ou de base de données. |
| Persistence/Core/Spring.Persistence.Core.Graphics | Cette unité contient des fonctionnalités graphiques dans le cadre des opérations de persistance, tel que le rendu visuel d'informations relatives à la persistance (peu commun dans les cadres d'application de persistance classiques). |
| Persistence/Core/Spring.Persistence.Core.Interfaces | Cette unité permet de définir les interfaces de base pour le système de persistance, fournissant des contrats pour les sessions, gestionnaires de base de données, entités et autres composantes. |
| Persistence/Core/Spring.Persistence.Core.ListSession | Cette unité permet d'implémenter une session basée sur une liste, optimisée pour des scénarios où les entités doivent être traitées sous forme de listes en mémoire, plutôt que des entités individuelles. |
| Persistence/Core/Spring.Persistence.Core.Repository.MongoDB | Cette unité permet d'implémenter un dépôt pour MongoDB, fournissant des méthodes spécifiques à MongoDB pour la gestion et la manipulation des entités. |
| Persistence/Core/Spring.Persistence.Core.Repository.Proxy | Cette unité permet de gérer les dépôts proxy, agissant comme des intermédiaires pour accéder aux entités, ajoutant potentiellement des fonctionnalités supplémentaires comme le cache ou l'interception. |
| Persistence/Core/Spring.Persistence.Core.Repository.Simple | Cette unité permet de fournir un dépôt simple implémentant les opérations CRUD (Create, Read, Update, Delete) de base pour les entités persistées. |
| Persistence/Core/Spring.Persistence.Core.ResourceStrings | Cette unité permet de définir des chaînes de ressources utilisées dans le système de persistance, telles que les messages d'erreurs ou les descriptions d'opérations. |
| Persistence/Core/Spring.Persistence.Core.Session.MongoDB | Cette unité permet d'implémenter une session spécifique à MongoDB, gérant les interactions avec une instance MongoDB et le cycle de vie des entités. |
| Persistence/Core/Spring.Persistence.Core.Session | Cette unité permet d'implémenter une session générale pour gérer les interactions avec la base de données, incluant les transactions, les chargements d'entités, et la persistance des modifications. |
| Persistence/Core/Spring.Persistence.Core.ValueConverters | Cette unité permet de gérer des convertisseurs de valeurs permettant de convertir les types de données entre Delphi et la base de données, facilitant l'adaptation des valeurs pour correspondre au format requis. |
| Persistence/Criteria/Spring.Persistence.Criteria.Criterion.Abstract | Cette unité permet de définir une classe abstraite pour les critères de requêtes, utilisée comme base pour construire des critères complexes afin de filtrer les résultats dans des requêtes de persistance. |
| Persistence/Criteria/Spring.Persistence.Criteria.Criterion.BetweenExpression | Cette unité permet d'implémenter une expression BETWEEN permettant de filtrer des résultats en spécifiant un intervalle de valeurs entre deux bornes. |
| Persistence/Criteria/Spring.Persistence.Criteria.Criterion.Conjunction | Cette unité permet de fournir une conjonction combinant plusieurs critères avec un opérateur logique AND. Cela permet de spécifier des conditions cumulatives dans une requête. |
| Persistence/Criteria/Spring.Persistence.Criteria.Criterion.Disjunction | Cette unité permet de fournir une disjonction combinant plusieurs critères avec un opérateur logique OR. Cela permet de spécifier des alternatives dans une requête. |
| Persistence/Criteria/Spring.Persistence.Criteria.Criterion.InExpression | Cette unité permet d'implémenter une expression IN filtrant les résultats où une propriété correspond à l'une des valeurs d'une liste spécifiée. |
| Persistence/Criteria/Spring.Persistence.Criteria.Criterion.Junction | Cette unité permet de définir une jonction de critères servant de base pour combiner des critères à l'aide d'opérateurs logiques (AND ou OR). |
| Persistence/Criteria/Spring.Persistence.Criteria.Criterion.LikeExpression | Cette unité permet d'implémenter une expression LIKE pour filtrer les résultats en fonction de correspondances partielles dans des chaînes de caractères. |
| Persistence/Criteria/Spring.Persistence.Criteria.Criterion.LogicalExpression | Cette unité permet de définir une expression logique combinant deux critères avec un opérateur logique (AND ou OR). |
| Persistence/Criteria/Spring.Persistence.Criteria.Criterion.NullExpression | Cette unité permet d'implémenter une expression NULL pour filtrer les résultats où une propriété est NULL. |
| Persistence/Criteria/Spring.Persistence.Criteria.Criterion.PropertyExpression | Cette unité permet d'implémenter des expressions basées sur des propriétés, permettant de comparer des propriétés d'entités avec des valeurs ou d'autres propriétés. |
| Persistence/Criteria/Spring.Persistence.Criteria.Criterion.SimpleExpression | Cette unité permet d'implémenter une expression simple comparant une propriété à une valeur avec un opérateur comme =, <>, <, >,... |
| Persistence/Criteria/Spring.Persistence.Criteria.Interfaces | Cette unité permet de déclarer les interfaces pour les critères de persistance, fournissant des contrats pour la création de critères complexes et leur évaluation. |
| Persistence/Criteria/Spring.Persistence.Criteria.OrderBy | Cette unité permet de spécifier des critères de tri pour les requêtes, définissant les colonnes sur lesquelles les résultats doivent être triés (ascendant ou descendant). |
| Persistence/Criteria/Spring.Persistence.Criteria.Properties | Cette unité permet de fournir des fonctionnalités liées à la gestion des propriétés dans les critères de persistance, facilitant leur accès et leur manipulation. |
| Persistence/Criteria/Spring.Persistence.Criteria.Restrictions | Cette unité permet de définir une classe de restrictions permettant de construire facilement des critères de filtrage (AND, OR, BETWEEN,...). |
| Persistence/Criteria/Spring.Persistence.Criteria | Cette unité permet de regrouper les fonctionnalités de création de critères de requêtes, centralisant la logique pour la construction, la gestion et l'exécution de requêtes basées sur des critères. |
| Persistence/Mapping/Spring.Persistence.Mapping.Attributes | Cette unité permet de fournir des attributs de cartographie utilisés pour définir comment les entités sont cartographiées aux tables et colonnes dans la base de données. Ces attributs facilitent la configuration de la persistance via des annotations sur les classes et propriétés Delphi. |
| Persistence/Mapping/Spring.Persistence.Mapping.CodeGenerator.Abstract | Cette unité permet de définir une classe abstraite pour un générateur de code de cartographie, servant de base pour des générateurs spécifiques traduisant les entités en requêtes SQL. |
| Persistence/Mapping/Spring.Persistence.Mapping.CodeGenerator.DB | Cette unité permet d'implémenter un générateur de code pour les bases de données, permettant de traduire les entités et les carographier en structures SQL telles que des tables et des colonnes. |
| Persistence/Mapping/Spring.Persistence.Mapping.CodeGenerator | Cette unité contient des générateurs de code de cartographie automatisant la création des instructions SQL à partir des entités cartographiées et des critères définis. |
| Persistence/SQL/Spring.Persistence.SQL.Commands.Abstract | Cette unité permet de définir une classe abstraite pour les commandes SQL, servant de base pour implémenter diverses opérations SQL comme l'insertion, la mise à jour, et la suppression. |
| Persistence/SQL/Spring.Persistence.SQL.Commands.BulkInsert.MongoDB | Cette unité permet d'implémenter une commande pour effectuer des insertions en masse dans une base de données MongoDB, optimisant l'insertion de multiples documents en une seule opération. |
| Persistence/SQL/Spring.Persistence.SQL.Commands.CreateForeignKey | Cette unité permet de fournir une commande pour la création de clefs étrangères dans une base de données relationnelle, permettant de définir des relations entre les tables. |
| Persistence/SQL/Spring.Persistence.SQL.Commands.CreateSequence | Cette unité permet d'implémenter une commande pour la création de séquences dans les bases de données supportant les séquences (comme Oracle ou PostgreSQL), souvent utilisées pour générer des valeurs uniques. |
| Persistence/SQL/Spring.Persistence.SQL.Commands.CreateTable | Cette unité permet de fournir une commande pour la création de tables dans une base de données, spécifiant les colonnes, les types de données, les contraintes,... |
| Persistence/SQL/Spring.Persistence.SQL.Commands.Delete | Cette unité permet d'implémenter une commande pour effectuer des suppressions de lignes dans une table de base de données selon des critères spécifiques. |
| Persistence/SQL/Spring.Persistence.SQL.Commands.Insert | Cette unité permet d'implémenter une commande pour effectuer des insertions dans une base de données, ajoutant de nouvelles lignes à une table donnée. |
| Persistence/SQL/Spring.Persistence.SQL.Commands.Page | Cette unité permet de fournir des commandes pour la pagination des résultats dans les requêtes SQL, permettant de récupérer des sous-ensembles de résultats par lots (utile pour afficher des résultats paginés dans les applications). |
| Persistence/SQL/Spring.Persistence.SQL.Commands.Select | Cette unité permet d'implémenter une commande pour effectuer des requêtes de sélection (SELECT), permettant de récupérer des données d'une ou plusieurs tables selon certains critères. |
| Persistence/SQL/Spring.Persistence.SQL.Commands.Update | Cette unité permet de fournir une commande pour effectuer des mises à jour dans une table de base de données, modifiant les données des lignes correspondant aux critères. |
| Persistence/SQL/Spring.Persistence.SQL.Commands | Cette unité permet d'indiquer un fichier regroupant différentes commandes SQL pour la gestion des opérations de base (CRUD) sur les bases de données. |
| Persistence/SQL/Spring.Persistence.SQL.Generators.ASA | Cette unité permet d'implémenter un générateur SQL pour ASA (Adaptive Server Anywhere), traduisant les requêtes Delphi en SQL spécifique à ce SGBD. |
| Persistence/SQL/Spring.Persistence.SQL.Generators.Abstract | Cette unité permet de définir une classe abstraite pour les générateurs SQL, fournissant une base pour les implémentations spécifiques à divers systèmes de gestion de bases de données (SGBD). |
| Persistence/SQL/Spring.Persistence.SQL.Generators.Ansi | Cette unité permet d'implémenter un générateur SQL conforme à la norme ANSI, garantissant que les requêtes sont générées selon les standards SQL reconnus. |
| Persistence/SQL/Spring.Persistence.SQL.Generators.Firebird | Cette unité contient un générateur SQL spécifique à Firebird, adaptant les requêtes pour ce SGBD. |
| Persistence/SQL/Spring.Persistence.SQL.Generators.MSSQL | Cette unité contient un générateur SQL pour Microsoft SQL Server, prenant en charge les particularités et les fonctionnalités propres à ce SGBD. |
| Persistence/SQL/Spring.Persistence.SQL.Generators.MongoDB | Cette unité contient un générateur pour les bases de données MongoDB, traduisant les requêtes SQL-like en commandes spécifiques à MongoDB, un SGBD NoSQL. |
| Persistence/SQL/Spring.Persistence.SQL.Generators.MySQL | Cette unité contient un générateur SQL pour MySQL, permettant de générer des requêtes spécifiques à ce SGBD open-source populaire. |
| Persistence/SQL/Spring.Persistence.SQL.Generators.NoSQL | Cette unité permet de définir un générateur pour les bases NoSQL, permettant de créer des requêtes compatibles avec des bases de données NoSQL comme MongoDB ou Couchbase. |
| Persistence/SQL/Spring.Persistence.SQL.Generators.Oracle | Cette unité contient un générateur SQL spécifique à Oracle, prenant en compte les fonctionnalités et optimisations spécifiques à ce SGBD. |
| Persistence/SQL/Spring.Persistence.SQL.Generators.PostgreSQL | Cette unité contient un générateur SQL pour PostgreSQL, adapté aux particularités de ce SGBD open-source avancé. |
| Persistence/SQL/Spring.Persistence.SQL.Generators.Register | Cette unité contient des enregistrements pour l'enregistrement de générateurs SQL, permettant d'associer chaque générateur à son SGBD respectif. |
| Persistence/SQL/Spring.Persistence.SQL.Generators.SQLite3 | Cette unité contient un générateur SQL pour SQLite3, créant des requêtes spécifiques à ce SGBD léger et intégré. |
| Persistence/SQL/Spring.Persistence.SQL.Interfaces | Cette unité permet de déclarer les interfaces nécessaires à l'implémentation de générateurs et de commandes SQL, fournissant des contrats pour la génération et l'exécution des requêtes. |
| Persistence/SQL/Spring.Persistence.SQL.Params | Cette unité permet de fournir une gestion des paramètres SQL, permettant d'utiliser des valeurs dynamiques dans les requêtes (comme les paramètres de requêtes préparées). |
| Persistence/SQL/Spring.Persistence.SQL.Register | Cette unité permet de gérer l'enregistrement des générateurs et des commandes SQL pour différents systèmes de bases de données. |
| Persistence/SQL/Spring.Persistence.SQL.Types | Cette unité permet de définir des types SQL spécifiques utilisés dans l'implémentation des générateurs et des commandes SQL, facilitant la gestion des types de données entre Delphi et les SGBD. |
Dernière mise à jour : Vendredi, le 4 octobre 2024