    1   /* DefaultEntry
    2   *
    3   * Created on September 12, 2006
    4   *
    5   * Copyright (C) 2006 Internet Archive.
    6   *
    7   * This file is part of the Heritrix web crawler (crawler.archive.org).
    8   *
    9   * Heritrix is free software; you can redistribute it and/or modify
    10  * it under the terms of the GNU Lesser Public License as published by
    11  * the Free Software Foundation; either version 2.1 of the License, or
    12  * any later version.
    13  *
    14  * Heritrix is distributed in the hope that it will be useful,
    15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
    16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    17  * GNU Lesser Public License for more details.
    18  *
    19  * You should have received a copy of the GNU Lesser Public License
    20  * along with Heritrix; if not, write to the Free Software
    21  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
    22  */
    23  package org.archive.util.ms;
    24
    25  import java.io.IOException;
    26  import java.nio.ByteBuffer;
    27  import java.nio.ByteOrder;
    28  import java.util.ArrayList;
    29  import java.util.List;
    30
    31  import org.archive.util.IoUtils;
    32  import org.archive.io.SeekInputStream;
    33
    34  class DefaultEntry implements Entry {
    35
    36
    37      private DefaultBlockFileSystem origin;
    38      private String name;
    39      private EntryType type;
    40      private int previous;
    41      private int next;
    42      private int child;
    43      private int startBlock;
    44      private int size;
    45      private int index;
    46
    47
    48      public DefaultEntry(DefaultBlockFileSystem origin, SeekInputStream input, int index)
    49      throws IOException {
    50          this.index = index;
    51          // FIXME: Read directly from the stream
    52          this.origin = origin;
    53          byte[] temp = new byte[128];
    54          IoUtils.readFully(input, temp);
    55          ByteBuffer buf = ByteBuffer.wrap(temp);
    56          buf.order(ByteOrder.LITTLE_ENDIAN);
    57          buf.position(0);
    58
    59          StringBuilder nameBuf = new StringBuilder();
    60
    61          char ch = buf.getChar();
    62          while (ch != 0) {
    63              nameBuf.append(ch);
    64              ch = buf.getChar();
    65          }
    66          this.name = nameBuf.toString();
    67
    68          byte typeFlag = buf.get(0x42);
    69          switch (typeFlag) {
    70              case 1:
    71                  this.type = EntryType.DIRECTORY;
    72                  break;
    73              case 2:
    74                  this.type = EntryType.FILE;
    75                  break;
    76              case 5:
    77                  this.type = EntryType.ROOT;
    78                  break;
    79              default:
    80                  throw new IllegalStateException("Invalid type: " + typeFlag);
    81          }
    82
    83          this.previous = buf.getInt(0x44);
    84          this.next = buf.getInt(0x48);
    85          this.child = buf.getInt(0x4C);
    86          this.startBlock = buf.getInt(0x74);
    87          this.size = buf.getInt(0x78);
    88      }
    89
    90
    91      public String getName() {
    92          return name;
    93      }
    94
    95
    96      public EntryType getType() {
    97          return type;
    98      }
    99
    100
    101     public Entry getNext() throws IOException {
    102         return origin.getEntry(next);
    103     }
    104
    105
    106     public Entry getPrevious() throws IOException {
    107         return origin.getEntry(previous);
    108     }
    109
    110
    111     public Entry getChild() throws IOException {
    112         return origin.getEntry(child);
    113     }
    114
    115     public SeekInputStream open() throws IOException {
    116         return new BlockInputStream(origin, startBlock);
    117     }
    118
    119
    120     public List<Entry> list() throws IOException {
    121         if (child < 0) {
    122             throw new IllegalStateException("Can't list non-directory.");
    123         }
    124         Entry child = getChild();
    125         ArrayList<Entry> r = new ArrayList<Entry>();
    126         list(r, child);
    127         return r;
    128     }
    129
    130
    131     public static void list(List<Entry> list, Entry e) throws IOException {
    132         if (e == null) {
    133             return;
    134         }
    135         list.add(e);
    136         list(list, e.getPrevious());
    137         list(list, e.getNext());
    138     }
    139
    140
    141     public int getIndex() {
    142         return index;
    143     }
    144
    145
    146     public String toString() {
    147         StringBuilder result = new StringBuilder("Entry{");
    148         result.append("name=").append(name);
    149         result.append(" index=").append(index);
    150         result.append(" type=").append(type);
    151         result.append(" size=").append(size);
    152         result.append(" prev=").append(previous);
    153         result.append(" next=").append(next);
    154         result.append(" child=").append(child);
    155         result.append(" startBlock=").append(startBlock);
    156         result.append("}");
    157         return result.toString();
    158     }
    159
    160
    161 }