code: public @Nonnull Collection<FingerprintFacet> getFacets() {
          if (transientFacets==null) {
              List<FingerprintFacet> transientFacets = new ArrayList<>();
              for (TransientFingerprintFacetFactory fff : TransientFingerprintFacetFactory.all()) {
                  fff.createFor(this,transientFacets);
              }
              this.transientFacets = ImmutableList.copyOf(transientFacets);
          }
  
          return new AbstractCollection<FingerprintFacet>() {
              @Override
              public Iterator<FingerprintFacet> iterator() {
                  return Iterators.sequence(facets.iterator(), transientFacets.iterator());
              }
  
              @Override
              public boolean add(FingerprintFacet e) {
                  facets.add(e);
                  return true;
              }
  
              @Override
              public boolean remove(Object o) {
                  return facets.remove(o);
              }
  
              @Override
              public boolean contains(Object o) {
                  return facets.contains(o) || transientFacets.contains(o);
              }
  
              @Override
              public int size() {
                  return facets.size()+transientFacets.size();
              }
          };
      }
docs: Gets the associated {@link FingerprintFacet}s.
  
  <p>
  This method always return a non-empty collection, which is a synthetic collection.
  It contains persisted {@link FingerprintFacet}s (those that are added explicitly, like
  {@code fingerprint.getFacets().add(x)}), as well those {@linkplain TransientFingerprintFacetFactory that are transient}.
  
  <p>
  Mutation to this collection will manipulate persisted set of {@link FingerprintFacet}s, and therefore regardless
  of what you do, this collection will always contain a set of {@link FingerprintFacet}s that are added
  by {@link TransientFingerprintFacetFactory}s.
  
  @since 1.421