How to use

with

method

in

it.tidalwave.bluemarine2.util.ModelBuilder

/*******************************************************************************************************************
 *
 *
 *
 ******************************************************************************************************************/
@Nonnull
public synchronized ModelBuilder with (final @Nonnull Optional<ModelBuilder> optionalBuiilder)
 {
  optionalBuiilder.ifPresent(builder -> ModelBuilder.this.with(builder));
  return this;
 }

/*******************************************************************************************************************
 *
 *
 *
 ******************************************************************************************************************/
@Nonnull
public synchronized ModelBuilder withOptional (final @Nonnull Resource subject,
                        final @Nonnull IRI predicate,
                        final @Nonnull Optional<? extends Value> optionalObject)
 {
  return optionalObject.map(object -> ModelBuilder.this.with(subject, predicate, object)).orElse(this);
 }

/*******************************************************************************************************************
 *
 *
 *
 ******************************************************************************************************************/
@Nonnull
public synchronized ModelBuilder withOptional (final @Nonnull Optional<? extends Resource> optionalSubject,
                        final @Nonnull IRI predicate,
                        final @Nonnull Value object)
 {
  return optionalSubject.map(subject -> ModelBuilder.this.with(subject, predicate, object)).orElse(this);
 }

/*******************************************************************************************************************
 *
 *
 *
 ******************************************************************************************************************/
@Nonnull
public synchronized ModelBuilder with (final @Nonnull Resource subject,
                    final @Nonnull IRI predicate,
                    final @Nonnull Stream<? extends Value> objects)
 {
  objects.forEach(object -> ModelBuilder.this.with(subject, predicate, object)); // FIXME ?? this = withOptional(...)
  return this;
 }

/*******************************************************************************************************************
 *
 *
 *
 ******************************************************************************************************************/
@Nonnull
public synchronized ModelBuilder with (final @Nonnull List<? extends Resource> subjects,
                    final @Nonnull IRI predicate,
                    final @Nonnull Value object)
 {
  subjects.stream().forEach(subject -> ModelBuilder.this.with(subject, predicate, object)); // FIXME ?? this = withOptional(...)
  return this;
 }

/*******************************************************************************************************************
 *
 *
 *
 ******************************************************************************************************************/
@Nonnull
public synchronized ModelBuilder with (final @Nonnull Resource subjext,
                    final @Nonnull IRI predicate,
                    final @Nonnull Optional<Value> optionalObject,
                    final @Nonnull Resource... contexts)
 {
  return optionalObject.map(object -> ModelBuilder.this.with(subjext, predicate, object, contexts)).orElse(this);
 }

/*******************************************************************************************************************
 *
 *
 *
 ******************************************************************************************************************/
@Nonnull
public synchronized ModelBuilder with (final @Nonnull ModelBuilder other)
 {
  return ModelBuilder.this.with(other.toModel());
 }

/*******************************************************************************************************************
 *
 *
 *
 ******************************************************************************************************************/
@Nonnull
public synchronized ModelBuilder with (final @Nonnull List<? extends Resource> subjects,
                    final @Nonnull IRI predicate,
                    final @Nonnull List<? extends Value> objects)
 {
  assert subjects.size() == objects.size();
  for (int i = 0; i < subjects.size(); i++)
   {
    ModelBuilder.this.with(subjects.get(i), predicate, objects.get(i)); // FIXME ?? this = withOptional(...)
   }
  return this;
 }

/*******************************************************************************************************************
 *
 * Extracts data from the relations of the given {@link Recording}.
 *
 * @param   signalIri   the IRI of the signal associated to the track we're handling
 * @param   recording   the {@code Recording}
 * @return              the RDF triples
*
 ******************************************************************************************************************/
@Nonnull
private ModelBuilder handleTrackRelations (final @Nonnull IRI signalIri,
                      final @Nonnull IRI trackIri,
                      final @Nonnull IRI recordIri,
                      final @Nonnull Recording recording)
 {
  return createModelBuilder().with(recording.getRelationList()
                       .stream()
                       .parallel()
                       .flatMap(RelationAndTargetType::toStream)
                       .map(ratt -> handleTrackRelation(signalIri, trackIri, recordIri, recording, ratt))
                       .collect(toList()));
 }

.with(recordIri, RDF.TYPE,              MO.C_RECORD)
.with(recordIri, RDFS.LABEL,            literalFor(recordTitle))
.with(recordIri, DC.TITLE,              literalFor(recordTitle))
.with(recordIri, BMMO.P_IMPORTED_FROM,  BMMO.O_SOURCE_MUSICBRAINZ)
.with(recordIri, BMMO.P_ALTERNATE_OF,   embeddedRecordIri)
.with(recordIri, MO.P_MEDIA_TYPE,       MO.C_CD)
.with(recordIri, MO.P_TRACK_COUNT,      literalFor(tracks.size()))
.with(recordIri, MO.P_MUSICBRAINZ_GUID, literalFor(releaseId))
.with(recordIri, MO.P_MUSICBRAINZ,      musicBrainzIriFor("release", releaseId))
.with(recordIri, MO.P_AMAZON_ASIN,      literalFor(rmd.getAsin()))
.with(recordIri, MO.P_GTIN,             literalFor(rmd.getBarcode()))
.with(tracks.stream().parallel()
           .map(_f(track -> handleTrack(rmd, cddb, recordIri, track)))
           .collect(toList()));
model = model.with(recordIri, BMMO.P_ALTERNATE_PICK_OF, embeddedRecordIri);

.with(performanceIri,  RDF.TYPE,              MO.C_PERFORMANCE)
.with(performanceIri,  BMMO.P_IMPORTED_FROM,  BMMO.O_SOURCE_MUSICBRAINZ)
.with(performanceIri,  MO.P_MUSICBRAINZ_GUID, literalFor(recording.getId()))
.with(performanceIri,  MO.P_RECORDED_AS,      signalIri)
.with(artistIri,       RDF.TYPE,              MO.C_MUSIC_ARTIST)
.with(artistIri,       RDFS.LABEL,            literalFor(artist.getName()))
.with(artistIri,       FOAF.NAME,             literalFor(artist.getName()))
.with(artistIri,       BMMO.P_IMPORTED_FROM,  BMMO.O_SOURCE_MUSICBRAINZ)
.with(artistIri,       MO.P_MUSICBRAINZ_GUID, literalFor(artist.getId()))
.with(artistIri,       MO.P_MUSICBRAINZ,      musicBrainzIriFor("artist", artist.getId()))
.with(recordIri,       FOAF.MAKER,            artistIri)
.with(trackIri,        FOAF.MAKER,            artistIri)
.with(performanceIri,  FOAF.MAKER,            artistIri);
    .forEach(predicate -> model.with(performanceIri, predicate, artistIri));

.with(recordIri, MO.P_TRACK,            trackIri)
.with(recordIri, BMMO.P_DISK_COUNT,     literalForInt(diskCount))
.with(recordIri, BMMO.P_DISK_NUMBER,    literalForInt(diskNumber))
.with(signalIri, MO.P_PUBLISHED_AS,     trackIri)
.with(trackIri,  RDF.TYPE,              MO.C_TRACK)
.with(trackIri,  RDFS.LABEL,            literalFor(trackTitle))
.with(trackIri,  DC.TITLE,              literalFor(trackTitle))
.with(trackIri,  BMMO.P_IMPORTED_FROM,  BMMO.O_SOURCE_MUSICBRAINZ)
.with(trackIri,  MO.P_TRACK_NUMBER,     literalFor(trackNumber))
.with(trackIri,  MO.P_MUSICBRAINZ_GUID, literalFor(track.getId()))
.with(trackIri,  MO.P_MUSICBRAINZ,      musicBrainzIriFor("track", track.getId()))
.with(handleTrackRelations(signalIri, trackIri, recordIri, recording));

model.with(markedAlternative(rmds, albumTitle).stream()
                         .parallel()
                         .map(_f(rmd -> handleRelease(metadata, rmd)))

modelBuilders.get(testSetName).with(model);