internal static SubscriptionDescriptor[] GetEventSinks(Type type)
{
if (m_subscriptionDescriptorCache.ContainsKey(type))
{
return(m_subscriptionDescriptorCache[type]);
}
var methods =
from n in type.GetMethods(BindingFlags.Public | BindingFlags.Instance)
where
!n.IsVirtual &&
n.GetCustomAttributes(typeof(EventSubscription), true).Length > 0
select n;
List <SubscriptionDescriptor> descriptors = new List <SubscriptionDescriptor>();
foreach (MethodInfo mi in methods)
{
descriptors.Add(new SubscriptionDescriptor
{
MethodInfo = mi,
Subscription = mi.GetCustomAttributes(typeof(EventSubscription), true).FirstOrDefault() as EventSubscription
});
}
SubscriptionDescriptor[] result = descriptors.ToArray();
m_subscriptionDescriptorCache.Add(type, result);
return(result);
}
public object this[string fieldName]
{
get
{
lock (m_fields)
{
if (!m_fields.ContainsKey(fieldName))
{
return(null);
}
return(m_fields[fieldName].Value);
}
}
set
{
lock (m_fields)
{
if (!m_fields.ContainsKey(fieldName))
{
m_fields.Add(fieldName, new FieldValue(fieldName, value));
}
else
{
m_fields[fieldName] = new FieldValue(fieldName, value);
}
}
}
}
internal static PublicationDescriptor[] GetEventSources(Type type)
{
if (m_publicationDescriptorCache.ContainsKey(type))
{
return(m_publicationDescriptorCache[type]);
}
// there has to be a less convoluted LINQ query to pull this off, I just can't work it out yet
var events =
from n in type.GetEvents(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance)
where n.GetCustomAttributes(typeof(EventPublication), true).Length > 0
select n;
List <PublicationDescriptor> descriptors = new List <PublicationDescriptor>();
foreach (EventInfo ei in events)
{
descriptors.Add(new PublicationDescriptor
{
EventInfo = ei,
Publication = ei.GetCustomAttributes(typeof(EventPublication), true).FirstOrDefault() as EventPublication
});
}
PublicationDescriptor[] result = descriptors.ToArray();
m_publicationDescriptorCache.Add(type, result);
return(result);
}
public void RemoveFile(string path)
{
if (filesMod.ContainsKey(path))
{
filesMod.Remove(path);
}
}
private PropertyInfo Getproperty(Type type, string propertyname)
{
if (propertyname == "$type")
{
return(null);
}
StringBuilder sb = new StringBuilder();
sb.Append(type.Name);
sb.Append("|");
sb.Append(propertyname);
string n = sb.ToString();
if (_propertycache.ContainsKey(n))
{
return(_propertycache[n]);
}
var pr = type.GetProperties();
foreach (PropertyInfo p in pr)
{
StringBuilder sbb = new StringBuilder();
sbb.Append(type.Name);
sbb.Append("|");
sbb.Append(p.Name);
string nn = sbb.ToString();
if (_propertycache.ContainsKey(nn) == false)
{
_propertycache.Add(nn, p);
}
}
return(_propertycache[n]);
}
public bool BuilderExists(int x, int y, int z)
{
if (Chunks.ContainsKey(new Vector3Int(x, y, z)))
{
return(Chunks[new Vector3Int(x, y, z)] != null);
}
return(false);
}
public void RegisterType(Type concreteType, Type registerAs)
{
if (m_typeRegistrations.ContainsKey(registerAs))
{
// replace the registration
m_typeRegistrations[registerAs] = concreteType;
}
else
{
m_typeRegistrations.Add(registerAs, concreteType);
}
}
public bool BuilderExists(int x, int y, int z)
{
try {
if (Chunks.ContainsKey(new Vector3Int(x, y, z)))
{
return(Chunks[new Vector3Int(x, y, z)] != null);
}
}
catch (KeyNotFoundException e) {
return(false);
}
return(false);
}
protected string GetInnerText(SafeDictionary <string> attributes, UltraLinkField linkField)
{
if (attributes.ContainsKey("text"))
{
return(attributes["text"]);
}
if (attributes.ContainsKey("description"))
{
return(attributes["description"]);
}
if (linkField.IsInternal)
{
if (linkField.UseItemDisplayName && linkField.TargetItem != null)
{
return(string.IsNullOrEmpty(linkField.TargetItem.DisplayName) ? linkField.TargetItem.Name : linkField.TargetItem.DisplayName);
}
return(linkField.LinkDisplayText);
}
if (!string.IsNullOrEmpty(linkField.LinkDisplayText))
{
return(linkField.LinkDisplayText);
}
if (linkField.LinkType == "phone")
{
if (linkField.PhoneMask != null && !string.IsNullOrEmpty(linkField.CustomLink))
{
var maskValue = linkField.PhoneMask["Mask"];
if (string.IsNullOrEmpty(maskValue))
{
return(linkField.CustomLink);
}
var mask = maskValue?.Replace(".", "\\.").Replace("_", "-");
return(FormatPhoneNumber(linkField.CustomLink, mask));
}
}
if (string.IsNullOrEmpty(linkField.LinkDisplayText))
{
return(linkField.CustomLink);
}
return(string.Empty);
}
public static void Register <TView, TViewModel>()
where TView : Page
where TViewModel : class, IViewModel, new()
{
lock (m_index)
{
var viewType = typeof(TView);
var viewModelType = typeof(TViewModel);
if (!m_index.ContainsKey(viewType))
{
m_index.Add(viewType, viewModelType);
}
}
}
private SafeTopicHandle getKafkaTopicHandle(string topic)
{
// TODO: We should consider getting rid of these and add proper support in librdkafka itself
// (producev() with RD_KAFKA_V_TOPIC() is one step closer)
if (topicHandles.ContainsKey(topic))
{
return(topicHandles[topic]);
}
var topicConfigHandle = SafeTopicConfigHandle.Create();
if (topicConfig != null)
{
topicConfig
.ToList()
.ForEach((kvp) => { topicConfigHandle.Set(kvp.Key, kvp.Value.ToString()); });
}
topicConfigHandle.Set("produce.offset.report", "true");
IntPtr configPtr = topicConfigHandle.DangerousGetHandle();
// note: there is a possible (benign) race condition here - topicHandle could have already
// been created for the topic (and possibly added to topicHandles). If the topicHandle has
// already been created, rdkafka will return it and not create another. the call to rdkafka
// is threadsafe.
var topicHandle = kafkaHandle.Topic(topic, configPtr);
topicHandles.Add(topic, topicHandle);
return(topicHandle);
}
public bool Complete(T req, bool isError)
{
if (loadingGroupRes.ContainsKey(req))
{
loadingGroupRes.Remove(req);
RemoveProgress(req);
loadedCount++;
if (m_OnComplete != null)
{
m_OnComplete(req, isError);
}
else
{
OnComplete(req, isError);
}
DispatchOnProgress();
}
// Debug.LogFormat("i={0},totalCount={1},loadedCount={2},IsDown={3},req={4},isErr={5}",i,totalCount,loadedCount,IsDown,req,isError);
if (IsDown)
{
DispatchOnComplete();
}
return(true);
// return i >= 0;
}
/// <summary>
/// Reflect the Class Name in the Source
/// </summary>
/// <param name="templateSource">
/// The template source.
/// </param>
/// <returns>
/// </returns>
private static Item[] RunEnumeration(string templateSource, Item sourceItem)
{
templateSource = templateSource.Replace("lucene:", string.Empty);
var commands = templateSource.Split(';');
var refinements = new SafeDictionary<string>();
foreach (var command in commands)
{
if (!command.IsNullOrEmpty())
{
var commandSplit = command.Split(':');
if (commandSplit.Length == 2)
{
refinements.Add(commandSplit[0], commandSplit[1]);
}
}
}
if (refinements.ContainsKey("location"))
{
int hitsCount;
var items = Context.ContentDatabase.GetItem(refinements["location"]).Search(refinements, out hitsCount);
return items.ToList().Select(x => x.GetItem()).ToArray();
}
else
{
int hitsCount;
var items = sourceItem.Search(refinements, out hitsCount);
return items.ToList().Select(x => x.GetItem()).ToArray();
}
}
/// <summary>
/// The get field crawler values.
/// </summary>
/// <param name="field">
/// The field.
/// </param>
/// <param name="fieldCrawlers">
/// The field crawlers.
/// </param>
/// <returns>
/// The IEnumerable of field crawler values.
/// </returns>
public static IEnumerable<string> GetFieldCrawlerValues(Field field, SafeDictionary<string, string> fieldCrawlers)
{
Assert.IsNotNull(field, "Field was not supplied");
Assert.IsNotNull(fieldCrawlers, "Field Crawler collection is not specified");
if (fieldCrawlers.ContainsKey(field.TypeKey))
{
var fieldCrawlerType = fieldCrawlers[field.TypeKey];
if (!string.IsNullOrEmpty(fieldCrawlerType))
{
var fieldCrawler = ReflectionUtil.CreateObject(fieldCrawlerType, new object[] { field });
if (fieldCrawler is IMultivaluedFieldCrawler)
{
return (fieldCrawler as IMultivaluedFieldCrawler).GetValues();
}
if (fieldCrawler is FieldCrawlerBase)
{
return new[] { (fieldCrawler as FieldCrawlerBase).GetValue() };
}
}
}
return new[] { new DefaultFieldCrawler(field).GetValue() };
}
/// <summary>
/// The get field crawler values.
/// </summary>
/// <param name="field">
/// The field.
/// </param>
/// <param name="fieldCrawlers">
/// The field crawlers.
/// </param>
/// <returns>
/// The IEnumerable of field crawler values.
/// </returns>
public static IEnumerable <string> GetFieldCrawlerValues(Field field, SafeDictionary <string, string> fieldCrawlers)
{
Assert.IsNotNull(field, "Field was not supplied");
Assert.IsNotNull(fieldCrawlers, "Field Crawler collection is not specified");
if (fieldCrawlers.ContainsKey(field.TypeKey))
{
var fieldCrawlerType = fieldCrawlers[field.TypeKey];
if (!string.IsNullOrEmpty(fieldCrawlerType))
{
var fieldCrawler = ReflectionUtil.CreateObject(fieldCrawlerType, new object[] { field });
if (fieldCrawler is IMultivaluedFieldCrawler)
{
return((fieldCrawler as IMultivaluedFieldCrawler).GetValues());
}
if (fieldCrawler is FieldCrawlerBase)
{
return(new[] { (fieldCrawler as FieldCrawlerBase).GetValue() });
}
}
}
return(new[] { new DefaultFieldCrawler(field).GetValue() });
}
/// <summary>
/// Reflect the Class Name in the Source
/// </summary>
/// <param name="templateSource">
/// The template source.
/// </param>
/// <returns>
/// </returns>
private static Item[] RunEnumeration(string templateSource, Item sourceItem)
{
templateSource = templateSource.Replace("lucene:", string.Empty);
var commands = templateSource.Split(';');
var refinements = new SafeDictionary <string>();
foreach (var command in commands)
{
if (!command.IsNullOrEmpty())
{
var commandSplit = command.Split(':');
if (commandSplit.Length == 2)
{
refinements.Add(commandSplit[0], commandSplit[1]);
}
}
}
if (refinements.ContainsKey("location"))
{
int hitsCount;
var items = Context.ContentDatabase.GetItem(refinements["location"]).Search(refinements, out hitsCount);
return(items.ToList().Select(x => x.GetItem()).ToArray());
}
else
{
int hitsCount;
var items = sourceItem.Search(refinements, out hitsCount);
return(items.ToList().Select(x => x.GetItem()).ToArray());
}
}
internal List <Getters> GetGetters(Type type)
{
if (_getterscache.ContainsKey(type))
{
return(_getterscache[type]);
}
else
{
PropertyInfo[] props = type.GetProperties(BindingFlags.Public | BindingFlags.Instance);
List <Getters> getters = new List <Getters>();
foreach (PropertyInfo p in props)
{
GenericGetter g = CreateGetMethod(p);
if (g != null)
{
Getters gg = new Getters();
gg.Name = p.Name;
gg.Getter = g;
getters.Add(gg);
}
}
_getterscache.Add(type, getters);
return(getters);
}
}
/// <summary>
/// Original Implementation of AddStandardValues
/// </summary>
/// <param name="template"></param>
/// <param name="database"></param>
/// <param name="language"></param>
/// <param name="result"></param>
private void AddStandardValues(Template template, Database database, Language language, SafeDictionary <ID, string> result)
{
ID standardValueHolderId = template.StandardValueHolderId;
if (ID.IsNullOrEmpty(standardValueHolderId))
{
return;
}
bool?currentValue = Switcher <bool?, LanguageFallbackItemSwitcher> .CurrentValue;
Item item;
if (currentValue == false)
{
try
{
Switcher <bool?, LanguageFallbackItemSwitcher> .Exit();
item = ItemManager.GetItem(standardValueHolderId, language, Version.Latest, database, SecurityCheck.Disable);
goto IL_5A;
}
finally
{
Switcher <bool?, LanguageFallbackItemSwitcher> .Enter(currentValue);
}
}
item = ItemManager.GetItem(standardValueHolderId, language, Version.Latest, database, SecurityCheck.Disable);
IL_5A:
if (item == null)
{
return;
}
foreach (Field field in item.Fields)
{
if (!result.ContainsKey(field.ID))
{
string value = field.GetValue(false, true);
if (value != null)
{
result[field.ID] = value;
}
}
}
if (!result.ContainsKey(FieldIDs.StandardValueHolderId))
{
result[FieldIDs.StandardValueHolderId] = standardValueHolderId.ToString();
}
}
private void PerformBroadcasting(UdpPacket packet, byte[] packageData)
{
if (clientCache.ContainsKey(packet.UserId))
{
var receivers = clientCache[packet.PId];
if (receivers.Count > 0)
{
Parallel.ForEach(receivers, receiver =>
{
if (receiver.Key != packet.UserId)
{
AsyncBeginSend(new UdpPacketBuffer(packageData, receiver.Value));
}
});
}
}
}
/// <summary>
///
/// </summary>
/// <param name="url"></param>
/// <param name="path"></param>
public void Load(string url, string path)
{
string key = CUtils.GetUDKey(url);
if (downloadings.ContainsKey(key))
{
return;
}
var req = new ReqInfo();
req.url = url;
req.saveName = path;//CUtils.GetFileName (url);
req.index = 0;
Load(req);
}
public T Get <T>(string key, T @default = default(T))
{
lock (this) {
if (PropertyData.ContainsKey(key))
{
return((T)PropertyData[key].GetValue(this, null));
}
var ret = Data[key];
if (ret == null || ret.Equals(default(T)))
{
return(@default);
}
return((T)ret);
}
}
/// <summary>
/// 增加一个成员字段
/// </summary>
/// <param name="fieldMap">成员字段的映射信息</param>
/// <returns></returns>
protected FieldMap AddField(FieldMap fieldMap)
{
Check.IsNull(fieldMap, "fieldMap");
Check.Valid(_Fields.ContainsKey(fieldMap.Field), "字段成员名称重复。");
ValidateReadonly();
_Fields.Add(fieldMap.Field, fieldMap);
return(fieldMap);
}
/// <summary>
/// Adds a field entity
/// </summary>
/// <param name="fd"></param>
public void AddFieldEntity(TypeDefinition td, FieldDefinition fd)
{
if (!fieldEntities.ContainsKey(fd.FullName))
{
var field = fd.Instantiate(MethodOrFieldAnalyzer.GetGenericTypeParameters(this.host, td));
DeclFieldEntity dfe = new DeclFieldEntity(field);
fieldEntities[field.FullName] = dfe;
}
}
/// <summary>
/// Tries to load the referenced assemblies.
/// </summary>
/// <param name="inputAssemblies">Assemblies</param>
private void TryLoadReferencedAssemblies(Assembly[] inputAssemblies)
{
var ws = new SafeDictionary <string, Assembly>();
foreach (Assembly a in inputAssemblies)
{
if (a == null)
{
continue;
}
// recursively load all the assemblies reachables from the root!
if (!Assemblies.ContainsKey(
a.GetName().FullName) && !ws.ContainsKey(a.GetName().FullName))
{
ws.Add(a.GetName().FullName, a);
}
while (ws.Count > 0)
{
var en = ws.Keys.GetEnumerator();
en.MoveNext();
var a_name = en.Current;
var a_assembly = ws[a_name];
Assemblies.Add(a_name, a_assembly);
ws.Remove(a_name);
foreach (AssemblyName name in a_assembly.GetReferencedAssemblies())
{
Assembly b;
ExtendedReflection.Utilities.ReflectionHelper.TryLoadAssembly(name.FullName, out b);
if (b != null)
{
if (!Assemblies.ContainsKey(b.GetName().FullName) &&
!ws.ContainsKey(b.GetName().FullName))
{
ws.Add(b.GetName().FullName, b);
}
}
}
}
}
}
/// <summary>
///ContainsKey 的测试
///</summary>
public void ContainsKeyTestHelper <KeyT, ValueT>()
{
SafeDictionary <KeyT, ValueT> target = new SafeDictionary <KeyT, ValueT>(); // TODO: 初始化为适当的值
KeyT key = default(KeyT); // TODO: 初始化为适当的值
bool expected = false; // TODO: 初始化为适当的值
bool actual;
actual = target.ContainsKey(key);
Assert.AreEqual(expected, actual);
Assert.Inconclusive("验证此测试方法的正确性。");
}
static bool IsMusicAvailabe(int roomId, int userId)
{
if (musicCache.ContainsKey(roomId))
{
if (musicCache[roomId].PlayerId != userId)
{
return(false);
}
}
return(true);
}
bool ICollection <KeyValuePair <TKey, TValue> > .Contains(KeyValuePair <TKey, TValue> item)
{
// No risk of dead needles here
Predicate <WeakNeedle <TKey> > check = input =>
{
TKey foundKey;
if (PrivateTryGetValue(input, out foundKey))
{
return(_keyComparer.Equals(foundKey, item.Key));
}
return(false);
};
return(_wrapped.ContainsKey
(
_keyComparer.GetHashCode(item.Key),
check,
input => EqualityComparer <TValue> .Default.Equals(input, item.Value)
));
}
public void GenerateChunks(int threads)
{
Stopwatch watch = new Stopwatch();
watch.Start();
List <Vector2Int>[] colCoords = new List <Vector2Int> [threads];
for (int t = 0; t < threads; t++)
{
colCoords[t] = new List <Vector2Int>();
}
int i = 0;
for (int x = 0; x < width; x++)
{
for (int z = 0; z < depth; z++)
{
Vector2Int col_pos = new Vector2Int(x, z);
if (!Columns.ContainsKey(col_pos))
{
GameObject obj = Instantiate(ColumnObj, VoxelConversions.ChunkCoordToWorld(new Vector3Int(x, 0, z)), Quaternion.identity, transform);
obj.name = "Column " + col_pos.ToString();
Columns[col_pos] = obj.GetComponent <ChunkColumn>();
Columns[col_pos].Init(col_pos, this, CreateTerrainSampler());
}
colCoords[i % colCoords.Length].Add(col_pos);
i++;
/*for (int y = 0; y < height; y++)
* {
* Vector3Int pos = new Vector3Int(x, y, z);
* chunkCoords.Add(pos);
*
* Vector2Int col_pos = new Vector2Int(pos.x, pos.z);
* if (!Columns.ContainsKey(col_pos))
* {
* GameObject obj = new GameObject("Column " + col_pos.ToString(), typeof(ChunkColumn));
* Columns[col_pos] = obj.GetComponent<ChunkColumn>();
* Columns[col_pos].Init(20, col_pos, CreateTerrainSampler());
* }
* }*/
}
}
watch.Stop();
Debug.Log("Finished spawning columns: " + watch.Elapsed);
for (int t = 0; t < colCoords.Length; t++)
{
//Debug.Log(colCoords[t].Count);
GenerateChunks("Gen_" + t, colCoords[t].ToArray());
}
}
public void CloseRemove(string name)
{
if (_asyncTasks.ContainsKey(name))
{
_asyncTasks.Remove(name);
}
if (_asyncTasks.Count == 0)
{
_closeWait.Set();
}
}
private GenericSetter GetSetter(PropertyInfo prop)
{
if (_settercache.ContainsKey(prop))
{
return(_settercache[prop]);
}
else
{
GenericSetter s = CreateSetMethod(prop);
_settercache.Add(prop, s);
return(s);
}
}
private Type GetTypeFromCache(string typename)
{
if (_typecache.ContainsKey(typename))
{
return(_typecache[typename]);
}
else
{
Type t = Type.GetType(typename);
_typecache.Add(typename, t);
return(t);
}
}
public void 取得SafeDictionary是否含有指定鍵值_SafeDictionary內包含該鍵值_應回傳True()
{
var safeDictionary = new SafeDictionary <int, int>
{
{ 1, 3 },
{ 2, 8 }
};
const int key = 2;
var result = safeDictionary.ContainsKey(key);
const bool expectedResult = true;
result.Should().Be(expectedResult);
}
public static string GetFieldCrawlerValue(Field field, SafeDictionary<string, string> fieldCrawlers)
{
Assert.IsNotNull(field, "Field was not supplied");
Assert.IsNotNull(fieldCrawlers, "Field Crawler collection is not specified");
if (fieldCrawlers.ContainsKey(field.TypeKey))
{
var fieldCrawlerType = fieldCrawlers[field.TypeKey];
if (!fieldCrawlerType.IsNullOrEmpty())
{
var fieldCrawler = ReflectionUtil.CreateObject(fieldCrawlerType, new object[] { field });
if (fieldCrawler.IsNotNull() && fieldCrawler is FieldCrawlerBase)
{
return (fieldCrawler as FieldCrawlerBase).GetValue();
}
}
}
return new DefaultFieldCrawler(field).GetValue();
}
/// <summary>
/// Compares current uncovered locations with the previous uncovered locations
/// </summary>
internal void AnalyzePreviousAndCurrentUncoveredLoc(string currPUTSignature,
out HashSet<string> allGivenUpLocations, out HashSet<string> allCoveredLocations,
out HashSet<string> newUncoveredLocations, out bool hasSomeCoveredLocation,
out bool bAllAreNewLocations, out bool bNoneAreNewLocations)
{
hasSomeCoveredLocation = false;
bAllAreNewLocations = true;
bNoneAreNewLocations = true;
var resolvedPrevLocations = new SafeSet<string>();
var bestFitnessValues = new SafeDictionary<string, int>();
//This dictionary is constructed since the FactorySuggestionStore is based
//on declarting type not on the explorable type, which can be different
allGivenUpLocations = new HashSet<string>();
allCoveredLocations = new HashSet<string>();
tempAllLocationStore = new SafeDictionary<string, PersistentUncoveredLocationStore>();
//All final suggested sequences of the current PUT
var putspecificsequences = new List<MethodSignatureSequence>();
foreach (var fss in this.FactorySuggestionsDictionary.Values)
{
foreach (var codelockey in fss.locationStoreSpecificSequences.Keys)
{
var pucls = fss.locationStoreSpecificSequences[codelockey];
if (!pucls.IsDormat()) //Donot touch dormant persistent stores
tempAllLocationStore[codelockey] = pucls;
}
foreach (var givenUpLocation in fss.PermanentFailedUncoveredLocations)
allGivenUpLocations.Add(givenUpLocation);
foreach (var coveredLocation in fss.SuccessfulCoveredLocations)
allCoveredLocations.Add(coveredLocation);
//MethodSignatureSequenceList mssl;
//if (fss.FinalPUTSequences.TryGetValue(currPUTSignature, out mssl))
//{
// foreach (var seq in mssl.SequenceList)
// {
// if (!putspecificsequences.Contains(seq))
// putspecificsequences.Add(seq);
// }
//}
}
var failedLocations = new SafeSet<PersistentUncoveredLocationStore>();
//Traverse all uncovered locations
foreach (var ucovLocList in this.UncoveredLocationDictionary.Values)
{
var locationStr = ucovLocList.Location.ToString();
var key = UncoveredCodeLocationStore.GetKey(ucovLocList.Location.ToString(),
ucovLocList.ExplorableType.ToString(), ucovLocList.TermIndex);
//Check whether there are any defect detecting sequences. If yes promote them
//in the associated factory store
foreach (var ucls in ucovLocList.StoreList)
{
if (ucls.IsADefectDetectingSequence)
{
var fss = this.FactorySuggestionsDictionary[ucls.ExplorableType.ToString()];
SafeDebug.AssumeNotNull(fss, "fss cannot be null");
fss.AddToDefectDetectingSequences(ucls.MethodCallSequence);
}
}
if (allGivenUpLocations.Contains(key))
{
//This location has been earlier given up. No need to deal with this
resolvedPrevLocations.Add(key);
this.Log.LogMessage(WikiTopics.MissingWikiTopic, "Location " + locationStr + " is ignored since it was already given up earlier!!!");
continue;
}
if (allCoveredLocations.Contains(key))
{
//This location has been covered earlier. Ideally this case should not happen
//resolvedPrevLocations.Add(key);
this.Log.LogMessage(WikiTopics.MissingWikiTopic,
"Location " + locationStr + " is previously covered, but can be reported since the caller could be different.");
bAllAreNewLocations = false;
//continue;
}
//Get the associated factory suggestion store
if (tempAllLocationStore.ContainsKey(key))
{
bAllAreNewLocations = false;
var pucls = tempAllLocationStore[key];
resolvedPrevLocations.Add(key);
//For some formats such as TRUE_SET, we do not need the fitness measure
//If they are not covered in one attempt, they won't be covered any time
if (ucovLocList.StoreList.Count > 0)
{
var fmt = ucovLocList.StoreList[0].DesiredFieldModificationType;
if (!this.IsFitnessRequired(fmt))
{
pucls.NumberOfUnsuccessfulAttempts = PexMeConstants.MAX_UNSUCCESSFUL_ATTEMPTS + 1;
}
}
//Reached the threshold of number of attempts. So deleting this uncovered location forever
if (pucls.NumberOfUnsuccessfulAttempts + 1 <= PexMeConstants.MAX_UNSUCCESSFUL_ATTEMPTS)
{
//Handle according to fitness value and drop the other methods that
//acutally did not help increase the fitness value
this.RemoveSuggestionsWithLowFitness(ucovLocList, tempAllLocationStore[key], putspecificsequences);
this.Log.LogMessage(WikiTopics.MissingWikiTopic,
"Location " + locationStr + " is resolved and is still uncovered in the new run " +
"(fitness: " + pucls.Fitnessvalue + "), (Attempt: " + pucls.NumberOfUnsuccessfulAttempts + ")");
}
else
{
this.Log.LogMessage(WikiTopics.MissingWikiTopic,
"Location " + locationStr + " is resolved and but not making any process!!! Will be deleted forever");
//This pucls data will be deleted forever since it reached its max attempts without any progress
failedLocations.Add(pucls);
}
}
}
//New locations that added to the factory suggestion store
newUncoveredLocations = new HashSet<string>();
foreach (var ucovLocList in this.UncoveredLocationDictionary.Values)
{
var key = UncoveredCodeLocationStore.GetKey(ucovLocList.Location.ToString(),
ucovLocList.ExplorableType.ToString(), ucovLocList.TermIndex);
if (!resolvedPrevLocations.Contains(key))
{
newUncoveredLocations.Add(key);
this.Log.LogMessage(WikiTopics.MissingWikiTopic,
"Location " + ucovLocList.Location.ToString() + " is newly added in the new run");
bNoneAreNewLocations = false;
}
}
//Unresolved locations from the previous run. This means that these sequences
//are either already covered or not covered due to some new exception...
var unresolvedPrevLocations = new SafeSet<PersistentUncoveredLocationStore>();
var alreadyCoveredLocations = new SafeSet<PersistentUncoveredLocationStore>();
foreach (var fss in this.FactorySuggestionsDictionary.Values)
{
var allRemovedPUCLS = new List<PersistentUncoveredLocationStore>();
//Delete all failed locations if the suggested methods for this
//failed location are all actually already explored. If not, place
//them in pending status. Usually this case happens, if covering
//the same location within the method is required by another location
foreach (var pucls in failedLocations)
{
var key = UncoveredCodeLocationStore.GetKey(pucls.CodeLocation.ToString(),
pucls.ExplorableType.ToString(), pucls.TermIndex);
fss.RemoveUncoveredLocationStore(pucls, false, this);
allRemovedPUCLS.Add(pucls);
}
foreach (var codelockey in fss.locationStoreSpecificSequences.Keys)
{
var tpucls = fss.locationStoreSpecificSequences[codelockey];
if (tpucls.IsDormat())
continue;
if (allGivenUpLocations.Contains(codelockey))
{
bAllAreNewLocations = false;
unresolvedPrevLocations.Add(tpucls);
this.Log.LogWarning(WikiTopics.MissingWikiTopic, "UncoveredLocation",
"Location " + codelockey + " was already given up. Should not be reported again!!! Anyways, Deleting this location forever");
continue;
}
if (!resolvedPrevLocations.Contains(codelockey))
{
//Check whether this location is covered based on the coverage
if (tpucls.AlreadyCovered || this.IsPrevUncoveredLocationCovered(tpucls))
{
alreadyCoveredLocations.Add(tpucls);
this.Log.LogMessage(WikiTopics.MissingWikiTopic,
"Location " + codelockey + " is successfully covered in the new run");
hasSomeCoveredLocation = true;
}
else
{
bAllAreNewLocations = false;
unresolvedPrevLocations.Add(tpucls);
this.Log.LogWarning(WikiTopics.MissingWikiTopic, "UncoveredLocation",
"Location " + codelockey + " from the previous run is not found in the new run!!! Deleting this location forever");
}
}
}
//Delete all unresolved locations as they won't be required anymore!!!
foreach (var pucls in unresolvedPrevLocations)
{
fss.RemoveUncoveredLocationStore(pucls, false, this);
allRemovedPUCLS.Add(pucls);
}
//Handle all removed PUCLS
foreach (var pucls in allRemovedPUCLS)
{
var key = UncoveredCodeLocationStore.GetKey(pucls.CodeLocation, pucls.ExplorableType, pucls.TermIndex);
fss.PermanentFailedUncoveredLocations.Add(key);
if (!fss.TemporaryFailedUncoveredLocations.ContainsKey(key))
{
//Are there any active uncovered locations
if (this.AnyActiveUncoveredLocations())
fss.TemporaryFailedUncoveredLocations[key] = 1;
else
fss.TemporaryFailedUncoveredLocations[key] = PexMeConstants.MAX_UNCOVEREDLOC_ATTEMPTS;
}
}
//Delete all the information regarding covered locations and upgrade their specific factory methods
foreach (var pucls in alreadyCoveredLocations)
{
fss.RemoveUncoveredLocationStore(pucls, true, this);
}
alreadyCoveredLocations.Clear();
}
}
/// <summary>
/// 取所有语言
/// </summary>
/// <returns></returns>
private ISafeDictionary<string, string> GetLang() {
if (lang.IsNullEmpty()) Msg.WriteEnd("语言未设置！");
string path = "".GetMapPath() + "\\lang\\{0}.lang".FormatWith(lang);
if (!FileDirectory.FileExists(path)) Msg.WriteEnd("语言文件{0}.lang不存在！".FormatWith(lang));
string lineText = string.Empty; ISafeDictionary<string, string> list = new SafeDictionary<string, string>();
using (StreamReader reader = new StreamReader(path, System.Text.Encoding.UTF8)) {
while ((lineText = reader.ReadLine()).IsNotNull()) {
int len = lineText.IndexOf('=');
if (lineText.IsNullEmpty() || len == -1) continue;
string key = lineText.Substring(0, len).Trim();
string value = lineText.Substring(len + 1).Trim();
if (!list.ContainsKey(key)) list.Add(key, value); else list[key] = value;
}
}
return list;
}
/// <summary>
/// Tries to load the referenced assemblies.
/// </summary>
/// <param name="inputAssemblies">Assemblies</param>
private void TryLoadReferencedAssemblies(Assembly[] inputAssemblies)
{
var ws = new SafeDictionary<string, Assembly>();
foreach (Assembly a in inputAssemblies)
{
if (a == null)
{
continue;
}
// recursively load all the assemblies reachables from the root!
if (!Assemblies.ContainsKey(
a.GetName().FullName) && !ws.ContainsKey(a.GetName().FullName))
{
ws.Add(a.GetName().FullName, a);
}
while (ws.Count > 0)
{
var en = ws.Keys.GetEnumerator();
en.MoveNext();
var a_name = en.Current;
var a_assembly = ws[a_name];
Assemblies.Add(a_name, a_assembly);
ws.Remove(a_name);
foreach (AssemblyName name in a_assembly.GetReferencedAssemblies())
{
Assembly b;
ExtendedReflection.Utilities.ReflectionHelper.TryLoadAssembly(name.FullName, out b);
if (b != null)
{
if (!Assemblies.ContainsKey(b.GetName().FullName) &&
!ws.ContainsKey(b.GetName().FullName))
{
ws.Add(b.GetName().FullName, b);
}
}
}
}
}
}
public static void Load()
{
BaseInformations = new SafeDictionary<uint, ConquerItemBaseInformation>(10000);
PlusInformations = new SafeDictionary<uint, SafeDictionary<byte, ConquerItemPlusInformation>>(10000);
GradeInformations = new SafeDictionary<string, SafeDictionary<int, ConquerItemBaseInformation>>(10000);
GradeInformations2 = new SafeDictionary<string, SafeDictionary<uint, int>>(10000);
string[] baseText = File.ReadAllLines(ServerBase.Constants.ItemBaseInfosPath);
string text = "►◄►◄►◄►◄►◄►◄►◄►◄►◄►◄►◄►◄►◄►◄►◄►◄►◄►◄►◄►◄";
int for1prg = baseText.Length / (System.Console.WindowWidth - text.Length);
int count = 0;
System.Console.Write(text);
var old1 = System.Console.BackgroundColor;
var old2 = System.Console.ForegroundColor;
System.Console.BackgroundColor = ConsoleColor.Gray;
System.Console.ForegroundColor = ConsoleColor.Gray;
int gkey = 0;
int lastlevel = 0;
string lastgr = "";
foreach (string line in baseText)
{
count++;
if (count == for1prg)
{
count = 0;
System.Console.Write("▼◘");
}
string _item_ = line.Trim();
if (_item_.Length > 11)
{
if (_item_.IndexOf("//", 0, 2) != 0)
{
ConquerItemBaseInformation CIBI = new ConquerItemBaseInformation();
CIBI.Parse(_item_);
var Grades = GradeInformations[CIBI.Description];
BaseInformations.Add(CIBI.ID, CIBI);
if (GradeInformations.ContainsKey(CIBI.Description) == false)
{
GradeInformations2.Add(CIBI.Description, new SafeDictionary<uint, int>(1000));
GradeInformations2[CIBI.Description].Add((uint)(CIBI.ID / 10), 0);
lastlevel = CIBI.Level;
GradeInformations.Add(CIBI.Description, new SafeDictionary<int, ConquerItemBaseInformation>(1000));
gkey = 0;
}
else
{
if (lastgr != CIBI.Description)
gkey = GradeInformations2[CIBI.Description].Count - 1;
if (GradeInformations2[CIBI.Description].ContainsKey(CIBI.ID / 10) && CIBI.Level == lastlevel)
{
CIBI.GradeKey = gkey;
continue;
}
else
{
GradeInformations2[CIBI.Description].Add((uint)(CIBI.ID / 10), 0);
lastlevel = CIBI.Level;
gkey = gkey + 1;
}
}
lastgr = CIBI.Description;
CIBI.GradeKey = gkey;
GradeInformations[CIBI.Description].Add(gkey, CIBI);
}
}
}
GradeInformations2.Base.Clear();
System.Console.BackgroundColor = old1;
System.Console.ForegroundColor = old2;
baseText = File.ReadAllLines(ServerBase.Constants.ItemPlusInfosPath);
foreach (string line in baseText)
{
try
{
string _item_ = line.Trim();
ConquerItemPlusInformation CIPI = new ConquerItemPlusInformation();
CIPI.Parse(_item_);
SafeDictionary<byte, ConquerItemPlusInformation> info = null;
if (PlusInformations.TryGetValue(CIPI.ID, out info))
{
info.Add(CIPI.Plus, CIPI);
}
else
{
PlusInformations.Add(CIPI.ID, new SafeDictionary<byte, ConquerItemPlusInformation>(1000));
if (PlusInformations.TryGetValue(CIPI.ID, out info))
{
info.Add(CIPI.Plus, CIPI);
}
}
}
catch
{
Console.WriteLine(line);
Console.ReadLine();
}
}
Console.WriteLine("Item Base and Plus information loaded.");
}
