public void Merge(IMergeable next)
{
var nextRange = next as LongitudinalStairExcav;
StairArea += nextRange.StairArea;
EndStation = nextRange.EndStation;
}
public int Merge <TTarget, TSource>(DataConnection dataConnection, IMergeable <TTarget, TSource> merge)
where TTarget : class
where TSource : class
{
if (dataConnection == null)
{
throw new ArgumentNullException(nameof(dataConnection));
}
if (merge == null)
{
throw new ArgumentNullException(nameof(merge));
}
var builder = GetMergeBuilder(dataConnection, merge);
builder.Validate();
var cmd = builder.BuildCommand();
if (builder.NoopCommand)
{
return(0);
}
return(dataConnection.Execute(cmd, builder.Parameters));
}
/// <summary>
/// Executes merge command and returns total number of target records, affected by merge operations.
/// </summary>
/// <typeparam name="TTarget">Target record type.</typeparam>
/// <typeparam name="TSource">Source record type.</typeparam>
/// <param name="merge">Merge command definition.</param>
/// <returns>Returns number of target table records, affected by merge comand.</returns>
public static int Merge <TTarget, TSource>(this IMergeable <TTarget, TSource> merge)
where TTarget : class
where TSource : class
{
if (merge == null)
{
throw new ArgumentNullException("merge");
}
var definition = (MergeDefinition <TTarget, TSource>)merge;
DataConnection dataConnection;
if (definition.Target.DataContext is DataConnection)
{
dataConnection = (DataConnection)definition.Target.DataContext;
}
else if (definition.Target.DataContext is DataContext)
{
dataConnection = ((DataContext)definition.Target.DataContext).GetDataConnection();
}
else
{
throw new ArgumentException("DataContext must be of DataConnection or DataContext type.");
}
return(dataConnection.DataProvider.Merge(dataConnection, definition));
}
public void Merge(IMergeable toBeMerged)
{
if (toBeMerged is SelectionRule selectionRule)
{
Merge(selectionRule);
}
}
/// <summary>
/// Executes merge command and returns total number of target records, affected by merge operations.
/// </summary>
/// <typeparam name="TTarget">Target record type.</typeparam>
/// <typeparam name="TSource">Source record type.</typeparam>
/// <param name="merge">Merge command definition.</param>
/// <returns>Returns number of target table records, affected by merge comand.</returns>
public async static Task <int> MergeAsync <TTarget, TSource>(
this IMergeable <TTarget, TSource> merge,
CancellationToken token = default(CancellationToken))
where TTarget : class
where TSource : class
{
if (merge == null)
{
throw new ArgumentNullException("merge");
}
var definition = (MergeDefinition <TTarget, TSource>)merge;
DataConnection dataConnection;
if (definition.Target.DataContext is DataConnection)
{
dataConnection = (DataConnection)definition.Target.DataContext;
}
else if (definition.Target.DataContext is DataContext)
{
dataConnection = ((DataContext)definition.Target.DataContext).GetDataConnection();
}
else
{
throw new ArgumentException("DataContext must be of DataConnection or DataContext type.");
}
return(await dataConnection.DataProvider.MergeAsync(dataConnection, definition, token));
}
/// <summary>
/// Executes merge command and returns total number of target records, affected by merge operations.
/// </summary>
/// <typeparam name="TTarget">Target record type.</typeparam>
/// <typeparam name="TSource">Source record type.</typeparam>
/// <param name="merge">Merge command definition.</param>
/// <param name="token">Asynchronous operation cancellation token.</param>
/// <returns>Returns number of target table records, affected by merge comand.</returns>
public static async Task <int> MergeAsync <TTarget, TSource>(
this IMergeable <TTarget, TSource> merge,
CancellationToken token = default)
where TTarget : class
where TSource : class
{
if (merge == null)
{
throw new ArgumentNullException(nameof(merge));
}
var definition = (MergeDefinition <TTarget, TSource>)merge;
DataConnection dataConnection;
switch (definition.Target.DataContext)
{
case DataConnection dcon: dataConnection = dcon; break;
case DataContext dctx: dataConnection = dctx.GetDataConnection(); break;
default:
throw new ArgumentException("DataContext must be of DataConnection or DataContext type.");
}
return(await dataConnection.DataProvider.MergeAsync(dataConnection, definition, token));
}
//
public override void Merge(IMergeable connectedHalf)
{
var conn = (FillCutIntersects)connectedHalf;
// var dist1 = Math.Abs(ParentStation - EdgeStation);
// var dist2 = Math.Abs(conn.EdgeStation - conn.ParentStation);
// TreatedArea = (conn.TreatedArea * dist2 + TreatedArea * dist1) / (dist1 + dist2);
}
/// <summary> 两个相邻区间是否可以合并到同一行 </summary>
/// <param name="next">与本区间紧密相连的下一个区间</param>
public override bool IsMergeable(IMergeable next)
{
var front = next as FillCutIntersects;
// 处理位置不同的区间要分开
// if (StairCutSide != front.StairCutSide) return false;
return(true);
}
protected virtual BasicMergeBuilder <TTarget, TSource> GetMergeBuilder <TTarget, TSource>(
DataConnection connection,
IMergeable <TTarget, TSource> merge)
where TTarget : class
where TSource : class
{
return(new UnsupportedMergeBuilder <TTarget, TSource>(connection, merge));
}
//
public override void Merge(IMergeable connectedHalf)
{
var conn = connectedHalf as ThinFillShallowCut;
var dist1 = Math.Abs(ParentStation - EdgeStation);
var dist2 = Math.Abs(conn.EdgeStation - conn.ParentStation);
AverageWidth = (conn.AverageWidth * dist2 + AverageWidth * dist1) / (dist1 + dist2);
AverageHeight = (conn.AverageHeight * dist2 + AverageHeight * dist1) / (dist1 + dist2);
}
//
public override void Merge(IMergeable connectedHalf)
{
var conn = connectedHalf as SubstitutedSoil;
//var dist1 = Math.Abs(ParentStation - EdgeStation);
//var dist2 = Math.Abs(conn.EdgeStation - conn.ParentStation);
TreatedSurfaceArea = (conn.TreatedSurfaceArea + TreatedSurfaceArea);
}
//
public override void Merge(IMergeable connectedHalf)
{
var conn = (SteepSlope)connectedHalf;
var dist1 = Math.Abs(ParentStation - EdgeStation);
var dist2 = Math.Abs(conn.EdgeStation - conn.ParentStation);
AverageTreatedWidth = (conn.AverageTreatedWidth * dist2 + AverageTreatedWidth * dist1) / (dist1 + dist2);
AverageStairArea = (conn.AverageStairArea * dist2 + AverageStairArea * dist1) / (dist1 + dist2);
}
/// <summary> 两个相邻区间是否可以合并到同一行 </summary>
/// <param name="next">与本区间紧密相连的下一个区间</param>
public override bool IsMergeable(IMergeable next)
{
var front = next as RoadSurface;
if (FillOrSoilCut != front.FillOrSoilCut)
{
return(false);
}
return(true);
}
/// <summary> 两个相邻区间是否可以合并到同一行 </summary>
/// <param name="next">与本区间紧密相连的下一个区间</param>
public override bool IsMergeable(IMergeable next)
{
var front = next as StairsExcav;
// 处理位置不同的区间要分开
if (StairCutSide != front.StairCutSide)
{
return(false);
}
return(true);
}
/// <summary> 两个相邻区间是否可以合并到同一行 </summary>
/// <param name="next">与本区间紧密相连的下一个区间</param>
public override bool IsMergeable(IMergeable next)
{
// 不进行合并
return(false);
var front = next as HardShoulder;
if (LeftType != front.LeftType)
{
return(false);
}
}
bool Merge(SharedDictionaryEntry e)
{
SharedDictionaryEntry result;
if (_values.TryGetValue(e, out result))
{
IMergeable existing = result.Value as IMergeable;
if (existing != null)
{
return(existing.Merge(e.Value));
}
}
return(false);
}
/// <summary>
/// Merges this object with another.
/// </summary>
/// <param name="obj"></param>
public virtual void MergeWith(IMergeable obj)
{
var c = obj as IICalendar;
if (c != null)
{
if (Name == null)
{
Name = c.Name;
}
foreach (ICalendarProperty p in c.Properties)
{
if (!Properties.ContainsKey(p.Name))
{
Properties.Add(p.Copy <ICalendarProperty>( ));
}
}
foreach (ICalendarObject child in c.Children)
{
var uniqueComponent = child as IUniqueComponent;
if (uniqueComponent != null)
{
IUniqueComponent component = UniqueComponents[uniqueComponent.Uid];
if (component == null)
{
this.AddChild(uniqueComponent.Copy <ICalendarObject>( ));
}
}
else
{
var timeZone = child as ITimeZone;
if (timeZone != null)
{
ITimeZone tz = GetTimeZone(timeZone.TzId);
if (tz == null)
{
this.AddChild(timeZone.Copy <ICalendarObject>( ));
}
}
else
{
this.AddChild(child.Copy <ICalendarObject>( ));
}
}
}
}
}
public virtual void MergeWith(IMergeable obj)
{
var fb = obj as IFreeBusy;
if (fb == null)
{
return;
}
foreach (var entry in fb.Entries.Where(entry => !Entries.Contains(entry)))
{
Entries.Add(entry);
}
}
public bool IsMergeable(IMergeable next)
{
var nextRange = next as LongitudinalStairExcav;
if ((nextRange.StartStation - EndStation > SQConstants.RangeMergeTolerance) ||
(StartStation - nextRange.EndStation > SQConstants.RangeMergeTolerance))
{
return(false);
}
else
{
return(true);
}
}
/// <summary>
/// Merges this object with another.
/// </summary>
/// <param name="obj"></param>
public void MergeWith(IMergeable obj)
{
var fb = obj as IFreeBusy;
if (fb != null)
{
foreach (IFreeBusyEntry entry in fb.Entries)
{
if (!Entries.Contains(entry))
{
Entries.Add(entry.Copy <IFreeBusyEntry>( ));
}
}
}
}
virtual public void MergeWith(IMergeable obj)
{
IICalendar c = obj as IICalendar;
if (c != null)
{
if (Name == null)
{
Name = c.Name;
}
Method = c.Method;
Version = c.Version;
ProductID = c.ProductID;
Scale = c.Scale;
foreach (ICalendarProperty p in c.Properties)
{
if (!Properties.ContainsKey(p.Name))
{
Properties.Add(p.Copy <ICalendarProperty>());
}
}
foreach (ICalendarObject child in c.Children)
{
if (child is IUniqueComponent)
{
if (!UniqueComponents.ContainsKey(((IUniqueComponent)child).UID))
{
AddChild(child.Copy <ICalendarObject>());
}
}
else if (child is ITimeZone)
{
ITimeZone tz = GetTimeZone(((ITimeZone)child).TZID);
if (tz == null)
{
AddChild(child.Copy <ICalendarObject>());
}
}
else
{
AddChild(child.Copy <ICalendarObject>());
}
}
}
}
/// <summary> 两个相邻区间是否可以合并到同一行 </summary>
/// <param name="next">与本区间紧密相连的下一个区间</param>
public override bool IsMergeable(IMergeable next)
{
var front = next as SteepSlope;
// 处理位置不同的区间要分开
if (Treatment != front.Treatment)
{
return(false);
}
// 有土工格栅与没有土工格栅的区间要分开
if ((Reinforcement == SectionSide.无 && front.Reinforcement != SectionSide.无) ||
(Reinforcement != SectionSide.无 && front.Reinforcement == SectionSide.无))
{
return(false);
}
return(true);
}
virtual public void MergeWith(IMergeable obj)
{
IICalendar c = obj as IICalendar;
if (c != null)
{
if (Name == null)
{
Name = c.Name;
}
foreach (ICalendarProperty p in c.Properties)
{
if (!Properties.ContainsKey(p.Name))
{
Properties.Add(p.Copy <ICalendarProperty>());
}
}
foreach (ICalendarObject child in c.Children)
{
if (child is IUniqueComponent)
{
var component = UniqueComponents[((IUniqueComponent)child).UID];
if (component == null)
{
this.AddChild(child.Copy <ICalendarObject>());
}
}
else if (child is ITimeZone)
{
ITimeZone tz = GetTimeZone(((ITimeZone)child).TZID);
if (tz == null)
{
this.AddChild(child.Copy <ICalendarObject>());
}
}
else
{
this.AddChild(child.Copy <ICalendarObject>());
}
}
}
}
public virtual void MergeWith(IMergeable obj)
{
var c = obj as Calendar;
if (c == null)
{
return;
}
if (Name == null)
{
Name = c.Name;
}
Method = c.Method;
Version = c.Version;
ProductId = c.ProductId;
Scale = c.Scale;
foreach (var p in c.Properties.Where(p => !Properties.ContainsKey(p.Name)))
{
Properties.Add(p);
}
foreach (var child in c.Children)
{
if (child is IUniqueComponent)
{
if (!UniqueComponents.ContainsKey(((IUniqueComponent)child).Uid))
{
this.AddChild(child);
}
}
else
{
this.AddChild(child);
}
}
}
public FirebirdMergeBuilder(DataConnection connection, IMergeable <TTarget, TSource> merge)
: base(connection, merge)
{
}
protected override BasicMergeBuilder <TTarget, TSource> GetMergeBuilder <TTarget, TSource>(
DataConnection connection,
IMergeable <TTarget, TSource> merge)
{
return(new InformixMergeBuilder <TTarget, TSource>(connection, merge));
}
virtual public void MergeWith(IMergeable obj)
{
IFreeBusy fb = obj as IFreeBusy;
if (fb != null)
{
foreach (IFreeBusyEntry entry in fb.Entries)
{
if (!Entries.Contains(entry))
Entries.Add(entry.Copy<IFreeBusyEntry>());
}
}
}
public SqlServerMergeBuilder(DataConnection connection, IMergeable <TTarget, TSource> merge)
: base(connection, merge)
{
}
public static void Add <T>(this IMergeable <IEnumerable <T> > mergeable, T data)
{
mergeable.MergeWith(new[] { data });
}
public InformixMergeBuilder(DataConnection connection, IMergeable <TTarget, TSource> merge)
: base(connection, merge)
{
}
/// <summary> 两个相邻区间是否可以合并到同一行 </summary>
/// <param name="next">与本区间紧密相连的下一个区间</param>
public override bool IsMergeable(IMergeable next)
{
return(true);
}
