public void AddStreamProvider(IStreamProvider streamProvider)
{
_streamProviders.Add(streamProvider);
streamProvider.StreamStarted += (sender, args) =>
{
if (StreamStarted != null)
StreamStarted(sender, args);
};
streamProvider.StreamStopped += (sender, args) =>
{
if (StreamStopped != null)
StreamStopped(sender, args);
};
streamProvider.StreamGlobalNotification += (sender, args) =>
{
if (StreamGlobalNotification != null)
{
StreamGlobalNotification(sender, args);
}
};
if (streamProvider.ToString() == "DeathmicChatbot.StreamInfo.Hitbox.HitboxProvider")
{
streamProvider.StartTimer();
}
}
/// <summary>
/// Retrieve stream provider
/// </summary>
/// <returns>and IStreamProvider</returns>
public static IStreamProvider GetStreamProvider()
{
if (_streamProvider == null)
_streamProvider = GrainClient.GetStreamProvider("SMSProvider");
return _streamProvider;
}
public ExpendableListWriter(IStreamProvider streamProvider, Action<ExpendableListWriter,Stream> onNewfileCreated)
{
m_onNewfileCreated = onNewfileCreated;
m_streamProvider = streamProvider;
m_stream = m_streamProvider.GetStream();
onNewfileCreated.Invoke(this,m_stream);
}
protected StreamCopier(bool autoCloseSource, bool autoCloseDestination, int bufferSize)
{
streamProvider = (IStreamProvider)this;
this.autoCloseSource = autoCloseSource;
this.autoCloseDestination = autoCloseDestination;
buffer = new byte[bufferSize > 0 ? bufferSize : DefaultBufferSize];
}
public DualBinaryStore(IStreamProvider provider, long start, long maxLength)
{
if (provider == null) throw new ArgumentNullException("provider");
if (start < 0) throw new ArgumentException("start parameter must have a value equal or greater than 0");
if (maxLength <= 0) throw new ArgumentException("maxLength parameter must have a value greater than 0");
_provider = provider;
_start = start;
_maxLength = maxLength;
_writeHeaderStream = provider.AcquireWriteStream();
_writeLeftStream = provider.AcquireWriteStream();
_writeRightStream = provider.AcquireWriteStream();
_writeHeaderStream.Seek(start, SeekOrigin.Begin);
if (_writeHeaderStream.Length > start)
{
using (var readStream = _provider.AcquireReadStream())
{
readStream.Seek(start, SeekOrigin.Begin);
var headerBuffer = new byte[16];
readStream.Read(headerBuffer, 0, headerBuffer.Length);
_leftOffset = BitConverter.ToInt64(headerBuffer, 0);
_rightOffset = BitConverter.ToInt64(headerBuffer, 8);
// If the buffer was not generated by the store
if (_leftOffset <= 0) _leftOffset = 16;
if (_rightOffset <= 0) _rightOffset = maxLength;
}
_writeLeftStream.Seek(start + _leftOffset, SeekOrigin.Begin);
_writeRightStream.Seek(start + _rightOffset, SeekOrigin.Begin);
}
else
{
_leftOffset = 16;
_rightOffset = maxLength;
var headerBuffer = BitConverter.GetBytes(_leftOffset);
_writeHeaderStream.Write(headerBuffer, 0, headerBuffer.Length);
headerBuffer = BitConverter.GetBytes(_rightOffset);
_writeHeaderStream.Write(headerBuffer, 0, headerBuffer.Length);
_writeHeaderStream.Seek(-16, SeekOrigin.Current);
_writeRightStream.Seek(start + _leftOffset, SeekOrigin.Begin);
var buffer = new byte[maxLength - _leftOffset];
_writeRightStream.Write(buffer, 0, buffer.Length);
_writeLeftStream.Seek(start + _leftOffset, SeekOrigin.Begin);
}
_lastFlushedLeftOffset = _leftOffset;
_lastFlushedRightOffset = _rightOffset;
_left = new LeftBinaryStoreSegment(this);
_right = new RightBinaryStoreSegment(this);
}
/// <summary>
/// Initializes a new instance of the DbaseFileReader class.
/// </summary>
/// <param name="streamProvider">A stream provider</param>
public DbaseFileReader(IStreamProvider streamProvider)
{
if (streamProvider == null)
throw new ArgumentNullException("streamProvider");
if (streamProvider.Kind != StreamTypes.Data)
throw new ArgumentException("Not a data stream provider", "streamProvider");
_streamProvider = streamProvider;
}
public ContinuesBinaryFileLogger(IStreamProvider streamProvider, ISubmitLogEntryFactory submitLogEntryFactory, IBufferAllocatorFactory bufferAllocatorFactory)
{
m_listWriter = new ExpendableListWriter(streamProvider, OnNewfileCreated);
m_logEntry = submitLogEntryFactory.CreateSubmitLogEntry(m_listWriter);
var stringCache = submitLogEntryFactory.CreateSubmitLogEntry(m_listWriter);
var definition = submitLogEntryFactory.CreateSubmitLogEntry(m_listWriter);
m_binaryLogSerilizer = new BinaryLogSerilizer(new BinaryLogSerilizer.BufferAndSubmiterTuple(m_logEntry, bufferAllocatorFactory.CreateBufferAllocator()),
new BinaryLogSerilizer.BufferAndSubmiterTuple(stringCache, bufferAllocatorFactory.CreateBufferAllocator()),
new BinaryLogSerilizer.BufferAndSubmiterTuple(definition, bufferAllocatorFactory.CreateBufferAllocator()));
}
public StreamCopier(IStreamProvider streamProvider, bool autoCloseSource, bool autoCloseDestination, int bufferSize)
{
this.streamProvider = streamProvider;
this.autoCloseSource = autoCloseSource;
this.autoCloseDestination = autoCloseDestination;
buffer = new byte[bufferSize > 0 ? bufferSize : DefaultBufferSize];
bytesReadMeter = new BytesReadMeter(this);
bytesWrittenMeter = new BytesReadMeter(this);
sourceLength = this.streamProvider.GetSourceLength();
}
public void Generate(IStreamProvider streamProvider)
{
GenerationContext ctx = new GenerationContext();
ctx.Dialect = GetDialect();
ctx.Model = new MappingModelImpl();
IDriver driver = GetDriver();
try
{
using (IDbConnection connection = driver.CreateConnection())
{
DbConnection dbConn = connection as DbConnection;
if (null == dbConn)
throw new Exception("Can't convert connection provided by driver to DbConnection");
connection.ConnectionString = cfg.connectioninfo.connectionstring;
connection.Open();
ctx.Schema = ctx.Dialect.GetDataBaseSchema(dbConn);
ctx.Configuration = cfg;
ctx.Connection = dbConn;
ctx.TableExceptions = new TableExceptions(cfg);
ctx.NamingStrategy = TypeFactory.Create<INamingStrategy>(cfg.namingstrategy);
log.Info("Retrieving working table list");
ctx.FilteredTables.AddRange(TableEnumerator.GetInstance(ctx.Schema));
foreach (IMetadataStrategy strategy in metaStrategies)
strategy.Process(ctx);
}
foreach (var clazz in ctx.Model.GetEntities())
{
TextWriter target = streamProvider.GetTextWriter(clazz.name);
hibernatemapping mapping = new hibernatemapping();
mapping.Items = new object[] { clazz };
if (!string.IsNullOrEmpty(cfg.entitiesnamespace))
mapping.@namespace = cfg.entitiesnamespace;
if (!string.IsNullOrEmpty(cfg.entitiesassembly))
mapping.assembly = cfg.entitiesassembly;
XmlSerializer ser = new XmlSerializer(typeof(hibernatemapping));
XmlSerializerNamespaces empty = new XmlSerializerNamespaces();
empty.Add(string.Empty, "urn:nhibernate-mapping-2.2");
ser.Serialize(target, mapping,empty);
target.Flush();
target.Close();
streamProvider.EndWrite();
}
}
catch (Exception e)
{
throw e;
}
}
/// <summary>
/// Creates an instance of this class
/// </summary>
/// <param name="shapeStream">A stream provider for the shape stream</param>
/// <param name="dataStream">A stream provider for the data stream</param>
/// <param name="indexStream">A stream provider for the shape index stream</param>
/// <param name="validateShapeProvider">A value indicating that the <paramref name="shapeStream"/> must be validated</param>
/// <param name="validateDataProvider">A value indicating that the <paramref name="dataStream"/> must be validated</param>
/// <param name="validateIndexProvider">A value indicating that the <paramref name="indexStream"/> must be validated</param>
public ShapefileStreamProviderRegistry(IStreamProvider shapeStream, IStreamProvider dataStream,
IStreamProvider indexStream,
bool validateShapeProvider = false, bool validateDataProvider = false, bool validateIndexProvider = false)
{
if (validateShapeProvider && shapeStream == null)
throw new ArgumentNullException("shapeStream");
if (validateDataProvider && dataStream == null)
throw new ArgumentNullException("dataStream");
if (validateIndexProvider && indexStream == null)
throw new ArgumentNullException("indexStream");
ShapeStream = shapeStream;
DataStream = dataStream;
IndexStream = indexStream;
}
/// <summary>
/// Runs the raw file processor on the specified files
/// </summary>
/// <param name="name">A name for the processor used for logging</param>
/// <param name="sources">The raw files to be processed</param>
/// <param name="streamProvider">Instance capable of reading the sources into a stream</param>
/// <param name="streamParser">Instance capable of parsing the provided stream</param>
/// <param name="processors">The data processors to process the parsed data</param>
/// <returns>True if the operation completed without error, otherwise false</returns>
public static bool Run(string name, IEnumerable<string> sources, IStreamProvider streamProvider, IStreamParser streamParser, params IDataProcessor[] processors)
{
using (var processor = new RawFileProcessor(streamProvider, streamParser, processors) { Name = name })
{
foreach (var zip in sources)
{
try
{
processor.Process(zip);
}
catch (Exception err)
{
Log.Error(err);
return false;
}
}
}
return true;
}
private BinaryStore(IStreamProvider provider, long start, long length, bool canGrow)
{
_writeStream = provider.AcquireWriteStream();
_provider = provider;
_start = start;
_length = length;
_canGrow = canGrow;
if (_writeStream.Length > start)
{
using (var readStream = _provider.AcquireReadStream())
{
readStream.Seek(start, SeekOrigin.Begin);
var offsetBuffer = new byte[8];
readStream.Read(offsetBuffer, 0, offsetBuffer.Length);
_currentOffset = BitConverter.ToInt64(offsetBuffer, 0);
}
}
else
{
_currentOffset = 8;
var offsetBuffer = BitConverter.GetBytes(_currentOffset);
_writeStream.Seek(start, SeekOrigin.Begin);
_writeStream.Write(offsetBuffer, 0, offsetBuffer.Length);
if (length > 0)
{
var requiredFileSize = _start + _length;
var buffer = new byte[requiredFileSize - _writeStream.Length - 8];
_writeStream.Write(buffer, 0, buffer.Length);
}
}
_lastFlushOffset = _currentOffset;
_writeStream.Seek(start + _currentOffset, SeekOrigin.Begin);
_offsetWriteStream = provider.AcquireWriteStream();
_offsetWriteStream.Seek(start, SeekOrigin.Begin);
}
//Here to support dependency injection
public MainViewModel(IWindowManager windowManager, IInformationProvider infoProvider,
IPersistenceManager persistenceManager, IStreamProvider streamProvider)
{
DisplayName = "Sojurn";
wm = windowManager;
pm = persistenceManager;
this.infoProvider = infoProvider;
StreamProvider = streamProvider;
Shows = new CollectionViewSource {Source = shows};
Shows.SortDescriptions.Add(new SortDescription("Name", ListSortDirection.Ascending));
TimeLine = new CollectionViewSource {Source = timeLine};
TimeLine.SortDescriptions.Add(new SortDescription("Date", ListSortDirection.Ascending));
TimeLine.GroupDescriptions.Add(new PropertyGroupDescription("Date"));
Backlog = new CollectionViewSource {Source = backlog};
Backlog.GroupDescriptions.Add(new PropertyGroupDescription("ShowName"));
Backlog.SortDescriptions.Add(new SortDescription("ShowName", ListSortDirection.Ascending));
Backlog.SortDescriptions.Add(new SortDescription("SeasonNumber", ListSortDirection.Ascending));
Backlog.SortDescriptions.Add(new SortDescription("EpisodeNumberThisSeason", ListSortDirection.Ascending));
}
public BinaryStore(IStreamProvider provider, long start, long maxLength)
: this(provider, start, maxLength, false)
{
}
public override void WriteValue(IStreamProvider value)
{
if (value == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("value"));
}
if (this.Writer.WriteState == System.Xml.WriteState.Element)
{
if (this.binaryDataChunks == null)
{
this.binaryDataChunks = new List<MtomBinaryData>();
this.contentID = GenerateUriForMimePart((this.mimeParts == null) ? 1 : (this.mimeParts.Count + 1));
}
this.binaryDataChunks.Add(new MtomBinaryData(value));
}
else
{
this.Writer.WriteValue(value);
}
}
public ShapefileStreamProviderRegistry(IStreamProvider shapeStream, IStreamProvider dataStream,
bool validateShapeProvider = false, bool validateDataProvider = false, bool validateIndexPath = false) :
this(shapeStream, dataStream, null, validateShapeProvider, validateDataProvider, false)
{
}
public BinaryReaderColumn(BinaryTableReader table, ColumnDetails details, IStreamProvider streamProvider)
{
_table = table;
_streamProvider = streamProvider;
ColumnDetails = details;
}
public virtual void WriteValue (IStreamProvider value)
{
if (value == null)
throw new ArgumentNullException ("value");
Stream stream = value.GetStream ();
byte[] buf = new byte [Math.Min (2048, stream.CanSeek ? stream.Length : 2048)];
int read;
while ((read = stream.Read (buf, 0, buf.Length)) > 0) {
WriteBase64 (buf, 0, read);
}
value.ReleaseStream (stream);
}
public static void Copy(this IStreamProvider streamProvider, string sourceFilePath, string targetPath)
{
Copy(streamProvider, File.OpenRead(sourceFilePath), targetPath);
}
private static void AddFullFolderContainers(this IStreamProvider streamProvider, string underPath, HashSet <string> results)
{
AddFullFolderContainers(streamProvider, underPath + "\\", underPath, results);
}
public static bool Exists(this IStreamProvider streamProvider, string logicalPath)
{
return(streamProvider.Attributes(logicalPath).Exists);
}
public NullableWriter(IStreamProvider streamProvider, string columnPath, IColumnWriter valueWriter)
{
_streamProvider = streamProvider;
_columnPath = columnPath;
_valueWriter = valueWriter;
}
/// <summary> /// This method queries the active grains for the given grain interface. /// </summary> /// <typeparam name="TIGrain">the given indexable grain interface type to query over its active instances</typeparam> /// <typeparam name="TProperty">the property type to query over</typeparam> /// <param name="streamProvider">the stream provider for the query results</param> /// <returns>the query to lookup all active grains of a given type</returns> public IOrleansQueryable <TIGrain, TProperty> GetActiveGrains <TIGrain, TProperty>(IStreamProvider streamProvider) where TIGrain : IIndexableGrain => new QueryActiveGrainsNode <TIGrain, TProperty>(this, streamProvider);
/// <summary>
/// This method queries the active grains for the given grain interface and the filter expression. The filter
/// expression should contain an indexed field.
/// </summary>
/// <typeparam name="TIGrain">the given indexable grain interface type to query over its active instances</typeparam>
/// <typeparam name="TProperties">the property type to query over</typeparam>
/// <param name="streamProvider">the stream provider for the query results</param>
/// <param name="filterExpr">the filter expression of the query</param>
/// <param name="queryResultObserver">the observer object to be called on every grain found for the query</param>
/// <returns>the result of the query</returns>
public Task GetActiveGrains <TIGrain, TProperties>(IStreamProvider streamProvider,
Expression <Func <TProperties, bool> > filterExpr, IAsyncBatchObserver <TIGrain> queryResultObserver) where TIGrain : IIndexableGrain
=> this.GetActiveGrains <TIGrain, TProperties>(streamProvider).Where(filterExpr).ObserveResults(queryResultObserver);
public YahooSpotProvider(IStreamProvider yahooStreamProvider)
{
_yahooStreamProvider = yahooStreamProvider;
}
internal static void RemoveStyle(IStreamProvider provider)
{
}
public WriteValueFastAsyncResult(XmlDictionaryWriter writer, IStreamProvider value, AsyncCallback callback, object state)
: base(callback, state)
{
this.streamProvider = value;
this.writer = writer;
this.stream = value.GetStream();
if (this.stream == null)
{
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(SR.GetString(SR.XmlInvalidStream)));
}
this.blockSize = 256;
this.bytesRead = 0;
this.block = new byte[this.blockSize];
this.nextOperation = Operation.Read;
this.ContinueWork(true);
}
public static string Path(this IStreamProvider streamProvider, LocationType type, string tableName, string extension)
{
return(System.IO.Path.Combine(type.ToString(), tableName + extension));
}
public async Task <bool> StartGameAsync(GameSystemVM system, IFile file, IFolder rootFolder = null)
{
if (CoreRunner == null)
{
RootFrame.Navigate(typeof(GamePlayerPage));
}
else
{
await CoreRunner.UnloadGameAsync();
}
StreamProvider?.Dispose();
StreamProvider = null;
string virtualMainFilePath = null;
if (!ArchiveExtensions.Contains(Path.GetExtension(file.Name)))
{
IStreamProvider streamProvider;
GetStreamProviderAndVirtualPath(system, file, rootFolder, out streamProvider, out virtualMainFilePath);
StreamProvider = streamProvider;
}
else
{
var archiveProvider = new ArchiveStreamProvider(VFS.RomPath, file);
await archiveProvider.InitializeAsync();
StreamProvider = archiveProvider;
var entries = await StreamProvider.ListEntriesAsync();
virtualMainFilePath = entries.FirstOrDefault(d => system.SupportedExtensions.Contains(Path.GetExtension(d)));
}
//Navigation should cause the player page to load, which in turn should initialize the core runner
while (CoreRunner == null)
{
await Task.Delay(100);
}
if (virtualMainFilePath == null)
{
return(false);
}
system.Core.OpenFileStream = OnCoreOpenFileStream;
system.Core.CloseFileStream = OnCoreCloseFileStream;
var loadSuccessful = false;
try
{
loadSuccessful = await CoreRunner.LoadGameAsync(system.Core, virtualMainFilePath);
}
catch
{
await StopGameAsync();
return(false);
}
if (loadSuccessful)
{
GameStarted(this);
}
else
{
await StopGameAsync();
return(false);
}
return(loadSuccessful);
}
public static string Path(this IStreamProvider streamProvider, LocationType type, string tableName, CrawlType crawlType)
{
return(System.IO.Path.Combine(type.ToString(), tableName, crawlType.ToString()));
}
public PooledMemoryStream(IStreamProvider provider, MemoryStream stream)
{
_provider = provider;
_stream = stream;
}
public static string Path(this IStreamProvider streamProvider, LocationType type, string tableName, CrawlType crawlType, DateTime version)
{
return(System.IO.Path.Combine(type.ToString(), tableName, crawlType.ToString(), version.ToUniversalTime().ToString(DateTimeFolderFormat)));
}
//---------------------------------------------------------------------
public IStreamProvider getStreamProvider()
{
IStreamProvider stream_provider = GetStreamProvider(StringDef.SMSProvider);
return(stream_provider);
}
public static void Clean(this IStreamProvider streamProvider, bool reallyDelete, DateTime cutoff = default(DateTime))
{
// By default, keep data from the last week (so Now, Yesterday, and Last Week 'as of' data is all available)
if (cutoff == default(DateTime))
{
cutoff = DateTime.UtcNow.AddDays(-8);
}
// Remove Sources and Tables older than the cutoff
ItemVersions currentVersions;
int countLeft;
foreach (string tableName in streamProvider.Tables())
{
// Find all Source versions
currentVersions = streamProvider.ItemVersions(LocationType.Source, tableName);
countLeft = currentVersions.Versions.Count;
// Delete ones older than the cutoff, keeping the last three
foreach (var version in currentVersions.Versions)
{
if (version.AsOfDate < cutoff)
{
if (countLeft <= 3)
{
break;
}
countLeft--;
Trace.WriteLine($"DELETE {version.Path}");
if (reallyDelete)
{
// Delete the source
streamProvider.DeleteWithRetries(version.Path);
version.LocationType = LocationType.Table;
// Delete the matching table, if found
streamProvider.DeleteWithRetries(version.Path);
}
}
}
// Find all Table versions
currentVersions = streamProvider.ItemVersions(LocationType.Table, tableName);
countLeft = currentVersions.Versions.Count;
// Delete ones older than the cutoff, keeping the last three
foreach (var version in currentVersions.Versions)
{
if (version.AsOfDate < cutoff)
{
if (countLeft <= 3)
{
break;
}
countLeft--;
Trace.WriteLine($"DELETE {version.Path}");
if (reallyDelete)
{
streamProvider.DeleteWithRetries(version.Path);
}
}
}
}
}
public override void WriteValue(IStreamProvider value)
{
this.effectiveWriter.WriteValue(value);
}
public TestTransactionalTransactionalStreamConsumerAggregate(IStreamProvider streamProvider) : base(streamProvider)
{
}
public BinaryStore(IStreamProvider provider)
: this(provider, 0, 0, true)
{
}
public StreamCopier(IStreamProvider streamProvider, bool autoCloseSource, bool autoCloseDestination)
: this(streamProvider, autoCloseSource, autoCloseDestination, -1)
{
}
public async Task <bool> StartGameAsync(GameSystemVM system, IFileInfo file, IDirectoryInfo rootFolder = null)
{
var core = system.Core;
if (CoreRunner == null)
{
RootFrame.Navigate(GamePlayerPageType);
}
else
{
await CoreRunner.UnloadGameAsync();
}
StreamProvider?.Dispose();
StreamProvider = null;
string virtualMainFilePath = null;
if (core.NativeArchiveSupport || !ArchiveExtensions.Contains(Path.GetExtension(file.Name)))
{
virtualMainFilePath = $"{VFSRomPath}{Path.DirectorySeparatorChar}{file.Name}";
StreamProvider = new SingleFileStreamProvider(virtualMainFilePath, file);
if (rootFolder != null)
{
virtualMainFilePath = file.FullName.Substring(rootFolder.FullName.Length + 1);
virtualMainFilePath = $"{VFSRomPath}{Path.DirectorySeparatorChar}{virtualMainFilePath}";
StreamProvider = new FolderStreamProvider(VFSRomPath, rootFolder);
}
}
else
{
var archiveProvider = new ArchiveStreamProvider(VFSRomPath, file);
await archiveProvider.InitializeAsync();
StreamProvider = archiveProvider;
var entries = await StreamProvider.ListEntriesAsync();
virtualMainFilePath = entries.FirstOrDefault(d => system.SupportedExtensions.Contains(Path.GetExtension(d)));
}
var systemFolder = await system.GetSystemDirectoryAsync();
var systemProvider = new FolderStreamProvider(VFSSystemPath, systemFolder);
var saveFolder = await system.GetSaveDirectoryAsync();
var saveProvider = new FolderStreamProvider(VFSSavePath, saveFolder);
StreamProvider = new CombinedStreamProvider(new HashSet <IStreamProvider>()
{
StreamProvider, systemProvider, saveProvider
});
//Navigation should cause the player page to load, which in turn should initialize the core runner
while (CoreRunner == null)
{
await Task.Delay(100);
}
if (virtualMainFilePath == null)
{
return(false);
}
var loadSuccessful = false;
try
{
loadSuccessful = await CoreRunner.LoadGameAsync(core, virtualMainFilePath);
}
catch
{
await StopGameAsync();
return(false);
}
if (loadSuccessful)
{
GameStarted?.Invoke(this);
}
else
{
await StopGameAsync();
return(false);
}
return(loadSuccessful);
}
public virtual Task WriteValueAsync(IStreamProvider value)
{
return Task.Factory.FromAsync(this.BeginWriteValue, this.EndWriteValue, value, null);
}
public virtual Task WriteValueAsync(IStreamProvider value)
{
WriteValue(value);
return Task.CompletedTask;
}
private void GetStreamProviderAndVirtualPath(GameSystemVM system, IFile file, IFolder rootFolder, out IStreamProvider provider, out string mainFileVirtualPath)
{
IStreamProvider romProvider;
if (rootFolder == null)
{
mainFileVirtualPath = $"{VFS.RomPath}{Path.DirectorySeparatorChar}{file.Name}";
romProvider = new SingleFileStreamProvider(mainFileVirtualPath, file);
}
else
{
mainFileVirtualPath = file.Path.Substring(rootFolder.Path.Length + 1);
mainFileVirtualPath = $"{VFS.RomPath}{Path.DirectorySeparatorChar}{mainFileVirtualPath}";
romProvider = new FolderStreamProvider(VFS.RomPath, rootFolder);
}
var systemProvider = new FolderStreamProvider(VFS.SystemPath, new WinRTFolder(system.Core.SystemFolder));
var saveProvider = new FolderStreamProvider(VFS.SavePath, new WinRTFolder(system.Core.SaveGameFolder));
var combinedProvider = new CombinedStreamProvider(new HashSet <IStreamProvider> {
romProvider, systemProvider, saveProvider
});
provider = combinedProvider;
}
public QueryIndexedGrainsNode(IIndexFactory indexFactory, IStreamProvider streamProvider, string indexName, object param) : base(indexFactory, streamProvider)
{
this._indexName = indexName;
this._param = param;
}
public IColumnWriter BinaryWriter(IStreamProvider streamProvider, string columnPath)
{
return(new ConvertingWriter(TypeProviderFactory.Get(typeof(long)).BinaryWriter(streamProvider, columnPath), TypeConverterFactory.GetConverter(typeof(TimeSpan), typeof(long))));
}
public virtual void WriteValue(IStreamProvider value)
{
if (value == null)
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("value"));
Stream stream = value.GetStream();
if (stream == null)
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(SR.GetString(SR.XmlInvalidStream)));
int blockSize = 256;
int bytesRead = 0;
byte[] block = new byte[blockSize];
while (true)
{
bytesRead = stream.Read(block, 0, blockSize);
if (bytesRead > 0)
WriteBase64(block, 0, bytesRead);
else
break;
if (blockSize < 65536 && bytesRead == blockSize)
{
blockSize = blockSize * 16;
block = new byte[blockSize];
}
}
value.ReleaseStream(stream);
}
protected override void ImportStream(PipelineContext ctx, IDatasourceSink sink, IStreamProvider elt, Stream strm)
{
if (selector != null)
{
XmlHelper h = new XmlHelper();
h.Load(strm.CreateTextReader(), elt.FullName);
selector.Process(ctx, new XmlNodeWrapper(h.DocumentElement));
return;
}
List <String> keys = new List <string>();
List <String> values = new List <String>();
int lvl = -1;
XmlReader rdr = XmlReader.Create(strm);
Logger l = ctx.DebugLog;
while (rdr.Read())
{
if (dumpReader)
{
l.Log("{0}: {1}, {2} [{3}]", rdr.Name, rdr.NodeType, rdr.IsEmptyElement, rdr.Value);
}
switch (rdr.NodeType)
{
case XmlNodeType.CDATA:
case XmlNodeType.Text:
case XmlNodeType.Whitespace:
case XmlNodeType.SignificantWhitespace:
if (lvl <= 0)
{
continue;
}
values[lvl] = values[lvl] + rdr.Value;
continue;
case XmlNodeType.Element:
lvl++;
if (lvl >= keys.Count)
{
keys.Add(null); values.Add(null);
}
if (lvl == 0)
{
keys[0] = rdr.Name;
}
else
{
keys[lvl] = keys[lvl - 1] + "/" + rdr.Name;
if (lvl == 1)
{
ctx.IncrementEmitted();
}
}
//l.Log("{0}: [{1}, {2}]", lvl, keys[lvl], rdr.NodeType);
bool isEmpty = rdr.IsEmptyElement; //cache this value: after reading the attribs its value is lost
if (rdr.AttributeCount > 0)
{
String pfx = keys[lvl] + "/@";
for (int j = 0; j < rdr.AttributeCount; j++)
{
rdr.MoveToNextAttribute();
sink.HandleValue(ctx, pfx + rdr.Name, rdr.Value);
}
}
if (!isEmpty)
{
continue;
}
//l.Log("{0}: [{1}]", keys[lvl], rdr.NodeType);
sink.HandleValue(ctx, keys[lvl], null);
lvl--;
continue;
case XmlNodeType.EndElement:
//l.Log("{0}: [{1}]", keys[lvl], rdr.NodeType);
sink.HandleValue(ctx, keys[lvl], values[lvl]);
values[lvl] = null;
lvl--;
continue;
}
}
rdr.Close();
}
internal virtual IAsyncResult BeginWriteValue(IStreamProvider value, AsyncCallback callback, object state)
{
if (value == null)
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("value"));
if (this.FastAsync)
{
return new WriteValueFastAsyncResult(this, value, callback, state);
}
else
{
return new WriteValueAsyncResult(this, value, callback, state);
}
}
public virtual void WriteValue(IStreamProvider value)
{
if (value == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("value"));
}
Stream stream = value.GetStream();
if (stream == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(System.Runtime.Serialization.SR.GetString("XmlInvalidStream")));
}
int count = 0x100;
int num2 = 0;
byte[] buffer = new byte[count];
Label_004B:
num2 = stream.Read(buffer, 0, count);
if (num2 > 0)
{
this.WriteBase64(buffer, 0, num2);
if ((count < 0x10000) && (num2 == count))
{
count *= 0x10;
buffer = new byte[count];
}
goto Label_004B;
}
value.ReleaseStream(stream);
}
public WriteValueAsyncResult(XmlDictionaryWriter writer, IStreamProvider value, AsyncCallback callback, object state)
: base(callback, state)
{
this.streamProvider = value;
this.writer = writer;
this.writeBlockHandler = this.writer.Settings != null && this.writer.Settings.Async ? handleWriteBlockAsync : handleWriteBlock;
this.stream = value.GetStream();
if (this.stream == null)
{
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(SR.GetString(SR.XmlInvalidStream)));
}
this.blockSize = 256;
this.bytesRead = 0;
this.block = new byte[blockSize]; //
bool completeSelf = ContinueWork(null);
if (completeSelf)
{
this.CompleteAndReleaseStream(true, null);
}
}
public static void AddStyle (IStreamProvider provider)
{
using (var stream = provider.Open ()) {
string styleName = ScanStyle (stream);
styleLookup [styleName] = provider;
}
}
public static Topic Player(IStreamProvider provider, Guid userId, string roomId)
{
return(new Topic(provider, TopicIds.Player(userId, roomId)));
}
public InfoController(ILogger <InfoController> logger, IStreamProvider streamProvider)
{
_streamProvider = streamProvider;
_logger = logger;
}
/// <summary>
/// Initializes a new instance of the <see cref="RawFileProcessor"/> class
/// </summary>
public RawFileProcessor(IStreamProvider streamProvider, IStreamParser parser, params IDataProcessor[] processors)
{
_streamProvider = streamProvider;
_parser = parser;
_processors = processors;
}
public virtual Task WriteValueAsync(IStreamProvider value)
{
WriteValue(value);
return(Task.CompletedTask);
}
public override void WriteValue(IStreamProvider value)
{
this.writer.WriteValue(value);
}
public XDatabaseContext(IWorkflowRunner runner, IStreamProvider streamProvider) : this()
{
this.Runner = runner;
this.StreamProvider = streamProvider;
}
public static void RemoveSyntaxMode (IStreamProvider provider)
{
using (var reader = provider.Open ()) {
string mimeTypes = Scan (reader, SyntaxMode.MimeTypesAttribute);
foreach (string mimeType in mimeTypes.Split (';')) {
syntaxModeLookup.Remove (mimeType);
}
}
}
public App(IStreamProvider streamProvider, ICompleter completer)
: base(streamProvider, completer)
{
}
public static void RemoveStyle (IStreamProvider provider)
{
using (var stream = provider.Open ()) {
string styleName = ScanStyle (stream);
styleLookup.Remove (styleName);
}
}
/// <summary>
/// Read the header data from the DBF file.
/// </summary>
/// <param name="reader">BinaryReader containing the header.</param>
/// <param name="cpgStreamProvider">A stream provider to read the contents of the CPG Encoding</param>
public void ReadHeader(BinaryReader reader, IStreamProvider cpgStreamProvider)
{
// type of reader.
_fileType = reader.ReadByte();
if (_fileType != 0x03)
{
throw new NotSupportedException("Unsupported DBF reader Type " + _fileType);
}
// parse the update date information.
int year = reader.ReadByte();
int month = reader.ReadByte();
int day = reader.ReadByte();
_updateDate = new DateTime(year + 1900, month, day);
// read the number of records.
_numRecords = reader.ReadInt32();
// read the length of the header structure.
_headerLength = reader.ReadInt16();
// read the length of a record
_recordLength = reader.ReadInt16();
// skip the reserved bytes in the header.
//in.skipBytes(20);
byte[] data = reader.ReadBytes(20);
byte ldid = data[29 - 12]; //get the 29th byte in the file... we've first to read into arry was no 12
var encoding = DetectEncoding(ldid, cpgStreamProvider);
if (_encoding == null)
{
_encoding = encoding;
}
//Replace reader with one with correct encoding..
reader = new BinaryReader(reader.BaseStream, _encoding);
// calculate the number of Fields in the header
_numFields = (_headerLength - FileDescriptorSize - 1) / FileDescriptorSize;
// read all of the header records
_fieldDescriptions = new DbaseFieldDescriptor[_numFields];
for (int i = 0; i < _numFields; i++)
{
_fieldDescriptions[i] = new DbaseFieldDescriptor();
// read the field name
byte[] buffer = reader.ReadBytes(11);
// NOTE: only this _encoding.GetString method is available in Silverlight
string name = DbaseEncodingUtility.Latin1.GetString(buffer, 0, buffer.Length);
int nullPoint = name.IndexOf((char)0);
if (nullPoint != -1)
{
name = name.Substring(0, nullPoint);
}
_fieldDescriptions[i].Name = name;
// read the field type
_fieldDescriptions[i].DbaseType = (char)reader.ReadByte();
// read the field data address, offset from the start of the record.
_fieldDescriptions[i].DataAddress = reader.ReadInt32();
// read the field length in bytes
int tempLength = reader.ReadByte();
if (tempLength < 0)
{
tempLength = tempLength + 256;
}
_fieldDescriptions[i].Length = tempLength;
// read the field decimal count in bytes
_fieldDescriptions[i].DecimalCount = reader.ReadByte();
// read the reserved bytes.
//reader.skipBytes(14);
reader.ReadBytes(14);
}
// Last byte is a marker for the end of the field definitions.
// Trond Benum: This fails for some presumeably valid test shapefiles, so I have commented it out.
/*byte lastByte = */ reader.ReadByte();//s(1)[0];
// if (lastByte != 0x0d)
// throw new ShapefileException("DBase Header is not terminated");
// Assure we are at the end of the header!
if (reader.BaseStream.Position != _headerLength)
{
reader.BaseStream.Seek(_headerLength, SeekOrigin.Begin);
}
}
