private ZipFileResultEntry[] SerializePerTable(SerializationSet serializationSet, DataRequest request)
{
var filteredMetaDataList = new List <SerializationSet>();
foreach (var table in serializationSet.Tables)
{
var filteredMetaData = serializationSet.Filter(table.Name);
filteredMetaData = ReplaceOptionProcessor.Process(filteredMetaData, request);
if (filteredMetaData.Tables.Any())
{
filteredMetaDataList.Add(filteredMetaData);
}
}
var entries = new List <ZipFileResultEntry>();
foreach (var dataSet in filteredMetaDataList)
{
var filename = $"{dataSet.Tables[0].Name}.{request.Ext}";
var serializationSetStream = new MemoryStream();
var serializer = this.GetDataSerializer(request.OutputType);
serializer.Serialize(serializationSetStream, dataSet);
entries.Add(new ZipFileResultEntry(filename, serializationSetStream));
}
return(entries.ToArray());
}
private void SerializeAll(SerializationSet metaData)
{
var serializer = this.GetDataSerializer(this.OutputType);
var filteredMetaData = ReplaceOptionProcessor.Process(metaData);
serializer.Serialize(this.Filename, filteredMetaData);
}
public SerializationSet Serialize(TagInfo tags, string filterExpression, bool isDevmode, long revision)
{
this.Dispatcher.VerifyAccess();
if (filterExpression == null)
{
throw new ArgumentNullException(nameof(filterExpression));
}
if (revision == -1)
{
var cacheKey = tags.ToString() + filterExpression;
if (isDevmode == false && this.caches.ContainsKey(cacheKey) == true)
{
return(this.caches[cacheKey]);
}
var dataSet = new SerializationSet()
{
Name = this.DataBaseName,
Revision = this.Revision,
};
var tableItems = this.ReadTables(isDevmode);
dataSet.Tables = tableItems.Cast <SerializationTable>().ToArray();
var typeItems = this.ReadTypes(isDevmode);
dataSet.Types = typeItems.Cast <SerializationType>().ToArray();
dataSet = dataSet.Filter(tags);
if (filterExpression != string.Empty)
{
dataSet = dataSet.Filter(filterExpression);
}
if (isDevmode == false)
{
this.caches[cacheKey] = dataSet;
}
return(dataSet);
}
else
{
var dataSet = this.DataBase.GetDataSet(this.authentication, revision);
var serializedSet = new SerializationSet(dataSet)
{
Name = this.DataBaseName,
Revision = this.Revision,
};
serializedSet = serializedSet.Filter(tags);
if (filterExpression != string.Empty)
{
serializedSet = serializedSet.Filter(filterExpression);
}
return(serializedSet);
}
}
public void Serialize(Stream stream, SerializationSet dataSet)
{
this.stringsIndex = 0;
var fileHeader = new BinaryFileHeader();
var tables = dataSet.Tables;
var tableIndexes = new List <BinaryTableIndex>(tables.Length);
var writer = new BinaryWriter(stream);
writer.WriteValue(fileHeader);
fileHeader.MagicValue = BinaryFileHeader.DefaultMagicValue;
fileHeader.IndexOffset = stream.Position;
writer.Seek(Marshal.SizeOf(typeof(BinaryTableIndex)) * tables.Length, SeekOrigin.Current);
fileHeader.TypesHashValue = this.GetStringID(dataSet.TypesHashValue);
fileHeader.TablesHashValue = this.GetStringID(dataSet.TablesHashValue);
fileHeader.Tags = this.GetStringID(dataSet.Tags.ToLower());
fileHeader.TablesOffset = stream.Position;
fileHeader.TableCount = tables.Length;
fileHeader.Revision = (int)dataSet.Revision;
fileHeader.Name = this.GetStringID(dataSet.Name);
var t = new Dictionary <string, Stream>();
tables.ToList().ForEach(item =>
{
var memory = new MemoryStream();
var formatter = new OrderedBinaryDataSerializer();
formatter.SerializeTable(memory, item, dataSet.Types);
memory.Position = 0;
lock (t)
{
t.Add(item.Name, memory);
}
});
foreach (var item in tables)
{
var tableIndex = new BinaryTableIndex()
{
TableName = this.GetStringID(item.Name),
Offset = stream.Position
};
tableIndexes.Add(tableIndex);
t[item.Name].CopyTo(stream);
}
fileHeader.StringResourcesOffset = stream.Position;
writer.WriteResourceStrings(this.strings.ToArray <int, string>());
writer.Seek(0, SeekOrigin.Begin);
writer.WriteValue(fileHeader);
writer.Seek((int)fileHeader.IndexOffset, SeekOrigin.Begin);
writer.WriteArray(tableIndexes.ToArray());
}
private Stream SerializeAll(SerializationSet serializationSet, DataRequest request)
{
var serializationSetStream = new MemoryStream();
var serializer = this.GetDataSerializer(request.OutputType);
serializer.Serialize(serializationSetStream, serializationSet);
return(serializationSetStream);
}
private void Serialize(SerializationSet metaData)
{
if (DataSplitSetting.Split)
{
this.SerializePerTable(metaData);
}
else
{
this.SerializeAll(metaData);
}
}
private IDataSet GetSerializedDataSet(SerializationSet generationData)
{
var serializer = this.fixture.CremaHost.GetService <IEnumerable <IDataSerializer> >().First(o => o.Name == "bin");
var ms = new MemoryStream();
serializer.Serialize(ms, generationData);
ms.Position = 0;
var dataSet = CremaReader.Read(ms);
return(dataSet);
}
public static SerializationSetResponse ConvertFrom(SerializationSet serializationSet)
{
return(new SerializationSetResponse
{
Name = serializationSet.Name,
Tags = serializationSet.Tags,
Revision = serializationSet.Revision,
TypesHashValue = serializationSet.TypesHashValue,
TablesHashValue = serializationSet.TablesHashValue,
Types = serializationSet.Types.Select(SerializationTypeResponse.ConvertFrom).ToArray(),
Tables = serializationSet.Tables.Select(SerializationTableResponse.ConvertFrom).ToArray()
});
}
public static SerializationSet Process(SerializationSet serializationSet)
{
if (ReplaceSettings.ReplaceRevision != long.MinValue)
{
serializationSet.Revision = ReplaceSettings.ReplaceRevision;
}
if (ReplaceSettings.ReplaceHashValue != null)
{
serializationSet.TablesHashValue = ReplaceSettings.ReplaceHashValue;
serializationSet.TypesHashValue = ReplaceSettings.ReplaceHashValue;
}
return(serializationSet);
}
public static SerializationSet Process(SerializationSet serializationSet, DataRequest request)
{
if (request.ReplaceRevision != null)
{
serializationSet.Revision = request.ReplaceRevision ?? -1;
}
if (request.ReplaceHashValue != null)
{
serializationSet.TablesHashValue = request.ReplaceHashValue;
serializationSet.TypesHashValue = request.ReplaceHashValue;
}
return(serializationSet);
}
private void SerializePerTable(SerializationSet metaData)
{
var filteredMetaDataList = new List <SerializationSet>();
foreach (var table in metaData.Tables)
{
var filteredMetaData = metaData.Filter(table.Name);
filteredMetaData = ReplaceOptionProcessor.Process(filteredMetaData);
if (filteredMetaData.Tables.Any())
{
filteredMetaDataList.Add(filteredMetaData);
}
}
foreach (var dataSet in filteredMetaDataList)
{
var filepath = Path.Combine(this.Filename, $"{dataSet.Tables[0].Name}.{DataSplitSetting.Ext}");
var serializer = this.GetDataSerializer(this.OutputType);
serializer.Serialize(filepath, dataSet);
}
}
