/// <summary>
/// 检测缓存是否存在
/// </summary>
/// <param name="value">日志信息</param>
/// <param name="isQueue">是否缓存队列</param>
/// <returns>是否继续输出日志</returns>
private bool checkCache(debug value, bool isQueue)
{
hashString key = value.ToString();
if (isQueue)
{
Monitor.Enter(cacheLock);
try
{
if (cache.Get(key, false))
{
return(false);
}
cache.Set(key, true);
if (cache.Count > maxCacheCount)
{
cache.UnsafePopValue();
}
}
finally { Monitor.Exit(cacheLock); }
return(true);
}
if (key.Equals(lastCache))
{
return(false);
}
lastCache = key;
return(true);
}
/// <summary>
/// 添加日志
/// </summary>
/// <param name="error">错误异常</param>
/// <param name="message">提示信息</param>
/// <param name="cache">缓存类型</param>
public void Add(Exception error, string message, cacheType cache)
{
if (error != null && error.Message.StartsWith(ExceptionPrefix, StringComparison.Ordinal))
{
error = null;
}
if (error == null)
{
if (message != null)
{
Add(message, null, cache);
}
}
else
{
debug value = new debug
{
Exception = error,
Message = message
};
if (cache == cacheType.None || checkCache(value, cache == cacheType.Queue))
{
queue.EnqueueNotNull(value);
}
}
}
/// <summary>
/// 实时添加日志并抛出异常
/// </summary>
/// <param name="error">错误异常</param>
/// <param name="message">提示信息</param>
/// <param name="cache">缓存类型</param>
public void ThrowReal(Exception error, string message, cacheType cache)
{
if (error != null && error.Message.StartsWith(ExceptionPrefix, StringComparison.Ordinal))
{
error = null;
}
if (error == null)
{
if (message != null)
{
ThrowReal(message, null, cache);
}
}
else
{
debug value = new debug
{
Exception = error,
Message = message
};
if (cache == cacheType.None || checkCache(value, cache == cacheType.Queue))
{
realOutput(value);
}
throw error != null ? new Exception(ExceptionPrefix + message, error) : new Exception(ExceptionPrefix + message);
}
}
// Use this for initialization
void Start()
{
de = new debug();
List <Assets.Nodo> solucion = new List <Assets.Nodo>();
Assets.Nodo nodo;
Assets.BusquedaEnAmplitud busqueda = new Assets.BusquedaEnAmplitud(de);
//llamamos a la función de búsqueda
nodo = busqueda.busqueda(1, 1);
//para ver la traza
Debug.Log(de.getDeb());
//a través del nodo padre creamos una lista con la solución
while (nodo.miPadre() != null)
{
solucion.Insert(0, nodo);
nodo = nodo.miPadre();
}
solucion.Insert(0, nodo);
Debug.Log("Lista de nodos con la solución");
//recorremos toda la lista para mostrar la solución
foreach (Assets.Nodo nod in solucion)
{
Debug.Log(nod.miEstado());
}
}
/// <summary>
/// 日志信息写文件
/// </summary>
/// <param name="value">日志信息</param>
private void realOutput(debug value)
{
if (isDisposed == 0)
{
if (isFieStream)
{
memoryPool.pushSubArray data = fileStreamWriter.GetBytes(@"
" + date.nowTime.Now.toString() + " : " + value.ToString() + @"
", fastCSharp.config.appSetting.Encoding);
Monitor.Enter(fileLock);
try
{
if (fileStream != null)
{
if (fileStream.UnsafeWrite(ref data) >= MaxSize && MaxSize > 0)
{
moveBak();
}
else
{
fileStream.Flush(true);
}
return;
}
}
finally { Monitor.Exit(fileLock); }
}
Console.WriteLine(@"
" + date.nowTime.Now.toString() + " : " + value.ToString());
}
}
/// <summary>
/// 添加新的日志
/// </summary>
/// <param name="value">日志信息</param>
private void add(debug value)
{
if (!isStop)
{
Monitor.Enter(logLock);
try
{
newDebugs.Add(value);
Monitor.Pulse(logLock);
}
finally { Monitor.Exit(logLock); }
}
}
/// <summary>
/// 实时添加日志并抛出异常
/// </summary>
/// <param name="error">异常类型</param>
public void ThrowReal(exceptionType error)
{
debug value = new debug
{
StackTrace = new StackTrace(),
Type = error
};
if (!checkCache(value))
{
output(value.ToString());
}
throw new Exception(ExceptionPrefix + value.ToString());
}
/// <summary>
/// 实时添加日志
/// </summary>
/// <param name="message">提示信息</param>
/// <param name="isStackTrace">是否包含调用堆栈</param>
/// <param name="isCache">是否缓存</param>
public void Real(string message, bool isStackTrace = false, bool isCache = false)
{
debug value = new debug
{
StackTrace = isStackTrace ? new StackTrace() : null,
StackFrame = isStackTrace ? null : new StackFrame(1),
Message = message
};
if (!isCache || !checkCache(value))
{
output(value.ToString());
}
}
/// <summary>
/// 添加日志
/// </summary>
/// <param name="message">提示信息</param>
/// <param name="stackFrame">堆栈帧函数信息</param>
/// <param name="cache">缓存类型</param>
public void Add(string message, StackFrame stackFrame, cacheType cache)
{
debug value = new debug
{
StackTrace = stackFrame == null ? new StackTrace(true) : null,
StackFrame = stackFrame,
Message = message
};
if (cache == cacheType.None || checkCache(value, cache == cacheType.Queue))
{
queue.EnqueueNotNull(value);
}
}
/// <summary>
/// 实时添加日志
/// </summary>
/// <param name="message">提示信息</param>
/// <param name="stackFrame">堆栈帧函数信息</param>
/// <param name="cache">缓存类型</param>
public void Real(string message, StackFrame stackFrame, cacheType cache)
{
debug value = new debug
{
StackTrace = stackFrame == null ? new StackTrace(true) : null,
StackFrame = stackFrame,
Message = message
};
if (cache == cacheType.None || checkCache(value, cache == cacheType.Queue))
{
realOutput(value);
}
}
/// <summary>
/// 添加日志并抛出异常
/// </summary>
/// <param name="error">异常类型</param>
public void Throw(exceptionType error)
{
debug value = new debug
{
StackTrace = new StackTrace(true),
Type = error
};
if (checkCache(value, true))
{
queue.EnqueueNotNull(value);
}
throw new Exception(ExceptionPrefix + value.ToString());
}
/// <summary>
/// 添加日志
/// </summary>
/// <param name="message">提示信息</param>
/// <param name="isStackTrace">是否包含调用堆栈</param>
/// <param name="isCache">是否缓存</param>
public void Add(string message, bool isStackTrace = false, bool isCache = false)
{
debug value = new debug
{
StackTrace = isStackTrace ? new StackTrace() : null,
StackFrame = isStackTrace ? null : new StackFrame(1),
Message = message
};
if (!isCache || !checkCache(value))
{
add(value);
}
}
/// <summary>
/// 添加日志并抛出异常
/// </summary>
/// <param name="message">提示信息</param>
/// <param name="stackFrame">堆栈帧函数信息</param>
/// <param name="cache">缓存类型</param>
public void Throw(string message, StackFrame stackFrame, cacheType cache)
{
debug value = new debug
{
StackTrace = stackFrame == null ? new StackTrace(true) : null,
StackFrame = stackFrame,
Message = message
};
if (cache == cacheType.None || checkCache(value, cache == cacheType.Queue))
{
queue.EnqueueNotNull(value);
}
throw new Exception(ExceptionPrefix + message);
}
/// <summary>
/// 添加日志并抛出异常
/// </summary>
/// <param name="message">提示信息</param>
/// <param name="isStackTrace">是否包含调用堆栈</param>
/// <param name="isCache">是否缓存</param>
public void Throw(string message, bool isStackTrace = false, bool isCache = false)
{
debug value = new debug
{
StackTrace = isStackTrace ? new StackTrace() : null,
StackFrame = isStackTrace ? null : new StackFrame(1),
Message = message
};
if (!isCache || !checkCache(value))
{
add(value);
}
throw new Exception(ExceptionPrefix + message);
}
//-------------------------------------------------------------------
void Start()
{
sun = GameObject.Find("sun");
ship = GameObject.Find("ship");
// gravity beam
gravityBeam = GameObject.Find("gravityBeam").GetComponent<gravityBeam>();
anim = GetComponent<planetAnimation>();
scoring = GameObject.Find("setup").GetComponent<scoring>();
// settings
tinker = GameObject.Find("tinker").GetComponent<tinker>();
// debug
debugScript = (debug)GameObject.Find("debug").GetComponent(typeof(debug));
}
/// <summary>
/// 检测缓存是否存在
/// </summary>
/// <param name="value">日志信息</param>
/// <returns>缓存是否存在</returns>
private bool checkCache(debug value)
{
string key = value.ToString();
while (Interlocked.CompareExchange(ref cacheLock, 1, 0) != 0)
{
Thread.Sleep(1);
}
try
{
if (cache.ContainsKey(key))
{
return(true);
}
cache.Add(key, value);
}
finally { cacheLock = 0; }
return(false);
}
public MainForm()
{
InitializeComponent();
beginDialog startDialog = new beginDialog();
if (startDialog.ShowDialog() == DialogResult.OK)
{
mLabelValueEinsatzOrt.Text = startDialog.getEinsatzLocation();
mLabelValueEinsatzStart.Text = startDialog.getStartDateTime();
mLabelValueProtocolLeader.Text = startDialog.getProtocolLeader();
mLabelValueEinsatzLeader.Text = startDialog.getEinsatzLeader();
mStartTime = DateTime.Now;
}
mBeginTypingNewMessage = false;
initListView();
mDebug = new debug();
mDebug.debugMaskSet(debug.DebugIds.DEBUG_MAINFORM);
mDebug.dprintf("MainForm.cs", 62, debug.DebugIds.DEBUG_MAINFORM, "Init Finished");
addedAutoCompleteValuesToTextBoxes();
}
//crea una lista de estados candidatos, los compara con los del padre por si se repite. devuelve una lista de nodos.
public List <Nodo> expandir(debug de)
{
this.de = de;
de.setDeb(this.miEstado());
estado.setDebug(de);
List <Estado> estadosCandidatos = estado.expandir();
List <Nodo> listaADevolver = new List <Nodo>();
foreach (Estado esta in estadosCandidatos)
{
if (padre == null)
{
Nodo nuevoNodo = new Nodo(this, esta.getJ3(), esta.getJ4(), null);
listaADevolver.Add(nuevoNodo);
}
else if (!esta.comparaEstado(padre.getEstado()))
{
Nodo nuevoNodo = new Nodo(this, esta.getJ3(), esta.getJ4(), esta.accion);
listaADevolver.Add(nuevoNodo);
}
}
return(listaADevolver);
}
//constructor con los estados originales de las jarras
public BusquedaEnAmplitud(debug de)
{
this.de = de;
}
private void Capitulo12Button_Click(object sender, RoutedEventArgs e)
{
debug debug = new debug();
debug.Show();
}
/// <summary>
/// 添加日志
/// </summary>
/// <param name="message">提示信息</param>
/// <param name="isStackTrace">是否包含调用堆栈</param>
/// <param name="isCache">是否缓存</param>
public void Add(string message, bool isStackTrace = false, bool isCache = false)
{
debug value = new debug
{
StackTrace = isStackTrace ? new StackTrace() : null,
StackFrame = isStackTrace ? null : new StackFrame(1),
Message = message
};
if (!isCache || !checkCache(value)) add(value);
}
/// <summary>
/// 实时添加日志并抛出异常
/// </summary>
/// <param name="message">提示信息</param>
/// <param name="isStackTrace">是否包含调用堆栈</param>
/// <param name="isCache">是否缓存</param>
public void ThrowReal(string message, bool isStackTrace = false, bool isCache = false)
{
debug value = new debug
{
StackTrace = isStackTrace ? new StackTrace() : null,
StackFrame = isStackTrace ? null : new StackFrame(1),
Message = message
};
if (!isCache || !checkCache(value)) output(value.ToString());
throw new Exception(ExceptionPrefix + message);
}
/// <summary>
/// 实时添加日志并抛出异常
/// </summary>
/// <param name="error">错误异常</param>
/// <param name="message">提示信息</param>
/// <param name="isCache">是否缓存</param>
public void ThrowReal(Exception error, string message = null, bool isCache = true)
{
if (error != null && error.Message.StartsWith(ExceptionPrefix, StringComparison.Ordinal)) error = null;
if (error == null)
{
if (message != null) ThrowReal(message, true, isCache);
}
else
{
debug value = new debug
{
Exception = error,
Message = message
};
if (!isCache || !checkCache(value)) output(value.ToString());
throw error != null ? new Exception(ExceptionPrefix + message, error) : new Exception(ExceptionPrefix + message);
}
}
/// <summary>
/// 实时添加日志并抛出异常
/// </summary>
/// <param name="error">异常类型</param>
public void ThrowReal(exceptionType error)
{
debug value = new debug
{
StackTrace = new StackTrace(),
Type = error
};
if (!checkCache(value)) output(value.ToString());
throw new Exception(ExceptionPrefix + value.ToString());
}
/// <summary>
/// 检测缓存是否存在
/// </summary>
/// <param name="value">日志信息</param>
/// <returns>缓存是否存在</returns>
private bool checkCache(debug value)
{
string key = value.ToString();
while (Interlocked.CompareExchange(ref cacheLock, 1, 0) != 0) Thread.Sleep(1);
try
{
if (cache.ContainsKey(key)) return true;
cache.Add(key, value);
}
finally { cacheLock = 0; }
return false;
}
/// <summary>
/// 添加日志
/// </summary>
/// <param name="error">错误异常</param>
/// <param name="message">提示信息</param>
/// <param name="isCache">是否缓存</param>
public void Add(Exception error, string message = null, bool isCache = true)
{
if (error != null && error.Message.StartsWith(ExceptionPrefix, StringComparison.Ordinal)) error = null;
if (error == null)
{
if (message != null) Add(message, true, isCache);
}
else
{
debug value = new debug
{
Exception = error,
Message = message
};
if (!isCache || !checkCache(value)) add(value);
}
}
public void setDebug(debug de)
{
this.de = de;
}
/// <summary>
/// 添加新的日志
/// </summary>
/// <param name="value">日志信息</param>
private void add(debug value)
{
if (!isStop)
{
Monitor.Enter(logLock);
try
{
newDebugs.Add(value);
Monitor.Pulse(logLock);
}
finally { Monitor.Exit(logLock); }
}
}
