Download JAR files tagged by implementation with all dependencies

The crypto4j library provides a simple and pluggable crypto abstraction library for Java, including both cryptographic primitives and the artifacts defined in the JOSE standard. This library separates the cryptographic primitives from the JOSE artifacts. The library uses the algorithms available through JCA (JCE). The implementations of the cryptographic primitives provided in this library rely on the standard JCA implementation, and can be configured and extended through the JCA mechanisms. The JOSE portion of the library allows custom extensions by either replacing the provided JOSE artifact implementations with custom implementations, or by adding new JOSE artifacts, for instance in form of additional algorithms, which is particularly useful in case that the JOSE standard is updated or in case custom extensions to the JOSE standard should be implemented. The implementations available in this library generally come in two variants: a standard implementation of the primitives and advanced algorithms, and a high-performance implementation that takes advantage of implementation patterns that do not compromise cryprographic security, but speed up the overall processing time.

Alpheus AFP Parser is a library and parser for the IBM Advanced Function Presentation (AFP) document/print stream format. Alpheus covers all AFP specifications: MO:DCA, BCOCA, CMOCA, FOCA, GOCA, IOCA, and PTOCA. It is a complete implementation. Every Structured Field, Repeating Group, and Triplet is fully implemented as Java class. Alpheus AFP Parser was written from scratch and has no external dependencies. Copyright 2015,2016 Rudolf Fiala Alpheus AFP Parser is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

Nuun Kernel is a software kernel for framework creation. It brings a powerful plugin design plus a JSR 330 compliant injection mechanism backed by Guice. Plugin benefits from kernel capabilities by sendings request to it : - kernel params request : - Classpath scans request :on class by name, annotation, meta annotation or more generally Predicate - Binding Request : Nuun Kernel provides an SPI in order to bring IOC from other vendors. Nuun Kernel come with 2 plugins: - Configuration Plugin : a plugin that inject the good property based on @Property annotation. - Log plugin : a Log handler that inject the good Log implementation

Welcome to the Blazegraph/TinkerPop3 project. The TP3 implementation has some significant differences from the TP2 version. The data model has been changed to use RDF*, an RDF reification framework described here: https://wiki.blazegraph.com/wiki/index.php/Reification_Done_Right. The concept behind blazegraph-gremlin is that property graph (PG) data can be loaded and accessed via the TinkerPop3 API, but underneath the hood the data will be stored as RDF using the PG data model described in this document. Once PG data has been loaded you can interact with it just like you would interact with ordinary RDF - you can run SPARQL queries or interact with the data via the SAIL API. It just works. The PG data model is also customizable via a round-tripping interface called the BlazeValueFactory, also described in detail in this document.

The Infinispan Spring Integration project provides Spring integration for Infinispan, a high performance distributed cache. Its primary features are * An implementation of org.springframework.cache.CacheManager, Spring's central caching abstraction, backed by Infinispan's EmbeddedCacheManager. To be used if your Spring-powered application and Infinispan are colocated, i.e. running within the same VM. * An implementation of org.springframework.cache.CacheManager backed by Infinispan's RemoteCacheManager. To bes used if your Spring-powered application accesses Infinispan remotely, i.e. over the network. * An implementation of org.springframework.cache.CacheManager backed by a CacheContainer reference. To be used if your Spring- powered application needs access to a CacheContainer defined outside the application (e.g. retrieved from JNDI) * Spring namespace support allowing shortcut definitions for all the components above In addition, Infinispan Spring Integration offers various FactoryBeans for facilitating creation of Infinispan core classes - Cache, CacheManager, ... - within a Spring context.

The HTTP server module (ks-server-http) implements the Web API of the KnowledgeStore, which includes the two CRUD and SPARQL endpoints. The CRUD Endpoint supports the retrieval and manipulation of semi-structured data about resource, mention, entity and axiom records (encoded in RDF, possibly using JSONLD), and the upload / download of resource representation. The SPARQL Endpoint supports SPARQL SELECT, CONSTRUCT, DESCRIBE and ASK queries according to the W3C SPARQL protocol. The two endpoints are implemented on top of a component implementing the KnowledgeStore Java API (the Store interface), which can be either the the KnowledgeStore frontend (ks-frontend) or the Java Client. The implementation of the module is based on the Jetty Web sever (run in embedded mode) and the Jersey JAX-RS implementation. Reference documentation of the Web API is automatically generated using the Enunciate tool.

The Virtuoso server module (ks-server-virtuoso) provides an implementation of the Triple Store server-side component (API in ks-triplestore) on top of the OpenLink Virtuoso triple store, a scalable native code triple store that is accessed as an external service. The Virtuoso Sesame driver, which builds on the Virtuoso JDBC driver, is used to remotely access the Virtuoso server for writing data and performing SPARQL queries. For performance reasons, data modification is performed in a non-transactional way, with the module managing possible failures in a way that trigger the external repopulation of the Virtuoso triple store starting from the master copy of data stored in the Data Store component.

This is the main aggregator for all implementation code shared between modules. Each module contains one or more service interfaces, exposed statically using "X_" prefixed classes. Core modules will define their API interfaces, their static accessor, and often a "plain-jre" default implementation which can be replaced by injection override. There must be zero external dependencies in any core modules. A low-performance, low-feature default is preferred over thick, dependency-ridden shared inherits.

Skeletal implementation of interface javax.lang.model.util.Types, plus concrete realization backed by core Java Reflection API, akin to JEP 119. This module implements those methods in interface javax.lang.model.util.Types that pertain to the Java type system, plus it provides a method for resolving formal type parameters to actual type arguments. These methods have no equivalent in the Java Reflection API. The abstract skeletal implementation in this module is meant to be specialized for a particular javax.lang.model implementation. The abstraction makes this module well-suited to be used in projects that contain javax.lang.model as part of their domain model (for instance, implementations of alternative languages on top of the JVM).

eFaps is a framework used to map objects with or without attached files to a relational database and optional file systems (only for attaches files). Configurable access control can be provided down to object and attribute level depending on implementation and use case. Depending on requirements, events (like triggers) allow to implement business logic and to separate business logic from user interface. The framework includes integrations (e.g. webdav, full text search) and a web application as 'simple' configurable user interface. Some best practises, example web application modules (e.g. team work module) support administrators and implementers using this framework.