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

   1 package org.apache.archiva.repository.storage.mock;
   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.storage.RepositoryStorage;
  23 import org.apache.archiva.repository.storage.StorageAsset;
  24
  25 import java.io.IOException;
  26 import java.io.InputStream;
  27 import java.io.OutputStream;
  28 import java.nio.channels.ReadableByteChannel;
  29 import java.nio.channels.WritableByteChannel;
  30 import java.nio.file.Path;
  31 import java.time.Instant;
  32 import java.util.ArrayList;
  33 import java.util.HashMap;
  34 import java.util.LinkedHashMap;
  35 import java.util.List;
  36 import java.util.Map;
  37
  38 public class MockAsset implements StorageAsset
  39 {
  40     private StorageAsset parent;
  41     private String path;
  42     private String name;
  43     private LinkedHashMap<String, StorageAsset> children = new LinkedHashMap<>( );
  44     private boolean container = false;
  45
  46     public MockAsset( String name ) {
  47         this.name = name;
  48         this.path = "/";
  49     }
  50
  51     public MockAsset( MockAsset parent, String name ) {
  52         this.parent = parent;
  53         this.path = (parent.hasParent()?parent.getPath( ):"") + "/" + name;
  54         this.name = name;
  55         parent.registerChild( this );
  56     }
  57
  58     public void registerChild(StorageAsset child) {
  59         children.putIfAbsent( child.getName(), child );
  60         this.container = true;
  61     }
  62
  63     @Override
  64     public RepositoryStorage getStorage( )
  65     {
  66         return null;
  67     }
  68
  69     @Override
  70     public String getPath( )
  71     {
  72         return this.path;
  73     }
  74
  75     @Override
  76     public String getName( )
  77     {
  78         return this.name;
  79     }
  80
  81     @Override
  82     public Instant getModificationTime( )
  83     {
  84         return Instant.now();
  85     }
  86
  87     @Override
  88     public boolean isContainer( )
  89     {
  90         return this.container;
  91     }
  92
  93     @Override
  94     public boolean isLeaf( )
  95     {
  96         return !this.container;
  97     }
  98
  99     @Override
 100     public List<StorageAsset> list( )
 101     {
 102         return new ArrayList( children.values( ) );
 103     }
 104
 105     @Override
 106     public long getSize( )
 107     {
 108         return 0;
 109     }
 110
 111     @Override
 112     public InputStream getReadStream( ) throws IOException
 113     {
 114         return null;
 115     }
 116
 117     @Override
 118     public ReadableByteChannel getReadChannel( ) throws IOException
 119     {
 120         return null;
 121     }
 122
 123     @Override
 124     public OutputStream getWriteStream( boolean replace ) throws IOException
 125     {
 126         return null;
 127     }
 128
 129     @Override
 130     public WritableByteChannel getWriteChannel( boolean replace ) throws IOException
 131     {
 132         return null;
 133     }
 134
 135     @Override
 136     public boolean replaceDataFromFile( Path newData ) throws IOException
 137     {
 138         return false;
 139     }
 140
 141     @Override
 142     public boolean exists( )
 143     {
 144         return false;
 145     }
 146
 147     @Override
 148     public void create( ) throws IOException
 149     {
 150
 151     }
 152
 153     @Override
 154     public Path getFilePath( ) throws UnsupportedOperationException
 155     {
 156         return null;
 157     }
 158
 159     @Override
 160     public boolean isFileBased( )
 161     {
 162         return false;
 163     }
 164
 165     @Override
 166     public boolean hasParent( )
 167     {
 168         return this.parent != null;
 169     }
 170
 171     @Override
 172     public StorageAsset getParent( )
 173     {
 174         return this.parent;
 175     }
 176
 177     @Override
 178     public StorageAsset resolve( String toPath )
 179     {
 180         if (children.containsKey( toPath )) {
 181             return children.get( toPath );
 182         } else {
 183             return null;
 184         }
 185     }
 186
 187     @Override
 188     public String toString( )
 189     {
 190         return getPath();
 191     }
 192
 193     @Override
 194     public boolean equals( Object o )
 195     {
 196         if ( this == o ) return true;
 197         if ( o == null || getClass( ) != o.getClass( ) ) return false;
 198
 199         MockAsset mockAsset = (MockAsset) o;
 200
 201         return path.equals( mockAsset.path );
 202     }
 203
 204     @Override
 205     public int hashCode( )
 206     {
 207         return path.hashCode( );
 208     }
 209 }