/* ====================================================================
|
Licensed to the Apache Software Foundation (ASF) under one or more
|
contributor license agreements. See the NOTICE file distributed with
|
this work for Additional information regarding copyright ownership.
|
The ASF licenses this file to You under the Apache License, Version 2.0
|
(the "License"); you may not use this file except in compliance with
|
the License. You may obtain a copy of the License at
|
|
http://www.apache.org/licenses/LICENSE-2.0
|
|
Unless required by applicable law or agreed to in writing, software
|
distributed under the License is distributed on an "AS IS" BASIS,
|
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
See the License for the specific language governing permissions and
|
limitations under the License.
|
==================================================================== */
|
|
/* ================================================================
|
* About NPOI
|
* Author: Tony Qu
|
* Author's email: tonyqus (at) gmail.com
|
* Author's Blog: tonyqus.wordpress.com.cn (wp.tonyqus.cn)
|
* HomePage: http://www.codeplex.com/npoi
|
* Contributors:
|
*
|
* ==============================================================*/
|
|
using System;
|
using System.Collections.Generic;
|
using System.Text;
|
using System.IO;
|
using System.Collections;
|
|
|
using HH.WMS.Utils.NPOI.POIFS.Properties;
|
using HH.WMS.Utils.NPOI.POIFS.Dev;
|
using HH.WMS.Utils.NPOI.POIFS.FileSystem;
|
using HH.WMS.Utils.NPOI.POIFS.EventFileSystem;
|
using HH.WMS.Utils.NPOI.Util;
|
|
namespace HH.WMS.Utils.NPOI.POIFS.FileSystem
|
{
|
/// <summary>
|
/// Simple implementation of DirectoryEntry
|
/// @author Marc Johnson (mjohnson at apache dot org)
|
/// </summary>
|
[Serializable]
|
public class DirectoryNode : EntryNode, DirectoryEntry, POIFSViewable, IEnumerable<Entry>
|
{
|
// Map of Entry instances, keyed by their names
|
private Dictionary<string, Entry> _byname;
|
|
private List<Entry> _entries;
|
|
// the POIFSFileSystem we belong to
|
private POIFSFileSystem _oFilesSystem;
|
|
private NPOIFSFileSystem _nFilesSystem;
|
|
// the path described by this document
|
private POIFSDocumentPath _path;
|
|
|
public DirectoryNode(DirectoryProperty property,
|
POIFSFileSystem fileSystem,
|
DirectoryNode parent)
|
: this(property, parent, fileSystem, (NPOIFSFileSystem)null)
|
{
|
}
|
|
/// <summary>
|
/// Create a DirectoryNode. This method Is not public by design; it
|
/// Is intended strictly for the internal use of this package
|
/// </summary>
|
/// <param name="property">the DirectoryProperty for this DirectoryEntry</param>
|
/// <param name="nFileSystem">the POIFSFileSystem we belong to</param>
|
/// <param name="parent">the parent of this entry</param>
|
public DirectoryNode(DirectoryProperty property,
|
NPOIFSFileSystem nFileSystem,
|
DirectoryNode parent)
|
: this(property, parent, (POIFSFileSystem)null, nFileSystem)
|
{
|
}
|
|
private DirectoryNode(DirectoryProperty property,
|
DirectoryNode parent,
|
POIFSFileSystem oFileSystem,
|
NPOIFSFileSystem nFileSystem)
|
: base(property, parent)
|
{
|
this._oFilesSystem = oFileSystem;
|
this._nFilesSystem = nFileSystem;
|
|
if (parent == null)
|
_path = new POIFSDocumentPath();
|
else
|
{
|
_path = new POIFSDocumentPath(parent._path, new string[] { property.Name });
|
}
|
|
_byname = new Dictionary<string, Entry>();
|
_entries = new List<Entry>();
|
IEnumerator<Property> iter = property.Children;
|
|
while (iter.MoveNext())
|
{
|
Property child = iter.Current;
|
Entry childNode = null;
|
|
if (child.IsDirectory)
|
{
|
DirectoryProperty childDir = (DirectoryProperty)child;
|
if (_oFilesSystem != null)
|
{
|
childNode = new DirectoryNode(childDir, _oFilesSystem, this);
|
}
|
else
|
{
|
childNode = new DirectoryNode(childDir, _nFilesSystem, this);
|
}
|
}
|
else
|
{
|
childNode = new DocumentNode((DocumentProperty)child, this);
|
}
|
_entries.Add(childNode);
|
_byname.Add(childNode.Name, childNode);
|
}
|
}
|
|
/// <summary>
|
/// open a document in the directory's entry's list of entries
|
/// </summary>
|
/// <param name="documentName">the name of the document to be opened</param>
|
/// <returns>a newly opened DocumentStream</returns>
|
public DocumentInputStream CreatePOIFSDocumentReader(
|
String documentName)
|
{
|
Entry document = GetEntry(documentName);
|
|
if (!document.IsDocumentEntry)
|
{
|
throw new IOException("Entry '" + documentName
|
+ "' Is not a DocumentEntry");
|
}
|
return new DocumentInputStream((DocumentEntry)document);
|
}
|
|
/// <summary>
|
/// Create a new DocumentEntry; the data will be provided later
|
/// </summary>
|
/// <param name="name">the name of the new DocumentEntry</param>
|
/// <param name="size">the size of the new DocumentEntry</param>
|
/// <returns>the new DocumentEntry</returns>
|
public DocumentEntry CreateDocument(POIFSDocument document)
|
{
|
DocumentProperty property = document.DocumentProperty;
|
DocumentNode rval = new DocumentNode(property, this);
|
|
((DirectoryProperty)Property).AddChild(property);
|
_oFilesSystem.AddDocument(document);
|
|
_entries.Add(rval);
|
_byname.Add(property.Name, rval);
|
|
return rval;
|
}
|
|
/// <summary>
|
/// Change a contained Entry's name
|
/// </summary>
|
/// <param name="oldName">the original name</param>
|
/// <param name="newName">the new name</param>
|
/// <returns>true if the operation succeeded, else false</returns>
|
public bool ChangeName(String oldName, String newName)
|
{
|
bool rval = false;
|
EntryNode child = (EntryNode)_byname[oldName];
|
|
if (child != null)
|
{
|
rval = ((DirectoryProperty)Property)
|
.ChangeName(child.Property, newName);
|
if (rval)
|
{
|
_byname.Remove(oldName);
|
_byname[child.Property.Name] = child;
|
}
|
}
|
return rval;
|
}
|
|
/// <summary>
|
/// Deletes the entry.
|
/// </summary>
|
/// <param name="entry">the EntryNode to be Deleted</param>
|
/// <returns>true if the entry was Deleted, else false</returns>
|
public bool DeleteEntry(EntryNode entry)
|
{
|
bool rval =
|
((DirectoryProperty)Property)
|
.DeleteChild(entry.Property);
|
|
if (rval)
|
{
|
_entries.Remove(entry);
|
_byname.Remove(entry.Name);
|
|
if (_oFilesSystem != null)
|
{
|
_oFilesSystem.Remove(entry);
|
}
|
else
|
{
|
_nFilesSystem.Remove(entry);
|
}
|
}
|
return rval;
|
}
|
|
/// <summary>
|
/// Gets the path.
|
/// </summary>
|
/// <value>this directory's path representation</value>
|
public POIFSDocumentPath Path
|
{
|
get { return _path; }
|
}
|
|
public POIFSFileSystem FileSystem
|
{
|
get { return _oFilesSystem; }
|
}
|
|
public NPOIFSFileSystem NFileSystem
|
{
|
get { return _nFilesSystem; }
|
}
|
|
/// <summary>
|
/// get an iterator of the Entry instances contained directly in
|
/// this instance (in other words, children only; no grandchildren
|
/// etc.)
|
/// </summary>
|
/// <value>
|
/// The entries.never null, but hasNext() may return false
|
/// immediately (i.e., this DirectoryEntry is empty). All
|
/// objects retrieved by next() are guaranteed to be
|
/// implementations of Entry.
|
/// </value>
|
public IEnumerator<Entry> Entries
|
{
|
get { return _entries.GetEnumerator(); }
|
}
|
internal Entry GetEntry(int index)
|
{
|
return _entries[index];
|
}
|
/// <summary>
|
/// is this DirectoryEntry empty?
|
/// </summary>
|
/// <value>
|
/// <c>true</c> if this instance contains no Entry instances; otherwise, <c>false</c>.
|
/// </value>
|
public bool IsEmpty
|
{
|
get { return _entries.Count == 0; }
|
}
|
|
/// <summary>
|
/// find out how many Entry instances are contained directly within
|
/// this DirectoryEntry
|
/// </summary>
|
/// <value>
|
/// number of immediately (no grandchildren etc.) contained
|
/// Entry instances
|
/// </value>
|
public int EntryCount
|
{
|
get { return _entries.Count; }
|
}
|
|
|
public bool HasEntry(String name)
|
{
|
return name != null && _byname.ContainsKey(name);
|
}
|
|
/// <summary>
|
/// get a specified Entry by name
|
/// </summary>
|
/// <param name="name">the name of the Entry to obtain.</param>
|
/// <returns>
|
/// the specified Entry, if it is directly contained in
|
/// this DirectoryEntry
|
/// </returns>
|
public Entry GetEntry(String name)
|
{
|
Entry rval = null;
|
|
if (name != null)
|
{
|
try
|
{
|
rval = (Entry)_byname[name];
|
}
|
catch (KeyNotFoundException)
|
{
|
throw new FileNotFoundException("no such entry: \"" + name + "\"");
|
}
|
}
|
if (rval == null)
|
{
|
|
// either a null name was given, or there Is no such name
|
throw new FileNotFoundException("no such entry: \"" + name + "\"");
|
}
|
return rval;
|
}
|
|
|
//public DocumentReader CreateDocumentReader(string documentName)
|
//{
|
// try
|
// {
|
// return CreateDocumentReader(GetEntry(documentName));
|
// }
|
// catch(IOException ex)
|
// {
|
// throw ex;
|
// }
|
//}
|
|
//public DocumentReader CreateDocumentReader(Entry document)
|
//{
|
// if (!document.IsDirectoryEntry)
|
// {
|
// throw new IOException("Entry '" + document.Name + "' is not a DocumentEntry");
|
// }
|
|
// DocumentEntry entry = (DocumentEntry)document;
|
// return new DocumentReader(entry);
|
//}
|
|
public DocumentInputStream CreateDocumentInputStream(Entry document)
|
{
|
if (!document.IsDocumentEntry)
|
{
|
throw new IOException("Entry '" + document.Name
|
+ "' is not a DocumentEntry");
|
}
|
|
DocumentEntry entry = (DocumentEntry)document;
|
return new DocumentInputStream(entry);
|
}
|
|
public DocumentInputStream CreateDocumentInputStream(string documentName)
|
{
|
return CreateDocumentInputStream(GetEntry(documentName));
|
}
|
|
|
public DocumentEntry CreateDocument(NPOIFSDocument document)
|
{
|
try
|
{
|
DocumentProperty property = document.DocumentProperty;
|
DocumentNode rval = new DocumentNode(property, this);
|
|
((DirectoryProperty)Property).AddChild(property);
|
|
_nFilesSystem.AddDocument(document);
|
|
_entries.Add(rval);
|
_byname[property.Name] = rval;
|
|
return rval;
|
|
}
|
catch (IOException ex)
|
{
|
throw ex;
|
}
|
}
|
|
|
/// <summary>
|
/// Create a new DirectoryEntry
|
/// </summary>
|
/// <param name="name">the name of the new DirectoryEntry</param>
|
/// <returns>the name of the new DirectoryEntry</returns>
|
public DirectoryEntry CreateDirectory(String name)
|
{
|
DirectoryProperty property = new DirectoryProperty(name);
|
DirectoryNode rval;
|
|
if (_oFilesSystem != null)
|
{
|
rval = new DirectoryNode(property, _oFilesSystem, this);
|
_oFilesSystem.AddDirectory(property);
|
}
|
else
|
{
|
rval = new DirectoryNode(property, _nFilesSystem, this);
|
_nFilesSystem.AddDirectory(property);
|
}
|
|
((DirectoryProperty)Property).AddChild(property);
|
_entries.Add(rval);
|
_byname[name] = rval;
|
|
return rval;
|
}
|
|
|
/// <summary>
|
/// Gets or Sets the storage clsid for the directory entry
|
/// </summary>
|
/// <value>The storage ClassID.</value>
|
public ClassID StorageClsid
|
{
|
set{
|
this.Property.StorageClsid=value;
|
}
|
get
|
{
|
return this.Property.StorageClsid;
|
}
|
}
|
|
/// <summary>
|
/// Is this a DirectoryEntry?
|
/// </summary>
|
/// <value>true if the Entry Is a DirectoryEntry, else false</value>
|
public override bool IsDirectoryEntry
|
{
|
get { return true; }
|
}
|
|
/// <summary>
|
/// extensions use this method to verify internal rules regarding
|
/// deletion of the underlying store.
|
/// </summary>
|
/// <value> true if it's ok to Delete the underlying store, else
|
/// false</value>
|
protected override bool IsDeleteOK
|
{
|
// if this directory Is empty, we can Delete it
|
get
|
{
|
return IsEmpty;
|
}
|
}
|
|
public DocumentEntry CreateDocument(string name, Stream stream)
|
{
|
try
|
{
|
if (_nFilesSystem != null)
|
{
|
return CreateDocument(new NPOIFSDocument(name, _nFilesSystem, stream));
|
}
|
else
|
{
|
return CreateDocument(new POIFSDocument(name, stream));
|
}
|
}
|
catch (IOException ex)
|
{
|
throw ex;
|
}
|
}
|
|
|
public DocumentEntry CreateDocument(string name, int size, POIFSWriterListener writer)
|
{
|
// return CreateDocument(name, size, write);
|
return CreateDocument(new POIFSDocument(name, size, _path, writer));
|
}
|
|
|
#region ViewableItertor interface
|
/// <summary>
|
/// Get an array of objects, some of which may implement POIFSViewable
|
/// </summary>
|
/// <value>an array of Object; may not be null, but may be empty</value>
|
public Array ViewableArray
|
{
|
get
|
{
|
return new Object[0];
|
}
|
}
|
|
/// <summary>
|
/// Get an Iterator of objects, some of which may implement
|
/// POIFSViewable
|
/// </summary>
|
/// <value>an Iterator; may not be null, but may have an empty
|
/// back end store</value>
|
public IEnumerator ViewableIterator
|
{
|
get
|
{
|
ArrayList components = new ArrayList();
|
|
components.Add(Property);
|
components.AddRange(this._entries);
|
//components.Sort();
|
return components.GetEnumerator();
|
}
|
}
|
|
/// <summary>
|
/// Give viewers a hint as to whether to call GetViewableArray or
|
/// GetViewableIterator
|
/// </summary>
|
/// <value><c>true</c> if a viewer should call GetViewableArray; otherwise, <c>false</c>if
|
/// a viewer should call GetViewableIterator</value>
|
public bool PreferArray
|
{
|
get { return false; }
|
}
|
|
/// <summary>
|
/// Provides a short description of the object, to be used when a
|
/// POIFSViewable object has not provided its contents.
|
/// </summary>
|
/// <value>The short description.</value>
|
public String ShortDescription
|
{
|
get { return Name; }
|
}
|
|
#endregion
|
|
|
|
#region IEnumerable<Entry> Members
|
|
public IEnumerator<Entry> GetEnumerator()
|
{
|
throw new NotImplementedException();
|
}
|
|
#endregion
|
|
#region IEnumerable Members
|
|
IEnumerator IEnumerable.GetEnumerator()
|
{
|
throw new NotImplementedException();
|
}
|
|
#endregion
|
|
|
|
|
public bool CanRead
|
{
|
get { throw new System.NotImplementedException(); }
|
}
|
|
public bool CanSeek
|
{
|
get { throw new System.NotImplementedException(); }
|
}
|
|
public bool CanWrite
|
{
|
get { throw new System.NotImplementedException(); }
|
}
|
|
public void Flush()
|
{
|
throw new System.NotImplementedException();
|
}
|
|
public long Length
|
{
|
get { throw new System.NotImplementedException(); }
|
}
|
|
public long Position
|
{
|
get
|
{
|
throw new System.NotImplementedException();
|
}
|
set
|
{
|
throw new System.NotImplementedException();
|
}
|
}
|
|
public int Read(byte[] buffer, int offset, int count)
|
{
|
throw new System.NotImplementedException();
|
}
|
|
public long Seek(long offset, SeekOrigin origin)
|
{
|
throw new System.NotImplementedException();
|
}
|
|
public void SetLength(long value)
|
{
|
throw new System.NotImplementedException();
|
}
|
|
|
|
|
}
|
|
|
}
|
