public async Task <IOperationResult> Update(UpdateOperation <User> model)
{
try
{
var entityToUpdate = _repository.Find <User>(x => x.Id == model.Entity.Id);
if (entityToUpdate == null)
{
throw new Exception($"{model?.Entity?.GetType()?.Name ?? "Entity"} to update was not found.");
}
entityToUpdate.FirstName = model.Entity.FirstName;
entityToUpdate.LastName = model.Entity.LastName;
entityToUpdate.Email = model.Entity.Email;
entityToUpdate.Roles = model.Entity.Roles;
_repository.Update(entityToUpdate);
await _repository.SaveChangesAsync();
await _repository.AggregateEntityHistory(entityToUpdate.Id, model.UserId, OperationType.Update);
return(OperationResult.Success);
}
catch (Exception ex)
{
return(OperationResult.Failed(ex.Message));
}
}
public void ValidateCollapse_UpdateOperation_OK()
{
var sut = new InsertOperation("test", "1234");
var newOp = new UpdateOperation("test", "1234");
sut.ValidateOperationCanCollapse(newOp);
}
public void Collapse_MismatchedItemId_Throws()
{
var sut = new InsertOperation("test", "1234");
var newOp = new UpdateOperation("test", "4321");
Assert.Throws <ArgumentException>(() => sut.CollapseOperation(newOp));
}
// (This region of code is not in normal use as of 3-30-2020)
internal static UpdateOperation GetNewBookUpdateOperation()
{
var updateOp = new UpdateOperation();
AddUpdateSource(updateOp);
return(updateOp);
}
/// <summary>
/// Runs an <see cref="UpdateOperation"/> on the dependencies contained in a <see cref="XmlDocument"/> loaded from a .nuspec file.
/// </summary>
/// <param name="document"></param>
/// <param name="operation"></param>
/// <returns></returns>
public static IEnumerable <UpdateOperation> UpdateDependencies(
this XmlDocument document,
UpdateOperation operation
)
{
var operations = new List <UpdateOperation>();
foreach (var node in document.SelectElements("dependency", $"[@id='{operation.PackageId}']"))
{
var versionNodeValue = node.GetAttribute("version");
// only nodes with explicit version, skip expansion.
if (!versionNodeValue.Contains("{", System.StringComparison.OrdinalIgnoreCase))
{
var currentOperation = operation.WithPreviousVersion(versionNodeValue);
if (currentOperation.ShouldProceed())
{
node.SetAttribute("version", currentOperation.UpdatedVersion.ToString());
}
operations.Add(currentOperation);
}
}
return(operations);
}
/// <summary>
/// Runs an <see cref="UpdateOperation"/> on the PackageReferences contained in a <see cref="XmlDocument"/>.
/// </summary>
/// <param name="document"></param>
/// <param name="operation"></param>
/// <returns></returns>
public static IEnumerable <UpdateOperation> UpdatePackageReferences(
this XmlDocument document,
UpdateOperation operation
)
{
var operations = new List <UpdateOperation>();
var packageId = operation.PackageId;
var packageReferences = document.SelectElements("PackageReference", $"[@Include='{packageId}' or @Update='{packageId}']");
var dotnetCliReferences = document.SelectElements("DotNetCliToolReference", $"[@Include='{packageId}' or @Update='{packageId}']");
foreach (var packageReference in packageReferences.Concat(dotnetCliReferences))
{
var packageVersion = packageReference.GetAttributeOrChild("Version");
if (packageVersion.HasValue())
{
var currentOperation = operation.WithPreviousVersion(packageVersion);
if (currentOperation.ShouldProceed())
{
packageReference.SetAttributeOrChild("Version", currentOperation.UpdatedVersion.ToString());
}
operations.Add(currentOperation);
}
}
return(operations);
}
/// <summary>
/// default constructor: initializes all members
/// </summary>
public UpdateOpInfo()
{
title = "";
ID = "";
date = DateTime.MinValue;
operation = UpdateOperation.uoUninstallation;
result = OperationResultCode.orcNotStarted;
}
public void Deserialize_Works_WithoutItem()
{
var expected = new UpdateOperation("test", "1234");
var operation = TableOperation.Deserialize(serializedObject);
Assert.IsAssignableFrom <UpdateOperation>(operation);
Assert.Equal(expected, operation);
}
public void Write(UpdateOperation <T> value, IMsgPackWriter writer)
{
writer.WriteArrayHeader(3);
_stringConverter.Write(value.OperationType, writer);
_intConverter.Write(value.FieldNumber, writer);
_argumentConverter.Write(value.Argument, writer);
}
public void Operation_CanBeCancelled()
{
var operation = new UpdateOperation("test", "1234");
Assert.False(operation.IsCancelled);
operation.Cancel();
Assert.True(operation.IsCancelled);
}
public object Update(UpdateOperation value)
{
Type type;
object instance;
ResolveTypeAndInstance(value, out type, out instance);
return(Repository.Update(type, instance));
}
UpdateResult <JSONDocument> IDocumentStore.UpdateDocument(UpdateOperation operation)
{
UsageStats stats = new UsageStats();
stats.BeginSample();
UpdateResult <JSONDocument> result = new UpdateResult <JSONDocument>();
CacheItem cItem;
if (!_cache.ContainsKey(operation.RowId))
{
//TODO: Read-through
if (!_persistenceManager.MetadataIndex(_parent.Name).ContainsRowId(operation.RowId))
{
if (LoggerManager.Instance.StorageLogger != null && LoggerManager.Instance.StorageLogger.IsWarnEnabled)
{
LoggerManager.Instance.StorageLogger.Warn("Update : document not found.", "Document not found while updating in metadataIndex. rowId = " + operation.RowId + " collection = " + Name);
}
AddFailedOperation(operation);
return(result);
}
cItem = LoadDocument(operation.RowId, operation.Context);
}
else
{
cItem = CacheGet(operation.RowId);//_cache[operation.RowId];
}
if (cItem == null)
{
throw new Exception("Item not found in cache.");
}
//removing cache item from eviction policy so that it will not be evicted.
_evictionPolicy.Remove(operation.RowId, cItem.EvictionHint);
result.OldDocument = cItem.Document.Clone() as JSONDocument;
cItem.Document = operation.Update;
result.RowId = operation.RowId;
result.NewDocument = cItem.Document.Clone() as JSONDocument;
cItem.Flag.SetBit(BitsetConstants.DocumentDirty);
_indexManager.UpdateIndex(operation.RowId, cItem.Document, operation.Update, operation.OperationId);
PersistenceOperation persistenceOperation = new PersistenceUpdateOperation(operation.OperationId,
_parent.Name, operation.RowId, cItem, operation.Context);
AddToPersistenceDictionary(persistenceOperation);
_parent.MetadataIndex.Update(new DocumentKey(operation.Update.Key), operation);
if (_statsCollector != null)
{
stats.EndSample();
_statsCollector.IncrementStatsValue(StatisticsType.AvgUpdateTime, stats.Current);
_statsCollector.IncrementStatsValue(StatisticsType.UpdatesPerSec);
}
return(result);
}
public void Operation_CanBeUpdated()
{
var operation = new UpdateOperation("test", "1234");
Assert.False(operation.IsUpdated);
operation.Update();
Assert.Equal(2, operation.Version);
Assert.True(operation.IsUpdated);
}
public void Operation_CanSetItem()
{
var operation = new UpdateOperation("test", "1234")
{
Item = testObject
};
Assert.Equal(operation.Item, testObject);
}
/// <summary>
/// Checks against the old database version to see which fields/properties have been updated and need to be written to the database
/// Note: Any dynamic objects are probably going to get updated every time. It's hard to compare them.
/// </summary>
/// <returns>UpdateOperation with the necessary updates</returns>
internal virtual UpdateOperation GetPendingUpdates()
{
var pendingUpdates = new UpdateOperation();
var type = this.GetType();
var writeableMemberNames = this.GetWriteableMembers();
List <MemberInfo> fieldsAndProperties =
// First collect all the fields and properties
type.GetFields().Cast <MemberInfo>()
.Concat(type.GetProperties().Cast <MemberInfo>())
// Only include those columns which are explicitly marked as writeable
.Where(member => writeableMemberNames.Contains(member.Name))
// Only include the ones which are serialized to JSON
.Where(member => member.CustomAttributes.Any(attr => attr.AttributeType.FullName == "Newtonsoft.Json.JsonPropertyAttribute"))
.ToList();
// Iterate over and process each automatically handled field/property
// to see if its value has been modified since the last time we read/wrote to the database
foreach (var memberInfo in fieldsAndProperties)
{
object oldValue;
object newValue;
if (memberInfo is FieldInfo)
{
var fieldInfo = (FieldInfo)memberInfo;
oldValue = fieldInfo.GetValue(this.DatabaseVersion);
newValue = fieldInfo.GetValue(this);
}
else
{
// We know that everything here is supposed to be either a FieldInfo or PropertyInfo,
// so if it's not FieldInfo, it should be a propertyInfo
var propertyInfo = (PropertyInfo)memberInfo;
if (this.DatabaseVersion == null)
{
oldValue = null;
}
else
{
oldValue = propertyInfo.GetValue(this.DatabaseVersion);
}
newValue = propertyInfo.GetValue(this);
}
// Record an update if the value has been modified
if (!AreObjectsEqual(oldValue, newValue))
{
string propertyName = GetMemberJsonName(memberInfo);
pendingUpdates.UpdateFieldWithObject(propertyName, newValue);
}
}
return(pendingUpdates);
}
public void GetHashCode_Works()
{
var sut = new UpdateOperation("test", "1234")
{
Item = testObject
};
var hash = "1234".GetHashCode();
Assert.Equal(hash, sut.GetHashCode());
}
public void Serialize_Works_WithoutItem()
{
var operation = new UpdateOperation("test", "1234");
JObject actual = operation.Serialize();
actual.Remove("id");
Assert.Equal(serializedObject, actual);
}
public async Task ExecuteOnOfflineStore_Throws_WithItemNotInStore()
{
var store = new Mock <IOfflineStore>();
store.Setup(x => x.GetItemAsync("test", "1234", It.IsAny <CancellationToken>())).Returns(Task.FromResult((JObject)null));
store.Setup(x => x.UpsertAsync("test", It.IsAny <IEnumerable <JObject> >(), It.IsAny <bool>(), It.IsAny <CancellationToken>())).Returns(Task.CompletedTask);
var sut = new UpdateOperation("test", "1234");
await Assert.ThrowsAsync <OfflineStoreException>(() => sut.ExecuteOperationOnOfflineStoreAsync(store.Object, testObject));
}
public void Collapse_UpdateOperation()
{
var sut = new UpdateOperation("test", "1234");
var newOp = new UpdateOperation("test", "1234");
sut.CollapseOperation(newOp);
Assert.False(sut.IsCancelled);
Assert.True(sut.IsUpdated);
Assert.True(newOp.IsCancelled);
}
private void ProcessOneBook(Book book)
{
try
{
_logger.TrackEvent("ProcessOneBook Start");
string message = $"Processing: {book.BaseUrl}";
Console.Out.WriteLine(message);
_logger.LogVerbose(message);
var initialUpdates = new UpdateOperation();
initialUpdates.UpdateField(Book.kHarvestStateField, Book.HarvestState.InProgress.ToString());
initialUpdates.UpdateField(Book.kHarvesterIdField, this.Identifier);
var startTime = new Parse.Model.Date(DateTime.UtcNow);
initialUpdates.UpdateField("harvestStartedAt", startTime.ToJson());
_parseClient.UpdateObject(book.GetParseClassName(), book.ObjectId, initialUpdates.ToJson());
// Process the book
var finalUpdates = new UpdateOperation();
var warnings = FindBookWarnings(book);
finalUpdates.UpdateField(Book.kWarningsField, Book.ToJson(warnings));
// ENHANCE: Do more processing here
// Write the updates
finalUpdates.UpdateField(Book.kHarvestStateField, Book.HarvestState.Done.ToString());
_parseClient.UpdateObject(book.GetParseClassName(), book.ObjectId, finalUpdates.ToJson());
_logger.TrackEvent("ProcessOneBook End - Success");
}
catch (Exception e)
{
YouTrackIssueConnector.SubmitToYouTrack(e, $"Unhandled exception thrown while processing book \"{book.BaseUrl}\"");
// Attempt to write to Parse that processing failed
if (!String.IsNullOrEmpty(book?.ObjectId))
{
try
{
var onErrorUpdates = new UpdateOperation();
onErrorUpdates.UpdateField(Book.kHarvestStateField, $"\"{Book.HarvestState.Failed.ToString()}\"");
onErrorUpdates.UpdateField(Book.kHarvesterIdField, this.Identifier);
_parseClient.UpdateObject(book.GetParseClassName(), book.ObjectId, onErrorUpdates.ToJson());
}
catch (Exception)
{
// If it fails, just let it be and throw the first exception rather than the nested exception.
}
}
throw;
}
}
public async Task ExecuteRemote_CallsRemoteServer_ThrowsWhenInvalidResponse()
{
var client = GetMockClient();
MockHandler.AddResponse(HttpStatusCode.OK, new string[] { "test" });
var sut = new UpdateOperation("test", "1234")
{
Item = testObject
};
await Assert.ThrowsAsync <DatasyncInvalidOperationException>(() => sut.ExecuteOperationOnRemoteServiceAsync(client));
}
public async Task ExecuteRemote_ThrowsError_WithNoItem()
{
var client = GetMockClient();
MockHandler.AddResponse(HttpStatusCode.OK);
var sut = new UpdateOperation("test", "1234");
var exception = await Assert.ThrowsAsync <DatasyncInvalidOperationException>(() => sut.ExecuteOperationOnRemoteServiceAsync(client));
Assert.Empty(MockHandler.Requests);
Assert.Contains("must have an item", exception.Message);
}
static async Task DoWork()
{
using (var box = await Box.Connect(
"operator:123123@localhost:3301"))
{
var schema = box.GetSchema();
var space = await schema.GetSpace("users");
var primaryIndex = await space.GetIndex("primary_id");
//await space.Insert(TarantoolTuple.Create(Guid.NewGuid().ToString(),
//"Vladimir Vladimirov", "vvladimirov", "*****@*****.**", 10L));
var updatedData = await space.Update <TarantoolTuple <string>,
TarantoolTuple <string, string, string, string, long> >(
TarantoolTuple.Create("600ca93b-10dc-4ebe-8c78-95f4d5384426"),
new UpdateOperation[] { UpdateOperation.CreateAssign(4, 47L) });
var data = await primaryIndex.Select <TarantoolTuple <string>,
TarantoolTuple <string, string, string, string, long> >(
TarantoolTuple.Create(String.Empty), new SelectOptions
{
Iterator = Iterator.All
});
var loginIndex = await space.GetIndex("secondary_login");
var users = await loginIndex.Select <TarantoolTuple <string>,
TarantoolTuple <string, string, string, string, long> >(
TarantoolTuple.Create("petrov"));
var petrov = users.Data;
var ratingIndex = await space.GetIndex("secondary_rating");
var ratingUsers = await ratingIndex.Select <TarantoolTuple <long>,
TarantoolTuple <string, string, string, string, long> >(
TarantoolTuple.Create(15L), new SelectOptions
{
Iterator = Iterator.Ge
});
await box.Call("update_rating");
foreach (var item in data.Data)
{
Console.WriteLine(item);
}
}
}
/// <summary>
/// Given the collection of available update scripts (which were added before either by explicitly calling
/// <see cref="AddUpdateScript"/> or by calling <see cref="AddDirectory"/>), this methods updates the sub schema
/// of this class in the database to the current version.
/// </summary>
/// <remarks>
/// The update is an iterative process. In each step, an update script will be applied which matches the current
/// subschema version.
/// If the subschema isn't present in the DB before this method gets called (i.e. its current version isn't present),
/// the first step will be to apply the "Create" script (i.e. the script with an empty "from" version).
/// If the subschema currently is at version A.B, potential update scripts are those with a
/// "from" version of "A.*" or "A.B". "A.*" will be preferrably used. The DB update will take place with the script
/// which was found (if any) and the next update step starts. If no more matching update script is found,
/// the update terminates.
/// </remarks>
/// <param name="newVersionMajor">Returns the subschema major version after the execution of this method.</param>
/// <param name="newVersionMinor">Returns the subschema minor version after the execution of this method.</param>
/// <returns><c>true</c>, if the requested ,
/// else <c>false</c>.</returns>
public bool UpdateSubSchema(out int newVersionMajor, out int newVersionMinor)
{
IDatabaseManager databaseManager = ServiceRegistration.Get <IDatabaseManager>();
int curVersionMajor = 0;
int curVersionMinor = 0;
try
{
// Create schema
if (!databaseManager.GetSubSchemaVersion(_subSchemaName, out curVersionMajor, out curVersionMinor))
{
CreateOperation createOperation = GetCreateOperation();
if (createOperation == null)
{
return(false); // No schema could be created
}
databaseManager.UpdateSubSchema(_subSchemaName, null, null,
createOperation.CreateScriptFilePath, createOperation.ToVersionMajor, createOperation.ToVersionMinor);
curVersionMajor = createOperation.ToVersionMajor;
curVersionMinor = createOperation.ToVersionMinor;
}
while (true)
{
UpdateOperation nextOperation = GetUpdateOperation(curVersionMajor, curVersionMinor);
if (nextOperation == null)
{
break;
}
// Avoid busy loops on wrong input data
if (nextOperation.ToVersionMajor < curVersionMajor ||
(nextOperation.ToVersionMajor == curVersionMajor && nextOperation.ToVersionMinor < curVersionMinor))
{
throw new ArgumentException(string.Format("Update script '{0}' seems to decrease the schema version",
nextOperation.UpdateScriptFilePath));
}
databaseManager.UpdateSubSchema(_subSchemaName, curVersionMajor, curVersionMinor,
nextOperation.UpdateScriptFilePath, nextOperation.ToVersionMajor, nextOperation.ToVersionMinor);
curVersionMajor = nextOperation.ToVersionMajor;
curVersionMinor = nextOperation.ToVersionMinor;
}
ServiceRegistration.Get <ILogger>().Info("DatabaseSubSchemaManager: Subschema '{0}' present in version {1}.{2}",
_subSchemaName, curVersionMajor, curVersionMinor);
return(true);
}
finally
{
newVersionMajor = curVersionMajor;
newVersionMinor = curVersionMinor;
}
}
public void UpdateOperation_UpdateFieldWithObject_String_SameAsUpdateFieldWithString(string inputValue)
{
var updateOp1 = new UpdateOperation();
updateOp1.UpdateFieldWithString("field", inputValue);
string json1 = updateOp1.ToJson();
var updateOp2 = new UpdateOperation();
updateOp2.UpdateFieldWithObject("field", inputValue);
string json2 = updateOp2.ToJson();
Assert.AreEqual(json1, json2);
}
private static string DecodeUpdateOperation(UpdateOperation updateOperation)
{
switch (updateOperation)
{
case UpdateOperation.ADD:
return(OpAdd);
case UpdateOperation.DEL:
return(OpDel);
default:
return(OpAdd);
}
}
private IEnumerator Download()
{
_updater.Initialize(RemoteUrl, ProjectName, VersionFileName);
yield return(_updater.LoadAllVersionFiles());
yield return(_updater.UpdateFromStreamingAsset());
_updateOperation = _updater.UpdateFromRemoteAsset();
_totalCount = _updateOperation.RemainBundleCount;
yield return(_updateOperation);
StartGameButton.gameObject.SetActive(true);
}
public void Collapse_CancelsExistingOperation_WithUpdateOperation()
{
var newOperation = new UpdateOperation("test", MobileServiceTableKind.Table, "abc");
this.operation.Collapse(newOperation);
// new operation should be cancelled
Assert.IsTrue(newOperation.IsCancelled);
// existing operation should be updated and not cancelled
Assert.IsFalse(this.operation.IsCancelled);
Assert.IsTrue(this.operation.IsUpdated);
Assert.AreEqual(this.operation.Version, 2);
}
public void UpdateOperation_AddsInts_DeserializesCorrectly()
{
// Setup
var updateOp = new UpdateOperation();
updateOp.UpdateFieldWithNumber("field1", "19");
// System under test
string resultJson = updateOp.ToJson();
// Verify
string expectedJson = "{\"field1\":19}";
Assert.AreEqual(expectedJson, resultJson);
}
public void Equals_TableOperation_Works()
{
var sut = new UpdateOperation("test", "1234")
{
Item = testObject
};
var other = new UpdateOperation("test", "1234")
{
Item = testObject
};
var notother = new DeleteOperation("test", "1234");
Assert.True(sut.Equals(other));
Assert.False(sut.Equals(notother));
}
/// <summary>
/// Repond Failure on the operation status result.
/// </summary>
/// <param name="subscriptionId">The subscription.</param>
/// <param name="operationId">The operation location.</param>
/// <param name="updateOperationStatus">The operation status to patch with.</param>
/// <returns>
/// Patch Operation Status Result.
/// </returns>
/// <exception cref="System.Exception">Error occurred while getting the operation result.</exception>
public async Task <Response> PatchOperationStatusResultAsync(Guid subscriptionId, Guid operationId, UpdateOperationStatusEnum updateOperationStatus)
{
this.Logger?.Info($"Inside PatchOperationStatusResultAsync() of FulfillmentApiService, trying to Update Operation Status to { updateOperationStatus} Operation ID : {operationId} Subscription ID : {subscriptionId}");
try
{
UpdateOperation updateOperation = new UpdateOperation();
updateOperation.Status = updateOperationStatus;
return(await this.marketplaceClient.Operations.UpdateOperationStatusAsync(subscriptionId, operationId, updateOperation));
}
catch (RequestFailedException ex)
{
this.ProcessErrorResponse(MarketplaceActionEnum.UPDATE_OPERATION_STATUS, ex);
return(null);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="PrototypeBackend.SequencesUpdatedArgs"/> class.
/// </summary>
/// <param name="seqUpdateOperation">Seq update operation.</param>
/// <param name="oldseq">The old sequence.</param>
/// <param name="newseq">The new sequence.</param>
public SequencesUpdatedArgs(UpdateOperation seqUpdateOperation, Sequence oldseq = null, Sequence newseq = null)
{
OldSeq = oldseq;
NewSeq = newseq;
UpdateOperation = seqUpdateOperation;
}
/// <summary>
/// returns a human-readable string to describe the passed
/// UpdateOperation value (e.g. "Installation" or "Uninstallation",
/// depending on what the value indicates)
/// </summary>
/// <param name="value">UpdateOperation value that shall be represented
/// as string</param>
/// <returns>string that describes the update operation</returns>
public static string UpdateOperationToString(UpdateOperation value)
{
switch (value)
{
case UpdateOperation.uoInstallation:
return "Installation";
case UpdateOperation.uoUninstallation:
return "Uninstallation";
default:
return "unknown operation";
} //switch
}
/// <summary>
/// Initializes a new instance of the <see cref="PrototypeBackend.ControllerPinUpdateArgs"/> class.
/// </summary>
/// <param name="oldpin">The old pin.</param>
/// <param name="pinUpdateOperation">Pin update operation.</param>
/// <param name="newpin">The new pin.</param>
public ControllerPinUpdateArgs(IPin oldpin, UpdateOperation pinUpdateOperation, IPin newpin = null)
{
OldPin = oldpin;
NewPin = newpin;
UpdateOperation = pinUpdateOperation;
}
/// <summary>
/// Update the specified data.
/// </summary>
/// <param name='key'>
/// The data key.
/// </param>
/// <param name='val'>
/// The data value.
/// </param>
/// <param name='operation'>
/// The operation type.
/// </param>
/// <param name='userData'>
/// <c>true</c> if is user data; otherwise, <c>false</c>. Default false (i.e. game data).
/// </param>
public void Update(string key, string val, UpdateOperation operation, bool userData = false )
{
if (key.Trim () == string.Empty)
{
GJAPI.Instance.GJDebug ("Key is empty. Can't get data.", LogType.Error);
return;
}
GJAPI.Instance.GJDebug ("Updating data.");
Dictionary<string,string> parameters = new Dictionary<string, string> ();
parameters.Add ("key", key);
parameters.Add ("operation", operation.ToString ().ToLower ());
parameters.Add ("format", "dump");
Dictionary<string,string> postParameters = new Dictionary<string, string> ();
postParameters.Add ("value", val);
GJAPI.Instance.Request (DATA_UPDATE, parameters, postParameters, userData, ReadUpdateResponse);
}
/// <summary>
/// Initializes a new instance of the <see cref="PrototypeBackend.MeasurementCombinationsUpdatedArgs"/> class.
/// </summary>
/// <param name="sigUpdateOperation">Sig update operation.</param>
/// <param name="oldmecom">The old measurementcombination.</param>
/// <param name="newmecom">The new measurementcombination.</param>
public MeasurementCombinationsUpdatedArgs(UpdateOperation sigUpdateOperation, MeasurementCombination oldmecom = null, MeasurementCombination newmecom = null)
{
OldMeCom = oldmecom;
NewMeCom = newmecom;
UpdateOperation = sigUpdateOperation;
}
