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.content.Artifact;
  23 import org.apache.archiva.repository.content.ArtifactType;
  24 import org.apache.archiva.repository.content.BaseArtifactTypes;
  25 import org.apache.archiva.repository.content.Version;
  26 import org.apache.archiva.repository.content.base.builder.ArtifactOptBuilder;
  27 import org.apache.archiva.repository.content.base.builder.ArtifactVersionBuilder;
  28 import org.apache.archiva.repository.content.base.builder.ArtifactWithIdBuilder;
  29 import org.apache.archiva.repository.content.base.builder.WithVersionObjectBuilder;
  30 import org.apache.archiva.repository.storage.StorageAsset;
  31 import org.apache.commons.lang3.StringUtils;
  32
  33 /**
  34  * Base implementation of artifact.
  35  * <p>
  36  * You have to use the builder method {@link #withAsset(StorageAsset)} to create a instance.
  37  * The build() method can be called after the required attributes are set.
  38  * <p>
  39  * Artifacts are equal if the following coordinates match:
  40  * <ul>
  41  *     <li>repository</li>
  42  *     <li>asset</li>
  43  *     <li>version</li>
  44  *     <li>artifactId</li>
  45  *     <li>artifactVersion</li>
  46  *     <li>type</li>
  47  *     <li>classifier</li>
  48  *     <li>artifactType</li>
  49  * </ul>
  50  *
  51  * @author Martin Stockhammer <martin_s@apache.org>
  52  */
  53 public class ArchivaArtifact extends ArchivaContentItem implements Artifact
  54 {
  55     private String id;
  56     private String artifactVersion;
  57     private Version version;
  58     private String type;
  59     private String classifier;
  60     private String remainder;
  61     private String contentType;
  62     private ArtifactType artifactType;
  63
  64     private ArchivaArtifact( )
  65     {
  66
  67     }
  68
  69
  70     @Override
  71     public String getId( )
  72     {
  73         return id;
  74     }
  75
  76     @Override
  77     public String getArtifactVersion( )
  78     {
  79         return artifactVersion;
  80     }
  81
  82     @Override
  83     public Version getVersion( )
  84     {
  85         return version;
  86     }
  87
  88     @Override
  89     public String getType( )
  90     {
  91         return type;
  92     }
  93
  94     @Override
  95     public String getClassifier( )
  96     {
  97         return classifier;
  98     }
  99
 100     @Override
 101     public String getRemainder( )
 102     {
 103         return remainder;
 104     }
 105
 106     @Override
 107     public String getContentType( )
 108     {
 109         return contentType;
 110     }
 111
 112     @Override
 113     public ArtifactType getArtifactType( )
 114     {
 115         return artifactType;
 116     }
 117
 118
 119     /**
 120      * Returns the builder for creating a new artifact instance. You have to fill the
 121      * required attributes before the build() method is available.
 122      *
 123      * @param asset the storage asset representing the artifact
 124      * @return a builder for creating new artifact instance
 125      */
 126     public static WithVersionObjectBuilder withAsset( StorageAsset asset )
 127     {
 128         return new Builder( ).withAsset( asset );
 129     }
 130
 131
 132     @Override
 133     public boolean equals( Object o )
 134     {
 135         if ( this == o ) return true;
 136         if ( o == null || getClass( ) != o.getClass( ) ) return false;
 137         if ( !super.equals( o ) ) return false;
 138
 139         ArchivaArtifact that = (ArchivaArtifact) o;
 140
 141         if ( !id.equals( that.id ) ) return false;
 142         if ( !artifactVersion.equals( that.artifactVersion ) ) return false;
 143         if ( !version.equals( that.version ) ) return false;
 144         if ( !type.equals( that.type ) ) return false;
 145         if ( !artifactType.equals(that.artifactType)) return false;
 146         return classifier.equals( that.classifier );
 147     }
 148
 149     @Override
 150     public int hashCode( )
 151     {
 152         int result = super.hashCode( );
 153         result = 31 * result + id.hashCode( );
 154         result = 31 * result + artifactVersion.hashCode( );
 155         result = 31 * result + version.hashCode( );
 156         result = 31 * result + type.hashCode( );
 157         result = 31 * result + classifier.hashCode( );
 158         result = 31 * result + artifactType.hashCode( );
 159         return result;
 160     }
 161
 162     @Override
 163     public String toString( )
 164     {
 165         final StringBuilder sb = new StringBuilder( "ArchivaArtifact{" );
 166         sb.append( "id='" ).append( id ).append( '\'' );
 167         sb.append( ", artifactVersion='" ).append( artifactVersion ).append( '\'' );
 168         sb.append( ", version=" ).append( version );
 169         sb.append( ", type='" ).append( type ).append( '\'' );
 170         sb.append( ", classifier='" ).append( classifier ).append( '\'' );
 171         sb.append( ", remainder='" ).append( remainder ).append( '\'' );
 172         sb.append( ", contentType='" ).append( contentType ).append( '\'' );
 173         sb.append( ", artifactType=" ).append( artifactType );
 174         sb.append( '}' );
 175         return sb.toString( );
 176     }
 177
 178     private static class Builder
 179         extends ContentItemBuilder<ArchivaArtifact, ArtifactOptBuilder, WithVersionObjectBuilder>
 180         implements ArtifactVersionBuilder, WithVersionObjectBuilder, ArtifactWithIdBuilder, ArtifactOptBuilder
 181     {
 182
 183         Builder( )
 184         {
 185             super( new ArchivaArtifact( ) );
 186         }
 187
 188         @Override
 189         protected ArtifactOptBuilder getOptBuilder( )
 190         {
 191             return this;
 192         }
 193
 194         @Override
 195         protected WithVersionObjectBuilder getNextBuilder( )
 196         {
 197             return this;
 198         }
 199
 200         @Override
 201         public ArtifactWithIdBuilder withVersion( Version version )
 202         {
 203             if ( version == null )
 204             {
 205                 throw new IllegalArgumentException( "version may not be null" );
 206             }
 207             item.version = version;
 208             super.setRepository( version.getRepository( ) );
 209             return this;
 210         }
 211
 212         @Override
 213         public ArtifactOptBuilder withId( String id )
 214         {
 215             if ( StringUtils.isEmpty( id ) )
 216             {
 217                 throw new IllegalArgumentException( "Artifact id may not be null or empty" );
 218             }
 219             item.id = id;
 220             return this;
 221         }
 222
 223
 224         @Override
 225         public ArtifactOptBuilder withArtifactVersion( String version )
 226         {
 227             if ( version == null )
 228             {
 229                 throw new IllegalArgumentException( "version may not be null" );
 230             }
 231             item.artifactVersion = version;
 232             return this;
 233         }
 234
 235         @Override
 236         public ArtifactOptBuilder withType( String type )
 237         {
 238             item.type = type;
 239             return this;
 240         }
 241
 242         @Override
 243         public ArtifactOptBuilder withClassifier( String classifier )
 244         {
 245             item.classifier = classifier;
 246             return this;
 247         }
 248
 249         @Override
 250         public ArtifactOptBuilder withRemainder( String remainder )
 251         {
 252             item.remainder = remainder;
 253             return this;
 254         }
 255
 256         @Override
 257         public ArtifactOptBuilder withContentType( String contentType )
 258         {
 259             item.contentType = contentType;
 260             return this;
 261         }
 262
 263         @Override
 264         public ArtifactOptBuilder withArtifactType( ArtifactType type )
 265         {
 266             item.artifactType = type;
 267             return this;
 268         }
 269
 270         @Override
 271         public ArchivaArtifact build( )
 272         {
 273             super.build( );
 274             if ( item.artifactVersion == null )
 275             {
 276                 item.artifactVersion = "";
 277             }
 278             if ( item.classifier == null )
 279             {
 280                 item.classifier = "";
 281             }
 282             if ( item.type == null )
 283             {
 284                 item.type = "";
 285             }
 286             if ( item.contentType == null )
 287             {
 288                 item.contentType = "";
 289             }
 290             if ( item.remainder == null )
 291             {
 292                 item.remainder = "";
 293             }
 294             if (item.artifactType==null) {
 295                 item.artifactType = BaseArtifactTypes.MAIN;
 296             }
 297
 298             return item;
 299         }
 300     }
 301 }