public void BaseTest()
{
Xtensive.Tuples.Tuple t1 = Xtensive.Tuples.Tuple.Create(1, "2");
Xtensive.Tuples.Tuple t2 = Xtensive.Tuples.Tuple.Create(3, 4.0, "5");
TestLog.Info("Originals: {0}, {1}", t1, t2);
CombineTransform mt = new CombineTransform(false, t1.Descriptor, t2.Descriptor);
CombineTransform mtro = new CombineTransform(true, t1.Descriptor, t2.Descriptor);
Xtensive.Tuples.Tuple wt1 = mt.Apply(TupleTransformType.TransformedTuple, t1, t2);
TestLog.Info("Wrapper: {0}", wt1);
Xtensive.Tuples.Tuple ct1 = mt.Apply(TupleTransformType.Tuple, t1, t2);
TestLog.Info("Copy: {0}", ct1);
Xtensive.Tuples.Tuple wt2 = mt.Apply(TupleTransformType.TransformedTuple, t1, t2);
Xtensive.Tuples.Tuple ct2 = mt.Apply(TupleTransformType.Tuple, t1, t2);
Assert.AreEqual(wt1, wt2);
Assert.AreEqual(wt2, ct1);
Assert.AreEqual(ct1, ct2);
wt1.SetValue(2, 0);
Assert.AreEqual(t2.GetValue(0), wt1.GetValue(2));
Assert.AreEqual(wt1, wt2);
Assert.AreNotEqual(wt2, ct1);
Assert.AreEqual(ct1, ct2);
ct1.SetValue(2, 0);
Assert.AreEqual(t2.GetValue(0), ct1.GetValue(2));
Assert.AreEqual(wt1, wt2);
Assert.AreEqual(wt2, ct1);
Assert.AreNotEqual(ct1, ct2);
Xtensive.Tuples.Tuple wtro = mtro.Apply(TupleTransformType.TransformedTuple, t1, t2);
AssertEx.Throws <NotSupportedException>(delegate {
wtro.SetValue(2, 0);
});
CombineTransform mt3 = new CombineTransform(false, t1.Descriptor, t1.Descriptor, t1.Descriptor);
Xtensive.Tuples.Tuple wt3 = mt3.Apply(TupleTransformType.TransformedTuple, t1, t1, t1);
TestLog.Info("Wrapper: {0}", wt3);
Xtensive.Tuples.Tuple ct3 = mt3.Apply(TupleTransformType.Tuple, t1, t1, t1);
TestLog.Info("Copy: {0}", ct3);
t1.SetValue(0, 0);
Assert.AreEqual(wt3.GetValue(4), t1.GetValue(0));
t1.SetValue(0, 1);
CombineTransform mt4 = new CombineTransform(false, t1.Descriptor, t1.Descriptor, t1.Descriptor, t1.Descriptor);
Xtensive.Tuples.Tuple wt4 = mt4.Apply(TupleTransformType.TransformedTuple, t1, t1, t1, t1);
TestLog.Info("Wrapper: {0}", wt4);
Xtensive.Tuples.Tuple ct4 = mt4.Apply(TupleTransformType.Tuple, t1, t1, t1, t1);
TestLog.Info("Copy: {0}", ct4);
t1.SetValue(0, 0);
Assert.AreEqual(wt4.GetValue(6), t1.GetValue(0));
t1.SetValue(0, 1);
}
public void PerformanceTest2()
{
AdvancedComparerStruct <Xtensive.Tuples.Tuple> comparer = AdvancedComparerStruct <Xtensive.Tuples.Tuple> .Default;
Xtensive.Tuples.Tuple t = Xtensive.Tuples.Tuple.Create(1);
CombineTransform mt = new CombineTransform(false, t.Descriptor, t.Descriptor, t.Descriptor, t.Descriptor);
SegmentTransform st = new SegmentTransform(false, mt.Descriptor, new Segment <int>(1, 2));
Xtensive.Tuples.Tuple wt1 = st.Apply(TupleTransformType.TransformedTuple, mt.Apply(TupleTransformType.TransformedTuple, t, t, t, t));
Xtensive.Tuples.Tuple wt2 = st.Apply(TupleTransformType.TransformedTuple, mt.Apply(TupleTransformType.TransformedTuple, t, t, t, t));
Xtensive.Tuples.Tuple ct1 = st.Apply(TupleTransformType.Tuple, mt.Apply(TupleTransformType.Tuple, t, t, t, t));
Xtensive.Tuples.Tuple ct2 = st.Apply(TupleTransformType.Tuple, mt.Apply(TupleTransformType.Tuple, t, t, t, t));
int count = IterationCount;
comparer.Equals(ct1, ct2);
comparer.Equals(ct1, wt1);
comparer.Equals(wt1, wt2);
TestHelper.CollectGarbage();
using (new Measurement("O&O", MeasurementOptions.Log, count))
for (int i = 0; i < count; i++)
{
comparer.Equals(ct1, ct2);
}
TestHelper.CollectGarbage();
using (new Measurement("O&W", MeasurementOptions.Log, count))
for (int i = 0; i < count; i++)
{
comparer.Equals(ct1, wt1);
}
TestHelper.CollectGarbage();
using (new Measurement("W&W", MeasurementOptions.Log, count))
for (int i = 0; i < count; i++)
{
comparer.Equals(wt1, wt2);
}
}
private void RemapEntitySetReference(RemapContext context, ReferenceFieldChangeInfo info)
{
var fieldAssociation = info.Field.GetAssociation(info.FieldValue.TypeInfo);
if (!fieldAssociation.IsMaster && fieldAssociation.IsPaired)
{
return;
}
var oldCombinedKey = info.AuxiliaryEntity;
var fieldOwnerKey = context.TryRemapKey(info.FieldOwner);
var fieldValueKey = context.TryRemapKey(info.FieldValue);
var transformer = new CombineTransform(false, fieldOwnerKey.Value.Descriptor, fieldValueKey.Value.Descriptor);
var combinedTuple = transformer.Apply(TupleTransformType.Tuple, fieldOwnerKey.Value, fieldValueKey.Value);
var newCombinedKey = Key.Create(Session.Domain, Session.StorageNodeId, fieldAssociation.AuxiliaryType, TypeReferenceAccuracy.ExactType, combinedTuple);
context.RegisterKeyMap(oldCombinedKey, newCombinedKey);
}
/// <summary>
/// Combines the <paramref name="left"/> with <paramref name="right"/>.
/// </summary>
/// <param name="left">The first <see cref="Tuple"/> to combine.</param>
/// <param name="right">The second <see cref="Tuple"/> to combine.</param>
/// <returns></returns>
public static Tuple Combine(this Tuple left, Tuple right)
{
var transform = new CombineTransform(false, new[] { left.Descriptor, right.Descriptor });
return(transform.Apply(TupleTransformType.TransformedTuple, left, right));
}
internal bool Add(Entity item, SyncContext syncContext, RemovalContext removalContext)
{
if (Contains(item))
{
return(false);
}
try {
var operations = Session.Operations;
using (var scope = operations.BeginRegistration(Operations.OperationType.System)) {
var itemKey = item.Key;
if (operations.CanRegisterOperation)
{
operations.RegisterOperation(new EntitySetItemAddOperation(Owner.Key, Field, itemKey));
}
SystemBeforeAdd(item);
int? index = null;
var association = Field.GetAssociation(item.TypeInfo);
Action finalizer = () => {
var auxiliaryType = association.AuxiliaryType;
if (auxiliaryType != null && association.IsMaster)
{
var combinedTuple = auxilaryTypeKeyTransform.Apply(
TupleTransformType.Tuple,
Owner.Key.Value,
itemKey.Value);
var combinedKey = Key.Create(
Session.Domain,
Session.StorageNodeId,
auxiliaryType,
TypeReferenceAccuracy.ExactType,
combinedTuple);
Session.CreateOrInitializeExistingEntity(auxiliaryType.UnderlyingType, combinedKey);
Session.ReferenceFieldsChangesRegistry.Register(Owner.Key, itemKey, combinedKey, Field);
}
var state = State;
state.Add(itemKey);
Session.EntitySetChangeRegistry.Register(state);
index = GetItemIndex(state, itemKey);
};
operations.NotifyOperationStarting();
if (association.IsPaired)
{
Session.PairSyncManager.ProcessRecursively(syncContext, removalContext,
OperationType.Add, association, Owner, item, finalizer);
}
else
{
finalizer.Invoke();
}
// removalContext is unused here, since Add is never
// invoked in reference cleanup process directly
if (!skipOwnerVersionChange)
{
Owner.UpdateVersionInfo(Owner, Field);
}
SystemAdd(item, index);
SystemAddCompleted(item, null);
scope.Complete();
return(true);
}
}
catch (Exception e) {
SystemAddCompleted(item, e);
throw;
}
}
