|
/* ====================================================================
|
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.
|
==================================================================== */
|
|
|
using System;
|
using System.Collections;
|
using System.Collections.Generic;
|
using System.IO;
|
using HH.WMS.Utils.NPOI.POIFS.Common;
|
using HH.WMS.Utils.NPOI.POIFS.Dev;
|
using HH.WMS.Utils.NPOI.POIFS.NIO;
|
using HH.WMS.Utils.NPOI.POIFS.Properties;
|
using HH.WMS.Utils.NPOI.POIFS.Storage;
|
using HH.WMS.Utils.NPOI.Util;
|
using HH.WMS.Utils.NPOI.POIFS.EventFileSystem;
|
|
namespace HH.WMS.Utils.NPOI.POIFS.FileSystem
|
{
|
|
|
/**
|
* This is the main class of the POIFS system; it manages the entire
|
* life cycle of the filesystem.
|
* This is the new NIO version
|
*/
|
|
public class NPOIFSFileSystem : BlockStore, POIFSViewable //, Closeable Leon
|
{
|
private static POILogger _logger =
|
POILogFactory.GetLogger(typeof(NPOIFSFileSystem));
|
|
/**
|
* Convenience method for clients that want to avoid the auto-close behaviour of the constructor.
|
*/
|
public static Stream CreateNonClosingInputStream(Stream stream)
|
{
|
return new CloseIgnoringInputStream(stream);
|
}
|
|
private NPOIFSMiniStore _mini_store;
|
private NPropertyTable _property_table;
|
private List<BATBlock> _xbat_blocks;
|
private List<BATBlock> _bat_blocks;
|
private HeaderBlock _header;
|
private DirectoryNode _root;
|
|
private DataSource _data;
|
|
/**
|
* What big block size the file uses. Most files
|
* use 512 bytes, but a few use 4096
|
*/
|
private POIFSBigBlockSize bigBlockSize =
|
POIFSConstants.SMALLER_BIG_BLOCK_SIZE_DETAILS;
|
|
public DataSource Data
|
{
|
get { return _data; }
|
set { _data = value; }
|
}
|
|
private NPOIFSFileSystem(bool newFS)
|
{
|
_header = new HeaderBlock(bigBlockSize);
|
_property_table = new NPropertyTable(_header);
|
_mini_store = new NPOIFSMiniStore(this, _property_table.Root, new List<BATBlock>(), _header);
|
_xbat_blocks = new List<BATBlock>();
|
_bat_blocks = new List<BATBlock>();
|
_root = null;
|
|
if (newFS)
|
{
|
// Data needs to Initially hold just the header block,
|
// a single bat block, and an empty properties section
|
_data = new ByteArrayBackedDataSource(new byte[bigBlockSize.GetBigBlockSize() * 3]);
|
}
|
}
|
|
/**
|
* Constructor, intended for writing
|
*/
|
public NPOIFSFileSystem()
|
: this(true)
|
{
|
|
// Mark us as having a single empty BAT at offset 0
|
_header.BATCount = 1;
|
_header.BATArray = new int[] { 0 };
|
_bat_blocks.Add(BATBlock.CreateEmptyBATBlock(bigBlockSize, false));
|
SetNextBlock(0, POIFSConstants.FAT_SECTOR_BLOCK);
|
|
// Now associate the properties with the empty block
|
_property_table.StartBlock = 1;
|
SetNextBlock(1, POIFSConstants.END_OF_CHAIN);
|
}
|
|
|
public NPOIFSFileSystem(FileStream channel)
|
: this(channel, true)
|
{
|
|
}
|
private NPOIFSFileSystem(FileStream channel, bool closeChannelOnError)
|
: this(false)
|
{
|
|
try
|
{
|
// Get the header
|
byte[] headerBuffer = new byte[POIFSConstants.SMALLER_BIG_BLOCK_SIZE];
|
IOUtils.ReadFully(channel, headerBuffer);
|
|
// Have the header Processed
|
_header = new HeaderBlock(headerBuffer);
|
|
// Now process the various entries
|
_data = new FileBackedDataSource(channel);
|
ReadCoreContents();
|
channel.Close();
|
|
}
|
catch (IOException e)
|
{
|
if (closeChannelOnError)
|
{
|
channel.Close();
|
}
|
throw e;
|
}
|
catch (Exception e)
|
{
|
// Comes from Iterators etc.
|
// TODO Decide if we can handle these better whilst
|
// still sticking to the iterator contract
|
if (closeChannelOnError)
|
{
|
channel.Close();
|
}
|
throw e;
|
}
|
}
|
|
/**
|
* Create a POIFSFileSystem from an <tt>InputStream</tt>. Normally the stream is read until
|
* EOF. The stream is always closed.<p/>
|
*
|
* Some streams are usable After reaching EOF (typically those that return <code>true</code>
|
* for <tt>markSupported()</tt>). In the unlikely case that the caller has such a stream
|
* <i>and</i> needs to use it After this constructor completes, a work around is to wrap the
|
* stream in order to trap the <tt>close()</tt> call. A convenience method (
|
* <tt>CreateNonClosingInputStream()</tt>) has been provided for this purpose:
|
* <pre>
|
* InputStream wrappedStream = POIFSFileSystem.CreateNonClosingInputStream(is);
|
* HSSFWorkbook wb = new HSSFWorkbook(wrappedStream);
|
* is.Reset();
|
* doSomethingElse(is);
|
* </pre>
|
* Note also the special case of <tt>MemoryStream</tt> for which the <tt>close()</tt>
|
* method does nothing.
|
* <pre>
|
* MemoryStream bais = ...
|
* HSSFWorkbook wb = new HSSFWorkbook(bais); // calls bais.Close() !
|
* bais.Reset(); // no problem
|
* doSomethingElse(bais);
|
* </pre>
|
*
|
* @param stream the InputStream from which to read the data
|
*
|
* @exception IOException on errors Reading, or on invalid data
|
*/
|
|
public NPOIFSFileSystem(Stream stream)
|
: this(false)
|
{
|
|
Stream channel = null;
|
bool success = false;
|
|
try
|
{
|
// Turn our InputStream into something NIO based
|
channel = stream;
|
|
// Get the header
|
ByteBuffer headerBuffer = ByteBuffer.CreateBuffer(POIFSConstants.SMALLER_BIG_BLOCK_SIZE);
|
IOUtils.ReadFully(channel, headerBuffer.Buffer);
|
|
// Have the header Processed
|
_header = new HeaderBlock(headerBuffer);
|
|
// Sanity check the block count
|
BlockAllocationTableReader.SanityCheckBlockCount(_header.BATCount);
|
|
// We need to buffer the whole file into memory when
|
// working with an InputStream.
|
// The max possible size is when each BAT block entry is used
|
int maxSize = BATBlock.CalculateMaximumSize(_header);
|
//ByteBuffer data = ByteBuffer.allocate(maxSize);
|
// byte[] data = new byte[maxSize];
|
//// Copy in the header
|
//for(int i = 0; i < headerBuffer.Length; i++)
|
//{
|
// data[i] = headerBuffer[i];
|
//}
|
// byte[] temp = new byte[channel.Length];
|
// Now read the rest of the stream
|
|
ByteBuffer data = ByteBuffer.CreateBuffer(maxSize);
|
headerBuffer.Position = 0;
|
data.Write(headerBuffer.Buffer);
|
data.Position = headerBuffer.Length;
|
|
//IOUtils.ReadFully(channel, data);
|
data.Position += IOUtils.ReadFully(channel, data.Buffer, data.Position, (int)channel.Length);
|
success = true;
|
|
// Turn it into a DataSource
|
_data = new ByteArrayBackedDataSource(data.Buffer, data.Position);
|
}
|
finally
|
{
|
// As per the constructor contract, always close the stream
|
if (channel != null)
|
channel.Close();
|
CloseInputStream(stream, success);
|
}
|
|
// Now process the various entries
|
ReadCoreContents();
|
}
|
/**
|
* @param stream the stream to be closed
|
* @param success <code>false</code> if an exception is currently being thrown in the calling method
|
*/
|
private void CloseInputStream(Stream stream, bool success)
|
{
|
try
|
{
|
stream.Close();
|
}
|
catch (IOException e)
|
{
|
if (success)
|
{
|
throw new Exception(e.Message);
|
}
|
|
}
|
}
|
|
/**
|
* Read and process the PropertiesTable and the
|
* FAT / XFAT blocks, so that we're Ready to
|
* work with the file
|
*/
|
private void ReadCoreContents()
|
{
|
// Grab the block size
|
bigBlockSize = _header.BigBlockSize;
|
|
// Each block should only ever be used by one of the
|
// FAT, XFAT or Property Table. Ensure it does
|
ChainLoopDetector loopDetector = GetChainLoopDetector();
|
|
// Read the FAT blocks
|
foreach (int fatAt in _header.BATArray)
|
{
|
ReadBAT(fatAt, loopDetector);
|
}
|
|
// Now read the XFAT blocks, and the FATs within them
|
BATBlock xfat;
|
int nextAt = _header.XBATIndex;
|
for (int i = 0; i < _header.XBATCount; i++)
|
{
|
loopDetector.Claim(nextAt);
|
ByteBuffer fatData = GetBlockAt(nextAt);
|
xfat = BATBlock.CreateBATBlock(bigBlockSize, fatData);
|
xfat.OurBlockIndex = nextAt;
|
nextAt = xfat.GetValueAt(bigBlockSize.GetXBATEntriesPerBlock());
|
_xbat_blocks.Add(xfat);
|
|
for (int j = 0; j < bigBlockSize.GetXBATEntriesPerBlock(); j++)
|
{
|
int fatAt = xfat.GetValueAt(j);
|
if (fatAt == POIFSConstants.UNUSED_BLOCK) break;
|
ReadBAT(fatAt, loopDetector);
|
}
|
}
|
|
// We're now able to load steams
|
// Use this to read in the properties
|
_property_table = new NPropertyTable(_header, this);
|
|
// Finally read the Small Stream FAT (SBAT) blocks
|
BATBlock sfat;
|
List<BATBlock> sbats = new List<BATBlock>();
|
_mini_store = new NPOIFSMiniStore(this, _property_table.Root, sbats, _header);
|
nextAt = _header.SBATStart;
|
for (int i = 0; i < _header.SBATCount; i++)
|
{
|
loopDetector.Claim(nextAt);
|
ByteBuffer fatData = GetBlockAt(nextAt);
|
sfat = BATBlock.CreateBATBlock(bigBlockSize, fatData);
|
sfat.OurBlockIndex = nextAt;
|
sbats.Add(sfat);
|
nextAt = GetNextBlock(nextAt);
|
}
|
}
|
|
private void ReadBAT(int batAt, ChainLoopDetector loopDetector)
|
{
|
loopDetector.Claim(batAt);
|
ByteBuffer fatData = GetBlockAt(batAt);
|
// byte[] fatData = GetBlockAt(batAt);
|
BATBlock bat = BATBlock.CreateBATBlock(bigBlockSize, fatData);
|
bat.OurBlockIndex = batAt;
|
_bat_blocks.Add(bat);
|
}
|
private BATBlock CreateBAT(int offset, bool isBAT)
|
{
|
// Create a new BATBlock
|
BATBlock newBAT = BATBlock.CreateEmptyBATBlock(bigBlockSize, !isBAT);
|
newBAT.OurBlockIndex = offset;
|
// Ensure there's a spot in the file for it
|
ByteBuffer buffer = ByteBuffer.CreateBuffer(bigBlockSize.GetBigBlockSize());
|
int WriteTo = (1 + offset) * bigBlockSize.GetBigBlockSize(); // Header isn't in BATs
|
_data.Write(buffer, WriteTo);
|
// All done
|
return newBAT;
|
}
|
|
/**
|
* Load the block at the given offset.
|
*/
|
public override ByteBuffer GetBlockAt(int offset)
|
{
|
// The header block doesn't count, so add one
|
long startAt = (offset + 1) * bigBlockSize.GetBigBlockSize();
|
return _data.Read(bigBlockSize.GetBigBlockSize(), startAt);
|
}
|
|
/**
|
* Load the block at the given offset,
|
* extending the file if needed
|
*/
|
public override ByteBuffer CreateBlockIfNeeded(int offset)
|
{
|
try
|
{
|
return GetBlockAt(offset);
|
}
|
catch (IndexOutOfRangeException)
|
{
|
// The header block doesn't count, so add one
|
long startAt = (offset + 1) * bigBlockSize.GetBigBlockSize();
|
// Allocate and write
|
ByteBuffer buffer = ByteBuffer.CreateBuffer(GetBigBlockSize());
|
// byte[] buffer = new byte[GetBigBlockSize()];
|
_data.Write(buffer, startAt);
|
// Retrieve the properly backed block
|
return GetBlockAt(offset);
|
}
|
}
|
|
/**
|
* Returns the BATBlock that handles the specified offset,
|
* and the relative index within it
|
*/
|
public override BATBlockAndIndex GetBATBlockAndIndex(int offset)
|
{
|
return BATBlock.GetBATBlockAndIndex(offset, _header, _bat_blocks);
|
}
|
|
/**
|
* Works out what block follows the specified one.
|
*/
|
public override int GetNextBlock(int offset)
|
{
|
BATBlockAndIndex bai = GetBATBlockAndIndex(offset);
|
return bai.Block.GetValueAt(bai.Index);
|
}
|
|
/**
|
* Changes the record of what block follows the specified one.
|
*/
|
public override void SetNextBlock(int offset, int nextBlock)
|
{
|
BATBlockAndIndex bai = GetBATBlockAndIndex(offset);
|
bai.Block.SetValueAt(bai.Index, nextBlock);
|
}
|
|
/**
|
* Finds a free block, and returns its offset.
|
* This method will extend the file if needed, and if doing
|
* so, allocate new FAT blocks to Address the extra space.
|
*/
|
public override int GetFreeBlock()
|
{
|
// First up, do we have any spare ones?
|
int offset = 0;
|
for (int i = 0; i < _bat_blocks.Count; i++)
|
{
|
int numSectors = bigBlockSize.GetBATEntriesPerBlock();
|
|
// Check this one
|
BATBlock temp = _bat_blocks[i];
|
if (temp.HasFreeSectors)
|
{
|
// Claim one of them and return it
|
for (int j = 0; j < numSectors; j++)
|
{
|
int batValue = temp.GetValueAt(j);
|
if (batValue == POIFSConstants.UNUSED_BLOCK)
|
{
|
// Bingo
|
return offset + j;
|
}
|
}
|
}
|
|
// Move onto the next BAT
|
offset += numSectors;
|
}
|
|
// If we Get here, then there aren't any free sectors
|
// in any of the BATs, so we need another BAT
|
BATBlock bat = CreateBAT(offset, true);
|
bat.SetValueAt(0, POIFSConstants.FAT_SECTOR_BLOCK);
|
_bat_blocks.Add(bat);
|
|
// Now store a reference to the BAT in the required place
|
if (_header.BATCount >= 109)
|
{
|
// Needs to come from an XBAT
|
BATBlock xbat = null;
|
foreach (BATBlock x in _xbat_blocks)
|
{
|
if (x.HasFreeSectors)
|
{
|
xbat = x;
|
break;
|
}
|
}
|
if (xbat == null)
|
{
|
// Oh joy, we need a new XBAT too...
|
xbat = CreateBAT(offset + 1, false);
|
xbat.SetValueAt(0, offset);
|
bat.SetValueAt(1, POIFSConstants.DIFAT_SECTOR_BLOCK);
|
|
// Will go one place higher as XBAT Added in
|
offset++;
|
|
// Chain it
|
if (_xbat_blocks.Count == 0)
|
{
|
_header.XBATStart = offset;
|
}
|
else
|
{
|
_xbat_blocks[_xbat_blocks.Count - 1].SetValueAt(
|
bigBlockSize.GetXBATEntriesPerBlock(), offset
|
);
|
}
|
_xbat_blocks.Add(xbat);
|
_header.XBATCount = _xbat_blocks.Count;
|
}
|
// Allocate us in the XBAT
|
for (int i = 0; i < bigBlockSize.GetXBATEntriesPerBlock(); i++)
|
{
|
if (xbat.GetValueAt(i) == POIFSConstants.UNUSED_BLOCK)
|
{
|
xbat.SetValueAt(i, offset);
|
}
|
}
|
}
|
else
|
{
|
// Store us in the header
|
int[] newBATs = new int[_header.BATCount + 1];
|
Array.Copy(_header.BATArray, 0, newBATs, 0, newBATs.Length - 1);
|
newBATs[newBATs.Length - 1] = offset;
|
_header.BATArray = newBATs;
|
}
|
_header.BATCount = _bat_blocks.Count;
|
|
// The current offset stores us, but the next one is free
|
return offset + 1;
|
}
|
|
|
public override ChainLoopDetector GetChainLoopDetector()
|
{
|
return new ChainLoopDetector(_data.Size, this);
|
}
|
|
/**
|
* For unit Testing only! Returns the underlying
|
* properties table
|
*/
|
public NPropertyTable PropertyTable
|
{
|
get { return _property_table; }
|
}
|
|
/**
|
* Returns the MiniStore, which performs a similar low
|
* level function to this, except for the small blocks.
|
*/
|
public NPOIFSMiniStore GetMiniStore()
|
{
|
return _mini_store;
|
}
|
|
/**
|
* add a new POIFSDocument to the FileSytem
|
*
|
* @param document the POIFSDocument being Added
|
*/
|
public void AddDocument(NPOIFSDocument document)
|
{
|
_property_table.AddProperty(document.DocumentProperty);
|
}
|
|
/**
|
* add a new DirectoryProperty to the FileSystem
|
*
|
* @param directory the DirectoryProperty being Added
|
*/
|
public void AddDirectory(DirectoryProperty directory)
|
{
|
_property_table.AddProperty(directory);
|
}
|
|
/**
|
* Create a new document to be Added to the root directory
|
*
|
* @param stream the InputStream from which the document's data
|
* will be obtained
|
* @param name the name of the new POIFSDocument
|
*
|
* @return the new DocumentEntry
|
*
|
* @exception IOException on error creating the new POIFSDocument
|
*/
|
|
public DocumentEntry CreateDocument(Stream stream, String name)
|
{
|
return Root.CreateDocument(name, stream);
|
}
|
|
/**
|
* create a new DocumentEntry in the root entry; the data will be
|
* provided later
|
*
|
* @param name the name of the new DocumentEntry
|
* @param size the size of the new DocumentEntry
|
* @param Writer the Writer of the new DocumentEntry
|
*
|
* @return the new DocumentEntry
|
*
|
* @exception IOException
|
*/
|
|
public DocumentEntry CreateDocument(String name, int size, POIFSWriterListener writer)
|
{
|
return Root.CreateDocument(name, size, writer);
|
}
|
|
/**
|
* create a new DirectoryEntry in the root directory
|
*
|
* @param name the name of the new DirectoryEntry
|
*
|
* @return the new DirectoryEntry
|
*
|
* @exception IOException on name duplication
|
*/
|
|
public DirectoryEntry CreateDirectory(String name)
|
{
|
return Root.CreateDirectory(name);
|
}
|
|
/**
|
* Write the filesystem out to the open file. Will thrown an
|
* {@link ArgumentException} if opened from an
|
* {@link InputStream}.
|
*
|
* @exception IOException thrown on errors writing to the stream
|
*/
|
public void WriteFilesystem()
|
{
|
if (_data is FileBackedDataSource)
|
{
|
// Good, correct type
|
}
|
else
|
{
|
throw new ArgumentException(
|
"POIFS opened from an inputstream, so WriteFilesystem() may " +
|
"not be called. Use WriteFilesystem(OutputStream) instead"
|
);
|
}
|
syncWithDataSource();
|
}
|
|
/**
|
* Write the filesystem out
|
*
|
* @param stream the OutputStream to which the filesystem will be
|
* written
|
*
|
* @exception IOException thrown on errors writing to the stream
|
*/
|
|
public void WriteFilesystem(Stream stream)
|
{
|
// Have the datasource updated
|
syncWithDataSource();
|
|
// Now copy the contents to the stream
|
_data.CopyTo(stream);
|
}
|
|
/**
|
* Has our in-memory objects write their state
|
* to their backing blocks
|
*/
|
private void syncWithDataSource()
|
{
|
// HeaderBlock
|
HeaderBlockWriter hbw = new HeaderBlockWriter(_header);
|
hbw.WriteBlock(GetBlockAt(-1));
|
|
// BATs
|
foreach (BATBlock bat in _bat_blocks)
|
{
|
ByteBuffer block = GetBlockAt(bat.OurBlockIndex);
|
//byte[] block = GetBlockAt(bat.OurBlockIndex);
|
BlockAllocationTableWriter.WriteBlock(bat, block);
|
}
|
|
// SBATs
|
_mini_store.SyncWithDataSource();
|
|
// Properties
|
_property_table.Write(new NPOIFSStream(this, _header.PropertyStart)
|
);
|
}
|
|
/**
|
* Closes the FileSystem, freeing any underlying files, streams
|
* and buffers. After this, you will be unable to read or
|
* write from the FileSystem.
|
*/
|
public void close()
|
{
|
_data.Close();
|
}
|
/**
|
* Get the root entry
|
*
|
* @return the root entry
|
*/
|
public DirectoryNode Root
|
{
|
get
|
{
|
if (_root == null)
|
{
|
_root = new DirectoryNode(_property_table.Root, this, null);
|
}
|
return _root;
|
}
|
}
|
|
/**
|
* open a document in the root entry's list of entries
|
*
|
* @param documentName the name of the document to be opened
|
*
|
* @return a newly opened DocumentInputStream
|
*
|
* @exception IOException if the document does not exist or the
|
* name is that of a DirectoryEntry
|
*/
|
public DocumentInputStream CreateDocumentInputStream(string documentName)
|
{
|
return Root.CreateDocumentInputStream(documentName);
|
}
|
|
/**
|
* remove an entry
|
*
|
* @param entry to be Removed
|
*/
|
|
public void Remove(EntryNode entry)
|
{
|
_property_table.RemoveProperty(entry.Property);
|
}
|
|
/* ********** START begin implementation of POIFSViewable ********** */
|
|
/**
|
* Get an array of objects, some of which may implement
|
* POIFSViewable
|
*
|
* @return an array of Object; may not be null, but may be empty
|
*/
|
|
protected Object[] GetViewableArray()
|
{
|
if (PreferArray)
|
{
|
Array ar = ((POIFSViewable)Root).ViewableArray;
|
Object[] rval = new Object[ar.Length];
|
|
for (int i = 0; i < ar.Length; i++)
|
rval[i] = ar.GetValue(i);
|
|
return rval;
|
|
}
|
return new Object[0];
|
}
|
|
/**
|
* Get an Iterator of objects, some of which may implement
|
* POIFSViewable
|
*
|
* @return an Iterator; may not be null, but may have an empty
|
* back end store
|
*/
|
|
protected IEnumerator GetViewableIterator()
|
{
|
if (!PreferArray)
|
{
|
return ((POIFSViewable)Root).ViewableIterator;
|
}
|
return null;
|
}
|
|
/**
|
* Provides a short description of the object, to be used when a
|
* POIFSViewable object has not provided its contents.
|
*
|
* @return short description
|
*/
|
|
protected String GetShortDescription()
|
{
|
return "POIFS FileSystem";
|
}
|
|
/* ********** END begin implementation of POIFSViewable ********** */
|
|
/**
|
* @return The Big Block size, normally 512 bytes, sometimes 4096 bytes
|
*/
|
public int GetBigBlockSize()
|
{
|
return bigBlockSize.GetBigBlockSize();
|
}
|
/**
|
* @return The Big Block size, normally 512 bytes, sometimes 4096 bytes
|
*/
|
public POIFSBigBlockSize GetBigBlockSizeDetails()
|
{
|
return bigBlockSize;
|
}
|
public override int GetBlockStoreBlockSize()
|
{
|
return GetBigBlockSize();
|
}
|
|
#region POIFSViewable Members
|
|
public bool PreferArray
|
{
|
get { return ((POIFSViewable)Root).PreferArray; }
|
}
|
|
public string ShortDescription
|
{
|
get { return GetShortDescription(); }
|
}
|
|
public Array ViewableArray
|
{
|
get { return GetViewableArray(); }
|
}
|
|
public IEnumerator ViewableIterator
|
{
|
get { return GetViewableIterator(); }
|
}
|
|
#endregion
|
}
|
|
}
|
