public ISequenceCache GetSequenceCache(string seqname, int step)
{
ISequenceCache seqCache = null;
if (m_sequences.ContainsKey(seqname))
{
seqCache = m_sequences[seqname];
}
if (seqCache == null)
{
lock (m_sequences)
{
if (m_sequences.ContainsKey(seqname))
{
seqCache = m_sequences[seqname];
}
if (seqCache == null)
{
seqCache = new SequenceCache(seqname, step);
m_sequences.Add(seqname, seqCache);
}
}
}
return(seqCache);
}
private void _ReadData(BinaryReader reader, ISequenceCache sequenceCache, int dataCounts, int outputCounts)
{
for (int i = 0; i < dataCounts; i++)
{
//sequenceCache.AppendData(reader.ReadBytes(outputCounts).ToList());
}
}
public void SaveToFile(ISequenceCache obj, string filePath)
{
IFileWriter fileWriter = FileWriterFactory.CreateBinaryFileWriter();
IObjectContentReader contentReader = ObjectContentReaderFactory.Instance.CreateSequenceCacheContentReader(filePath);
ObjectPersistorService.Instance.SaveToFile(obj, fileWriter, contentReader, filePath);
}
private void _ReadData(BinaryReader reader, ISequenceCache sequenceCache, int dataCounts, int outputCounts)
{
for (int i = 0; i < dataCounts; i++)
{
//sequenceCache.AppendData(reader.ReadBytes(outputCounts).ToList());
}
}
private void _InitializeCache()
{
ISequenceCache cache = SequenceService.Instance.CreateNewCache(Sequence.FilePath);
cache.Length = Sequence.Length;
cache.Interval = TimingSource.Interval;
Cache = cache;
}
public void SaveSequenceCacheFile(ISequenceCache sequence, string filePath)
{
filePath = _GetRootedPath(filePath, SequenceService.SequenceDirectory);
IObjectPersistor persistor = PersistorFactory.Instance.CreateSequenceCachePersister();
persistor.SaveToFile(sequence, filePath);
}
/// <summary>
/// Create a cache object for the given sequence path.
/// </summary>
/// <param name="filePath"></param>
/// <returns></returns>
public ISequenceCache CreateNewCache(string filePath)
{
ISequenceCache sequenceCache = _CreateSequenceCacheInstance(filePath);
if (sequenceCache != null)
{
sequenceCache.SequenceFilePath = filePath;
}
return(sequenceCache);
}
public object ReadContentFromObject(object obj)
{
ISequenceCache sequenceCache = obj as ISequenceCache;
if (sequenceCache == null)
{
throw new InvalidOperationException("Object must be an ISequenceCache.");
}
return(_GenerateSequenceCacheDataContent(sequenceCache));
}
public long GetSEQNextValue(String seqname, int step)
{
ISequenceCache seqCache = GetSequenceCache(seqname, step);
if (seqCache != null)
{
return(seqCache.GetNextValue());
}
else
{
return(-1);
}
}
public void SaveCache(ISequenceCache sequenceCache, string filePath)
{
if (sequenceCache == null)
{
throw new ArgumentNullException("sequenceCache");
}
if (string.IsNullOrWhiteSpace(filePath))
{
throw new InvalidOperationException("File path must be a file name or path.");
}
FileService.Instance.SaveSequenceCacheFile(sequenceCache, filePath);
}
public object LoadFromFile(string filePath)
{
if (filePath == null)
{
throw new InvalidOperationException("Cannot load from a null file path.");
}
if (!File.Exists(filePath))
{
throw new InvalidOperationException("File does not exist.");
}
IFileReader fileReader = FileReaderFactory.Instance.CreateBinaryFileReader();
if (fileReader == null)
{
return(null);
}
IObjectContentWriter contentWriter = ObjectContentWriterFactory.Instance.CreateSequenceCacheContentWriter(filePath);
if (contentWriter == null)
{
return(null);
}
ISequenceCache sequenceCache = SequenceService.Instance.CreateNewCache(filePath);
if (sequenceCache == null)
{
return(null);
}
object content = fileReader.ReadFile(sequenceCache.CacheFilePath);
if (content == null)
{
return(null);
}
var cacheContainer = new CacheContainer();
cacheContainer.SequenceCache = sequenceCache;
contentWriter.WriteContentToObject(content, cacheContainer);
return(cacheContainer.SequenceCache);
}
private byte[] _GenerateSequenceCacheDataContent(ISequenceCache sequenceCache)
{
byte[] cacheData;
var writer = new BinaryFormatter();
using (var stream = new MemoryStream())
{
try
{
writer.Serialize(stream,sequenceCache);
}
catch (Exception e)
{
Logging.ErrorException("Error serializing cache instance", e);
}
stream.Flush();
cacheData = stream.ToArray();
}
return cacheData;
}
private byte[] _GenerateSequenceCacheDataContent(ISequenceCache sequenceCache)
{
byte[] cacheData;
var writer = new BinaryFormatter();
using (var stream = new MemoryStream())
{
try
{
writer.Serialize(stream, sequenceCache);
}
catch (Exception e)
{
Logging.ErrorException("Error serializing cache instance", e);
}
stream.Flush();
cacheData = stream.ToArray();
}
return(cacheData);
}
private void _ReadHeader(BinaryReader reader, ISequenceCache sequenceCache)
{
sequenceCache.SequenceFilePath = reader.ReadString();
sequenceCache.Interval = reader.ReadInt32();
sequenceCache.Length = TimeSpan.FromMilliseconds(reader.ReadDouble());
}
private void _ReadHeader(BinaryReader reader, ISequenceCache sequenceCache)
{
sequenceCache.SequenceFilePath = reader.ReadString();
sequenceCache.Interval = reader.ReadInt32();
sequenceCache.Length = TimeSpan.FromMilliseconds(reader.ReadDouble());
}
public void SaveToFile(ISequenceCache obj, string filePath)
{
IFileWriter fileWriter = FileWriterFactory.CreateBinaryFileWriter();
IObjectContentReader contentReader = ObjectContentReaderFactory.Instance.CreateSequenceCacheContentReader(filePath);
ObjectPersistorService.Instance.SaveToFile(obj, fileWriter, contentReader, filePath);
}
public void SaveCache(ISequenceCache sequenceCache, string filePath)
{
if (sequenceCache == null) throw new ArgumentNullException("sequenceCache");
if (string.IsNullOrWhiteSpace(filePath))
throw new InvalidOperationException("File path must be a file name or path.");
FileService.Instance.SaveSequenceCacheFile(sequenceCache, filePath);
}
public void SaveSequenceCacheFile(ISequenceCache sequence, string filePath)
{
filePath = _GetRootedPath(filePath, SequenceService.SequenceDirectory);
IObjectPersistor persistor = PersistorFactory.Instance.CreateSequenceCachePersister();
persistor.SaveToFile(sequence, filePath);
}
