SnapshotVersion sv = new SnapshotVersion(); sv.setClassifier( artifact.getClassifier() ); sv.setExtension( artifact.getExtension() ); sv.setVersion( getVersion() ); sv.setUpdated( lastUpdated ); versions.put( getKey( sv.getClassifier(), sv.getExtension() ), sv ); String key = getKey( sv.getClassifier(), sv.getExtension() ); if ( !versions.containsKey( key ) )
/** * Method writeSnapshotVersion. * * @param snapshotVersion * @param serializer * @param tagName * @throws java.io.IOException */ private void writeSnapshotVersion( SnapshotVersion snapshotVersion, String tagName, XmlSerializer serializer ) throws java.io.IOException { serializer.startTag( NAMESPACE, tagName ); if ( ( snapshotVersion.getClassifier() != null ) && !snapshotVersion.getClassifier().equals( "" ) ) { serializer.startTag( NAMESPACE, "classifier" ).text( snapshotVersion.getClassifier() ).endTag( NAMESPACE, "classifier" ); } if ( snapshotVersion.getExtension() != null ) { serializer.startTag( NAMESPACE, "extension" ).text( snapshotVersion.getExtension() ).endTag( NAMESPACE, "extension" ); } if ( snapshotVersion.getVersion() != null ) { serializer.startTag( NAMESPACE, "value" ).text( snapshotVersion.getVersion() ).endTag( NAMESPACE, "value" ); } if ( snapshotVersion.getUpdated() != null ) { serializer.startTag( NAMESPACE, "updated" ).text( snapshotVersion.getUpdated() ).endTag( NAMESPACE, "updated" ); } serializer.endTag( NAMESPACE, tagName ); } //-- void writeSnapshotVersion( SnapshotVersion, String, XmlSerializer )
SnapshotVersion snapshotVersion = new SnapshotVersion(); for ( int i = parser.getAttributeCount() - 1; i >= 0; i-- ) snapshotVersion.setClassifier( interpolatedTrimmed( parser.nextText(), "classifier" ) ); snapshotVersion.setExtension( interpolatedTrimmed( parser.nextText(), "extension" ) ); snapshotVersion.setVersion( interpolatedTrimmed( parser.nextText(), "value" ) ); snapshotVersion.setUpdated( interpolatedTrimmed( parser.nextText(), "updated" ) );
boolean found = false; for (SnapshotVersion preExisting : lv.getSnapshotVersions()) { if (Objects.equals(snapshotVersion.getExtension(), preExisting.getExtension()) && Objects.equals(nullOrEmptyStringFilter(snapshotVersion.getClassifier()), nullOrEmptyStringFilter(preExisting.getClassifier()))) { found = true; if (version(snapshotVersion.getVersion()).compareTo(version(preExisting.getVersion())) > 0) { preExisting.setClassifier(nullOrEmptyStringFilter(snapshotVersion.getClassifier())); preExisting.setVersion(snapshotVersion.getVersion()); preExisting.setUpdated(snapshotVersion.getUpdated()); final SnapshotVersion newSnapshotVersion = new SnapshotVersion(); newSnapshotVersion.setExtension(snapshotVersion.getExtension()); newSnapshotVersion.setClassifier(snapshotVersion.getClassifier()); newSnapshotVersion.setVersion(snapshotVersion.getVersion()); newSnapshotVersion.setUpdated(snapshotVersion.getUpdated()); lv.getSnapshotVersions().add(newSnapshotVersion);
@Override public int compare(SnapshotVersion o1, SnapshotVersion o2) { int c = VERSION_COMPARATOR.compare(o1.getVersion(), o2.getVersion()); if (c == 0) { c = o1.getExtension().compareTo(o2.getExtension()); } if (c == 0) { c = o1.getClassifier().compareTo(o2.getClassifier()); } return c; } };
private static SnapshotVersion get(SnapshotVersion s1, List<SnapshotVersion> snapshotVersions) { for (SnapshotVersion s2 : snapshotVersions) { if (StringUtils.equals(s1.getClassifier(), s2.getClassifier()) && StringUtils.equals(s1.getExtension(), s2.getExtension())) { return s2; } } return null; }
@Override public int compare( final SnapshotVersion first, final SnapshotVersion second ) { int comp = first.getVersion() .compareTo( second.getVersion() ); if ( comp == 0 ) { comp = first.getExtension() .compareTo( second.getExtension() ); } return comp; } }
private boolean equals( List<SnapshotVersion> old, List<SnapshotVersion> md ) { if ( old.size() != md.size() ) { return false; } for ( SnapshotVersion version : md ) { SnapshotVersion oldVersion = MetadataUtil.searchForEquivalent( version, old ); if ( oldVersion == null ) { return false; } if ( !StringUtils.equals( oldVersion.getVersion(), version.getVersion() ) || !StringUtils.equals( oldVersion.getUpdated(), version.getUpdated() ) ) { return false; } } return true; } }
public String getExpandedVersion( Artifact artifact ) { String key = getKey( artifact.getClassifier(), artifact.getExtension() ); return versions.get( key ).getVersion(); }
if ( versionComparator.compare( current.getVersion(), extra.getVersion() ) < 0 ) current.setUpdated( operand.getTimestamp() );
private SnapshotVersion buildVersioning( Gav gav ) { SnapshotVersion version = new SnapshotVersion(); version.setClassifier( gav.getClassifier() ); version.setExtension( gav.getExtension() ); version.setVersion( gav.getVersion() ); version.setUpdated( TimeUtil.getUTCTimestamp() ); return version; }
public static SnapshotVersion searchForEquivalent( SnapshotVersion source, List<SnapshotVersion> list ) { for ( SnapshotVersion equivalent : list ) { if ( StringUtils.equals( source.getExtension(), equivalent.getExtension() ) && ( ( StringUtils.isEmpty( source.getClassifier() ) && StringUtils.isEmpty( equivalent.getClassifier() ) ) || StringUtils.equals( source.getClassifier(), equivalent.getClassifier() ) ) ) { return equivalent; } } return null; }
public String getExpandedVersion( Artifact artifact ) { String key = getKey( artifact.getClassifier(), artifact.getExtension() ); return versions.get( key ).getVersion(); }
SnapshotVersion sv = new SnapshotVersion(); sv.setClassifier( artifact.getClassifier() ); sv.setExtension( artifact.getExtension() ); sv.setVersion( version ); sv.setUpdated( lastUpdated ); versions.put( getKey( sv.getClassifier(), sv.getExtension() ), sv ); String key = getKey( sv.getClassifier(), sv.getExtension() ); if ( !versions.containsKey( key ) )
if ( StringUtils.isNotEmpty( sv.getVersion() ) ) String key = getKey( sv.getClassifier(), sv.getExtension() ); merge( SNAPSHOT + key, infos, sv.getUpdated(), sv.getVersion(), repository );
private SnapshotVersion[] buildVersion( Gav gav ) throws MetadataException { if ( gav.getBaseVersion().equals( gav.getVersion() ) ) { return new SnapshotVersion[0]; } SnapshotVersion snap = new SnapshotVersion(); snap.setClassifier( gav.getClassifier() ); snap.setExtension( gav.getExtension() ); snap.setVersion( gav.getVersion() ); Snapshot timestamp = buildSnapshot( gav ); if ( timestamp != null ) { snap.setUpdated( timestamp.getTimestamp().replace( ".", "" ) ); } else { snap.setUpdated( TimeUtil.getUTCTimestamp().replace( ".", "" ) ); } return new SnapshotVersion[] { snap }; }
private static SnapshotVersion get( SnapshotVersion s1, List<SnapshotVersion> snapshotVersions ) { for ( SnapshotVersion s2 : snapshotVersions ) { if ( StringUtils.equals( s1.getClassifier(), s2.getClassifier() ) && StringUtils.equals( s1.getExtension(), s2.getExtension() ) ) { return s2; } } return null; }
public String getExpandedVersion( Artifact artifact ) { String key = getKey( artifact.getClassifier(), artifact.getExtension() ); return versions.get( key ).getVersion(); }
SnapshotVersion sv = new SnapshotVersion(); sv.setClassifier( artifact.getClassifier() ); sv.setExtension( artifact.getExtension() ); sv.setVersion( getVersion() ); sv.setUpdated( lastUpdated ); versions.put( getKey( sv.getClassifier(), sv.getExtension() ), sv ); String key = getKey( sv.getClassifier(), sv.getExtension() ); if ( !versions.containsKey( key ) )
private boolean snapshotVersionEquals(final SnapshotVersion s1, final SnapshotVersion s2) { return Objects.equals(s1.getClassifier(), s2.getClassifier()) && // NOSONAR Objects.equals(s1.getExtension(), s2.getExtension()) && Objects.equals(s1.getVersion(), s2.getVersion()) && Objects.equals(s1.getUpdated(), s2.getUpdated()); }