public TableToken(int startIndex, int stopIndex, IdentifierValue identifier, ISqlCommandContext <ISqlCommand> sqlCommandContext, ShardingRule shardingRule) : base(startIndex) { this.stopIndex = stopIndex; this.identifier = identifier; this.sqlCommandContext = sqlCommandContext; this.shardingRule = shardingRule; }
private void FoldAssign(IdentifierValue constResult, LocalOperation[] localOperations, int pos) { localOperations[pos] = new Assignment() { Right = constResult }; }
private void FoldAssign(IdentifierValue constResult, LocalOperation[] localOperations, int pos) { localOperations[pos] = new LocalOperation() { Kind = OperationKind.Assignment, Value = constResult }; }
public static void WriteCompareBranch(IdentifierValue localVar, IdentifierValue secondVar, StringBuilder sb, int jumpAddress, string comparisonOperator) { var local = localVar.Name; var second = secondVar.Name; sb.AppendFormat("if({0}{3}{1}) goto label_{2};", local, second, jumpAddress, comparisonOperator); }
/// <summary> /// Construct a virtual IdentifierProperty. /// </summary> /// <param name="type">The Hibernate Type for the identifier property.</param> /// <param name="embedded">Is this an embedded identifier.</param> /// <param name="unsavedValue">The value which, if found as the value on the identifier /// property, represents new (i.e., un-saved) instances of the owning entity.</param> /// <param name="identifierGenerator">The generator to use for id value generation.</param> /// <param name="hasIdentifierMapper"></param> public IdentifierProperty(IType type, bool embedded, bool hasIdentifierMapper, IdentifierValue unsavedValue, IIdentifierGenerator identifierGenerator) : base(null, type) { isVirtual = true; this.embedded = embedded; this.hasIdentifierMapper = hasIdentifierMapper; this.unsavedValue = unsavedValue; this.identifierGenerator = identifierGenerator; identifierAssignedByInsert = identifierGenerator is IPostInsertIdentifierGenerator; }
private static void AddUsage(this List <LocalVariable> usages, IdentifierValue usage) { var localVar = usage as LocalVariable; if (localVar == null) { return; } usages.Add(localVar); }
private static void SwitchUsageInReturn(LocalOperation op, LocalVariable usageVariable, IdentifierValue definitionIdentifier) { var returnValue = op.Get <Return>(); if (usageVariable.Equals(returnValue.Returning)) { returnValue.Returning = definitionIdentifier; } }
private static void SwitchUsageInSetStaticField(LocalOperation op, LocalVariable usageVariable, IdentifierValue definitionIdentifier) { var opSetField = (Assignment)op; if (usageVariable.Equals(opSetField.Right)) { opSetField.Right = definitionIdentifier; } }
public Customer( int age, string email, IdentifierValue identifier, string name) { Age = age; Email = email; Identifier = identifier; Name = name; }
/// <summary> /// Xor of the hash codes of the layer length, datalink, message type, query version, code, identifier, group address and access key. /// </summary> public override int GetHashCode() { return(new[] { base.GetHashCode(), CodeValue.GetHashCode(), IdentifierValue.GetHashCode(), GroupAddressValue.GetHashCode(), AccessKeyValue.GetHashCode() }.Xor()); }
public CustomerDetails( int age, IdentifierValue identifier, string name, int customerId) { Age = age; Identifier = identifier; Name = name; CustomerId = customerId; }
public static void SwitchAllUsagesWithDefinition(this CilMethodInterpreter interpreter, LocalVariable usageVariable, IdentifierValue definitionIdentifier) { var midRep = interpreter.MidRepresentation; var localOperations = midRep.UseDef.GetLocalOperations(); foreach (var operation in localOperations) { operation.SwitchUsageWithDefinition(usageVariable, definitionIdentifier); } midRep.UpdateUseDef(); }
static void SwitchUsageInSetField(LocalOperation op, LocalVariable usageVariable, IdentifierValue definitionIdentifier) { var opSetField = (SetField)op; if (usageVariable.Equals(opSetField.Instance)) { opSetField.Instance = definitionIdentifier; } if (usageVariable.Equals(opSetField.Right)) { opSetField.Right = definitionIdentifier; } }
private static void SwitchUsageUnbox(LocalOperation op, LocalVariable usageVariable, IdentifierValue definitionIdentifier) { var unbox = (Unboxing)op; if (usageVariable.Equals(unbox.AssignedTo)) { unbox.AssignedTo = (LocalVariable)definitionIdentifier; } if (usageVariable.Equals(unbox.Right)) { unbox.Right = definitionIdentifier; } }
private static void SwitchUsageInCall(LocalOperation op, LocalVariable usageVariable, IdentifierValue definitionIdentifier) { var methodData = op.Get <MethodData>(); for (var index = 0; index < methodData.Parameters.Count; index++) { var identifierValue = methodData.Parameters[index]; if (usageVariable.Equals(identifierValue)) { methodData.Parameters[index] = definitionIdentifier; } } }
private static void SwitchUsageInAssignment(LocalOperation op, LocalVariable usageVariable, IdentifierValue definitionIdentifier) { var opAssignment = (Assignment)op; if (usageVariable.Equals(opAssignment.AssignedTo)) { opAssignment.AssignedTo = (LocalVariable)definitionIdentifier; } if (usageVariable.Equals(opAssignment.Right)) { opAssignment.Right = definitionIdentifier; } }
private static void SwitchUsageInBranchOperator(LocalOperation op, LocalVariable usageVariable, IdentifierValue definitionIdentifier) { var opBranchOperator = (BranchOperator)op; if (usageVariable.Equals(opBranchOperator.CompareValue)) { opBranchOperator.CompareValue = definitionIdentifier; } if (usageVariable.Equals(opBranchOperator.SecondValue)) { opBranchOperator.SecondValue = definitionIdentifier; } }
private static void SwitchUsageInUnaryOperator(LocalOperation op, LocalVariable usageVariable, IdentifierValue definitionIdentifier) { var opUnaryOperator = (UnaryOperator)op; if (usageVariable.Equals(opUnaryOperator.Left)) { opUnaryOperator.Left = definitionIdentifier; } if (usageVariable.Equals(opUnaryOperator.AssignedTo)) { opUnaryOperator.AssignedTo = (LocalVariable)definitionIdentifier; } }
private static void SwitchUsageInFieldRefAssignment(LocalOperation op, LocalVariable usageVariable, IdentifierValue definitionIdentifier) { var returnValue = op.Get <FieldRefAssignment>(); if (usageVariable.Equals(returnValue.Right)) { returnValue.Right = (LocalVariable)definitionIdentifier; } if (usageVariable.Equals(returnValue.Left)) { returnValue.Left = (LocalVariable)definitionIdentifier; } }
private static void SwitchUsageInNewArray(LocalOperation op, LocalVariable usageVariable, IdentifierValue definitionIdentifier) { var assign = (NewArrayObject)op; if (usageVariable.Equals(assign.AssignedTo)) { assign.AssignedTo = (LocalVariable)definitionIdentifier; } if (usageVariable.Equals(assign.ArrayLength)) { assign.ArrayLength = definitionIdentifier; } }
/// <summary> /// Caso de uso "Crear cliente" /// </summary> /// <param name="age"></param> /// <param name="email"></param> /// <param name="identifier"></param> /// <param name="name"></param> /// <returns></returns> public CustomerViewModel Create( int age, string email, IdentifierValue identifier, string name) { var customer = new Customer( age: age, email: email, identifier: identifier, name: name); repository.Insert(customer); return(mapper.Map <CustomerViewModel>(customer)); }
/// <summary> /// Construct a non-virtual identifier property. /// </summary> /// <param name="name">The name of the property representing the identifier within /// its owning entity.</param> /// <param name="type">The Hibernate Type for the identifier property.</param> /// <param name="embedded">Is this an embedded identifier.</param> /// <param name="unsavedValue">The value which, if found as the value on the identifier /// property, represents new (i.e., un-saved) instances of the owning entity.</param> /// <param name="identifierGenerator">The generator to use for id value generation.</param> public IdentifierProperty( String name, IType type, bool embedded, IdentifierValue unsavedValue, IIdentifierGenerator identifierGenerator) : base(name, type) { isVirtual = false; this.embedded = embedded; hasIdentifierMapper = false; this.unsavedValue = unsavedValue; this.identifierGenerator = identifierGenerator; identifierAssignedByInsert = identifierGenerator is IPostInsertIdentifierGenerator; }
private static void SwichUsageInGetField(LocalOperation op, LocalVariable usageVariable, IdentifierValue definitionIdentifier) { var getFieldData = (GetField)op; if (!(definitionIdentifier is LocalVariable)) { return; } if (usageVariable.Equals(getFieldData.Instance)) { getFieldData.Instance = (LocalVariable)definitionIdentifier; } if (usageVariable.Equals(getFieldData.AssignedTo)) { getFieldData.AssignedTo = (LocalVariable)definitionIdentifier; } }
private static void SwitchUsageInSetArrayItem(LocalOperation op, LocalVariable usageVariable, IdentifierValue definitionIdentifier) { var setArrayData = (SetArrayElement)op; if (usageVariable.Equals(setArrayData.Instance)) { setArrayData.Instance = (LocalVariable)definitionIdentifier; } if (usageVariable.Equals(setArrayData.Index)) { setArrayData.Index = definitionIdentifier; } if (usageVariable.Equals(setArrayData.Right)) { setArrayData.Right = definitionIdentifier; } }
private static void SwitchUsageInGetArrayItem(LocalOperation op, LocalVariable usageVariable, IdentifierValue definitionIdentifier) { var getArrayData = (GetArrayElement)op; if (usageVariable.Equals(getArrayData.Instance)) { getArrayData.Instance = (LocalVariable)definitionIdentifier; } if (usageVariable.Equals(getArrayData.Index)) { getArrayData.Index = definitionIdentifier; } if (usageVariable.Equals(getArrayData.AssignedTo)) { getArrayData.AssignedTo = (LocalVariable)definitionIdentifier; } }
public static string ComputedValue(this IdentifierValue identifierValue) { var constValue = identifierValue as ConstValue; if (constValue == null) { return(identifierValue.Name); } var computeType = identifierValue.ComputedType(); if (computeType.ClrTypeCode == TypeCode.String) { var stringTable = LinkingData.Instance.Strings; var stringId = stringTable.GetStringId((string)constValue.Value); return(String.Format("_str({0})", stringId)); } return(constValue.Name); }
private static void SwitchUsageInSetArrayItem(LocalOperation op, LocalVariable usageVariable, IdentifierValue definitionIdentifier) { var opSetArrayItem = (Assignment)op.Value; var setArrayData = (ArrayVariable)opSetArrayItem.AssignedTo; if (usageVariable.Equals(setArrayData.Parent)) { setArrayData.Parent = (LocalVariable)definitionIdentifier; } if (usageVariable.Equals(setArrayData.Index)) { setArrayData.Index = definitionIdentifier; } if (usageVariable.Equals(opSetArrayItem.Right)) { opSetArrayItem.Right = definitionIdentifier; } }
private static void SwitchUsageInSetField(LocalOperation op, LocalVariable usageVariable, IdentifierValue definitionIdentifier) { var opSetField = (Assignment)op.Value; var setFieldData = (FieldSetter)opSetField.AssignedTo; if (usageVariable.Equals(setFieldData.Instance)) { setFieldData.Instance = definitionIdentifier; } if (usageVariable.Equals(opSetField.Right)) { opSetField.Right = definitionIdentifier; } if (usageVariable.Equals(opSetField.AssignedTo)) { opSetField.AssignedTo = (LocalVariable)definitionIdentifier; } }
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer) { var jobject = JObject.Load(reader); if (jobject.HasValues) { if (!Enum.TryParse(jobject["taxIdentifier"].Value <string>(), out TaxIdentifier taxIdentifier)) { throw new InvalidCastException(); } var identifier = new IdentifierValue( taxIdentifier, jobject["value"].Value <string>()); return(identifier); } return(default);
/// <summary> /// Generates an IdentifierProperty representation of the for a given entity mapping. /// </summary> /// <param name="mappedEntity">The mapping definition of the entity.</param> /// <param name="generator">The identifier value generator to use for this identifier.</param> /// <returns>The appropriate IdentifierProperty definition.</returns> public static IdentifierProperty BuildIdentifierProperty(PersistentClass mappedEntity, IIdentifierGenerator generator) { string mappedUnsavedValue = mappedEntity.Identifier.NullValue; IType type = mappedEntity.Identifier.Type; Mapping.Property property = mappedEntity.IdentifierProperty; IdentifierValue unsavedValue = UnsavedValueFactory.GetUnsavedIdentifierValue(mappedUnsavedValue, GetGetter(property), type, GetConstructor(mappedEntity)); if (property == null) { // this is a virtual id property... return(new IdentifierProperty(type, mappedEntity.HasEmbeddedIdentifier, mappedEntity.HasIdentifierMapper, unsavedValue, generator)); } else { return(new IdentifierProperty(property.Name, property.NodeName, type, mappedEntity.HasEmbeddedIdentifier, unsavedValue, generator)); } }