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.BaseArtifactTypes;
  23 import org.apache.archiva.repository.content.BaseDataItemTypes;
  24 import org.apache.archiva.repository.content.ContentItem;
  25 import org.apache.archiva.repository.content.DataItem;
  26 import org.apache.archiva.repository.content.DataItemType;
  27 import org.apache.archiva.repository.content.base.builder.DataItemOptBuilder;
  28 import org.apache.archiva.repository.content.base.builder.DataItemWithIdBuilder;
  29 import org.apache.archiva.repository.storage.StorageAsset;
  30 import org.apache.commons.lang3.StringUtils;
  31
  32 /**
  33  * Base implementation of artifact.
  34  * <p>
  35  * You have to use the builder method {@link #withAsset(StorageAsset)} to create a instance.
  36  * The build() method can be called after the required attributes are set.
  37  * <p>
  38  * Artifacts are equal if the following coordinates match:
  39  * <ul>
  40  *     <li>repository</li>
  41  *     <li>asset</li>
  42  *     <li>version</li>
  43  *     <li>artifactId</li>
  44  *     <li>artifactVersion</li>
  45  *     <li>type</li>
  46  *     <li>classifier</li>
  47  *     <li>artifactType</li>
  48  * </ul>
  49  *
  50  * @author Martin Stockhammer <martin_s@apache.org>
  51  */
  52 public class ArchivaDataItem extends ArchivaContentItem implements DataItem
  53 {
  54     private String id;
  55     private ContentItem parent;
  56     private String contentType;
  57     private DataItemType dataItemType;
  58
  59     private ArchivaDataItem( )
  60     {
  61
  62     }
  63
  64     @Override
  65     public String getId( )
  66     {
  67         return id;
  68     }
  69
  70     @Override
  71     public ContentItem getParent( )
  72     {
  73         return parent;
  74     }
  75
  76     @Override
  77     public String getContentType( )
  78     {
  79         return contentType;
  80     }
  81
  82     @Override
  83     public DataItemType getDataType( )
  84     {
  85         return dataItemType;
  86     }
  87
  88
  89     /**
  90      * Returns the builder for creating a new artifact instance. You have to fill the
  91      * required attributes before the build() method is available.
  92      *
  93      * @param asset the storage asset representing the artifact
  94      * @return a builder for creating new artifact instance
  95      */
  96     public static DataItemWithIdBuilder withAsset( StorageAsset asset )
  97     {
  98         return new Builder( ).withAsset( asset );
  99     }
 100
 101
 102     @Override
 103     public boolean equals( Object o )
 104     {
 105         if ( this == o ) return true;
 106         if ( o == null || getClass( ) != o.getClass( ) ) return false;
 107         if ( !super.equals( o ) ) return false;
 108
 109         ArchivaDataItem that = (ArchivaDataItem) o;
 110
 111         if ( !id.equals( that.id ) ) return false;
 112         if ( !parent.equals( that.parent ) ) return false;
 113         return dataItemType.equals(that.dataItemType );
 114     }
 115
 116     @Override
 117     public int hashCode( )
 118     {
 119         int result = super.hashCode( );
 120         result = 31 * result + id.hashCode( );
 121         result = 31 * result + parent.hashCode( );
 122         result = 31 * result + dataItemType.hashCode( );
 123         return result;
 124     }
 125
 126     @Override
 127     public String toString( )
 128     {
 129         final StringBuilder sb = new StringBuilder( "ArchivaArtifact{" );
 130         sb.append( "id='" ).append( id ).append( '\'' );
 131         sb.append( ", parent=" ).append( parent );
 132         sb.append( ", contentType='" ).append( contentType ).append( '\'' );
 133         sb.append( ", artifactType=" ).append( dataItemType );
 134         sb.append( '}' );
 135         return sb.toString( );
 136     }
 137
 138     public static String defaultString( String value )
 139     {
 140         if ( value == null )
 141         {
 142             return "";
 143         }
 144
 145         return value.trim();
 146     }
 147
 148     private static class Builder
 149         extends ContentItemBuilder<ArchivaDataItem, DataItemOptBuilder, DataItemWithIdBuilder >
 150         implements DataItemOptBuilder,DataItemWithIdBuilder
 151     {
 152
 153         Builder( )
 154         {
 155             super( new ArchivaDataItem( ) );
 156         }
 157
 158         @Override
 159         protected DataItemOptBuilder getOptBuilder( )
 160         {
 161             return this;
 162         }
 163
 164         @Override
 165         protected DataItemWithIdBuilder getNextBuilder( )
 166         {
 167             return this;
 168         }
 169
 170         @Override
 171         public DataItemOptBuilder withParent( ContentItem parent )
 172         {
 173             if ( parent == null )
 174             {
 175                 throw new IllegalArgumentException( "version may not be null" );
 176             }
 177             item.parent = parent;
 178             super.setRepository( parent.getRepository( ) );
 179             return this;
 180         }
 181
 182         @Override
 183         public DataItemOptBuilder withId( String id )
 184         {
 185             if ( StringUtils.isEmpty( id ) )
 186             {
 187                 throw new IllegalArgumentException( "Artifact id may not be null or empty" );
 188             }
 189             item.id = id;
 190             return this;
 191         }
 192
 193
 194         @Override
 195         public DataItemOptBuilder withContentType( String contentType )
 196         {
 197             item.contentType = contentType;
 198             return this;
 199         }
 200
 201         @Override
 202         public DataItemOptBuilder withDataType( DataItemType type )
 203         {
 204             item.dataItemType = type;
 205             return this;
 206         }
 207
 208         @Override
 209         public ArchivaDataItem build( )
 210         {
 211             super.build( );
 212             if ( item.contentType == null )
 213             {
 214                 item.contentType = "";
 215             }
 216             if (item.dataItemType ==null) {
 217                 item.dataItemType = BaseDataItemTypes.UNKNOWN;
 218             }
 219
 220             return item;
 221         }
 222     }
 223 }