public void Release()
{
#if GF_DEBUG
if (m_Root._After != null)
{
MDebug.Assert(m_Root._After == null
, "ArrayPool"
, "m_Root._After == null");
StringBuilder stringBuilder = StringUtility.AllocStringBuilder();
stringBuilder.Append("ArrayPool<").Append(typeof(T).FullName).Append(">has memory leak!\n");
Node iterNode = m_Root;
while (iterNode != null)
{
stringBuilder.Append("Offset:").Append(iterNode.GetOffset())
.Append("\tSize:").Append(iterNode.GetSize())
.Append("\tIsUsed:").Append(iterNode.IsUsed())
.Append('\n');
iterNode = iterNode._After;
}
MDebug.LogError("ArrayPool"
, StringUtility.ReleaseStringBuilder(stringBuilder));
}
#endif
m_Buffer = null;
ms_NodePool.Release(m_Root);
m_Root = null;
}
public override void ProcessAll(Object[] assets)
{
StringBuilder stringBuilder = StringUtility.AllocStringBuilder()
.AppendLine("处理以下资源:");
for (int iAsset = 0; iAsset < assets.Length; iAsset++)
{
string iterAssetPath = AssetDatabase.GetAssetPath(assets[iAsset]);
if (string.IsNullOrEmpty(iterAssetPath))
{
continue;
}
stringBuilder.AppendLine(iterAssetPath);
}
MDebug.Log("Asset", StringUtility.ReleaseStringBuilder(stringBuilder));
}
public override string ToString()
{
System.Text.StringBuilder stringBuilder = StringUtility.AllocStringBuilder();
stringBuilder.Append($"ObjectPool<{typeof(T).FullName}> alloc {m_AllCount} objects. ")
.Append($"{m_UsingCount} obejcts being used");
#if GF_DEBUG
long currentTime = MDebug.GetMillisecondsSinceStartup();
for (int iObject = 0; iObject < m_Using.Count; iObject++)
{
UsingObject usingObject = m_Using[iObject];
float beUsedTime = (currentTime - usingObject.WhenBeUse) * 0.001f;
stringBuilder.Append($"\nObject be used {beUsedTime:F2} seconds. ({usingObject.ToString()})");
}
#endif
return(StringUtility.ReleaseStringBuilder(stringBuilder));
}
public EventCenter(List <Type> eventTypes
, string name
, int priority
, string groupName)
: base(name, priority, groupName)
{
List <Array> eventEnumValues = new List <Array>();
int maxEventID = int.MinValue;
for (int iEventType = 0; iEventType < eventTypes.Count; iEventType++)
{
Array enumValues = eventTypes[iEventType].GetEnumValues();
maxEventID = Math.Max(maxEventID, (int)enumValues.GetValue(enumValues.Length - 1));
eventEnumValues.Add(enumValues);
}
m_Listeners = new EventFunction[maxEventID + 1];
m_EventIdToName = new string[maxEventID + 1];
for (int iEventType = 0; iEventType < eventEnumValues.Count; iEventType++)
{
Array enumValues = eventEnumValues[iEventType];
for (int iEnum = 0; iEnum < enumValues.Length; iEnum++)
{
object iterEnum = enumValues.GetValue(iEnum);
m_EventIdToName[(int)iterEnum] = iterEnum.ToString();
}
}
System.Text.StringBuilder stringBuilder = StringUtility.AllocStringBuilder()
.Append("Events id to name:\n");
for (int iEvent = 0; iEvent < m_EventIdToName.Length; iEvent++)
{
stringBuilder.Append(iEvent).Append(", ").Append(m_EventIdToName[iEvent]).Append('\n');
}
MDebug.Log("EventCenter", StringUtility.ReleaseStringBuilder(stringBuilder));
m_EventItemPool = new ObjectPool <EventItem>(32);
m_MajorEventCache = new BetterQueue <EventItem>();
m_MajorEvents = new BetterQueue <EventItem> [(int)UpdateMethod.Count];
for (int iMajor = 0; iMajor < m_MajorEvents.Length; iMajor++)
{
m_MajorEvents[iMajor] = new BetterQueue <EventItem>();
}
}
/// <summary>
/// 解析字符串中的宏定义
/// </summary>
public string Parse(string script)
{
string[] lines = script.Split(SEPARATOR, StringSplitOptions.None);
System.Text.StringBuilder stringBuilder = StringUtility.AllocStringBuilder();
bool enableCode = true;
m_EnableCodeStackCache.Push(true);
for (int iLine = 0; iLine < lines.Length; iLine++)
{
string iterLine = lines[iLine];
string iterLineTrim = iterLine.Trim();
if (iterLineTrim.StartsWith(DEINFE_BEGIN))
{
m_DefineLine = iterLineTrim.Substring(DEINFE_BEGIN.Length);
enableCode &= ParseDefineLine();
m_EnableCodeStackCache.Push(enableCode);
}
else if (iterLineTrim.StartsWith(DEINFE_END))
{
MDebug.Assert(m_EnableCodeStackCache.Count > 1, "XLua", "m_EnableCodeStack.Count > 0");
m_EnableCodeStackCache.Pop();
enableCode = m_EnableCodeStackCache.Peek();
}
else if (enableCode)
{
stringBuilder.Append(iterLine);
}
stringBuilder.Append('\n');
}
m_EnableCodeStackCache.Pop();
MDebug.Assert(m_EnableCodeStackCache.Count == 0, "XLua", "m_EnableCodeStack.Count == 0");
#if GF_DEBUG
MDebug.Log("XLua", stringBuilder.ToString());
#endif
return(StringUtility.ReleaseStringBuilder(stringBuilder));
}
public static Dictionary <string, MethodInfo> GetOrCollectAllStaticMethods()
{
if (ms_AllStaticMethods == null)
{
ms_AllStaticMethods = new Dictionary <string, MethodInfo>();
List <ReflectionUtility.MethodAndAttributeData> staticMethodDatas = new List <ReflectionUtility.MethodAndAttributeData>();
Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
for (int iAssembly = 0; iAssembly < assemblies.Length; iAssembly++)
{
ReflectionUtility.CollectionMethodWithAttribute(staticMethodDatas
, assemblies[iAssembly]
, BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.Public
, typeof(StaticMethodAttribute)
, false);
}
StringBuilder methodSignBuilder = StringUtility.AllocStringBuilder();
for (int iMethod = 0; iMethod < staticMethodDatas.Count; iMethod++)
{
ReflectionUtility.MethodAndAttributeData iterStaticMethodData = staticMethodDatas[iMethod];
StaticMethodAttribute iterAttribute = iterStaticMethodData.Attribute as StaticMethodAttribute;
methodSignBuilder.Append(string.IsNullOrEmpty(iterAttribute.Alias)
? iterStaticMethodData.Method.Name
: iterAttribute.Alias);
ParameterInfo[] parameterInfos = iterStaticMethodData.Method.GetParameters();
for (int iParameter = 0; iParameter < parameterInfos.Length; iParameter++)
{
ParameterInfo iterParameter = parameterInfos[iParameter];
Type iterParameterType = iterParameter.ParameterType;
if (iterParameterType.IsValueType)
{
if (iterParameterType == typeof(byte))
{
AppendValueType(methodSignBuilder, ValueType.Byte);
}
else if (iterParameterType == typeof(int))
{
AppendValueType(methodSignBuilder, ValueType.Int);
}
else if (iterParameterType == typeof(short))
{
AppendValueType(methodSignBuilder, ValueType.Short);
}
else if (iterParameterType == typeof(long))
{
AppendValueType(methodSignBuilder, ValueType.Long);
}
else if (iterParameterType == typeof(float))
{
AppendValueType(methodSignBuilder, ValueType.Float);
}
else if (iterParameterType == typeof(double))
{
AppendValueType(methodSignBuilder, ValueType.Double);
}
// struct
else if (!iterParameterType.IsPrimitive)
{
MDebug.Assert(false
, "Rpc"
, $"Not support ParameterType {iterParameterType}");
}
else
{
MDebug.LogWarning("Rpc"
, $"Not support ParameterType: {iterParameterType} (IsValueType). But maybe we can support it.");
}
}
else if (iterParameterType.IsArray)
{
AppendValueType(methodSignBuilder, ValueType.FixedValueTypeArray);
}
else
{
MDebug.Assert(false
, "Rpc"
, $"Not support ParameterType {iterParameterType}");
}
}
string methodSign = methodSignBuilder.ToString();
methodSignBuilder.Clear();
#if GF_DEBUG
MDebug.Assert(!ms_AllStaticMethods.ContainsKey(methodSign)
, "Rpc"
, "!ms_AllStaticMethods.ContainsKey(methodSign)");
#endif
ms_AllStaticMethods[methodSign] = iterStaticMethodData.Method;
}
methodSignBuilder.Clear();
foreach (KeyValuePair <string, MethodInfo> kv in ms_AllStaticMethods)
{
methodSignBuilder.AppendLine(kv.Key);
}
MDebug.Log("Rpc"
, "All static methods:\n" + methodSignBuilder);
}
return(ms_AllStaticMethods);
}