/// <summary>
/// Create a name set record
/// </summary>
public static decimal CreateNameSet(IDbConnection conn, IDbTransaction tx, NameSet nameSet)
{
IDbCommand cmd = CreateCommandStoredProc(conn, tx);
try
{
cmd.CommandText = "crt_name_cmp";
cmd.Parameters.Add(CreateParameterIn(cmd, "name_value_in", DbType.StringFixedLength, null));
cmd.Parameters.Add(CreateParameterIn(cmd, "name_cls_in", DbType.Decimal, null));
cmd.Parameters.Add(CreateParameterIn(cmd, "name_set_id_in", DbType.Decimal, DBNull.Value));
// Name set parts
foreach (var cmp in nameSet.Parts)
{
((IDataParameter)cmd.Parameters["name_value_in"]).Value = cmp.Value;
((IDataParameter)cmd.Parameters["name_cls_in"]).Value = (decimal)cmp.Type;
((IDataParameter)cmd.Parameters["name_set_id_in"]).Value = nameSet.Key == default(decimal) ? (object)DBNull.Value : nameSet.Key;
// Execute
decimal retVal = Convert.ToDecimal(cmd.ExecuteScalar());
if (nameSet.Key == default(decimal))
{
nameSet.Key = retVal;
}
}
return(nameSet.Key);
}
finally
{
cmd.Dispose();
}
}
/// <summary>
/// Create a name set
/// </summary>
public NameSet CreateNameSet(EN legalName, List <IResultDetail> dtls)
{
NameSet retVal = new NameSet();
NameSet.NameSetUse internalNameUse = 0;
var lnu = legalName.Use == null || legalName.Use.IsNull || legalName.Use.IsEmpty ? EntityNameUse.Search : (EntityNameUse)legalName.Use[0];
if ((lnu == EntityNameUse.Legal || lnu == EntityNameUse.OfficialRecord) &&
legalName.Use.Count > 1 &&
(legalName.Use[1] == EntityNameUse.OfficialRecord | legalName.Use[1] == EntityNameUse.Legal))
{
internalNameUse = NameSet.NameSetUse.OfficialRecord;
}
else if (!m_nameUseMap.TryGetValue(lnu, out internalNameUse))
{
return(null);
}
retVal.Use = internalNameUse;
// Create the parts
foreach (ENXP namePart in legalName.Part)
{
retVal.Parts.Add(new NamePart()
{
Value = namePart.Value,
Type = namePart.Type.HasValue ? m_namePartTypeMap[namePart.Type] : NamePart.NamePartType.None
});
}
return(retVal);
}
/// <summary>
/// Returns new Identity with gender, nameset, and country settings.
/// </summary>
/// <param name="g">Male or Female</param>
/// <param name="ns">Country origin for name.</param>
/// <param name="c">Country origin for Identity.</param>
/// <returns>Identity</returns>
public Identity CreateIdentity(Gender g, NameSet ns, Country c)
{
string url = (AdvancedOptions.Enabled)
? "https://www.fakenamegenerator.com/advanced.php?t=country&n[]=" + String.Format("{0}&c[]={1}&gen={2}&age-min={3}&age-max={4}", GetNameSet(ns), GetCountry(c), AdvancedOptions.MalePercentage, AdvancedOptions.MinAge, AdvancedOptions.MaxAge)
: "http://www.fakenamegenerator.com" + String.Format("/gen-{0}-{1}-{2}.php", (g == Gender.Male) ? "male" : ((g == Gender.Female) ? "female" : "random"), GetNameSet(ns), GetCountry(c))
;
return(FetchIdentityData(url));
}
/// <summary>
/// Convert a name
/// </summary>
internal NameSet ConvertName(HumanName name, List <IResultDetail> dtls)
{
NameSet retVal = new NameSet();
if (name.Use != null)
{
retVal.Use = HackishCodeMapping.Lookup(HackishCodeMapping.NAME_USE, name.Use);
retVal.Use |= ExtensionUtil.ParsePNUseExtension(name.Use.Extension, dtls);
}
// Name text
if (name.Text != null)
{
dtls.Add(new UnsupportedFhirDatatypePropertyResultDetail(ResultDetailType.Warning, "Text", "Name"));
name.Text = null;
}
foreach (var fn in name.Family)
{
retVal.Parts.Add(new NamePart()
{
Type = NamePart.NamePartType.Family, Value = fn
});
}
foreach (var sfx in name.Suffix)
{
retVal.Parts.Add(new NamePart()
{
Type = NamePart.NamePartType.Suffix, Value = sfx
});
}
foreach (var gn in name.Given)
{
retVal.Parts.Add(new NamePart()
{
Type = NamePart.NamePartType.Given, Value = gn
});
}
foreach (var pfx in name.Prefix)
{
retVal.Parts.Add(new NamePart()
{
Type = NamePart.NamePartType.Prefix, Value = pfx
});
}
retVal.Parts.RemoveAll(o => String.IsNullOrEmpty(o.Value));
// Use period
if (name.Period != null)
{
dtls.Add(new UnsupportedFhirDatatypePropertyResultDetail(ResultDetailType.Warning, "Period", "Name"));
name.Period = null;
}
return(retVal);
}
/// <summary>
/// Returns true if the name is a soundex match
/// </summary>
public static bool IsSoundexMatch(this NameSet ns, NameSet other)
{
bool isMatch = true;
foreach (var cmp in ns.Parts)
{
isMatch &= ns.Parts.Exists(o => other.Parts.Exists(p => p.CalculateSoundexCode() == o.CalculateSoundexCode() && o.Type == p.Type));
}
return(isMatch);
}
/// <summary>
/// Confidence equals
/// </summary>
public static float ConfidenceEquals(this NameSet ns, NameSet other)
{
// Matches
int nExact = other.Parts.Count(o => ns.Parts.Exists(p => p.Value.ToLower() == o.Value.ToLower() && p.Type == o.Type)),
nSoundex = other.Parts.Count(o => !o.Value.Contains("*") && ns.Parts.Exists(p => p.CalculateSoundexCode() == o.CalculateSoundexCode() && o.Type == p.Type && Math.Abs(o.Value.Length - p.Value.Length) < 2)) - nExact,
nPattern = other.Parts.Count(o => ns.Parts.Exists(p => o.Value.Contains("*") && p.Value.ToLower() != o.Value.ToLower() && p.Value.ToLower().StartsWith(o.Value.ToLower().Substring(0, o.Value.IndexOf("*"))) && o.Type == p.Type)),
nOthers = other.Parts.Count - nExact - nSoundex - nPattern,
nParts = other.Parts.Count;
return(nExact / (float)nParts + nPattern / (float)(nParts * 1.1) + nOthers / (float)(nParts * 1.25f) + nSoundex / ((float)nParts * 2));
}
private void EMP_ISERT_CANCEL_Click(object sender, EventArgs e)
{
NameSet.Clear();
AgeSet.Value = 20;
SalarySet.Value = 5000;
PremiumSet.Value = 0;
PhoneSet.Clear();
EmailSet.Clear();
Dep_IdSET.Value = 0;
label22.Visible = false;
}
/// <summary>
/// Called from AdventureUI.cs and determines which nameSet will be used
/// </summary>
/// <param name="index"></param>
public void SetNameSet(int index)
{
if (index > -1 && index < arrayOfNameSets.Length)
{
nameSet = arrayOfNameSets[index];
Debug.LogFormat("[Tst] AdventureManager.cs -> SetNameSet: \"{0}\" NAMESET now in use{1}", nameSet.name, "\n");
}
else
{
Debug.LogErrorFormat("Invalid index \"{0}\" (should be between 0 and {1})", arrayOfNameSets.Length);
}
}
/// <summary>
/// Matches the two names and gives a percentage probability that name
/// A matches name B
/// </summary>
internal static float MatchName(NameSet a, NameSet b)
{
if (a == b)
{
return(1);
}
else if ((a != null) ^ (b != null))
{
return(0);
}
var retVal = a.SimilarityTo(b) * b.SimilarityTo(a);
return(retVal);
}
private Dictionary <string, NameSet> ConstructGroups(Dictionary <string, int> names)
{
var nameGroups = new Dictionary <string, NameSet>();
foreach (var pair in names)
{
var name = pair.Key;
var frequency = pair.Value;
var group = new NameSet(name, frequency);
nameGroups.Add(name, group);
}
return(nameGroups);
}
// После подключения Tcp клиент шлет свое имя, чтобы его как то идентифицироваль остальные пользователи
// Этот метод обрабатывает эту ситуацию
private void OnSetName(NameSet nameSetMessage)
{
if (string.IsNullOrWhiteSpace(nameSetMessage.Name))
{
return;
}
Name = nameSetMessage.Name;
RefreshLiveCycle();
// посылаем сообщение о входе в чат всем подключенным пользователям
_sender.BroadcastMessage(new UserNetworkEvent(Id, Name, NetworkEvent.Connect).ToString(), Id);
_sender.SendOnlineUsers(Id);
}
/// <summary>
/// Get a name from the database
/// </summary>
public static NameSet GetName(IDbConnection conn, IDbTransaction tx, decimal?nsSetId, bool loadFast)
{
IDbCommand cmd = CreateCommandStoredProc(conn, tx);
try
{
cmd.CommandText = "get_name_set";
if (!loadFast)
{
cmd.CommandText += "_efft";
}
cmd.Parameters.Add(CreateParameterIn(cmd, "name_set_id_in", DbType.Decimal, nsSetId));
// Execute a reader
IDataReader reader = cmd.ExecuteReader();
NameSet retVal = new NameSet()
{
Use = NameSet.NameSetUse.Legal
};
// Populate set
while (reader.Read())
{
NamePart part = new NamePart();
part.Value = Convert.ToString(reader["name_cmp_value"]);
part.Type = (NamePart.NamePartType)Convert.ToInt32(reader["name_cmp_cls"]);
retVal.Parts.Add(part);
// Effective time
if (!loadFast && retVal.EffectiveTime == default(DateTime) && reader["efft_utc"] != DBNull.Value)
{
retVal.EffectiveTime = Convert.ToDateTime(reader["efft_utc"]);
if (!loadFast && reader["obslt_utc"] != DBNull.Value)
{
retVal.EffectiveTime = Convert.ToDateTime(reader["obslt_utc"]);
}
}
}
return(retVal);
}
finally
{
cmd.Dispose();
}
}
private async void EMP_UPDATE_OK_Click(object sender, EventArgs e)
{
if (label25.Visible)
{
label25.Visible = false;
}
if (!string.IsNullOrEmpty(Name_Update.Text) && !string.IsNullOrWhiteSpace(Name_Update.Text) &&
!string.IsNullOrEmpty(ID_UPDATE.Text) && !string.IsNullOrWhiteSpace(ID_UPDATE.Text))
{
SqlCommand command = new SqlCommand("UPDATE [Employees] SET [Name]=@Name, " +
"[Age]=@Age,[Salary]=@Salary,[Premium]=@Premium,[PhoneNumber]=@phoneNumber," +
"[Email]=@Email,[Dep_Id]=@Dep_Id WHERE [Id]=@Id", sqlconnection);
command.Parameters.AddWithValue("Id", ID_UPDATE.Text);
command.Parameters.AddWithValue("Name", Name_Update.Text);
command.Parameters.AddWithValue("Age", Age_Update.Value);
command.Parameters.AddWithValue("Salary", Salary_Update.Value);
command.Parameters.AddWithValue("Premium", Premium_Update.Value);
command.Parameters.AddWithValue("PhoneNumber", PhoneNumber_Update.Text);
command.Parameters.AddWithValue("Email", Email_Update.Text);
command.Parameters.AddWithValue("Dep_Id", DepID_Update.Text);
await command.ExecuteNonQueryAsync();
ID_UPDATE.Clear();
NameSet.Clear();
Age_Update.Value = 20;
Salary_Update.Value = 5000;
Premium_Update.Value = 0;
PhoneNumber_Update.Clear();
Email_Update.Clear();
DepID_Update.Value = 1;
}
else if (string.IsNullOrEmpty(ID_UPDATE.Text) && string.IsNullOrWhiteSpace(ID_UPDATE.Text))
{
label25.Visible = true;
label25.Text = "идентификатор должен быть заполнен ";
}
else
{
label25.Visible = true;
label25.Text = "поля введены не коректно";
}
}
private NameSet nameSet; //nameSet currently in use (default set in Initialise to be arrayOfNameSets[index 0]
/// <summary>
/// Initialise
/// </summary>
public void Initialise()
{
if (arrayOfNameSets.Length > 0)
{
for (int i = 0; i < arrayOfNameSets.Length; i++)
{
if (arrayOfNameSets[i] == null)
{
Debug.LogErrorFormat("Invalid nameSet (Null) for arrayOfNameSets[{0}]", i);
}
}
//set default nameSet to be the first in the array (probably American)
nameSet = arrayOfNameSets[0];
}
else
{
Debug.LogError("Invalid arrayOfNameSets (Empty)");
}
}
/// <summary>
/// Process a name set
/// </summary>
protected HumanName ConvertNameSet(NameSet name)
{
HumanName retVal = new HumanName();
if (name.Use != NameSet.NameSetUse.Search)
{
retVal.Use = new PrimitiveCode <string>(HackishCodeMapping.ReverseLookup(HackishCodeMapping.NAME_USE, name.Use));
if (String.IsNullOrEmpty(retVal.Use.Value))
{
retVal.Use.Extension.Add(ExtensionUtil.CreatePNUseExtension(name.Use));
}
}
foreach (var pt in name.Parts)
{
switch (pt.Type)
{
case NamePart.NamePartType.Family:
retVal.Family.Add(pt.Value);
break;
case NamePart.NamePartType.Given:
retVal.Given.Add(pt.Value);
break;
case NamePart.NamePartType.Prefix:
retVal.Prefix.Add(pt.Value);
break;
case NamePart.NamePartType.Suffix:
retVal.Suffix.Add(pt.Value);
break;
case NamePart.NamePartType.None:
retVal.Text = pt.Value;
break;
}
}
return(retVal);
}
private async void EMP_INSERT_OK_Click(object sender, EventArgs e)
{
if (label22.Visible)
{
label22.Visible = false;
}
if (!string.IsNullOrEmpty(NameSet.Text) && !string.IsNullOrWhiteSpace(NameSet.Text) &&
!string.IsNullOrEmpty(PhoneSet.Text) && !string.IsNullOrWhiteSpace(PhoneSet.Text) &&
!string.IsNullOrEmpty(EmailSet.Text) && !string.IsNullOrWhiteSpace(EmailSet.Text) &&
Dep_IdSET.Value != 0)
{
SqlCommand command = new SqlCommand("INSERT INTO [Employees](Name,Age,Salary,Premium,PhoneNumber,Email,Dep_Id)" +
"Values(@Name,@Age,@Salary,@Premium,@PhoneNumber,@Email,@Dep_Id)", sqlconnection);
command.Parameters.AddWithValue("Name", NameSet.Text);
command.Parameters.AddWithValue("Age", AgeSet.Value);
command.Parameters.AddWithValue("Salary", SalarySet.Value);
command.Parameters.AddWithValue("Premium", PremiumSet.Value);
command.Parameters.AddWithValue("PhoneNumber", PhoneSet.Text);
command.Parameters.AddWithValue("Email", EmailSet.Text);
command.Parameters.AddWithValue("Dep_Id", Dep_IdSET.Value);
await command.ExecuteNonQueryAsync();
NameSet.Clear();
AgeSet.Value = 20;
SalarySet.Value = 5000;
PremiumSet.Value = 0;
PhoneSet.Clear();
EmailSet.Clear();
Dep_IdSET.Value = 0;
}
else
{
label22.Visible = true;
label22.Text = "поля введены не коректно";
}
}
/// <summary>
/// Update name
/// </summary>
public void UpdateXPN(NameSet name, NHapi.Model.V25.Datatype.XPN xpn)
{
xpn.NameTypeCode.Value = ReverseLookup(ComponentUtility.XPN_USE_MAP, name.Use);
// IF SEAGULL!!! NOOO!!!! Hopefully nobody finds this thing
foreach (var cmp in name.Parts)
{
string cmpStr = ReverseLookup(ComponentUtility.XPN_MAP, cmp.Type);
int cmpNo = int.Parse(cmpStr);
if (xpn.Components[cmpNo - 1] is AbstractPrimitive)
{
if (cmp.Type == NamePart.NamePartType.Given && (!String.IsNullOrEmpty((xpn.Components[cmpNo - 1] as AbstractPrimitive).Value)))// given is taken so use other segment
{
if (!String.IsNullOrEmpty(xpn.SecondAndFurtherGivenNamesOrInitialsThereof.Value))
{
xpn.SecondAndFurtherGivenNamesOrInitialsThereof.Value += " ";
}
xpn.SecondAndFurtherGivenNamesOrInitialsThereof.Value += cmp.Value;
}
else
{
(xpn.Components[cmpNo - 1] as AbstractPrimitive).Value = cmp.Value;
}
}
else if (xpn.Components[cmpNo - 1] is NHapi.Model.V25.Datatype.FN)
{
var fn = xpn.Components[cmpNo - 1] as NHapi.Model.V25.Datatype.FN;
if (!String.IsNullOrEmpty(fn.Surname.Value))
{
fn.Surname.Value += "-";
}
fn.Surname.Value += cmp.Value;
}
}
}
/// <summary>
/// Search
/// </summary>
public static Models.PatientMatch[] Search(string familyName, string givenName, string dob, string identifier, int offset, int count)
{
ClientRegistryAdminInterfaceClient client = new ClientRegistryAdminInterfaceClient();
// Query prototype
Person queryPrototype = new Person();
NameSet name = new NameSet();
NamePart familyNamePart = null,
givenNamePart = null;
if (familyName != null)
{
familyNamePart = new NamePart()
{
type = NamePartType.Family,
value = familyName
}
}
;
if (givenName != null)
{
givenNamePart = new NamePart()
{
type = NamePartType.Given,
value = givenName
}
}
;
List <NamePart> parts = new List <NamePart>();
if (givenNamePart != null)
{
parts.Add(givenNamePart);
}
if (familyNamePart != null)
{
parts.Add(familyNamePart);
}
name.part = parts.ToArray();
if (name.part.Length > 0)
{
queryPrototype.name = new NameSet[] { name }
}
;
if (identifier != null)
{
queryPrototype.altId = new DomainIdentifier[] { new DomainIdentifier()
{
uid = identifier
} }
}
;
// dob
if (dob != null)
{
TS tsDob = (TS)dob;
queryPrototype.birthTime = new TimestampPart()
{
type = TimestampPartType.Standlone,
value = tsDob.DateValue,
precision = tsDob.DateValuePrecision == DatePrecision.Day ? "D" :
tsDob.DateValuePrecision == DatePrecision.Month ? "M" :
tsDob.DateValuePrecision == DatePrecision.Year ? "Y" :
"F"
};
}
try
{
var registrations = client.GetRegistrations(queryPrototype, offset, count);
ClientRegistryAdmin.Models.PatientMatch[] retVal = new PatientMatch[registrations.count];
for (int i = 0; i < registrations.registration.Length; i++)
{
ClientRegistryAdmin.Models.PatientMatch pm = ConvertRegistrationEvent(registrations.registration[i]);
// Address?
retVal[offset + i] = pm;
}
return(retVal);
}
catch
{
return(null);
}
}
/// <summary>
/// Find client by name
/// </summary>
/// TODO: Make this more friendly for other DBMS other than PGSQL
public Client[] FindClient(NameSet name, string genderCode, TimestampPart birthTime)
{
throw new NotImplementedException("Find not supported");
}
/// <summary>
/// Convert interface methods that have an explicit implementation.
/// </summary>
public void Convert(ReachableContext reachableContext)
{
this.reachableContext = reachableContext;
// Do we need to convert anything?
if (!reachableContext.ReachableTypes.SelectMany(x => x.Methods).Any(NeedsConversion))
{
return;
}
// Initialize some sets
reachableMethods = reachableContext.ReachableTypes.SelectMany(x => x.Methods).Where(m => m.IsReachable).OrderBy(x => x.FullName).ToList();
methodNames = new NameSet(reachableMethods.Select(m => m.Name));
interfaces = reachableContext.ReachableTypes.Where(x => x.IsInterface).ToList();
// Go over all interfaces
foreach (var iType in interfaces)
{
foreach (var iMethod in iType.Methods)
{
ConvertInterfaceMethod(iType, iMethod);
}
}
// Remove added stubs that are an override of another added stub.
foreach (var stubPair in addedStubs)
{
var stub = stubPair.Item1;
var oldName = stubPair.Item2;
if (stub.GetBaseMethod() != null)
{
stub.DeclaringType.Methods.Remove(stub);
}
else
{
// Check for duplicate methods
var resolver = new GenericsResolver(stub.DeclaringType);
//var methodsWithSameName = stub.DeclaringType.Methods.Where(x => (x != stub) && (x.Name == stub.Name)).ToList();
//var duplicate = methodsWithSameName.FirstOrDefault(x => (x != stub) && x.AreSame(stub, resolver.Resolve));
var duplicate = stub.DeclaringType.Methods.FirstOrDefault(x => (x != stub) && x.AreSame(stub, resolver.Resolve));
if (duplicate != null)
{
stub.DeclaringType.Methods.Remove(stub);
continue;
}
if (oldName != stub.Name)
{
var newName = stub.Name;
stub.Name = oldName;
duplicate = stub.DeclaringType.Methods.FirstOrDefault(x => (x != stub) && x.AreSame(stub, resolver.Resolve));
if (duplicate != null)
{
stub.DeclaringType.Methods.Remove(stub);
continue;
}
stub.Name = newName;
}
}
}
}
/// <summary>
/// Rename "new" methods that override a final base method.
/// </summary>
public void Convert(ReachableContext reachableContext)
{
// Collect all names
var newSlotMethods = reachableContext.ReachableTypes
.SelectMany(x => x.Methods)
.Where(m => m.IsHideBySig && !m.IsStatic &&
!m.IsRuntimeSpecialName &&
!m.DeclaringType.IsInterface &&
(m.GetDexOrJavaImportAttribute() == null))
.ToList();
if (newSlotMethods.Count == 0)
{
return;
}
// Go over each method, find methods to rename
var methodsToRename = new HashSet <MethodDefinition>();
foreach (var method in newSlotMethods)
{
// Is the direct base method final?
var baseMethod = method.GetBaseMethod();
if (baseMethod == null)
{
continue;
}
if ((baseMethod.IsVirtual || baseMethod.IsAbstract) && !baseMethod.IsFinal)
{
continue;
}
methodsToRename.Add(method);
methodsToRename.Add(baseMethod);
}
if (methodsToRename.Count == 0)
{
return;
}
// Initialize some sets
reachableMethods = reachableContext.ReachableTypes.SelectMany(x => x.Methods)
.Where(m => m.IsReachable)
.ToList();
methodNames = new NameSet(reachableMethods.Select(m => m.Name));
var reachableMethodReferences = InterfaceHelper.GetReachableMethodReferencesByName(reachableMethods);
var baseMethodToImplementation = reachableMethods.Except(methodsToRename)
.SelectMany(m => m.GetBaseMethods(),
(e, m) => new { Impl = e, Base = m })
.ToLookup(p => p.Base, p => p.Impl);
// Rename methods that need renaming
foreach (var method in methodsToRename)
{
// Create new name
var newName = methodNames.GetUniqueName(method.Name);
// Find all methods that derive from method
var groupMethods = new HashSet <MethodDefinition> {
method
};
foreach (var otherMethod in baseMethodToImplementation[method])
{
// Rename this other method as well
groupMethods.Add(otherMethod);
}
// Add explicit implementations for interface methods
foreach (var iMethod in method.GetBaseInterfaceMethods())
{
var iMethodIsJavaWithGenericParams = iMethod.IsJavaMethodWithGenericParams();
var explicitName = methodNames.GetUniqueName(method.DeclaringType.Name + "_" + iMethod.Name);
var stub = InterfaceHelper.CreateExplicitStub(method.DeclaringType, method, explicitName, iMethod, iMethodIsJavaWithGenericParams);
stub.IsPrivate = true;
stub.IsFinal = false;
stub.IsVirtual = true;
}
// Rename all methods in the group
foreach (var m in groupMethods)
{
InterfaceHelper.Rename(m, newName, reachableMethodReferences);
}
}
}
internal void NameSet(string name)
{
var nameSetMessage = new NameSet(name);
Send(nameSetMessage.ToString());
}
void Start()
{
ns1 = light1.GetComponent <NameSet>();
ns2 = light2.GetComponent <Nameset2>();
}
/// <summary>
/// Rename "new" methods that override a final base method.
/// </summary>
public void Convert(ReachableContext reachableContext)
{
// Only consider
// - methods that don't implement and interface or overwrite another method
// - are not getters or setters, if they don't hide a base setter/getter.
// - are not event-adders or removers
// - do not generics-rename Nullable<T>, as it is used heavily by the compiler.
// - don't belong to Dot42.Internal namespace (as these are compiler-used)
// TODO: either check here or in CreateSignaturePostfix, but not at both places...
var consideredMethods = reachableContext.ReachableTypes
.AsParallel()
.SelectMany(x => x.Methods)
.Where(m => !m.IsRuntimeSpecialName &&
((!m.IsGetter && !m.IsSetter) || m.IsHideBySig) &&
!DontConsiderForMethodRenaming(m.DeclaringType) &&
m.GetDexOrJavaImportAttribute() == null &&
!m.IsExplicitImplementation() &&
m.GetBaseInterfaceMethod() == null &&
m.GetBaseMethod() == null)
.ToList();
// Go over each method, check if it needs renaming
var methodsToRename = new Dictionary <MethodDefinition, string>();
foreach (var method in consideredMethods)
{
var postfix = CreateSignaturePostfix(method);
if (string.IsNullOrEmpty(postfix))
{
continue;
}
methodsToRename.Add(method, postfix);
}
var orderedRenames = methodsToRename.OrderBy(p => p.Key.DeclaringType.FullName)
.ThenBy(p => p.Key.MemberFullName())
.ThenBy(p => p.Key.FullName)
.ToList();
if (orderedRenames.Count == 0)
{
}
if (methodsToRename.Count == 0)
{
return;
}
// Initialize some sets
var reachableMethods = reachableContext.ReachableTypes
.SelectMany(x => x.Methods)
.Where(m => m.IsReachable)
.ToList();
var methodNames = new NameSet(reachableMethods.Select(m => m.Name));
var baseMethodToImplementationOrOverride = reachableMethods.Except(methodsToRename.Keys)
.SelectMany(m => m.GetBaseMethods()
.Concat(m.GetBaseInterfaceMethods())
.Concat(m.Overrides),
(e, m) => new { Impl = e, Base = m })
.ToLookup(p => p.Base, p => p.Impl);
var reachableMethodReferences = InterfaceHelper.GetReachableMethodReferencesByName(reachableMethods);
// Rename methods that need renaming
foreach (var keyVal in methodsToRename)
{
var method = keyVal.Key;
var postfix = keyVal.Value;
// Create new name
var newName = methodNames.GetUniqueName(method.Name + postfix);
// Find all methods that derive from method
var groupMethods = new HashSet <MethodDefinition> {
method
};
if (method.IsVirtual && !method.IsFinal)
{
foreach (var otherMethod in baseMethodToImplementationOrOverride[method])
{
// Rename this other method as well
groupMethods.Add(otherMethod);
}
}
// Rename all methods in the group
foreach (var m in groupMethods)
{
InterfaceHelper.Rename(m, newName, reachableMethodReferences);
}
}
}
/// <summary>
/// Returns new Identity with gender, nameset, and country settings.
/// </summary>
/// <param name="g">Male or Female</param>
/// <param name="ns">Country origin for name.</param>
/// <param name="c">Country origin for Identity.</param>
/// <returns>Identity</returns>
public Identity CreateIdentity(Gender g, NameSet ns, Country c)
{
Identity id = new Identity();
try
{
using (HttpClient wClient = new HttpClient())
{
string html_source = wClient.GetAsync("http://www.fakenamegenerator.com" + String.Format("/gen-{0}-{1}-{2}.php", (g == Gender.Male) ? "male" : "female", GetNameSet(ns), GetCountry(c))).ToString();
Match m = Regex.Match(html_source, "<h3>(.*?)<");
id.Name = m.Groups[1].Value;
m = Regex.Match(html_source, "\"adr\">\n(.*?)<");
string street = m.Groups[1].Value.Trim();
m = Regex.Match(html_source, ".<br.>(.*?)<.div>");
id.Address = (street + " " + m.Groups[1].Captures[0].Value.Trim());
//Lazy bug fix
if (id.Address.Contains("</br>") || id.Address.Contains("<br>"))
{
id.Address = id.Address.Remove(id.Address.IndexOf('<'), 5);
}
m = Regex.Match(html_source, "<.dt>\\n\\s*<dd>(.*)<.");
id.MaidenName = m.Groups[1].Value;
m = Regex.Match(html_source, "SSN<.dt><dd>(.*?)<div class=");
id.SSN = (!string.IsNullOrEmpty(m.Groups[1].Value)) ? m.Groups[1].Value : "N/A";
m = Regex.Match(html_source, "Phone<.dt>\\n\\s*<dd>(.*?)<.dd>");
id.Phone = m.Groups[1].Value;
m = Regex.Match(html_source, "Country code<.dt>\\n\\s*<dd>(.*?)<.dd>");
id.CountryCode = m.Groups[1].Value;
m = Regex.Match(html_source, "Birthday<.dt>\\n\\s*<dd>(.*?)<.dd>");
id.Birthday = m.Groups[1].Value;
id.Age = (int)(DateTime.Now - Convert.ToDateTime(id.Birthday)).TotalDays / 365;
m = Regex.Match(html_source, @"Email Address<.dt>\n\n\s*<dd>(.*?)<div");
id.Email = m.Groups[1].Value.Trim();
m = Regex.Match(html_source, @"Username<.dt>\n\s*<dd>(.*?)<.dd>");
id.Username = m.Groups[1].Value;
m = Regex.Match(html_source, @"Password<.dt>\n\s*<dd>(.*?)<.dd>");
id.Password = m.Groups[1].Value;
m = Regex.Match(html_source, @"Website<.dt>\n\s*<dd>(.*?)<.dd>");
id.Website = m.Groups[1].Value;
m = Regex.Match(html_source, @"Browser user agent<.dt>\n\s*<dd>(.*?)<.dd>");
id.UserAgent = m.Groups[1].Value;
m = Regex.Match(html_source, "Finance</h3>(.*?)</dl>", RegexOptions.Singleline);
Match m2 = Regex.Match(m.Groups[1].Value, "<dt>(.*?)<.dt>");
m = Regex.Match(m.Groups[1].Value, @"<.dt>\n\s*<dd>(.*?)<.dd>");
id.CardNumber = m.Groups[1].Value;
id.CardType = m2.Groups[1].Value;
m = Regex.Match(html_source, @"<dt>Expires<.dt>\n\s*<dd>(.*?)</dd>");
id.CardExpiration = m.Groups[1].Value;
m = Regex.Match(html_source, @"<dt>Company<.dt>\n\s*<dd>(.*?)</dd>");
id.Company = m.Groups[1].Value;
m = Regex.Match(html_source, @"<dt>Occupation<.dt>\n\s*<dd>(.*?)</dd>");
id.Occupation = m.Groups[1].Value;
m = Regex.Match(html_source, @"<dt>Height<.dt>\n\s*<dd>(.*?)</dd>");
id.Height = m.Groups[1].Value;
m = Regex.Match(html_source, @"<dt>Weight<.dt>\n\s*<dd>(.*?)</dd>");
id.Weight = m.Groups[1].Value;
m = Regex.Match(html_source, @"<dt>Blood type<.dt>\n\s*<dd>(.*?)<.dd>");
id.BloodType = m.Groups[1].Value;
m = Regex.Match(html_source, @"<dt>Vehicle<.dt>\n\s*<dd>(.*?)<.dd>");
id.Vehicle = m.Groups[1].Value;
}
}
catch (Exception ex)
{
throw ex;
}
return(id);
}
/// <summary>
/// Returns new Identity with gender and nameset settings.
/// </summary>
/// <param name="g">Male or Female</param>
/// <param name="ns">Country origin for name.</param>
/// <returns>Identity</returns>
public Identity CreateIdentity(Gender g, NameSet ns)
{
return(CreateIdentity(g, ns, Country.UnitedStates));
}
private string GetNameSet(NameSet ns)
{
switch (ns)
{
case NameSet.American:
return("us");
case NameSet.Arabic:
return("ar");
case NameSet.Australian:
return("au");
case NameSet.Brazil:
return("br");
case NameSet.Chechen:
return("celat");
case NameSet.Chinese:
return("ch");
case NameSet.Croatian:
return("hr");
case NameSet.Czech:
return("cs");
case NameSet.Danish:
return("dk");
case NameSet.Dutch:
return("nl");
case NameSet.England:
return("en");
case NameSet.Eritrean:
return("er");
case NameSet.Finnish:
return("fi");
case NameSet.French:
return("fr");
case NameSet.German:
return("gr");
case NameSet.Greenland:
return("gl");
case NameSet.Hispanic:
return("sp");
case NameSet.Hobbit:
return("hobbit");
case NameSet.Hungarian:
return("hu");
case NameSet.Icelandic:
return("is");
case NameSet.Igbo:
return("ig");
case NameSet.Italian:
return("it");
case NameSet.Japanese:
return("jpja");
case NameSet.Norwegian:
return("no");
case NameSet.Persian:
return("fa");
case NameSet.Polish:
return("pl");
case NameSet.Russian:
return("ru");
case NameSet.Scottish:
return("gd");
case NameSet.Slovenian:
return("sl");
case NameSet.Swedish:
return("sw");
case NameSet.Thai:
return("th");
case NameSet.Vietnamese:
return("vn");
default: return("us");
}
}
