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

   1 package org.apache.archiva.metadata.repository.memory;
   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.metadata.model.ArtifactMetadata;
  23 import org.apache.archiva.metadata.model.ProjectVersionMetadata;
  24 import org.apache.archiva.metadata.model.ProjectVersionReference;
  25 import org.apache.archiva.metadata.repository.MetadataResolver;
  26
  27 import java.util.Collection;
  28 import java.util.Collections;
  29 import java.util.HashMap;
  30 import java.util.LinkedHashSet;
  31 import java.util.List;
  32 import java.util.Map;
  33 import java.util.Set;
  34
  35 public class TestMetadataResolver
  36     implements MetadataResolver
  37 {
  38     private Map<String, ProjectVersionMetadata> projectVersions = new HashMap<String, ProjectVersionMetadata>();
  39
  40     private Map<String, List<ArtifactMetadata>> artifacts = new HashMap<String, List<ArtifactMetadata>>();
  41
  42     private Map<String, List<ProjectVersionReference>> references =
  43         new HashMap<String, List<ProjectVersionReference>>();
  44
  45     private Map<String, List<String>> namespaces = new HashMap<String, List<String>>();
  46
  47     private Map<String, Collection<String>> projectsInNamespace = new HashMap<String, Collection<String>>();
  48
  49     private Map<String, Collection<String>> versionsInProject = new HashMap<String, Collection<String>>();
  50
  51     public ProjectVersionMetadata resolveProjectVersion( String repoId, String namespace, String projectId,
  52                                                          String projectVersion )
  53     {
  54         return projectVersions.get( createMapKey( repoId, namespace, projectId, projectVersion ) );
  55     }
  56
  57     public Collection<ProjectVersionReference> resolveProjectReferences( String repoId, String namespace,
  58                                                                          String projectId, String projectVersion )
  59     {
  60         return references.get( createMapKey( repoId, namespace, projectId, projectVersion ) );
  61     }
  62
  63     public Collection<String> resolveRootNamespaces( String repoId )
  64     {
  65         return resolveNamespaces( repoId, null );
  66     }
  67
  68     public Collection<String> resolveNamespaces( String repoId, String baseNamespace )
  69     {
  70         Set<String> namespaces = new LinkedHashSet<String>();
  71         int fromIndex = baseNamespace != null ? baseNamespace.length() + 1 : 0;
  72         for ( String namespace : this.namespaces.get( repoId ) )
  73         {
  74             if ( baseNamespace == null || namespace.startsWith( baseNamespace + "." ) )
  75             {
  76                 int i = namespace.indexOf( '.', fromIndex );
  77                 if ( i >= 0 )
  78                 {
  79                     namespaces.add( namespace.substring( fromIndex, i ) );
  80                 }
  81                 else
  82                 {
  83                     namespaces.add( namespace.substring( fromIndex ) );
  84                 }
  85             }
  86         }
  87         return namespaces;
  88     }
  89
  90     public Collection<String> resolveProjects( String repoId, String namespace )
  91     {
  92         Collection<String> list = projectsInNamespace.get( namespace );
  93         return list != null ? list : Collections.<String>emptyList();
  94     }
  95
  96     public Collection<String> resolveProjectVersions( String repoId, String namespace, String projectId )
  97     {
  98         Collection<String> list = versionsInProject.get( namespace + ":" + projectId );
  99         return list != null ? list : Collections.<String>emptyList();
 100     }
 101
 102     public Collection<ArtifactMetadata> resolveArtifacts( String repoId, String namespace, String projectId,
 103                                                           String projectVersion )
 104     {
 105         List<ArtifactMetadata> artifacts = this.artifacts.get( createMapKey( repoId, namespace, projectId,
 106                                                                              projectVersion ) );
 107         return ( artifacts != null ? artifacts : Collections.<ArtifactMetadata>emptyList() );
 108     }
 109
 110     public void setProjectVersion( String repoId, String namespace, String projectId,
 111                                    ProjectVersionMetadata versionMetadata )
 112     {
 113         projectVersions.put( createMapKey( repoId, namespace, projectId, versionMetadata.getId() ), versionMetadata );
 114
 115         Collection<String> projects = projectsInNamespace.get( namespace );
 116         if ( projects == null )
 117         {
 118             projects = new LinkedHashSet<String>();
 119             projectsInNamespace.put( namespace, projects );
 120         }
 121         projects.add( projectId );
 122
 123         String key = namespace + ":" + projectId;
 124         Collection<String> versions = versionsInProject.get( key );
 125         if ( versions == null )
 126         {
 127             versions = new LinkedHashSet<String>();
 128             versionsInProject.put( key, versions );
 129         }
 130         versions.add( versionMetadata.getId() );
 131     }
 132
 133     public void setArtifacts( String repoId, String namespace, String projectId, String projectVersion,
 134                               List<ArtifactMetadata> artifacts )
 135     {
 136         this.artifacts.put( createMapKey( repoId, namespace, projectId, projectVersion ), artifacts );
 137     }
 138
 139     private String createMapKey( String repoId, String namespace, String projectId, String projectVersion )
 140     {
 141         return repoId + ":" + namespace + ":" + projectId + ":" + projectVersion;
 142     }
 143
 144     public void setProjectReferences( String repoId, String namespace, String projectId, String projectVersion,
 145                                       List<ProjectVersionReference> references )
 146     {
 147         this.references.put( createMapKey( repoId, namespace, projectId, projectVersion ), references );
 148     }
 149
 150     public void setNamespaces( String repoId, List<String> namespaces )
 151     {
 152         this.namespaces.put( repoId, namespaces );
 153     }
 154 }