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

   1 package org.apache.archiva.repository.content;
   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.UnsupportedRepositoryTypeException;
  23 import org.apache.archiva.repository.storage.StorageAsset;
  24
  25 import java.util.Map;
  26
  27 /**
  28  *
  29  * Represents a artifact of a repository. This object contains unique coordinates of the
  30  * artifact. A artifact has exactly one file representation in the repository.
  31  * The artifact instance does not tell, if the file exists or is readable. It just
  32  * keeps the coordinates and some meta information of the artifact.
  33  *
  34  * Artifact implementations should be immutable. The implementation must not always represent the current state of the
  35  * corresponding storage asset (file). It is just a view of the attributes for a given point in time.
  36  *
  37  * Implementations must provide proper hash and equals methods.
  38  *
  39  *
  40  * @author Martin Stockhammer <martin_s@apache.org>
  41  */
  42 public interface Artifact extends Comparable<Artifact>
  43 {
  44     /**
  45      * The namespace is the location of the artifact.
  46      * E.g. for maven artifacts it is the groupId.
  47      * The namespace may be empty. Which means that is the base or root namespace.
  48      *
  49      * @return the namespace of the artifact. Never returns <code>null</code>.
  50      */
  51     String getNamespace();
  52
  53     /**
  54      * The artifact identifier. The ID is unique in a given namespace of a given repository.
  55      * But there may exist artifacts with the same ID but different types, classifiers or extensions.
  56      *
  57      * Never returns <code>null</code> or a empty string.
  58      *
  59      * @return the identifier of the artifact. Never returns <code>null</code> or empty string
  60      */
  61     String getId();
  62
  63     /**
  64      * The version string of the artifact. The version string is exactly the version that is attached
  65      * to the artifact.
  66      * The version string may be different to the version string returned by the attached {@link Version} object.
  67      * E.g for maven artifacts the artifact version may be 1.3-20070725.210059-1 and the attached {@link Version} object
  68      * has version 1.3-SNAPSHOT.
  69      *
  70      * @return the artifact version string
  71      * @see #getVersion()
  72      */
  73     String getArtifactVersion();
  74
  75     /**
  76      * Returns the attached version this artifact is part of.
  77      * @return the version object
  78      */
  79     Version getVersion();
  80
  81     /**
  82      * Returns the project this artifact is part of.
  83      * @return the project object
  84      */
  85     Project getProject();
  86
  87     /**
  88      * Returns the type of the artifact. The type is some hint about the usage of the artifact.
  89      * Implementations may always return a empty string, if it is not used.
  90      *
  91      * @return the type of the artifact. Returns never <code>null</code>, but may be empty string
  92      */
  93     String getType();
  94
  95     /**
  96      * A classifier that distinguishes artifacts.
  97      * Implementations may always return a empty string, if it is not used.
  98      *
  99      * @return the classifier of the artifact. Returns never <code>null</code>, but may be empty string
 100      */
 101     String getClassifier();
 102
 103     /**
 104      * Short cut for the file name. Should always return the same value as the artifact name.
 105      * @return the name of the file
 106      */
 107     default String getFileName() {
 108         return getAsset( ).getName( );
 109     }
 110
 111     /**
 112      * Returns the extension of the file. This method should always return the extension string after the last
 113      * '.'-character.
 114      *
 115      * @return the file name extension
 116      */
 117     default String getExtension() {
 118         final String name = getAsset().getName();
 119         final int idx = name.lastIndexOf( '.' );
 120         if (idx>=0) {
 121             return name.substring( idx );
 122         } else {
 123             return "";
 124         }
 125     }
 126
 127     /**
 128      * This may be different from extension and gives the remainder that is used to build the file path from
 129      * the artifact coordinates (namespace, id, version, classifier, type)
 130      *
 131      * @return the file name remainder
 132      */
 133     String getRemainder();
 134
 135     /**
 136      * Should return the mime type of the artifact.
 137      *
 138      * @return the mime type of the artifact.
 139      */
 140     String getContentType();
 141
 142     /**
 143      * Returns the storage representation of the artifact. The asset must not exist.
 144      *
 145      * @return the asset this artifact corresponds to.
 146      */
 147     StorageAsset getAsset();
 148
 149     /**
 150      * Returns additional attributes of the artifact. Implementations may add additional attributes, e.g. author name
 151      * or creation date. Specific implementation attributes can be accessed either by the {@link #getAttributes()} method
 152      * or by a specific implementation class (see {@link #adapt(Class)}. Use via the adapter is type safe.
 153      *
 154      * @return a map of attribute key, value pairs
 155      */
 156     Map<String,String> getAttributes();
 157
 158
 159     /**
 160      * Returns the repository type specific implementation
 161      * @param clazz the specific implementation class
 162      * @param <T> the class or interface
 163      * @return the specific project implementation
 164      */
 165     <T extends Artifact> T adapt(Class<T> clazz) throws UnsupportedRepositoryTypeException;
 166
 167     /**
 168      * Returns <code>true</code>, if this project supports the given adaptor class.
 169      * @param clazz the class to convert this project to
 170      * @param <T> the type
 171      * @return <code>true/code>, if the implementation is supported, otherwise false
 172      */
 173     <T extends Artifact> boolean supports(Class<T> clazz);
 174
 175 }