public Token(Regex match, TokenType tokenType, OperationType operationType = OperationType.Operator, TokenDiscardPolicy discardPolicy = TokenDiscardPolicy.Keep)
{
m_TokenType = tokenType;
m_DiscardPolicy = discardPolicy;
m_OperationType = operationType;
m_Regex = match;
}
public TokenRule( OperationType op, Symbol tokenID, string symbol )
{
this.operation = op;
this.tokenID = tokenID;
this.symbol = symbol;
this.errorID = 0;
}
internal DependencyPropertyChangedEventArgs(
DependencyProperty property,
PropertyMetadata metadata,
bool isAValueChange,
EffectiveValueEntry oldEntry,
EffectiveValueEntry newEntry,
OperationType operationType)
{
_property = property;
_metadata = metadata;
_oldEntry = oldEntry;
_newEntry = newEntry;
_flags = 0;
_operationType = operationType;
IsAValueChange = isAValueChange;
// This is when a mutable default is promoted to a local value. On this operation mutable default
// value acquires a freezable context. However this value promotion operation is triggered
// whenever there has been a sub property change to the mutable default. Eg. Adding a TextEffect
// to a TextEffectCollection instance which is the mutable default. Since we missed the sub property
// change due to this add, we flip the IsASubPropertyChange bit on the following change caused by
// the value promotion to coalesce these operations.
IsASubPropertyChange = (operationType == OperationType.ChangeMutableDefaultValue);
}
public virtual void AddAfter(IQueryPart part, OperationType operation)
{
var first = Parts.LastOrDefault(p => p.OperationType == operation);
var index = Parts.IndexOf(first) + 1;
Parts.Insert(index, part);
}
private async Task<String> GetProductDetailsXml(String asins, OperationType type = OperationType.ItemLookup)
{
var requestParameters = new Dictionary<String, String>
{
{ "IdType", "ASIN" },
{ "ResponseGroup", "Large" },
{ "Service", "AWSECommerceService" },
{ "AssociateTag", _associateTag }
};
if (type == OperationType.ItemLookup)
{
requestParameters.Add("Operation", "ItemLookup");
requestParameters.Add("ItemId", asins);
}
else if (type == OperationType.ItemSearch)
{
requestParameters.Add("Operation", "ItemSearch");
requestParameters.Add("SearchIndex", "All");
requestParameters.Add("Keywords", asins);
}
var amazonRequestUri = _requestSigner.Sign(requestParameters);
var httpClient = new HttpClient
{
Timeout = TimeSpan.FromSeconds(5)
};
return await httpClient.GetStringAsync(amazonRequestUri);
}
public IVariable Calculate(IMilpManager milpManager, OperationType type, params IVariable[] arguments)
{
if(!SupportsOperation(type,arguments)) throw new NotSupportedException(SolverUtilities.FormatUnsupportedMessage(type, arguments));
if (arguments.All(x => x.IsConstant()))
{
if (arguments[0].IsInteger())
{
return milpManager.FromConstant(Math.Abs((int)arguments[0].ConstantValue.Value));
}
return milpManager.FromConstant(Math.Abs(arguments[0].ConstantValue.Value));
}
var number = arguments[0];
var numberNegated = number.Operation(OperationType.Negation);
var result = milpManager.CreateAnonymous(number.IsInteger() ? Domain.PositiveOrZeroInteger : Domain.PositiveOrZeroReal);
result.Set(ConstraintType.GreaterOrEqual, number)
.Set(ConstraintType.GreaterOrEqual, numberNegated);
milpManager.Operation(OperationType.Addition,
result.Operation(OperationType.IsEqual, number),
result.Operation(OperationType.IsEqual, numberNegated))
.Set(ConstraintType.GreaterOrEqual, milpManager.FromConstant(1));
result.ConstantValue = number.ConstantValue.HasValue ? Math.Abs(number.ConstantValue.Value) : number.ConstantValue;
result.Expression = $"|{number.FullExpression()}|";
return result;
}
public Operation(OperationType type, int fileNumber, int start, int length)
{
Type = type;
FileNumber = fileNumber;
Start = start;
Length = length;
}
public TextChangedEventArgs(OperationType operation, int start, int length, string text)
{
_operation = operation;
_start = start;
_length = length;
_text = text;
}
public DesktopChangeEventArgs(int x1, int y1, int x2, int y2, OperationType type) {
this.x = x1;
this.y = y1;
this.w = x2 - x1;
this.h = y2 - y1;
this.type = type;
}
public static LogOrder GetLogOrderEntity(OrderTask orderTask,OperationType operationType,string objectId)
{
LogOrder logEntity = new LogOrder();
string hostname = Dns.GetHostName();
IPHostEntry localhost = Dns.GetHostEntry(hostname);
IPAddress localaddr = localhost.AddressList[0];
logEntity.IP = localaddr.ToString();
logEntity.UserId = ConsoleClient.Instance.User.UserId;
logEntity.UserName = ConsoleClient.Instance.User.UserName;
logEntity.Event = objectId;// "ExecuteOrder";
logEntity.ExchangeCode = orderTask.ExchangeCode;
logEntity.OperationType = operationType;
logEntity.OrderId = orderTask.OrderId;
logEntity.OrderCode = orderTask.Code;
logEntity.AccountCode = orderTask.AccountCode;
logEntity.InstrumentCode = orderTask.InstrumentCode;
logEntity.IsBuy = orderTask.IsBuy == BuySell.Buy;
logEntity.IsOpen = orderTask.IsOpen == OpenClose.Open;
logEntity.Lot = orderTask.Lot.Value;
logEntity.SetPrice = orderTask.SetPrice;
logEntity.OrderType = orderTask.OrderType;
logEntity.OrderRelation = null;
logEntity.TransactionCode = orderTask.Transaction.Code;
return logEntity;
}
public Token(TokenType type, OperationType operationType, string value, TokenPosition position)
{
OperationType = operationType;
Type = type;
Value = value;
Position = position;
}
public NetSendResult EnqueueMessage(OperationType opType, PacketPayload payload, DeliveryMethod method, bool encrypt, byte channel, int connectionId)
{
outgoingMessageQueue.syncRoot.EnterWriteLock();
try
{
//This is similar to how Photon works on the Unity client.
//They enqueue actions
outgoingMessageQueue.Enqueue(() =>
{
INetworkMessageRouterService sender = sendServiceStrategy.GetRouterService(connectionId);
sender.TrySendMessage(opType, payload, method, encrypt, channel);
});
//signal any handlers that a message is in the queue
//it is important to do this in a lock. Reset could be called after Set
//in the other thread and we'd end up with potential unhandled messages in that race condition
outgoingMessageQueue.QueueSemaphore.Set();
}
finally
{
outgoingMessageQueue.syncRoot.ExitWriteLock();
}
return NetSendResult.Queued;
}
public IVariable Calculate(IMilpManager milpManager, OperationType type, params IVariable[] arguments)
{
if (!SupportsOperation(type, arguments)) throw new NotSupportedException(SolverUtilities.FormatUnsupportedMessage(type, arguments));
if (arguments.All(a => a.IsConstant()))
{
var constantResult = (int) arguments[0].ConstantValue.Value%(int) arguments[1].ConstantValue.Value;
return milpManager.FromConstant((int)constantResult);
}
IVariable numerator = arguments[0];
IVariable denominator = arguments[1];
var one = milpManager.FromConstant(1);
var any = milpManager.CreateAnonymous(Domain.PositiveOrZeroInteger);
any.Operation(OperationType.Multiplication, denominator).Set(ConstraintType.LessOrEqual, numerator);
any.Operation(OperationType.Addition, one)
.Operation(OperationType.Multiplication, denominator)
.Set(ConstraintType.GreaterOrEqual, numerator.Operation(OperationType.Addition, one));
IVariable result = milpManager.CreateAnonymous(Domain.PositiveOrZeroInteger);
result.Set(ConstraintType.LessOrEqual, denominator);
result.Set(ConstraintType.Equal,
numerator.Operation(OperationType.Subtraction,
denominator.Operation(OperationType.Multiplication, any)));
result.ConstantValue = numerator.ConstantValue%denominator.ConstantValue;
result.Expression = $"{numerator.FullExpression()} % {denominator.FullExpression()}";
return result;
}
public GceOperation(OperationType operationType, string projectId, string zoneName, string name)
{
OperationType = operationType;
ProjectId = projectId;
ZoneName = zoneName;
Name = name;
}
internal Operation(int id, string name, string desc, OperationType type)
{
_operationId = id;
_name = name;
_description = desc;
_type = type;
}
// For send/receive
private TransportAsyncWorker(ITransport transport, OperationType operation, byte[] buffer, int offset, int size, AsyncCallback callback, object state)
: this(transport, operation, callback, state)
{
_buffer = buffer;
_offset = offset;
_size = size;
}
public QueryPart(OperationType operation, Type entityType, string id)
{
OperationType = operation;
ID = id ?? operation.ToString();
EntityType = entityType;
_parts = new Lazy<List<IQueryPart>>(() => new List<IQueryPart>());
}
/// <summary>
/// Отправить уведомление об изменении состоянии объекта
/// </summary>
/// <param name="replicationInfo">Информация о реплицируемом объекте</param>
/// <param name="operationType">Тип операции репликации</param>
/// <param name="sender">Отправитель</param>
public void SendObjectChanged(ReplicationInfo replicationInfo, OperationType operationType, IReplicationCallbackContract sender)
{
IReplicationCallbackContract[] subscribersCopy;
lock (_subscribers)
{
subscribersCopy = _subscribers.Where(s=> s!=sender).ToArray();
}
foreach (var subscriber in subscribersCopy)
{
if (((ICommunicationObject)subscriber).State == CommunicationState.Opened)
{
try
{
subscriber.SimulateObjectChanged(replicationInfo, operationType);
}
catch (Exception ex)
{
//TODO сделать лог
}
}
else
{
RemoveSubscriber(subscriber);
}
}
}
public OperationInfo(
OperationType type, bool isCommutative, bool isBinary)
{
this.type = type;
this.isCommutative = isCommutative;
this.isBinary = isBinary;
}
// defaults to no texture
public MapTextureStage()
{
this.Operation = OperationType.Replace;
this.Tilesize = 50;
CreateBlankTexture();
CreateBlankBlendTexture();
}
public void Add(List<XObject> objects, bool checkUploadFile = false)
{
if (objects == null)
throw new ArgumentNullException("objects", "Can not be null.");
if (objects.Count == 0)
return;
CurrentOperationType = OperationType.Add;
var data = new { objects };
var arrList = ExecuteTemplate<ArrayList>(EndPoint.object_array, XHttpMethod.POST, data);
// Parse arrayList. Item of array can contains id object or error
var errors = new Dictionary<int, object>();
int i = 0;
foreach (var obj in objects){
int id = -1;
if (arrList[i] is string && int.TryParse(arrList[i] as string, out id)){
obj.Id = id;
if (checkUploadFile)
CheckNeedUploadFiles(obj);
}
else
errors.Add(i, arrList[i]);
i++;
}
if (errors.Count > 0){
var concatErrors = new StringBuilder();
foreach (var error in errors)
if (error.Value is ArrayList && (error.Value as ArrayList).Count > 0 && arrList.Count > error.Key)
concatErrors.AppendLine("Index object: " + error.Key + ". Error: " + (arrList[error.Key] as ArrayList)[0] + "; ");
throw new FxServerException("FlexiDB server error." + concatErrors);
}
}
public FRConfiguration(String fileName, String source, FRSearch search)
{
this.type = OperationType.FindInSource;
this.path = fileName;
this.search = search;
this.source = source;
}
public void SetAuditTrail(string un, OperationType op, string cat, string msg)
{
UserName = un;
Operation = op;
Category = cat;
Message = msg;
}
/// <summary>
/// 同步计划的运营历史操作
/// </summary>
/// <param name="StartDate">开始时间</param>
/// <param name="planHistoryID">计划明细ID</param>
/// <param name="tag">标志</param>
/// <param name="dbContext">域上下文</param>
public static void SyncOperationHistroy(FleetEntities dbContext, Guid planHistoryID, OperationType tag)
{
//当前计划历史
var currentPlanHisotry = dbContext.PlanHistories.FirstOrDefault(p => p.PlanHistoryID == planHistoryID);
if (currentPlanHisotry == null || currentPlanHisotry.ApprovalHistoryID == null) return;
//运行日期
DateTime? StartDate = GetOperationDateByApprovalHistory(currentPlanHisotry.ApprovalHistoryID, dbContext);
if (StartDate == null) return;
//当前有效的年度
var currentOpenAnnual = (from t in dbContext.Plans.Include("Annuals")
from r in dbContext.PlanHistories
where
t.PlanID == r.PlanID &&
r.PlanHistoryID == currentPlanHisotry.PlanHistoryID
select t.Annual).FirstOrDefault();
if (currentOpenAnnual == null) return;
switch (tag)
{
case OperationType.OperationLastYearPlan:
SynOperationLastYearPlan(dbContext, currentPlanHisotry, (DateTime)StartDate, currentOpenAnnual);
break;
case OperationType.OperationNextYearPlan:
SynOperationNextYearPlan(dbContext, currentPlanHisotry, currentOpenAnnual);
break;
default:
break;
}
}
protected BaseProcessor(Stream inputStream, Stream outputStream, OperationType operationType, HashTypes hashType = HashTypes.Undefined)
{
this.hashType = hashType;
this.inputStream = inputStream;
this.outputStream = outputStream;
this.operationType = operationType;
}
public TokenRule( OperationType op, Symbol tokenID )
{
this.operation = op;
this.tokenID = tokenID;
this.symbol = "";
this.errorID = 0;
}
public bool SupportsOperation(OperationType type, params IVariable[] arguments)
{
return type == OperationType.Multiplication && HasVariablesToMultiply(arguments) && (
MultiplyOnlyConstants(arguments) ||
MultiplyBinaryVariables(arguments) ||
MultiplyAtMostOneNonconstant(arguments) ||
MultiplyAnyIntegers(arguments));
}
public FRConfiguration(String path, String fileMask, Boolean recursive, FRSearch search)
{
this.path = path;
this.type = OperationType.FindInPath;
this.recursive = recursive;
this.mask = fileMask;
this.search = search;
}
// For accept
private TransportAsyncWorker(ITransport transport, OperationType operation, AsyncCallback callback, object state)
{
_transport = transport;
_operation = operation;
_callback = callback;
_result = new TransportAsyncResult(this, state);
}
// blend needs two textures
public MapTextureStageModel( OperationType operation, int Tilesize, ImageWrapper splattexture, ImageWrapper blendtexture )
{
LogFile.WriteLine("MapTextureStage(), two stages");
this.Operation = operation;
this.splattexture = splattexture;
this.blendtexture = blendtexture;
this.Tilesize = Tilesize;
}
protected ChooseOperationBase(bool highlightEntities, DocumentChoiceType choiceType, OperationType operationType = OperationType.Any)
: base(choiceType)
{
this.highlightEntities = highlightEntities;
this.operationType = operationType;
Initialize();
}
public async Task <FetchRequireClaimsResult <IEnumerable <Claim> > > FetchRequiredClaimsAsync(OperationType operationType, string fieldPath)
{
var query = from item in GraphQLFieldAuthorityRecords
where item.OperationType == operationType && fieldPath == item.FieldPath
select item;
GraphQLFieldAuthorityRecord record;
var result = new FetchRequireClaimsResult <IEnumerable <Claim> >()
{
StatusCode = query.Any() ? GraphQLFieldAuthority_CODE.FOUND : GraphQLFieldAuthority_CODE.NOT_FOUND,
Value = !query.Any() ? new List <Claim>() : query.FirstOrDefault().Claims
};
return(result);
}
// Merge
public void Merge <T>(DbContext context, Type type, IList <T> entities, TableInfo tableInfo, OperationType operationType, Action <decimal> progress) where T : class
{
MergeAsync(context, type, entities, tableInfo, operationType, progress, CancellationToken.None, isAsync: false).GetAwaiter().GetResult();
}
protected async Task MergeAsync <T>(DbContext context, Type type, IList <T> entities, TableInfo tableInfo, OperationType operationType, Action <decimal> progress, CancellationToken cancellationToken, bool isAsync) where T : class
{
var entityPropertyWithDefaultValue = entities.GetPropertiesWithDefaultValue(type);
if (tableInfo.BulkConfig.CustomSourceTableName == null)
{
tableInfo.InsertToTempTable = true;
var dropTempTableIfExists = tableInfo.BulkConfig.UseTempDB;
if (dropTempTableIfExists)
{
var sqlDropTable = SqlQueryBuilder.DropTable(tableInfo.FullTempTableName, tableInfo.BulkConfig.UseTempDB);
if (isAsync)
{
await context.Database.ExecuteSqlRawAsync(sqlDropTable, cancellationToken).ConfigureAwait(false);
}
else
{
context.Database.ExecuteSqlRaw(sqlDropTable);
}
}
var sqlCreateTableCopy = SqlQueryBuilder.CreateTableCopy(tableInfo.FullTableName, tableInfo.FullTempTableName, tableInfo);
if (isAsync)
{
await context.Database.ExecuteSqlRawAsync(sqlCreateTableCopy, cancellationToken).ConfigureAwait(false);
}
else
{
context.Database.ExecuteSqlRaw(sqlCreateTableCopy);
}
if (tableInfo.TimeStampColumnName != null)
{
var sqlAddColumn = SqlQueryBuilder.AddColumn(tableInfo.FullTempTableName, tableInfo.TimeStampColumnName, tableInfo.TimeStampOutColumnType);
if (isAsync)
{
await context.Database.ExecuteSqlRawAsync(sqlAddColumn, cancellationToken).ConfigureAwait(false);
}
else
{
context.Database.ExecuteSqlRaw(sqlAddColumn);
}
}
}
if (tableInfo.CreatedOutputTable)
{
var sqlCreateOutputTableCopy = SqlQueryBuilder.CreateTableCopy(tableInfo.FullTableName, tableInfo.FullTempOutputTableName, tableInfo, true);
if (isAsync)
{
await context.Database.ExecuteSqlRawAsync(sqlCreateOutputTableCopy, cancellationToken).ConfigureAwait(false);
}
else
{
context.Database.ExecuteSqlRaw(sqlCreateOutputTableCopy);
}
if (tableInfo.TimeStampColumnName != null)
{
var sqlAddColumn = SqlQueryBuilder.AddColumn(tableInfo.FullTempOutputTableName, tableInfo.TimeStampColumnName, tableInfo.TimeStampOutColumnType);
if (isAsync)
{
await context.Database.ExecuteSqlRawAsync(sqlAddColumn, cancellationToken).ConfigureAwait(false);
}
else
{
context.Database.ExecuteSqlRaw(sqlAddColumn);
}
}
if (operationType == OperationType.InsertOrUpdateOrDelete)
{
// Output returns all changes including Deleted rows with all NULL values, so if TempOutput.Id col not Nullable it breaks
var sqlAlterTableColumnsToNullable = SqlQueryBuilder.AlterTableColumnsToNullable(tableInfo.FullTempOutputTableName, tableInfo);
if (isAsync)
{
await context.Database.ExecuteSqlRawAsync(sqlAlterTableColumnsToNullable, cancellationToken).ConfigureAwait(false);
}
else
{
context.Database.ExecuteSqlRaw(sqlAlterTableColumnsToNullable);
}
}
}
bool keepIdentity = tableInfo.BulkConfig.SqlBulkCopyOptions.HasFlag(SqlBulkCopyOptions.KeepIdentity);
try
{
if (tableInfo.BulkConfig.CustomSourceTableName == null)
{
if (isAsync)
{
await InsertAsync(context, type, entities, tableInfo, progress, cancellationToken).ConfigureAwait(false);
}
else
{
Insert(context, type, entities, tableInfo, progress);
}
}
if (keepIdentity && tableInfo.HasIdentity)
{
var sqlSetIdentityInsertTrue = SqlQueryBuilder.SetIdentityInsert(tableInfo.FullTableName, true);
if (isAsync)
{
await context.Database.OpenConnectionAsync(cancellationToken).ConfigureAwait(false);
await context.Database.ExecuteSqlRawAsync(sqlSetIdentityInsertTrue, cancellationToken).ConfigureAwait(false);
}
else
{
context.Database.OpenConnection();
context.Database.ExecuteSqlRaw(sqlSetIdentityInsertTrue);
}
}
var sqlMergeTable = SqlQueryBuilder.MergeTable <T>(context, tableInfo, operationType, entityPropertyWithDefaultValue);
if (isAsync)
{
await context.Database.ExecuteSqlRawAsync(sqlMergeTable.sql, sqlMergeTable.parameters, cancellationToken).ConfigureAwait(false);
}
else
{
context.Database.ExecuteSqlRaw(sqlMergeTable.sql, sqlMergeTable.parameters);
}
if (tableInfo.CreatedOutputTable)
{
if (isAsync)
{
await tableInfo.LoadOutputDataAsync(context, type, entities, tableInfo, cancellationToken, isAsync : true).ConfigureAwait(false);
}
else
{
tableInfo.LoadOutputDataAsync(context, type, entities, tableInfo, cancellationToken, isAsync: false).GetAwaiter().GetResult();
}
}
}
finally
{
if (!tableInfo.BulkConfig.UseTempDB)
{
if (tableInfo.CreatedOutputTable)
{
var sqlDropOutputTable = SqlQueryBuilder.DropTable(tableInfo.FullTempOutputTableName, tableInfo.BulkConfig.UseTempDB);
if (isAsync)
{
await context.Database.ExecuteSqlRawAsync(sqlDropOutputTable, cancellationToken).ConfigureAwait(false);
}
else
{
context.Database.ExecuteSqlRaw(sqlDropOutputTable);
}
}
if (tableInfo.BulkConfig.CustomSourceTableName == null)
{
var sqlDropTable = SqlQueryBuilder.DropTable(tableInfo.FullTempTableName, tableInfo.BulkConfig.UseTempDB);
if (isAsync)
{
await context.Database.ExecuteSqlRawAsync(sqlDropTable, cancellationToken).ConfigureAwait(false);
}
else
{
context.Database.ExecuteSqlRaw(sqlDropTable);
}
}
}
if (keepIdentity && tableInfo.HasIdentity)
{
var sqlSetIdentityInsertFalse = SqlQueryBuilder.SetIdentityInsert(tableInfo.FullTableName, false);
if (isAsync)
{
await context.Database.ExecuteSqlRawAsync(sqlSetIdentityInsertFalse, cancellationToken).ConfigureAwait(false);
}
else
{
context.Database.ExecuteSqlRaw(sqlSetIdentityInsertFalse);
}
context.Database.CloseConnection();
}
}
}
public void SolveTask(string data, OperationType operationType)
{
CombControllerArgs combControllerArgs = new CombControllerArgs(data, operationType);
SolveTaskEvent(this, combControllerArgs);
}
/// <summary>
/// Logs the header of the summary of an operation
/// </summary>
/// <param name="operationType"></param>
/// <param name="libraryId"></param>
public static void LogEventsHeader(OperationType operationType, string libraryId)
{
LogEvent(LogMessageGenerator.GetOperationHeaderString(operationType, libraryId), LogLevel.Task);
}
private static void LogOperationSummary(IEnumerable <ILibraryOperationResult> totalResults, OperationType operation, TimeSpan elapsedTime)
{
string messageText = LogMessageGenerator.GetOperationSummaryString(totalResults, operation, elapsedTime);
if (!string.IsNullOrEmpty(messageText))
{
LogEvent(messageText, LogLevel.Operation);
}
}
/// <summary>
/// Logs errors messages for a given <see cref="OperationType"/>
/// </summary>
/// <param name="results">Operation results</param>
/// <param name="operationType"><see cref="OperationType"/></param>
/// <param name="endOfMessage">Whether or not to log end of message lines</param>
public static void LogErrorsSummary(IEnumerable <ILibraryOperationResult> results, OperationType operationType, bool endOfMessage = true)
{
List <string> errorStrings = GetErrorStrings(results);
LogErrorsSummary(errorStrings, operationType, endOfMessage);
}
public static void Run()
{
Console.WriteLine("\nDay 16");
List <string> input = new List <string>();
using (StreamReader reader = new StreamReader("input/input16-1.txt"))
{
string line;
while ((line = reader.ReadLine()) != null)
{
input.Add(line);
}
}
int total = 0;
List <List <OperationType> > opcodeCandidates = new List <List <OperationType> >();
for (OperationType op = OperationType.ADDR; op < OperationType.NUM_TYPES; op++)
{
opcodeCandidates.Add(Enumerable.Range(0, (int)OperationType.NUM_TYPES).Cast <OperationType>().ToList());
}
for (int index = 0; index < input.Count - 2; index = index + 4)
{
int[] before = new int[] { input[index][9] - '0', input[index][12] - '0', input[index][15] - '0', input[index][18] - '0' };
string[] operation = input[index + 1].Split(' ');
int[] operands = new int[] { int.Parse(operation[1]), int.Parse(operation[2]), int.Parse(operation[3]) };
int currOpcode = int.Parse(operation[0]);
int[] after = new int[] { input[index + 2][9] - '0', input[index + 2][12] - '0', input[index + 2][15] - '0', input[index + 2][18] - '0' };
int validOpcodes = 0;
for (OperationType opcode = OperationType.ADDR; opcode < OperationType.NUM_TYPES; opcode++)
{
int[] result = doOperation(opcode, before, operands);
bool validOp = true;
for (int i = 0; i < result.Length; i++)
{
if (result[i] != after[i])
{
opcodeCandidates[currOpcode].Remove(opcode);
validOp = false;
break;
}
}
if (validOp)
{
validOpcodes++;
if (validOpcodes == 3)
{
total++;
}
}
}
}
Dictionary <int, OperationType> assignedOpcodes = new Dictionary <int, OperationType>();
while (assignedOpcodes.Count < (int)OperationType.NUM_TYPES)
{
for (int index = 0; index < (int)OperationType.NUM_TYPES; index++)
{
if (assignedOpcodes.ContainsKey(index))
{
continue;
}
List <OperationType> toRemove = assignedOpcodes.Values.ToList();
opcodeCandidates[index].RemoveAll(x => toRemove.Contains(x));
}
for (int index = 0; index < (int)OperationType.NUM_TYPES; index++)
{
if (assignedOpcodes.ContainsKey(index))
{
continue;
}
if (opcodeCandidates[index].Count == 1)
{
assignedOpcodes.Add(index, opcodeCandidates[index][0]);
}
}
}
Console.WriteLine(String.Format("3+ opcode samples: {0}", total));
input = new List <string>();
using (StreamReader reader = new StreamReader("input/input16-2.txt"))
{
string line;
while ((line = reader.ReadLine()) != null)
{
input.Add(line);
}
}
int[] registers = new int[] { 0, 0, 0, 0 };
for (int index = 0; index < input.Count; index++)
{
string[] operation = input[index].Split(' ');
int[] operands = new int[] { int.Parse(operation[1]), int.Parse(operation[2]), int.Parse(operation[3]) };
OperationType currOpcode = assignedOpcodes[int.Parse(operation[0])];
registers = doOperation(currOpcode, registers, operands);
}
Console.WriteLine("Test program output: " + registers[0]);
}
public void FinishOperation(bool completeInstance, bool performPersistence, Exception operationException)
{
try
{
bool disposeInstance;
OperationType operation = FinishOperationCommon(completeInstance, operationException, out disposeInstance);
Fx.Assert(
(performPersistence || (operation != OperationType.Delete && operation != OperationType.Unlock)),
"If we aren't performing persistence then we are a NotAllowed contract and therefore should never have loaded from persistence.");
if (performPersistence)
{
switch (operation)
{
case OperationType.Unlock:
// Do the null check out here to avoid creating the scope
if (this.lockingProvider != null)
{
using (PersistenceScope scope = new PersistenceScope(
this.saveStateInOperationTransaction,
this.clonedTransaction))
{
this.lockingProvider.Unlock(this.operationTimeout);
}
}
break;
case OperationType.Delete:
using (PersistenceScope scope = new PersistenceScope(
this.saveStateInOperationTransaction,
this.clonedTransaction))
{
this.provider.Delete(this.instance, this.operationTimeout);
if (DiagnosticUtility.ShouldTraceInformation)
{
string traceText = SR.GetString(SR.TraceCodeServiceDurableInstanceDeleted, this.InstanceId);
TraceUtility.TraceEvent(TraceEventType.Information,
TraceCode.ServiceDurableInstanceDeleted, traceText,
new StringTraceRecord("DurableInstanceDetail", traceText),
this, null);
}
}
break;
case OperationType.Create:
using (PersistenceScope scope = new PersistenceScope(
this.saveStateInOperationTransaction,
this.clonedTransaction))
{
if (this.lockingProvider != null)
{
this.lockingProvider.Create(this.Instance, this.operationTimeout, disposeInstance);
}
else
{
this.provider.Create(this.Instance, this.operationTimeout);
}
if (DiagnosticUtility.ShouldTraceInformation)
{
string traceText = SR2.GetString(SR2.ServiceDurableInstanceSavedDetails, this.InstanceId, (this.lockingProvider != null) ? "True" : "False");
TraceUtility.TraceEvent(TraceEventType.Information,
TraceCode.ServiceDurableInstanceSaved, SR.GetString(SR.TraceCodeServiceDurableInstanceSaved),
new StringTraceRecord("DurableInstanceDetail", traceText),
this, null);
}
}
break;
case OperationType.Update:
using (PersistenceScope scope = new PersistenceScope(
this.saveStateInOperationTransaction,
this.clonedTransaction))
{
if (this.lockingProvider != null)
{
this.lockingProvider.Update(this.Instance, this.operationTimeout, disposeInstance);
}
else
{
this.provider.Update(this.Instance, this.operationTimeout);
}
if (DiagnosticUtility.ShouldTraceInformation)
{
string traceText = SR2.GetString(SR2.ServiceDurableInstanceSavedDetails, this.InstanceId, (this.lockingProvider != null) ? "True" : "False");
TraceUtility.TraceEvent(TraceEventType.Information,
TraceCode.ServiceDurableInstanceSaved, SR.GetString(SR.TraceCodeServiceDurableInstanceSaved),
new StringTraceRecord("DurableInstanceDetail", traceText),
this, null);
}
}
break;
case OperationType.None:
break;
default:
Fx.Assert("We should never get an unknown OperationType.");
break;
}
}
if (disposeInstance)
{
DisposeInstance();
}
}
finally
{
CompleteClonedTransaction();
}
}
/// <summary>
/// Gets the operation summary string based on number of successful and failure operations.
/// </summary>
public static string GetOperationSummaryString(IEnumerable <ILibraryOperationResult> results, OperationType operation, TimeSpan elapsedTime)
{
if (results != null && results.Any())
{
int totalResultsCounts = results.Count();
IEnumerable <ILibraryOperationResult> successfulResults = results.Where(r => r.Success && !r.UpToDate);
IEnumerable <ILibraryOperationResult> failedResults = results.Where(r => r.Errors.Any());
IEnumerable <ILibraryOperationResult> cancelledRessults = results.Where(r => r.Cancelled);
IEnumerable <ILibraryOperationResult> upToDateResults = results.Where(r => r.UpToDate);
bool allSuccess = successfulResults.Count() == totalResultsCounts;
bool allFailed = failedResults.Count() == totalResultsCounts;
bool allCancelled = cancelledRessults.Count() == totalResultsCounts;
bool allUpToDate = upToDateResults.Count() == totalResultsCounts;
string messageText = string.Empty;
string libraryId = string.Empty;
if (allUpToDate)
{
messageText = LibraryManager.Resources.Text.Restore_LibrariesUptodate + Environment.NewLine;
}
else if (allSuccess)
{
libraryId = GetLibraryId(results, operation);
messageText = LogMessageGenerator.GetAllSuccessString(operation, totalResultsCounts, elapsedTime, libraryId);
}
else if (allCancelled)
{
libraryId = GetLibraryId(results, operation);
messageText = LogMessageGenerator.GetAllCancelledString(operation, totalResultsCounts, elapsedTime, libraryId);
}
else if (allFailed)
{
libraryId = GetLibraryId(results, operation);
messageText = LogMessageGenerator.GetAllFailuresString(operation, totalResultsCounts, libraryId);
}
else
{
messageText = LogMessageGenerator.GetPartialSuccessString(operation,
successfulResults.Count(), failedResults.Count(), cancelledRessults.Count(), upToDateResults.Count(), elapsedTime);
}
return(messageText);
}
return(string.Empty);
}
protected ChooseOperation(bool highlightEntities, DocumentChoiceType choiceType, OperationType operationType = OperationType.Any)
: base(highlightEntities, choiceType, operationType)
{
}
public FinishOperationAsyncResult(ServiceDurableInstance durableInstance, bool completeInstance, bool performPersistence, Exception operationException, AsyncCallback callback, object state)
: base(callback, state)
{
this.durableInstance = durableInstance;
IAsyncResult result = null;
OperationType operation = OperationType.None;
bool completeSelf = false;
bool disposeInstace;
operation = this.durableInstance.FinishOperationCommon(completeInstance, operationException, out disposeInstace);
if (performPersistence)
{
switch (operation)
{
case OperationType.Unlock:
if (this.durableInstance.lockingProvider != null)
{
using (PersistenceScope scope = new PersistenceScope(
this.durableInstance.saveStateInOperationTransaction,
this.durableInstance.clonedTransaction))
{
result = this.durableInstance.lockingProvider.BeginUnlock(this.durableInstance.operationTimeout, unlockCallback, this);
}
}
break;
case OperationType.Delete:
using (PersistenceScope scope = new PersistenceScope(
this.durableInstance.saveStateInOperationTransaction,
this.durableInstance.clonedTransaction))
{
result = this.durableInstance.provider.BeginDelete(this.durableInstance.Instance, this.durableInstance.operationTimeout, deleteCallback, this);
}
break;
case OperationType.Create:
using (PersistenceScope scope = new PersistenceScope(
this.durableInstance.saveStateInOperationTransaction,
this.durableInstance.clonedTransaction))
{
if (this.durableInstance.lockingProvider != null)
{
result = this.durableInstance.lockingProvider.BeginCreate(this.durableInstance.Instance, this.durableInstance.operationTimeout, disposeInstace, createCallback, this);
}
else
{
result = this.durableInstance.provider.BeginCreate(this.durableInstance.Instance, this.durableInstance.operationTimeout, createCallback, this);
}
}
break;
case OperationType.Update:
using (PersistenceScope scope = new PersistenceScope(
this.durableInstance.saveStateInOperationTransaction,
this.durableInstance.clonedTransaction))
{
if (this.durableInstance.lockingProvider != null)
{
result = this.durableInstance.lockingProvider.BeginUpdate(this.durableInstance.Instance, this.durableInstance.operationTimeout, disposeInstace, updateCallback, this);
}
else
{
result = this.durableInstance.provider.BeginUpdate(this.durableInstance.Instance, this.durableInstance.operationTimeout, updateCallback, this);
}
}
break;
case OperationType.None:
break;
default:
Fx.Assert("Unknown OperationType was passed in.");
break;
}
}
if (disposeInstace)
{
this.durableInstance.DisposeInstance();
}
if (operation == OperationType.None ||
(result != null && result.CompletedSynchronously))
{
completeSelf = true;
}
if (!performPersistence)
{
Fx.Assert(result == null, "Should not have had a result if we didn't perform persistence.");
Complete(true);
return;
}
if (completeSelf)
{
CallEndOperation(operation, result);
Complete(true);
}
}
/// <summary>
/// Logs the footer message of the summary of an operation
/// </summary>
/// <param name="operationType"></param>
/// <param name="elapsedTime"></param>
public static void LogEventsFooter(OperationType operationType, TimeSpan elapsedTime)
{
LogEvent(string.Format(LibraryManager.Resources.Text.TimeElapsed, elapsedTime), LogLevel.Operation);
LogEvent(LibraryManager.Resources.Text.SummaryEndLine + Environment.NewLine, LogLevel.Operation);
}
// Extracted partition key might be invalid as CollectionCache might be stale.
// Stale collection cache is refreshed through PartitionKeyMismatchRetryPolicy
// and partition-key is extracted again.
private async Task <ResponseMessage> ExtractPartitionKeyAndProcessItemStreamAsync <T>(
PartitionKey?partitionKey,
string itemId,
T item,
OperationType operationType,
ItemRequestOptions requestOptions,
CosmosDiagnosticsContext diagnosticsContext,
CancellationToken cancellationToken)
{
if (diagnosticsContext == null)
{
throw new ArgumentNullException(nameof(diagnosticsContext));
}
Stream itemStream;
using (diagnosticsContext.CreateScope("ItemSerialize"))
{
itemStream = this.ClientContext.SerializerCore.ToStream <T>(item);
}
// User specified PK value, no need to extract it
if (partitionKey.HasValue)
{
return(await this.ProcessItemStreamAsync(
partitionKey,
itemId,
itemStream,
operationType,
requestOptions,
diagnosticsContext : diagnosticsContext,
cancellationToken : cancellationToken));
}
PartitionKeyMismatchRetryPolicy requestRetryPolicy = null;
while (true)
{
using (diagnosticsContext.CreateScope("ExtractPkValue"))
{
partitionKey = await this.GetPartitionKeyValueFromStreamAsync(itemStream, cancellationToken);
}
ResponseMessage responseMessage = await this.ProcessItemStreamAsync(
partitionKey,
itemId,
itemStream,
operationType,
requestOptions,
diagnosticsContext : diagnosticsContext,
cancellationToken : cancellationToken);
if (responseMessage.IsSuccessStatusCode)
{
return(responseMessage);
}
if (requestRetryPolicy == null)
{
requestRetryPolicy = new PartitionKeyMismatchRetryPolicy(await this.ClientContext.DocumentClient.GetCollectionCacheAsync(), null);
}
ShouldRetryResult retryResult = await requestRetryPolicy.ShouldRetryAsync(responseMessage, cancellationToken);
if (!retryResult.ShouldRetry)
{
return(responseMessage);
}
}
}
/// <summary>
/// Logs the summary messages for a given <see cref="OperationType"/>
/// </summary>
/// <param name="totalResults"></param>
/// <param name="operationType"></param>
/// <param name="elapsedTime"></param>
/// <param name="endOfMessage"></param>
public static void LogEventsSummary(IEnumerable <ILibraryOperationResult> totalResults, OperationType operationType, TimeSpan elapsedTime, bool endOfMessage = true)
{
LogErrors(totalResults);
LogEvent(LogMessageGenerator.GetSummaryHeaderString(operationType), LogLevel.Task);
LogOperationSummary(totalResults, operationType, elapsedTime);
if (endOfMessage)
{
LogEventsFooter(operationType, elapsedTime);
}
}
public async Task MergeAsync <T>(DbContext context, Type type, IList <T> entities, TableInfo tableInfo, OperationType operationType, Action <decimal> progress, CancellationToken cancellationToken) where T : class
{
await MergeAsync(context, type, entities, tableInfo, operationType, progress, cancellationToken, isAsync : true).ConfigureAwait(false);
}
public static void Execute <T>(DbContext context, Type type, IList <T> entities, OperationType operationType, BulkConfig bulkConfig, Action <decimal> progress) where T : class
{
type ??= typeof(T);
using (ActivitySources.StartExecuteActivity(operationType, entities.Count))
{
if (entities.Count == 0 &&
operationType != OperationType.InsertOrUpdateOrDelete &&
operationType != OperationType.Truncate &&
operationType != OperationType.SaveChanges &&
(bulkConfig == null || bulkConfig.CustomSourceTableName == null))
{
return;
}
if (operationType == OperationType.SaveChanges)
{
DbContextBulkTransactionSaveChanges.SaveChanges(context, bulkConfig, progress);
return;
}
else if (bulkConfig?.IncludeGraph == true)
{
DbContextBulkTransactionGraphUtil.ExecuteWithGraph(context, entities, operationType, bulkConfig, progress);
}
else
{
TableInfo tableInfo = TableInfo.CreateInstance(context, type, entities, operationType, bulkConfig);
if (operationType == OperationType.Insert && !tableInfo.BulkConfig.SetOutputIdentity && tableInfo.BulkConfig.CustomSourceTableName == null)
{
SqlBulkOperation.Insert(context, type, entities, tableInfo, progress);
}
else if (operationType == OperationType.Read)
{
SqlBulkOperation.Read(context, type, entities, tableInfo, progress);
}
else if (operationType == OperationType.Truncate)
{
SqlBulkOperation.Truncate(context, tableInfo);
}
else
{
SqlBulkOperation.Merge(context, type, entities, tableInfo, operationType, progress);
}
}
}
}
public async Task AddClaimsAsync(OperationType operationType, string fieldPath, List <Claim> claims)
{
AddClaims(operationType, fieldPath, claims);
}
public static async Task ExecuteAsync <T>(DbContext context, Type type, IList <T> entities, OperationType operationType, BulkConfig bulkConfig, Action <decimal> progress, CancellationToken cancellationToken = default) where T : class
{
type ??= typeof(T);
using (ActivitySources.StartExecuteActivity(operationType, entities.Count))
{
if (entities.Count == 0 && operationType != OperationType.InsertOrUpdateOrDelete && operationType != OperationType.Truncate && operationType != OperationType.SaveChanges)
{
return;
}
if (operationType == OperationType.SaveChanges)
{
await DbContextBulkTransactionSaveChanges.SaveChangesAsync(context, bulkConfig, progress, cancellationToken);
}
else if (bulkConfig?.IncludeGraph == true)
{
await DbContextBulkTransactionGraphUtil.ExecuteWithGraphAsync(context, entities, operationType, bulkConfig, progress, cancellationToken);
}
else
{
TableInfo tableInfo = TableInfo.CreateInstance(context, type, entities, operationType, bulkConfig);
if (operationType == OperationType.Insert && !tableInfo.BulkConfig.SetOutputIdentity)
{
await SqlBulkOperation.InsertAsync(context, type, entities, tableInfo, progress, cancellationToken);
}
else if (operationType == OperationType.Read)
{
await SqlBulkOperation.ReadAsync(context, type, entities, tableInfo, progress, cancellationToken);
}
else if (operationType == OperationType.Truncate)
{
await SqlBulkOperation.TruncateAsync(context, tableInfo, cancellationToken);
}
else
{
await SqlBulkOperation.MergeAsync(context, type, entities, tableInfo, operationType, progress, cancellationToken);
}
}
}
}
public async Task <IEnumerable <History> > GetAllAsyncBy(string currency, OperationType operationType) => await _context.History.Where(x => x.Currency == currency.ToUpperInvariant()) .Where(x => x.OperationType == operationType) .OrderByDescending(x => x.ExchangeTime) .ToListAsync();
public OperationResult(OperationType operationType, object result)
{
OperationType = operationType;
Result = result;
}
private OperationType GetOperation(
TypeContext tc,
ResolvedTypeCategory leftType,
ResolvedTypeCategory rightType,
string op)
{
Dictionary <string, Dictionary <ResolvedTypeCategory, Dictionary <ResolvedTypeCategory, OperationType> > > consolidationLookup;
if (tc.OpConsolidationLookupHack != null)
{
consolidationLookup = (Dictionary <string, Dictionary <ResolvedTypeCategory, Dictionary <ResolvedTypeCategory, OperationType> > >)tc.OpConsolidationLookupHack;
}
else
{
consolidationLookup = new Dictionary <string, Dictionary <ResolvedTypeCategory, Dictionary <ResolvedTypeCategory, OperationType> > >();
tc.OpConsolidationLookupHack = consolidationLookup;
OperationType[] operations = new OperationType[] {
new OperationType(ResolvedTypeCategory.NULL, ResolvedTypeCategory.NULL, "==", tc.BOOLEAN, (opChain) => { return(MakeBool(opChain.FirstToken, true)); }),
new OperationType(ResolvedTypeCategory.NULL, ResolvedTypeCategory.NULL, "!=", tc.BOOLEAN, (opChain) => { return(MakeBool(opChain.FirstToken, false)); }),
new OperationType(ResolvedTypeCategory.BOOLEAN, ResolvedTypeCategory.BOOLEAN, "==", tc.BOOLEAN, (opChain) => { return(MakeBool(opChain.FirstToken, GetBool(opChain.Left) == GetBool(opChain.Right))); }),
new OperationType(ResolvedTypeCategory.BOOLEAN, ResolvedTypeCategory.BOOLEAN, "!=", tc.BOOLEAN, (opChain) => { return(MakeBool(opChain.FirstToken, GetBool(opChain.Left) != GetBool(opChain.Right))); }),
new OperationType(ResolvedTypeCategory.INTEGER, ResolvedTypeCategory.INTEGER, "&", tc.INTEGER, (opChain) => { return(MakeInt(opChain.FirstToken, GetInt(opChain.Left) & GetInt(opChain.Right))); }),
new OperationType(ResolvedTypeCategory.INTEGER, ResolvedTypeCategory.INTEGER, "|", tc.INTEGER, (opChain) => { return(MakeInt(opChain.FirstToken, GetInt(opChain.Left) | GetInt(opChain.Right))); }),
new OperationType(ResolvedTypeCategory.INTEGER, ResolvedTypeCategory.INTEGER, "^", tc.INTEGER, (opChain) => { return(MakeInt(opChain.FirstToken, GetInt(opChain.Left) ^ GetInt(opChain.Right))); }),
new OperationType(ResolvedTypeCategory.INTEGER, ResolvedTypeCategory.INTEGER, "<<", tc.INTEGER, (opChain) =>
{
int right = GetInt(opChain.Right);
if (right < 0)
{
throw new ParserException(opChain.FirstToken, "Cannot bit shift by a negative number.");
}
return(MakeInt(opChain.FirstToken, GetInt(opChain.Left) << right));
}),
new OperationType(ResolvedTypeCategory.INTEGER, ResolvedTypeCategory.INTEGER, ">>", tc.INTEGER, (opChain) =>
{
int right = GetInt(opChain.Right);
if (right < 0)
{
throw new ParserException(opChain.FirstToken, "Cannot bit shift by a negative number.");
}
return(MakeInt(opChain.FirstToken, GetInt(opChain.Left) >> right));
}),
new OperationType(ResolvedTypeCategory.INTEGER, ResolvedTypeCategory.INTEGER, "+", tc.INTEGER, (opChain) => { return(MakeInt(opChain.FirstToken, GetInt(opChain.Left) + GetInt(opChain.Right))); }),
new OperationType(ResolvedTypeCategory.INTEGER, ResolvedTypeCategory.INTEGER, "-", tc.INTEGER, (opChain) => { return(MakeInt(opChain.FirstToken, GetInt(opChain.Left) - GetInt(opChain.Right))); }),
new OperationType(ResolvedTypeCategory.INTEGER, ResolvedTypeCategory.INTEGER, "*", tc.INTEGER, (opChain) => { return(MakeInt(opChain.FirstToken, GetInt(opChain.Left) * GetInt(opChain.Right))); }),
new OperationType(ResolvedTypeCategory.INTEGER, ResolvedTypeCategory.INTEGER, "/", tc.INTEGER, (opChain) => { CheckZero(opChain.Right); return(MakeInt(opChain.FirstToken, GetInt(opChain.Left) / GetInt(opChain.Right))); }),
new OperationType(ResolvedTypeCategory.INTEGER, ResolvedTypeCategory.INTEGER, "%", tc.INTEGER, (opChain) => { return(MakeInt(opChain.FirstToken, PositiveModInt(opChain.Left, opChain.Right))); }),
new OperationType(ResolvedTypeCategory.INTEGER, ResolvedTypeCategory.INTEGER, "<=", tc.BOOLEAN, (opChain) => { return(MakeBool(opChain.FirstToken, GetInt(opChain.Left) <= GetInt(opChain.Right))); }),
new OperationType(ResolvedTypeCategory.INTEGER, ResolvedTypeCategory.INTEGER, ">=", tc.BOOLEAN, (opChain) => { return(MakeBool(opChain.FirstToken, GetInt(opChain.Left) >= GetInt(opChain.Right))); }),
new OperationType(ResolvedTypeCategory.INTEGER, ResolvedTypeCategory.INTEGER, "<", tc.BOOLEAN, (opChain) => { return(MakeBool(opChain.FirstToken, GetInt(opChain.Left) < GetInt(opChain.Right))); }),
new OperationType(ResolvedTypeCategory.INTEGER, ResolvedTypeCategory.INTEGER, ">", tc.BOOLEAN, (opChain) => { return(MakeBool(opChain.FirstToken, GetInt(opChain.Left) > GetInt(opChain.Right))); }),
new OperationType(ResolvedTypeCategory.INTEGER, ResolvedTypeCategory.INTEGER, "==", tc.BOOLEAN, (opChain) => { return(MakeBool(opChain.FirstToken, GetInt(opChain.Left) == GetInt(opChain.Right))); }),
new OperationType(ResolvedTypeCategory.INTEGER, ResolvedTypeCategory.INTEGER, "!=", tc.BOOLEAN, (opChain) => { return(MakeBool(opChain.FirstToken, GetInt(opChain.Left) != GetInt(opChain.Right))); }),
new OperationType(ResolvedTypeCategory.INTEGER, ResolvedTypeCategory.INTEGER, "**", tc.FLOAT, (opChain) =>
{
int right = GetInt(opChain.Right);
int left = GetInt(opChain.Left);
if (right == 0)
{
return(MakeFloat(opChain.FirstToken, 1.0));
}
return(MakeFloat(opChain.FirstToken, Math.Pow(left, right)));
}),
new OperationType(ResolvedTypeCategory.INTEGER, ResolvedTypeCategory.FLOAT, "+", tc.FLOAT, (opChain) => { return(MakeFloat(opChain.FirstToken, GetInt(opChain.Left) + GetFloat(opChain.Right))); }),
new OperationType(ResolvedTypeCategory.INTEGER, ResolvedTypeCategory.FLOAT, "-", tc.FLOAT, (opChain) => { return(MakeFloat(opChain.FirstToken, GetInt(opChain.Left) - GetFloat(opChain.Right))); }),
new OperationType(ResolvedTypeCategory.INTEGER, ResolvedTypeCategory.FLOAT, "*", tc.FLOAT, (opChain) => { return(MakeFloat(opChain.FirstToken, GetInt(opChain.Left) * GetFloat(opChain.Right))); }),
new OperationType(ResolvedTypeCategory.INTEGER, ResolvedTypeCategory.FLOAT, "/", tc.FLOAT, (opChain) => { CheckZero(opChain.Right); return(MakeFloat(opChain.FirstToken, GetInt(opChain.Left) / GetFloat(opChain.Right))); }),
new OperationType(ResolvedTypeCategory.INTEGER, ResolvedTypeCategory.FLOAT, "%", tc.FLOAT, (opChain) => { return(MakeFloat(opChain.FirstToken, PositiveModFloat(opChain.Left, opChain.Right))); }),
new OperationType(ResolvedTypeCategory.INTEGER, ResolvedTypeCategory.FLOAT, "<=", tc.BOOLEAN, (opChain) => { return(MakeBool(opChain.FirstToken, GetInt(opChain.Left) <= GetFloat(opChain.Right))); }),
new OperationType(ResolvedTypeCategory.INTEGER, ResolvedTypeCategory.FLOAT, ">=", tc.BOOLEAN, (opChain) => { return(MakeBool(opChain.FirstToken, GetInt(opChain.Left) >= GetFloat(opChain.Right))); }),
new OperationType(ResolvedTypeCategory.INTEGER, ResolvedTypeCategory.FLOAT, "<", tc.BOOLEAN, (opChain) => { return(MakeBool(opChain.FirstToken, GetInt(opChain.Left) < GetFloat(opChain.Right))); }),
new OperationType(ResolvedTypeCategory.INTEGER, ResolvedTypeCategory.FLOAT, ">", tc.BOOLEAN, (opChain) => { return(MakeBool(opChain.FirstToken, GetInt(opChain.Left) > GetFloat(opChain.Right))); }),
new OperationType(ResolvedTypeCategory.INTEGER, ResolvedTypeCategory.FLOAT, "==", tc.BOOLEAN, (opChain) => { return(MakeBool(opChain.FirstToken, GetInt(opChain.Left) == GetFloat(opChain.Right))); }),
new OperationType(ResolvedTypeCategory.INTEGER, ResolvedTypeCategory.FLOAT, "!=", tc.BOOLEAN, (opChain) => { return(MakeBool(opChain.FirstToken, GetInt(opChain.Left) != GetFloat(opChain.Right))); }),
new OperationType(ResolvedTypeCategory.INTEGER, ResolvedTypeCategory.FLOAT, "**", tc.FLOAT, (opChain) =>
{
double right = GetFloat(opChain.Right);
int left = GetInt(opChain.Left);
if (FloatIsAbsoluteZero(right))
{
return(MakeFloat(opChain.FirstToken, 1.0));
}
if (!FloatIsAbsoluteZero(right % 1) && left < 0)
{
throw new ParserException(opChain.OpToken, "Exponent creates a complex expression.");
}
return(MakeFloat(opChain.FirstToken, Math.Pow(left, right)));
}),
new OperationType(ResolvedTypeCategory.FLOAT, ResolvedTypeCategory.INTEGER, "+", tc.FLOAT, (opChain) => { return(MakeFloat(opChain.FirstToken, GetFloat(opChain.Left) + GetInt(opChain.Right))); }),
new OperationType(ResolvedTypeCategory.FLOAT, ResolvedTypeCategory.INTEGER, "-", tc.FLOAT, (opChain) => { return(MakeFloat(opChain.FirstToken, GetFloat(opChain.Left) - GetInt(opChain.Right))); }),
new OperationType(ResolvedTypeCategory.FLOAT, ResolvedTypeCategory.INTEGER, "*", tc.FLOAT, (opChain) => { return(MakeFloat(opChain.FirstToken, GetFloat(opChain.Left) * GetInt(opChain.Right))); }),
new OperationType(ResolvedTypeCategory.FLOAT, ResolvedTypeCategory.INTEGER, "/", tc.FLOAT, (opChain) => { CheckZero(opChain.Right); return(MakeFloat(opChain.FirstToken, GetFloat(opChain.Left) / GetInt(opChain.Right))); }),
new OperationType(ResolvedTypeCategory.FLOAT, ResolvedTypeCategory.INTEGER, "%", tc.FLOAT, (opChain) => { return(MakeFloat(opChain.FirstToken, PositiveModFloat(opChain.Left, opChain.Right))); }),
new OperationType(ResolvedTypeCategory.FLOAT, ResolvedTypeCategory.INTEGER, "<=", tc.BOOLEAN, (opChain) => { return(MakeBool(opChain.FirstToken, GetFloat(opChain.Left) <= GetInt(opChain.Right))); }),
new OperationType(ResolvedTypeCategory.FLOAT, ResolvedTypeCategory.INTEGER, ">=", tc.BOOLEAN, (opChain) => { return(MakeBool(opChain.FirstToken, GetFloat(opChain.Left) >= GetInt(opChain.Right))); }),
new OperationType(ResolvedTypeCategory.FLOAT, ResolvedTypeCategory.INTEGER, "<", tc.BOOLEAN, (opChain) => { return(MakeBool(opChain.FirstToken, GetFloat(opChain.Left) < GetInt(opChain.Right))); }),
new OperationType(ResolvedTypeCategory.FLOAT, ResolvedTypeCategory.INTEGER, ">", tc.BOOLEAN, (opChain) => { return(MakeBool(opChain.FirstToken, GetFloat(opChain.Left) > GetInt(opChain.Right))); }),
new OperationType(ResolvedTypeCategory.FLOAT, ResolvedTypeCategory.INTEGER, "==", tc.BOOLEAN, (opChain) => { return(MakeBool(opChain.FirstToken, GetFloat(opChain.Left) == GetInt(opChain.Right))); }),
new OperationType(ResolvedTypeCategory.FLOAT, ResolvedTypeCategory.INTEGER, "!=", tc.BOOLEAN, (opChain) => { return(MakeBool(opChain.FirstToken, GetFloat(opChain.Left) != GetInt(opChain.Right))); }),
new OperationType(ResolvedTypeCategory.FLOAT, ResolvedTypeCategory.INTEGER, "**", tc.FLOAT, (opChain) =>
{
int right = GetInt(opChain.Right);
double left = GetFloat(opChain.Left);
if (right == 0)
{
return(MakeFloat(opChain.FirstToken, 1.0));
}
return(MakeFloat(opChain.FirstToken, Math.Pow(left, right)));
}),
new OperationType(ResolvedTypeCategory.FLOAT, ResolvedTypeCategory.FLOAT, "+", tc.FLOAT, (opChain) => { return(MakeFloat(opChain.FirstToken, GetFloat(opChain.Left) + GetFloat(opChain.Right))); }),
new OperationType(ResolvedTypeCategory.FLOAT, ResolvedTypeCategory.FLOAT, "-", tc.FLOAT, (opChain) => { return(MakeFloat(opChain.FirstToken, GetFloat(opChain.Left) - GetFloat(opChain.Right))); }),
new OperationType(ResolvedTypeCategory.FLOAT, ResolvedTypeCategory.FLOAT, "*", tc.FLOAT, (opChain) => { return(MakeFloat(opChain.FirstToken, GetFloat(opChain.Left) * GetFloat(opChain.Right))); }),
new OperationType(ResolvedTypeCategory.FLOAT, ResolvedTypeCategory.FLOAT, "/", tc.FLOAT, (opChain) => { CheckZero(opChain.Right); return(MakeFloat(opChain.FirstToken, GetFloat(opChain.Left) / GetFloat(opChain.Right))); }),
new OperationType(ResolvedTypeCategory.FLOAT, ResolvedTypeCategory.FLOAT, "%", tc.FLOAT, (opChain) => { return(MakeFloat(opChain.FirstToken, PositiveModFloat(opChain.Left, opChain.Right))); }),
new OperationType(ResolvedTypeCategory.FLOAT, ResolvedTypeCategory.FLOAT, "<=", tc.BOOLEAN, (opChain) => { return(MakeBool(opChain.FirstToken, GetFloat(opChain.Left) <= GetFloat(opChain.Right))); }),
new OperationType(ResolvedTypeCategory.FLOAT, ResolvedTypeCategory.FLOAT, ">=", tc.BOOLEAN, (opChain) => { return(MakeBool(opChain.FirstToken, GetFloat(opChain.Left) >= GetFloat(opChain.Right))); }),
new OperationType(ResolvedTypeCategory.FLOAT, ResolvedTypeCategory.FLOAT, "<", tc.BOOLEAN, (opChain) => { return(MakeBool(opChain.FirstToken, GetFloat(opChain.Left) < GetFloat(opChain.Right))); }),
new OperationType(ResolvedTypeCategory.FLOAT, ResolvedTypeCategory.FLOAT, ">", tc.BOOLEAN, (opChain) => { return(MakeBool(opChain.FirstToken, GetFloat(opChain.Left) > GetFloat(opChain.Right))); }),
new OperationType(ResolvedTypeCategory.FLOAT, ResolvedTypeCategory.FLOAT, "==", tc.BOOLEAN, (opChain) => { return(MakeBool(opChain.FirstToken, GetFloat(opChain.Left) == GetFloat(opChain.Right))); }),
new OperationType(ResolvedTypeCategory.FLOAT, ResolvedTypeCategory.FLOAT, "!=", tc.BOOLEAN, (opChain) => { return(MakeBool(opChain.FirstToken, GetFloat(opChain.Left) != GetFloat(opChain.Right))); }),
new OperationType(ResolvedTypeCategory.FLOAT, ResolvedTypeCategory.FLOAT, "**", tc.FLOAT, (opChain) =>
{
double right = GetFloat(opChain.Right);
double left = GetFloat(opChain.Left);
if (FloatIsAbsoluteZero(right))
{
return(MakeFloat(opChain.FirstToken, 1.0));
}
if (!FloatIsAbsoluteZero(right % 1) && left < 0)
{
throw new ParserException(opChain.OpToken, "Exponent creates a complex expression.");
}
return(MakeFloat(opChain.FirstToken, Math.Pow(left, right)));
}),
new OperationType(ResolvedTypeCategory.BOOLEAN, ResolvedTypeCategory.STRING, "+", tc.STRING, (opChain) => { return(MakeString(opChain.FirstToken, GetBool(opChain.Left).ToString() + GetString(opChain.Right))); }),
new OperationType(ResolvedTypeCategory.INTEGER, ResolvedTypeCategory.STRING, "+", tc.STRING, (opChain) => { return(MakeString(opChain.FirstToken, GetInt(opChain.Left).ToString() + GetString(opChain.Right))); }),
new OperationType(ResolvedTypeCategory.FLOAT, ResolvedTypeCategory.STRING, "+", tc.STRING, (opChain) => { return(MakeString(opChain.FirstToken, GetFloatAsString(opChain.Left) + GetString(opChain.Right))); }),
new OperationType(ResolvedTypeCategory.STRING, ResolvedTypeCategory.BOOLEAN, "+", tc.STRING, (opChain) => { return(MakeString(opChain.FirstToken, GetString(opChain.Left) + GetBool(opChain.Right).ToString())); }),
new OperationType(ResolvedTypeCategory.STRING, ResolvedTypeCategory.INTEGER, "+", tc.STRING, (opChain) => { return(MakeString(opChain.FirstToken, GetString(opChain.Left) + GetInt(opChain.Right).ToString())); }),
new OperationType(ResolvedTypeCategory.STRING, ResolvedTypeCategory.FLOAT, "+", tc.STRING, (opChain) => { return(MakeString(opChain.FirstToken, GetString(opChain.Left) + GetFloatAsString(opChain.Right))); }),
new OperationType(ResolvedTypeCategory.STRING, ResolvedTypeCategory.STRING, "+", tc.STRING, (opChain) => { return(MakeString(opChain.FirstToken, GetString(opChain.Left) + GetString(opChain.Right))); }),
new OperationType(ResolvedTypeCategory.STRING, ResolvedTypeCategory.STRING, "==", tc.BOOLEAN, (opChain) => { return(MakeBool(opChain.FirstToken, GetString(opChain.Left) == GetString(opChain.Right))); }),
new OperationType(ResolvedTypeCategory.STRING, ResolvedTypeCategory.STRING, "!=", tc.BOOLEAN, (opChain) => { return(MakeBool(opChain.FirstToken, GetString(opChain.Left) != GetString(opChain.Right))); }),
new OperationType(ResolvedTypeCategory.STRING, ResolvedTypeCategory.INSTANCE, "+", tc.STRING, null),
new OperationType(ResolvedTypeCategory.INSTANCE, ResolvedTypeCategory.STRING, "+", tc.STRING, null),
new OperationType(ResolvedTypeCategory.STRING, ResolvedTypeCategory.CLASS_DEFINITION, "+", tc.STRING, null),
new OperationType(ResolvedTypeCategory.CLASS_DEFINITION, ResolvedTypeCategory.STRING, "+", tc.STRING, null),
new OperationType(ResolvedTypeCategory.STRING, ResolvedTypeCategory.FUNCTION_POINTER, "+", tc.STRING, null),
new OperationType(ResolvedTypeCategory.FUNCTION_POINTER, ResolvedTypeCategory.STRING, "+", tc.STRING, null),
new OperationType(ResolvedTypeCategory.STRING, ResolvedTypeCategory.LIST, "+", tc.STRING, null),
new OperationType(ResolvedTypeCategory.LIST, ResolvedTypeCategory.STRING, "+", tc.STRING, null),
new OperationType(ResolvedTypeCategory.STRING, ResolvedTypeCategory.DICTIONARY, "+", tc.STRING, null),
new OperationType(ResolvedTypeCategory.DICTIONARY, ResolvedTypeCategory.STRING, "+", tc.STRING, null),
new OperationType(ResolvedTypeCategory.STRING, ResolvedTypeCategory.OBJECT, "+", tc.STRING, null),
new OperationType(ResolvedTypeCategory.OBJECT, ResolvedTypeCategory.STRING, "+", tc.STRING, null),
new OperationType(ResolvedTypeCategory.BOOLEAN, ResolvedTypeCategory.BOOLEAN, "&&", tc.BOOLEAN, (opChain) => { return(MakeBool(opChain.FirstToken, GetBool(opChain.Left) && GetBool(opChain.Right))); }),
new OperationType(ResolvedTypeCategory.BOOLEAN, ResolvedTypeCategory.BOOLEAN, "||", tc.BOOLEAN, (opChain) => { return(MakeBool(opChain.FirstToken, GetBool(opChain.Left) || GetBool(opChain.Right))); }),
new OperationType(ResolvedTypeCategory.INTEGER, ResolvedTypeCategory.STRING, "*", tc.STRING, (opChain) => { return(GenerateMultipliedStringIfNotTooLong(opChain, opChain.Left, opChain.Right)); }),
new OperationType(ResolvedTypeCategory.STRING, ResolvedTypeCategory.INTEGER, "*", tc.STRING, (opChain) => { return(GenerateMultipliedStringIfNotTooLong(opChain, opChain.Left, opChain.Right)); }),
};
foreach (OperationType ot in operations)
{
if (!consolidationLookup.ContainsKey(ot.Op))
{
consolidationLookup[ot.Op] = new Dictionary <ResolvedTypeCategory, Dictionary <ResolvedTypeCategory, OperationType> >();
}
if (!consolidationLookup[ot.Op].ContainsKey(ot.LeftType))
{
consolidationLookup[ot.Op][ot.LeftType] = new Dictionary <ResolvedTypeCategory, OperationType>();
}
consolidationLookup[ot.Op][ot.LeftType].Add(ot.RightType, ot); // causes exception if duplicate
}
}
// The op will always have some types registered, so you can dereference the first level of lookups without checking.
Dictionary <ResolvedTypeCategory, Dictionary <ResolvedTypeCategory, OperationType> > l1 = consolidationLookup[op];
if (l1.ContainsKey(leftType))
{
Dictionary <ResolvedTypeCategory, OperationType> l2 = l1[leftType];
if (l2.ContainsKey(rightType))
{
return(l2[rightType]);
}
}
if (op == "==")
{
// == comparisons between different kinds of objects should resolve to false at compile time.
// Lazily initialize these operation types as they are encountered.
if (leftType != rightType &&
!(leftType == ResolvedTypeCategory.INTEGER && rightType == ResolvedTypeCategory.FLOAT) &&
!(leftType == ResolvedTypeCategory.FLOAT && rightType == ResolvedTypeCategory.INTEGER) &&
leftType != ResolvedTypeCategory.ANY &&
rightType != ResolvedTypeCategory.ANY &&
leftType != ResolvedTypeCategory.OBJECT &&
rightType != ResolvedTypeCategory.OBJECT)
{
if (!consolidationLookup[op].ContainsKey(leftType))
{
consolidationLookup[op][leftType] = new Dictionary <ResolvedTypeCategory, OperationType>();
}
OperationType ot = new OperationType(leftType, rightType, op, tc.BOOLEAN, (opChain) => { return(MakeBool(opChain.FirstToken, false)); });
consolidationLookup[op][leftType][rightType] = ot;
return(ot);
}
}
return(null);
}
static int[] doOperation(OperationType opcode, int[] before, int[] operands)
{
int[] result = new int[4];
before.CopyTo(result, 0);
switch (opcode)
{
case OperationType.ADDI:
result[operands[2]] = before[operands[0]] + operands[1];
return(result);
case OperationType.ADDR:
result[operands[2]] = before[operands[0]] + before[operands[1]];
return(result);
case OperationType.MULI:
result[operands[2]] = before[operands[0]] * operands[1];
return(result);
case OperationType.MULR:
result[operands[2]] = before[operands[0]] * before[operands[1]];
return(result);
case OperationType.BANI:
result[operands[2]] = before[operands[0]] & operands[1];
return(result);
case OperationType.BANR:
result[operands[2]] = before[operands[0]] & before[operands[1]];
return(result);
case OperationType.BORI:
result[operands[2]] = before[operands[0]] | operands[1];
return(result);
case OperationType.BORR:
result[operands[2]] = before[operands[0]] | before[operands[1]];
return(result);
case OperationType.SETI:
result[operands[2]] = operands[0];
return(result);
case OperationType.SETR:
result[operands[2]] = before[operands[0]];
return(result);
case OperationType.EQIR:
result[operands[2]] = operands[0] == before[operands[1]] ? 1 : 0;
return(result);
case OperationType.EQRI:
result[operands[2]] = before[operands[0]] == operands[1] ? 1 : 0;
return(result);
case OperationType.EQRR:
result[operands[2]] = before[operands[0]] == before[operands[1]] ? 1 : 0;
return(result);
case OperationType.GTIR:
result[operands[2]] = operands[0] > before[operands[1]] ? 1 : 0;
return(result);
case OperationType.GTRI:
result[operands[2]] = before[operands[0]] > operands[1] ? 1 : 0;
return(result);
case OperationType.GTRR:
result[operands[2]] = before[operands[0]] > before[operands[1]] ? 1 : 0;
return(result);
default:
return(null);
}
}
private Parameters(OperationType operation, string inputFilePath, string outputFilePath)
{
Operation = operation;
InputFilePath = inputFilePath;
OutputFilePath = outputFilePath;
}
public ExerciseOption(IntervalType resultIntervalType, OperationType operationType, QuantityType quantityType)
{
this.resultIntervalType = resultIntervalType;
this.operationType = operationType;
this.quantityType = quantityType;
}
private ReadOnlyCollection <Uri> GetPreferredAvailableEndpoints(ReadOnlyDictionary <string, Uri> endpointsByLocation, ReadOnlyCollection <string> orderedLocations, OperationType expectedAvailableOperation, Uri fallbackEndpoint)
{
List <Uri> endpoints = new List <Uri>();
DatabaseAccountLocationsInfo currentLocationInfo = this.locationInfo;
// if enableEndpointDiscovery is false, we always use the defaultEndpoint that user passed in during documentClient init
if (this.enableEndpointDiscovery)
{
if (this.CanUseMultipleWriteLocations() || expectedAvailableOperation.HasFlag(OperationType.Read))
{
List <Uri> unavailableEndpoints = new List <Uri>();
// When client can not use multiple write locations, preferred locations list should only be used
// determining read endpoints order.
// If client can use multiple write locations, preferred locations list should be used for determining
// both read and write endpoints order.
foreach (string location in currentLocationInfo.PreferredLocations)
{
Uri endpoint;
if (endpointsByLocation.TryGetValue(location, out endpoint))
{
if (this.IsEndpointUnavailable(endpoint, expectedAvailableOperation))
{
unavailableEndpoints.Add(endpoint);
}
else
{
endpoints.Add(endpoint);
}
}
}
if (endpoints.Count == 0)
{
endpoints.Add(fallbackEndpoint);
}
endpoints.AddRange(unavailableEndpoints);
}
else
{
foreach (string location in orderedLocations)
{
Uri endpoint;
if (!string.IsNullOrEmpty(location) && // location is empty during manual failover
endpointsByLocation.TryGetValue(location, out endpoint))
{
endpoints.Add(endpoint);
}
}
}
}
if (endpoints.Count == 0)
{
endpoints.Add(fallbackEndpoint);
}
return(endpoints.AsReadOnly());
}
public CombControllerArgs(string data, OperationType operationType)
{
Data = data;
OperationType = operationType;
}
private static string GetLibraryId(IEnumerable <ILibraryOperationResult> totalResults, OperationType operation)
{
if (operation == OperationType.Uninstall || operation == OperationType.Upgrade)
{
if (totalResults != null && totalResults.Count() == 1)
{
return(totalResults.First().InstallationState.LibraryId);
}
}
return(string.Empty);
}
OperationType FinishOperationCommon(bool completeInstance, Exception operationException, out bool disposeInstance)
{
// No need for Interlocked because we don't support
// ConcurrencyMode.Multiple
this.outstandingOperations--;
DurableOperationContext.EndOperation();
Fx.Assert(this.outstandingOperations >= 0,
"OutstandingOperations should never go below zero.");
Fx.Assert(this.instance != null,
"Instance should never been null here - we only get here if StartOperation completes successfully.");
OperationType operation = OperationType.None;
disposeInstance = false;
// This is a "fuzzy" still referenced. Immediately
// after this line another message could come in and
// reference this InstanceContext, but it doesn't matter
// because regardless of scheme used the other message
// would have had to reacquire the database lock.
bool stillReferenced = this.contextManager.GetReferenceCount(this.InstanceId) > 1;
this.markedForCompletion |= completeInstance;
if (this.outstandingOperations == 0)
{
if (this.saveStateInOperationTransaction &&
this.clonedTransaction != null &&
this.clonedTransaction.TransactionInformation.Status == TransactionStatus.Aborted)
{
this.abortInstance = false;
this.markedForCompletion = false;
disposeInstance = true;
}
else if (operationException != null && !(operationException is FaultException))
{
if (this.unknownExceptionAction == UnknownExceptionAction.TerminateInstance)
{
if (this.existsInPersistence)
{
operation = OperationType.Delete;
}
this.existsInPersistence = true;
disposeInstance = true;
}
else
{
Fx.Assert(this.unknownExceptionAction == UnknownExceptionAction.AbortInstance, "If it is not TerminateInstance then it must be AbortInstance.");
if (this.existsInPersistence)
{
operation = OperationType.Unlock;
}
this.existsInPersistence = true;
disposeInstance = true;
this.markedForCompletion = false;
}
}
else if (this.abortInstance)
{
this.abortInstance = false;
// AbortInstance can only be called in ConcurrencyMode.Single
// and therefore markedForCompletion could only have been
// set true by this same operation (either declaratively or
// programmatically). We set it false again so that the
// next operation doesn't cause instance completion.
this.markedForCompletion = false;
if (this.existsInPersistence && !stillReferenced)
{
// No need for a transactional version of this as we do not allow
// AbortInstance to be called in scenarios with SaveStateInOperationTransaction
// set to true
Fx.Assert(!this.saveStateInOperationTransaction,
"SaveStateInOperationTransaction must be false if we allowed an abort.");
if (this.lockingProvider != null)
{
operation = OperationType.Unlock;
}
}
this.existsInPersistence = true;
disposeInstance = true;
}
else if (this.markedForCompletion)
{
if (this.existsInPersistence)
{
// We don't set exists in persistence to
// false here because we want the proper
// persistence exceptions to get back to the
// client if we end up here again.
operation = OperationType.Delete;
}
// Even if we didn't delete the instance because it
// never existed we should set this to true. This will
// make sure that any future requests to this instance of
// ServiceDurableInstance will treat the object as deleted.
this.existsInPersistence = true;
disposeInstance = true;
}
else
{
if (this.existsInPersistence)
{
operation = OperationType.Update;
}
else
{
operation = OperationType.Create;
}
this.existsInPersistence = true;
if (!stillReferenced)
{
disposeInstance = true;
}
}
}
return(operation);
}