source.dussan.org Git - archiva.git/blob

   1 package org.apache.archiva.repository.content.base;
   2
   3 /*
   4  * Licensed to the Apache Software Foundation (ASF) under one
   5  * or more contributor license agreements.  See the NOTICE file
   6  * distributed with this work for additional information
   7  * regarding copyright ownership.  The ASF licenses this file
   8  * to you under the Apache License, Version 2.0 (the
   9  * "License"); you may not use this file except in compliance
  10  * with the License.  You may obtain a copy of the License at
  11  *
  12  *  http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing,
  15  * software distributed under the License is distributed on an
  16  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  17  * KIND, either express or implied.  See the License for the
  18  * specific language governing permissions and limitations
  19  * under the License.
  20  */
  21
  22 import org.apache.archiva.repository.ManagedRepositoryContent;
  23 import org.apache.archiva.repository.content.Project;
  24 import org.apache.archiva.repository.content.Version;
  25 import org.apache.archiva.repository.content.base.builder.VersionOptBuilder;
  26 import org.apache.archiva.repository.content.base.builder.WithAssetBuilder;
  27 import org.apache.archiva.repository.content.base.builder.WithNamespaceBuilder;
  28 import org.apache.archiva.repository.content.base.builder.WithProjectBuilder;
  29 import org.apache.archiva.repository.content.base.builder.WithVersionBuilder;
  30 import org.apache.archiva.repository.storage.StorageAsset;
  31 import org.apache.commons.lang3.StringUtils;
  32
  33 import java.util.Arrays;
  34 import java.util.List;
  35 import java.util.regex.PatternSyntaxException;
  36
  37 /**
  38  * Immutable version instance.
  39  * <p>
  40  * You have to use the builder method to create instances of this version object.
  41  * <p>
  42  * The project and the version string are required attributes of this instance additional to the base
  43  * attributes repository and asset.
  44  * <p>
  45  * Two instances are equal, if the project and the version match in addition to the base attributes repository and asset.
  46  */
  47 public class ArchivaVersion extends BaseContentItem implements Version
  48 {
  49
  50     private String version;
  51     private Project project;
  52     private String separatorExpression = "\\.";
  53     private List<String> versionSegments;
  54
  55     private ArchivaVersion( )
  56     {
  57
  58     }
  59
  60     /**
  61      * Creates a new builder for creating new version instances. You have to provide the required
  62      * attributes before the build() method can be called.
  63      *
  64      * @param storageAsset the storage asset
  65      * @return the builder for creating new version instances
  66      */
  67     public static WithProjectBuilder withAsset( StorageAsset storageAsset )
  68     {
  69         return new Builder( ).withAsset( storageAsset );
  70     }
  71
  72     public static WithAssetBuilder<WithProjectBuilder> withRepository( ManagedRepositoryContent repository )
  73     {
  74         return new ArchivaVersion.Builder( ).withRepository( repository );
  75     }
  76
  77     @Override
  78     public List<String> getVersionSegments( )
  79     {
  80         return versionSegments;
  81     }
  82
  83     @Override
  84     public String getVersion( )
  85     {
  86         return version;
  87     }
  88
  89     @Override
  90     public Project getProject( )
  91     {
  92         return project;
  93     }
  94
  95
  96     @Override
  97     public boolean equals( Object o )
  98     {
  99         if ( this == o ) return true;
 100         if ( o == null || getClass( ) != o.getClass( ) ) return false;
 101
 102         ArchivaVersion that = (ArchivaVersion) o;
 103         if (!repository.equals( that.repository )) return false;
 104         if ( !version.equals( that.version ) ) return false;
 105         return project.equals( that.project );
 106     }
 107
 108     @Override
 109     public int hashCode( )
 110     {
 111         int result = super.hashCode( );
 112         result = 31 * result + version.hashCode( );
 113         result = 31 * result + project.hashCode( );
 114         return result;
 115     }
 116
 117     @Override
 118     public String toString( )
 119     {
 120         return "ArchivaVersion{ "+version+", project="+project.toString()+"}";
 121     }
 122
 123     private static final class Builder extends ContentItemBuilder<ArchivaVersion, VersionOptBuilder, WithProjectBuilder>
 124         implements WithProjectBuilder, WithVersionBuilder, VersionOptBuilder
 125     {
 126
 127         Builder( )
 128         {
 129             super( new ArchivaVersion( ) );
 130         }
 131
 132         @Override
 133         protected WithProjectBuilder getNextBuilder( )
 134         {
 135             return this;
 136         }
 137
 138         @Override
 139         protected VersionOptBuilder getOptBuilder( )
 140         {
 141             return this;
 142         }
 143
 144         @Override
 145         public VersionOptBuilder withVersion( String version )
 146         {
 147             if ( StringUtils.isEmpty( version ) )
 148             {
 149                 throw new IllegalArgumentException( "Version parameter must not be empty or null." );
 150             }
 151             item.version = version;
 152             updateVersionSegments( );
 153             return this;
 154         }
 155
 156
 157         private void updateVersionSegments( )
 158         {
 159             item.versionSegments = Arrays.asList( item.version.split( item.separatorExpression ) );
 160         }
 161
 162         @Override
 163         public WithVersionBuilder withProject( Project project )
 164         {
 165             if ( project == null )
 166             {
 167                 throw new IllegalArgumentException( "Project may not be null" );
 168             }
 169             item.project = project;
 170             super.setRepository( project.getRepository( ) );
 171             return this;
 172         }
 173
 174         @Override
 175         public ArchivaVersion build( )
 176         {
 177             super.build( );
 178             return item;
 179         }
 180
 181         @Override
 182         public VersionOptBuilder withSeparatorExpression( String expression )
 183         {
 184             if ( StringUtils.isEmpty( expression ) )
 185             {
 186                 throw new IllegalArgumentException( "Separator expression may not be null or empty" );
 187             }
 188             this.item.separatorExpression = expression;
 189             try
 190             {
 191                 updateVersionSegments( );
 192             }
 193             catch ( PatternSyntaxException e )
 194             {
 195                 throw new IllegalArgumentException( "Bad separator expression " + expression + ": " + e.getMessage( ), e );
 196             }
 197             return this;
 198         }
 199     }
 200
 201 }