/// <inheritdoc />
protected override void OnFrameApply(ImageFrame <TPixel> source)
{
var interest = Rectangle.Intersect(this.SourceRectangle, source.Bounds());
// We need a clean copy for each pass to start from
using ImageFrame <TPixel> cleanCopy = source.Clone();
using (var processor = new ConvolutionProcessor <TPixel>(this.Configuration, in this.kernels[0], true, this.Source, interest))
{
processor.Apply(source);
}
if (this.kernels.Length == 1)
{
return;
}
// Additional runs
for (int i = 1; i < this.kernels.Length; i++)
{
using ImageFrame <TPixel> pass = cleanCopy.Clone();
using (var processor = new ConvolutionProcessor <TPixel>(this.Configuration, in this.kernels[i], true, this.Source, interest))
{
processor.Apply(pass);
}
var operation = new RowOperation(source.PixelBuffer, pass.PixelBuffer, interest);
ParallelRowIterator.IterateRows(
this.Configuration,
interest,
in operation);
}
}
private void OperateOnSubmitRange(RowOperation operation, IEnumerable <TEntity> entities)
{
foreach (var entity in entities)
{
OperateOnSubmit(operation, entity);
}
}
internal void SetPrincipalOperation(RowOperation operation)
{
if (this.Operation < operation)
{
this.Operation = operation;
}
}
/// <inheritdoc/>
protected override void OnFrameApply(ImageFrame <TPixel> source)
{
TPixel glowColor = this.definition.GlowColor.ToPixel <TPixel>();
float blendPercent = this.definition.GraphicsOptions.BlendPercentage;
var interest = Rectangle.Intersect(this.SourceRectangle, source.Bounds());
Vector2 center = Rectangle.Center(interest);
float finalRadius = this.definition.Radius.Calculate(interest.Size);
float maxDistance = finalRadius > 0
? MathF.Min(finalRadius, interest.Width * .5F)
: interest.Width * .5F;
Configuration configuration = this.Configuration;
MemoryAllocator allocator = configuration.MemoryAllocator;
using IMemoryOwner <TPixel> rowColors = allocator.Allocate <TPixel>(interest.Width);
rowColors.GetSpan().Fill(glowColor);
var operation = new RowOperation(configuration, interest, rowColors, this.blender, center, maxDistance, blendPercent, source);
ParallelRowIterator.IterateRows <RowOperation, float>(
configuration,
interest,
in operation);
}
/// <summary>
/// Swaps the image at the Y-axis, which goes vertically through the middle at half of the width of the image.
/// </summary>
/// <param name="source">The source image to apply the process to.</param>
/// <param name="configuration">The configuration.</param>
private void FlipY(ImageFrame <TPixel> source, Configuration configuration)
{
var operation = new RowOperation(source);
ParallelRowIterator.IterateRows(
configuration,
source.Bounds(),
in operation);
}
/// <inheritdoc/>
protected override void OnFrameApply(ImageFrame <TPixel> source)
{
var interest = Rectangle.Intersect(this.SourceRectangle, source.Bounds());
var operation = new RowOperation(interest.X, source, this.definition.Matrix, this.Configuration);
ParallelRowIterator.IterateRows <RowOperation, Vector4>(
this.Configuration,
interest,
in operation);
}
/// <summary>
/// Creates a shallow copy of a row from another row.
/// </summary>
/// <param name="source">The row the data is copied from.</param>
protected Row(Row source)
{
this.table = source.table;
this.tableDefinition = source.tableDefinition;
this.rowNumber = source.rowNumber;
this.operation = source.operation;
this.sectionId = source.sectionId;
this.sourceLineNumbers = source.sourceLineNumbers;
this.fields = source.fields;
this.symbol = source.symbol;
}
/// <summary>
/// Executa ação definida para o registro no objeto de destino
/// </summary>
/// <param name="rowOp">Operação que deverás er executada</param>
/// <param name="transformedRow">Linha que foi transformada</param>
public void ProcessTransformedRow(RowOperation rowOp, DictionaryRow transformedRow)
{
if (this.RowBeforeProcess != null)
{
this.RowBeforeProcess(transformedRow, rowOp);
}
try
{
switch (rowOp)
{
case RowOperation.Process:
_dest.Process(transformedRow);
break;
case RowOperation.Insert:
_dest.Insert(transformedRow);
break;
case RowOperation.Update:
_dest.Update(transformedRow);
break;
case RowOperation.Delete:
_dest.Delete(transformedRow);
break;
}
if (this.RowSuccess != null && rowOp != RowOperation.Ignore)
{
this.RowSuccess(transformedRow, rowOp);
}
}
catch (Exception exRow)
{
if (this.RowError != null)
{
this.RowError(transformedRow, rowOp, exRow);
}
else
{
throw exRow;
}
}
if (this.RowAfterProcess != null)
{
this.RowAfterProcess(transformedRow, rowOp);
}
}
private void OperateOnSubmit(RowOperation operation, TEntity entity)
{
SqlMaker gen = this.Generator;
var dict = broker.ToDictionary(entity);
gen.AddRange(dict);
string sql = null;
switch (operation)
{
case RowOperation.Insert:
sql = gen.Insert();
break;
case RowOperation.Update:
sql = gen.Update();
break;
case RowOperation.InsertOrUpdate:
sql = gen.InsertOrUpdate();
break;
case RowOperation.Delete:
sql = gen.Delete();
break;
}
if (sql == null)
{
return;
}
Context.CodeBlock.AppendLine <TEntity>(sql);
var evt = new RowEvent
{
TypeName = typeof(TEntity).Name,
Operation = operation,
Row = gen.ToDictionary(),
};
Context.RowEvents.Add(evt);
gen.Clear();
}
/// <inheritdoc/>
protected override void OnFrameApply(ImageFrame <TPixel> source)
{
byte threshold = (byte)MathF.Round(this.definition.Threshold * 255F);
TPixel upper = this.definition.UpperColor.ToPixel <TPixel>();
TPixel lower = this.definition.LowerColor.ToPixel <TPixel>();
Rectangle sourceRectangle = this.SourceRectangle;
Configuration configuration = this.Configuration;
var interest = Rectangle.Intersect(sourceRectangle, source.Bounds());
bool isAlphaOnly = typeof(TPixel) == typeof(A8);
var operation = new RowOperation(interest, source, upper, lower, threshold, isAlphaOnly);
ParallelRowIterator.IterateRows(
configuration,
interest,
in operation);
}
/// <summary>
/// Indica que está no contexto de transformação do objeto
/// </summary>
/// <param name="context">Contexto de transformação</param>
/// <param name="action">Ação que será executada para a transformação</param>
protected override void InTransformContext(Unimake.ETL.ITransform context, System.Action action)
{
ObjectResult = new T();
foreach (var inputRow in context.Source.Rows)
{
RowValidation rowValidation = new RowValidation();
context.DoRowValidation(inputRow, rowValidation);
if (rowValidation.HasErrors)
{
context.RaiseRowInvalid(inputRow, rowValidation);
}
else
{
RowOperation rowOp = context.GetRowOperation(inputRow);
if (rowOp != RowOperation.Ignore)
{
DictionaryRow transformedRow = new DictionaryRow();
foreach (var mapping in context.TransformMap)
{
object rowValue = inputRow[mapping.Key];
Func <object, object> transformFunc;
if (context.TransformFuncs.TryGetValue(mapping.Key, out transformFunc))
{
rowValue = transformFunc(rowValue);
}
transformedRow[mapping.Value] = rowValue;
//aqui temos que preencher o objeto com suas propriedades
SetValue(mapping, rowValue);
}
context.ProcessTransformedRow(rowOp, transformedRow);
}
}
}
}
/// <inheritdoc/>
protected override void OnFrameApply(ImageFrame <TPixelBg> source)
{
Rectangle sourceRectangle = this.SourceRectangle;
Configuration configuration = this.Configuration;
Image <TPixelFg> targetImage = this.Image;
PixelBlender <TPixelBg> blender = this.Blender;
int locationY = this.Location.Y;
// Align start/end positions.
Rectangle bounds = targetImage.Bounds();
int minX = Math.Max(this.Location.X, sourceRectangle.X);
int maxX = Math.Min(this.Location.X + bounds.Width, sourceRectangle.Right);
int targetX = minX - this.Location.X;
int minY = Math.Max(this.Location.Y, sourceRectangle.Y);
int maxY = Math.Min(this.Location.Y + bounds.Height, sourceRectangle.Bottom);
int width = maxX - minX;
var workingRect = Rectangle.FromLTRB(minX, minY, maxX, maxY);
// Not a valid operation because rectangle does not overlap with this image.
if (workingRect.Width <= 0 || workingRect.Height <= 0)
{
throw new ImageProcessingException(
"Cannot draw image because the source image does not overlap the target image.");
}
var operation = new RowOperation(source, targetImage, blender, configuration, minX, width, locationY, targetX, this.Opacity);
ParallelRowIterator.IterateRows(
configuration,
workingRect,
in operation);
}
private KuduOperation NewOperation(RowOperation rowOperation)
{
return(new KuduOperation(this, rowOperation));
}
private Row CompareRows(Table targetTable, Row targetRow, Row updatedRow, out RowOperation operation, out bool keepRow)
{
Row comparedRow = null;
keepRow = false;
operation = RowOperation.None;
if (null == targetRow ^ null == updatedRow)
{
if (null == targetRow)
{
operation = updatedRow.Operation = RowOperation.Add;
comparedRow = updatedRow;
}
else if (null == updatedRow)
{
operation = targetRow.Operation = RowOperation.Delete;
targetRow.SectionId = targetRow.SectionId + sectionDelimiter;
comparedRow = targetRow;
keepRow = true;
}
}
else // possibly modified
{
updatedRow.Operation = RowOperation.None;
if (!this.suppressKeepingSpecialRows && "_SummaryInformation" == targetTable.Name)
{
// ignore rows that shouldn't be in a transform
if (Enum.IsDefined(typeof(SummaryInformation.Transform), (int)updatedRow[0]))
{
updatedRow.SectionId = targetRow.SectionId + sectionDelimiter + updatedRow.SectionId;
comparedRow = updatedRow;
keepRow = true;
operation = RowOperation.Modify;
}
}
else
{
if (this.preserveUnchangedRows)
{
keepRow = true;
}
for (int i = 0; i < updatedRow.Fields.Length; i++)
{
ColumnDefinition columnDefinition = updatedRow.Fields[i].Column;
if (!columnDefinition.IsPrimaryKey)
{
bool modified = false;
if (i >= targetRow.Fields.Length)
{
columnDefinition.Added = true;
modified = true;
}
else if (ColumnType.Number == columnDefinition.Type && !columnDefinition.IsLocalizable)
{
if (null == targetRow[i] ^ null == updatedRow[i])
{
modified = true;
}
else if (null != targetRow[i] && null != updatedRow[i])
{
modified = ((int)targetRow[i] != (int)updatedRow[i]);
}
}
else if (ColumnType.Preserved == columnDefinition.Type)
{
updatedRow.Fields[i].PreviousData = (string)targetRow.Fields[i].Data;
// keep rows containing preserved fields so the historical data is available to the binder
keepRow = !this.suppressKeepingSpecialRows;
}
else if (ColumnType.Object == columnDefinition.Type)
{
ObjectField targetObjectField = (ObjectField)targetRow.Fields[i];
ObjectField updatedObjectField = (ObjectField)updatedRow.Fields[i];
updatedObjectField.PreviousCabinetFileId = targetObjectField.CabinetFileId;
updatedObjectField.PreviousBaseUri = targetObjectField.BaseUri;
// always keep a copy of the previous data even if they are identical
// This makes diff.wixmst clean and easier to control patch logic
updatedObjectField.PreviousData = (string)targetObjectField.Data;
// always remember the unresolved data for target build
updatedObjectField.UnresolvedPreviousData = (string)targetObjectField.UnresolvedData;
// keep rows containing object fields so the files can be compared in the binder
keepRow = !this.suppressKeepingSpecialRows;
}
else
{
modified = ((string)targetRow[i] != (string)updatedRow[i]);
}
if (modified)
{
if (null != updatedRow.Fields[i].PreviousData)
{
updatedRow.Fields[i].PreviousData = targetRow.Fields[i].Data.ToString();
}
updatedRow.Fields[i].Modified = true;
operation = updatedRow.Operation = RowOperation.Modify;
keepRow = true;
}
}
}
if (keepRow)
{
comparedRow = updatedRow;
comparedRow.SectionId = targetRow.SectionId + sectionDelimiter + updatedRow.SectionId;
}
}
}
return comparedRow;
}
internal PartialRowOperation(PartialRowOperation row, RowOperation operation)
: base(row)
{
Operation = operation;
}
/// <summary>
/// Executa o processo de transformação do objeto e retorna o resultado transformado
/// </summary>
/// <returns></returns>
public Transform Execute()
{
if (TransformMap.Count == 0)
{
throw new InvalidOperationException("No mappings defined.");
}
if (this.Start != null)
{
this.Start(this);
}
try
{
Source.InTransformContext(this, () =>
{
_dest.InTransformContext(this, () =>
{
foreach (var inputRow in Source.Rows)
{
RowValidation rowValidation = new RowValidation();
DoRowValidation(inputRow, rowValidation);
if (rowValidation.HasErrors)
{
if (this.RowInvalid != null)
{
this.RowInvalid(inputRow, rowValidation);
}
}
else
{
RowOperation rowOp = this.GetRowOperation(inputRow);
if (rowOp != RowOperation.Ignore)
{
DictionaryRow transformedRow = new DictionaryRow();
foreach (var mapping in TransformMap)
{
object rowValue = inputRow[mapping.Key];
Func <object, object> transformFunc;
if (TransformFuncs.TryGetValue(mapping.Key, out transformFunc))
{
rowValue = transformFunc(rowValue);
}
transformedRow[mapping.Value] = rowValue;
}
ProcessTransformedRow(rowOp, transformedRow);
}
}
}
});
});
}
catch (Exception exTransform)
{
if (this.Error != null)
{
this.Error(this, exTransform);
}
else
{
throw exTransform;
}
}
if (this.Complete != null)
{
this.Complete(this);
}
return(this);
}
/// <summary>
/// Creates a Row from the XmlReader.
/// </summary>
/// <param name="reader">Reader to get data from.</param>
/// <param name="table">Table for this row.</param>
/// <returns>New row object.</returns>
internal static Row Parse(XmlReader reader, Table table)
{
Debug.Assert("row" == reader.LocalName);
bool empty = reader.IsEmptyElement;
RowOperation operation = RowOperation.None;
string sectionId = null;
SourceLineNumberCollection sourceLineNumbers = null;
while (reader.MoveToNextAttribute())
{
switch (reader.LocalName)
{
case "op":
switch (reader.Value)
{
case "add":
operation = RowOperation.Add;
break;
case "delete":
operation = RowOperation.Delete;
break;
case "modify":
operation = RowOperation.Modify;
break;
default:
throw new WixException(WixErrors.IllegalAttributeValue(SourceLineNumberCollection.FromUri(reader.BaseURI), "row", reader.Name, reader.Value, "Add", "Delete", "Modify"));
}
break;
case "sectionId":
sectionId = reader.Value;
break;
case "sourceLineNumber":
sourceLineNumbers = new SourceLineNumberCollection(reader.Value);
break;
default:
if (!reader.NamespaceURI.StartsWith("http://www.w3.org/", StringComparison.Ordinal))
{
throw new WixException(WixErrors.UnexpectedAttribute(SourceLineNumberCollection.FromUri(reader.BaseURI), "row", reader.Name));
}
break;
}
}
Row row = table.CreateRow(sourceLineNumbers);
row.Operation = operation;
row.SectionId = sectionId;
// loop through all the fields in a row
if (!empty)
{
bool done = false;
int field = 0;
// loop through all the fields in a row
while (!done && reader.Read())
{
switch (reader.NodeType)
{
case XmlNodeType.Element:
switch (reader.LocalName)
{
case "field":
if (row.Fields.Length <= field)
{
if (!reader.IsEmptyElement)
{
throw new WixException(WixErrors.UnexpectedColumnCount(SourceLineNumberCollection.FromUri(reader.BaseURI), table.Name));
}
}
else
{
row.fields[field].Parse(reader);
}
++field;
break;
default:
throw new WixException(WixErrors.UnexpectedElement(SourceLineNumberCollection.FromUri(reader.BaseURI), "row", reader.Name));
}
break;
case XmlNodeType.EndElement:
done = true;
break;
}
}
if (!done)
{
throw new WixException(WixErrors.ExpectedEndElement(SourceLineNumberCollection.FromUri(reader.BaseURI), "row"));
}
}
return row;
}
/// <summary>
/// Creates a shallow copy of a row from another row.
/// </summary>
/// <param name="source">The row the data is copied from.</param>
protected Row(Row source)
{
this.table = source.table;
this.tableDefinition = source.tableDefinition;
this.rowNumber = source.rowNumber;
this.operation = source.operation;
this.sectionId = source.sectionId;
this.sourceLineNumbers = source.sourceLineNumbers;
this.fields = source.fields;
this.symbol = source.symbol;
}
public PartialRowOperation(KuduSchema schema, RowOperation operation)
: base(schema)
{
Operation = operation;
}
private Row CompareRows(Table targetTable, Row targetRow, Row updatedRow, out RowOperation operation, out bool keepRow)
{
Row comparedRow = null;
keepRow = false;
operation = RowOperation.None;
if (null == targetRow ^ null == updatedRow)
{
if (null == targetRow)
{
operation = updatedRow.Operation = RowOperation.Add;
comparedRow = updatedRow;
}
else if (null == updatedRow)
{
operation = targetRow.Operation = RowOperation.Delete;
targetRow.SectionId = targetRow.SectionId + sectionDelimiter;
comparedRow = targetRow;
keepRow = true;
}
}
else // possibly modified
{
updatedRow.Operation = RowOperation.None;
if (!this.suppressKeepingSpecialRows && "_SummaryInformation" == targetTable.Name)
{
// ignore rows that shouldn't be in a transform
if (Enum.IsDefined(typeof(SummaryInformation.Transform), (int)updatedRow[0]))
{
updatedRow.SectionId = targetRow.SectionId + sectionDelimiter + updatedRow.SectionId;
comparedRow = updatedRow;
keepRow = true;
operation = RowOperation.Modify;
}
}
else
{
if (this.preserveUnchangedRows)
{
keepRow = true;
}
for (int i = 0; i < updatedRow.Fields.Length; i++)
{
ColumnDefinition columnDefinition = updatedRow.Fields[i].Column;
if (!columnDefinition.IsPrimaryKey)
{
bool modified = false;
if (i >= targetRow.Fields.Length)
{
columnDefinition.Added = true;
modified = true;
}
else if (ColumnType.Number == columnDefinition.Type && !columnDefinition.IsLocalizable)
{
if (null == targetRow[i] ^ null == updatedRow[i])
{
modified = true;
}
else if (null != targetRow[i] && null != updatedRow[i])
{
modified = ((int)targetRow[i] != (int)updatedRow[i]);
}
}
else if (ColumnType.Preserved == columnDefinition.Type)
{
updatedRow.Fields[i].PreviousData = (string)targetRow.Fields[i].Data;
// keep rows containing preserved fields so the historical data is available to the binder
keepRow = !this.suppressKeepingSpecialRows;
}
else if (ColumnType.Object == columnDefinition.Type)
{
ObjectField targetObjectField = (ObjectField)targetRow.Fields[i];
ObjectField updatedObjectField = (ObjectField)updatedRow.Fields[i];
updatedObjectField.PreviousCabinetFileId = targetObjectField.CabinetFileId;
updatedObjectField.PreviousBaseUri = targetObjectField.BaseUri;
// always keep a copy of the previous data even if they are identical
// This makes diff.wixmst clean and easier to control patch logic
updatedObjectField.PreviousData = (string)targetObjectField.Data;
// always remember the unresolved data for target build
updatedObjectField.UnresolvedPreviousData = (string)targetObjectField.UnresolvedData;
// keep rows containing object fields so the files can be compared in the binder
keepRow = !this.suppressKeepingSpecialRows;
}
else
{
modified = ((string)targetRow[i] != (string)updatedRow[i]);
}
if (modified)
{
if (null != updatedRow.Fields[i].PreviousData)
{
updatedRow.Fields[i].PreviousData = targetRow.Fields[i].Data.ToString();
}
updatedRow.Fields[i].Modified = true;
operation = updatedRow.Operation = RowOperation.Modify;
keepRow = true;
}
}
}
if (keepRow)
{
comparedRow = updatedRow;
comparedRow.SectionId = targetRow.SectionId + sectionDelimiter + updatedRow.SectionId;
}
}
}
return(comparedRow);
}
private RowCollection CompareTables(Output targetOutput, Table targetTable, Table updatedTable, out TableOperation operation)
{
RowCollection rows = new RowCollection();
operation = TableOperation.None;
// dropped tables
if (null == updatedTable ^ null == targetTable)
{
if (null == targetTable)
{
operation = TableOperation.Add;
rows.AddRange(updatedTable.Rows);
}
else if (null == updatedTable)
{
operation = TableOperation.Drop;
}
}
else // possibly modified tables
{
SortedList updatedPrimaryKeys = new SortedList();
SortedList targetPrimaryKeys = new SortedList();
// compare the table definitions
if (0 != targetTable.Definition.CompareTo(updatedTable.Definition))
{
// continue to the next table; may be more mismatches
this.OnMessage(WixErrors.DatabaseSchemaMismatch(targetOutput.SourceLineNumbers, targetTable.Name));
}
else
{
this.IndexPrimaryKeys(targetTable, targetPrimaryKeys, updatedTable, updatedPrimaryKeys);
// diff the target and updated rows
foreach (DictionaryEntry targetPrimaryKeyEntry in targetPrimaryKeys)
{
string targetPrimaryKey = (string)targetPrimaryKeyEntry.Key;
bool keepRow = false;
RowOperation rowOperation = RowOperation.None;
Row compared = this.CompareRows(targetTable, targetPrimaryKeyEntry.Value as Row, updatedPrimaryKeys[targetPrimaryKey] as Row, out rowOperation, out keepRow);
if (keepRow)
{
rows.Add(compared);
}
}
// find the inserted rows
foreach (DictionaryEntry updatedPrimaryKeyEntry in updatedPrimaryKeys)
{
string updatedPrimaryKey = (string)updatedPrimaryKeyEntry.Key;
if (!targetPrimaryKeys.Contains(updatedPrimaryKey))
{
Row updatedRow = (Row)updatedPrimaryKeyEntry.Value;
updatedRow.Operation = RowOperation.Add;
updatedRow.SectionId = sectionDelimiter + updatedRow.SectionId;
rows.Add(updatedRow);
}
}
}
}
return(rows);
}
/// <summary>
/// Creates a Row from the XmlReader.
/// </summary>
/// <param name="reader">Reader to get data from.</param>
/// <param name="table">Table for this row.</param>
/// <returns>New row object.</returns>
internal static Row Read(XmlReader reader, Table table)
{
Debug.Assert("row" == reader.LocalName);
bool empty = reader.IsEmptyElement;
RowOperation operation = RowOperation.None;
bool redundant = false;
string sectionId = null;
SourceLineNumber sourceLineNumbers = null;
while (reader.MoveToNextAttribute())
{
switch (reader.LocalName)
{
case "op":
operation = (RowOperation)Enum.Parse(typeof(RowOperation), reader.Value, true);
break;
case "redundant":
redundant = reader.Value.Equals("yes");
break;
case "sectionId":
sectionId = reader.Value;
break;
case "sourceLineNumber":
sourceLineNumbers = SourceLineNumber.CreateFromEncoded(reader.Value);
break;
}
}
var row = table.CreateRow(sourceLineNumbers);
row.Operation = operation;
row.Redundant = redundant;
row.SectionId = sectionId;
// loop through all the fields in a row
if (!empty)
{
var done = false;
var field = 0;
// loop through all the fields in a row
while (!done && reader.Read())
{
switch (reader.NodeType)
{
case XmlNodeType.Element:
switch (reader.LocalName)
{
case "field":
if (row.Fields.Length <= field)
{
if (!reader.IsEmptyElement)
{
throw new XmlException();
}
}
else
{
row.Fields[field].Read(reader);
}
++field;
break;
default:
throw new XmlException();
}
break;
case XmlNodeType.EndElement:
done = true;
break;
}
}
if (!done)
{
throw new XmlException();
}
}
return(row);
}
public MutationState(int key, RowOperation endType, int minMutations)
{
Key = key;
EndType = endType;
MinMutations = minMutations;
}
/// <summary>
/// Creates a Row from the XmlReader.
/// </summary>
/// <param name="reader">Reader to get data from.</param>
/// <param name="table">Table for this row.</param>
/// <returns>New row object.</returns>
internal static Row Parse(XmlReader reader, Table table)
{
Debug.Assert("row" == reader.LocalName);
bool empty = reader.IsEmptyElement;
RowOperation operation = RowOperation.None;
string sectionId = null;
SourceLineNumberCollection sourceLineNumbers = null;
while (reader.MoveToNextAttribute())
{
switch (reader.LocalName)
{
case "op":
switch (reader.Value)
{
case "add":
operation = RowOperation.Add;
break;
case "delete":
operation = RowOperation.Delete;
break;
case "modify":
operation = RowOperation.Modify;
break;
default:
throw new WixException(WixErrors.IllegalAttributeValue(SourceLineNumberCollection.FromUri(reader.BaseURI), "row", reader.Name, reader.Value, "Add", "Delete", "Modify"));
}
break;
case "sectionId":
sectionId = reader.Value;
break;
case "sourceLineNumber":
sourceLineNumbers = new SourceLineNumberCollection(reader.Value);
break;
default:
if (!reader.NamespaceURI.StartsWith("http://www.w3.org/", StringComparison.Ordinal))
{
throw new WixException(WixErrors.UnexpectedAttribute(SourceLineNumberCollection.FromUri(reader.BaseURI), "row", reader.Name));
}
break;
}
}
Row row = table.CreateRow(sourceLineNumbers);
row.Operation = operation;
row.SectionId = sectionId;
// loop through all the fields in a row
if (!empty)
{
bool done = false;
int field = 0;
// loop through all the fields in a row
while (!done && reader.Read())
{
switch (reader.NodeType)
{
case XmlNodeType.Element:
switch (reader.LocalName)
{
case "field":
if (row.Fields.Length <= field)
{
if (!reader.IsEmptyElement)
{
throw new WixException(WixErrors.UnexpectedColumnCount(SourceLineNumberCollection.FromUri(reader.BaseURI), table.Name));
}
}
else
{
row.fields[field].Parse(reader);
}
++field;
break;
default:
throw new WixException(WixErrors.UnexpectedElement(SourceLineNumberCollection.FromUri(reader.BaseURI), "row", reader.Name));
}
break;
case XmlNodeType.EndElement:
done = true;
break;
}
}
if (!done)
{
throw new WixException(WixErrors.ExpectedEndElement(SourceLineNumberCollection.FromUri(reader.BaseURI), "row"));
}
}
return(row);
}
public KuduOperation(KuduTable table, RowOperation operation)
: base(table.Schema, operation)
{
Table = table;
}
