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));
}
}
