/// <summary>
/// 可能ならコールバックを呼びます。
/// </summary>
/// <param name="cagt">仮引数スタック</param>
/// <param name="func">コールバック変数</param>
protected void TryCallCallBack(DummyArgumentsStack cagt, ICbValue func)
{
if (CanCallBack(func))
{
CallCallBack(cagt, func);
}
}
public override void Set(ICbValue n)
{
try
{
if (n.IsError)
{
throw new Exception(n.ErrorMessage);
}
// 値を文字列にしてコピーする
if (n.IsNull)
{
Value = null;
}
else
{
ValueString = n.ValueString;
}
IsLiteral = n.IsLiteral;
if (IsError)
{
// エラーからの復帰
IsError = false;
ErrorMessage = "";
}
}
catch (Exception ex)
{
IsError = true;
ErrorMessage = ex.Message;
throw;
}
}
/// <summary>
/// コールバックを呼び出します。
/// </summary>
/// <param name="variable">変数</param>
/// <param name="dummyArgumentstack">仮引数スタック</param>
/// <returns>コールバックの返し値</returns>
protected ICbValue CallEvent(ICbValue variable, DummyArgumentsStack dummyArgumentstack)
{
ICbEvent cbEvent = variable as ICbEvent;
cbEvent.InvokeCallback(dummyArgumentstack);
return(cbEvent.Value);
}
/// <summary>
/// 引数からリストを参照します。
/// </summary>
/// <param name="arguments">引数リスト</param>
/// <param name="index">引数のインデックス</param>
/// <returns>配列</returns>
protected List <ICbValue> GetArgumentList(List <ICbValue> arguments, int index)
{
ICbValue valueData = arguments[index];
CheckArgument(valueData);
return(valueData.GetListValue.Value);
}
/// <summary>
/// 引数付きでコールバックを呼んで返り値を得ます。
/// </summary>
/// <typeparam name="R">返り値の型</typeparam>
/// <param name="dummyArgumentsControl">仮引数コントロール</param>
/// <param name="cagt">仮引数スタック</param>
/// <param name="func">コールバック変数</param>
/// <param name="arg">コールバック引数</param>
/// <param name="def">コールバックの返り値を得られなかったときの返り値</param>
/// <returns>コールバックの返り値</returns>
protected R GetCallBackResult <R>(DummyArgumentsControl dummyArgumentsControl, DummyArgumentsStack cagt, ICbValue func, object arg, R def)
{
if (!CanCallBack(func))
{
return(def);
}
if (arg is ICbValue cbValue)
{
dummyArgumentsControl.EnableCbValue(cagt, cbValue); // 仮引数に引数を登録
}
else
{
dummyArgumentsControl.Enable(cagt, (dynamic)arg); // 仮引数に引数を登録
}
if (typeof(R) == typeof(ICbValue))
{
ICbValue result = CallEvent(func, cagt);
dummyArgumentsControl.Invalidated(cagt); // 仮引数後処理
return((R)result);
}
else
{
R result = (R)CallEvent(func, cagt).Data;
dummyArgumentsControl.Invalidated(cagt); // 仮引数後処理
return(result);
}
}
public virtual bool IsAssignment(ICbValue obj, bool isCast)
{
if (obj is ParamNameOnly)
{
return(false);
}
if (IsList)
{
ICbList cbList = GetListValue;
if (isCast && cbList.IsArrayType && obj.IsList)
{
return(true); // ToArrya() を行う特殊なキャスト
}
if (isCast && obj.IsList)
{
ICbList ListObj = obj.GetListValue;
if (ListObj.IsArrayType)
{
return(true); // List<>(array) を行う特殊なキャスト
}
}
if (OriginalType.IsAssignableFrom(obj.OriginalType))
{
return(true);
}
}
return(CbSTUtils.IsAssignment(OriginalType, obj.OriginalType, isCast));
}
/// <summary>
/// CbStruct<T> 型なら同様の型の変数を返します。
/// </summary>
/// <param name="value">参考変数</param>
/// <param name="name">変数名</param>
/// <returns>CbStruct<T>型の変数</returns>
public static ICbValue StructValue(ICbValue value, string name)
{
if (value is ICbStruct cbStruct)
{
return(StructValue(cbStruct.OriginalReturnType, name));
}
return(null);
}
/// <summary>
/// CbEnum<T> 型なら同様の型の変数を返します。
/// </summary>
/// <param name="value">参考変数</param>
/// <param name="name">変数名</param>
/// <returns>CbEnum<T>型の変数</returns>
public static ICbValue EnumValue(ICbValue value, string name)
{
if (value is ICbEnum cbEnum)
{
return(EnumValue(CbST.GetTypeEx(cbEnum.ItemName), name));
}
return(null);
}
/// <summary>
/// CbClass<T> 型なら同様の型の変数を返します。
/// </summary>
/// <param name="value">参考変数</param>
/// <param name="name">変数名</param>
/// <returns>CbClass<T>型の変数</returns>
public static ICbValue ClassValue(ICbValue value, string name)
{
if (value is ICbClass cbClass)
{
return(ClassValue(cbClass.OriginalReturnType, name));
}
return(null);
}
/// <summary>
/// コールバックかを判断します。
/// </summary>
/// <param name="variable">変数</param>
/// <returns>true = コールバック</returns>
protected bool CanCallBack(ICbValue variable)
{
ICbEvent cbEvent = variable as ICbEvent;
if (cbEvent is null)
{
return(false);
}
return(cbEvent.IsCallback);
}
private static ICbValue CallGetCbFunc(ICbValue ret, string name, Type originalType)
{
object result = GetFuncType(originalType, ret.OriginalReturnType)
.InvokeMember(
nameof(CbFunc <int, CbInt> .GetCbFunc),
BindingFlags.InvokeMethod,
null, null, new object[] { name }) as ICbValue;
return(result as ICbValue);
}
/// <summary>
/// 変数が異常かをチェックします。
/// </summary>
/// <param name="variable">変数</param>
protected void CheckArgument(ICbValue variable)
{
if (variable is null)
{
throw new Exception("Argument is null.");
}
if (variable.IsError)
{
throw new Exception(variable.ErrorMessage);
}
}
/// <summary>
/// コールバックを呼んで返り値を得ます。
/// </summary>
/// <typeparam name="R">返り値の型</typeparam>
/// <param name="dummyArgumentsControl">仮引数コントロール</param>
/// <param name="cagt">仮引数スタック</param>
/// <param name="func">コールバック変数</param>
/// <param name="def">コールバックの返り値を得られなかったときの返り値</param>
/// <returns>コールバックの返り値</returns>
protected R GetCallBackResult <R>(DummyArgumentsStack cagt, ICbValue func, R def)
{
if (!CanCallBack(func))
{
return(def);
}
if (typeof(R) == typeof(ICbValue))
{
ICbValue result = CallEvent(func, cagt);
return((R)result);
}
else
{
R result = (R)CallEvent(func, cagt).Data;
return(result);
}
}
public override void Set(ICbValue n)
{
try
{
if (n.IsError)
{
throw new Exception(n.ErrorMessage);
}
// 型情報を残す
copyOriginal = n;
if (n is ICbEvent || n is ICbClass)
{
Value = n;
}
else
{
if (n.IsNullable && n.IsNull)
{
// null許容型は、null のときに参照してはならない
Value = null;
}
else
{
Value = n.Data;
}
}
IsLiteral = n.IsLiteral;
if (IsError)
{
// エラーからの復帰
IsError = false;
ErrorMessage = "";
}
}
catch (Exception ex)
{
IsError = true;
ErrorMessage = ex.Message;
throw;
}
}
protected void TryArgListProc(ICbValue variable, Action <ICbValue> func)
{
if (func is null)
{
return;
}
var argList = variable.GetListValue.Value;
foreach (var node in argList)
{
if (node.IsError)
{
throw new Exception(node.ErrorMessage);
}
func?.Invoke(node);
}
}
/// <summary>
/// オリジナル型の値に変換します。
/// </summary>
/// <param name="value"></param>
/// <param name="col"></param>
/// <param name="dummyArgumentsControl"></param>
/// <param name="dummyArgumentsStack"></param>
/// <returns></returns>
private object getBindObject(
ICbValue value,
MultiRootConnector col,
DummyArgumentsControl dummyArgumentsControl,
DummyArgumentsStack dummyArgumentsStack
)
{
if (value.IsList)
{
ICbList cbList = value.GetListValue;
// リストは、オリジナルの型のインスタンスを用意する
if (dummyArgumentsControl is null)
{
return(cbList.ConvertOriginalTypeList(col, dummyArgumentsStack));
}
else
{
return(cbList.ConvertOriginalTypeList(dummyArgumentsControl, dummyArgumentsStack));
}
}
else if (dummyArgumentsControl != null && value is ICbEvent cbEvent)
{
// Func<> 及び Action<> は、オリジナルの型のインスタンスを用意する
if (cbEvent.Callback is null)
{
return(null);
}
else
{
Debug.Assert(dummyArgumentsControl != null);
return(cbEvent.GetCallbackOriginalType(dummyArgumentsControl, dummyArgumentsStack));
}
}
if (value.IsNull)
{
return(null);
}
return(value.Data);
}
protected void TryArgListCancelableProc(ICbValue variable, Func <ICbValue, bool> func)
{
if (func is null)
{
return;
}
var argList = variable.GetListValue.Value;
foreach (var node in argList)
{
if (node.IsError)
{
throw new Exception(node.ErrorMessage);
}
if (func.Invoke(node))
{
break;
}
}
}
/// <summary>
/// コールバックを呼びます。
/// </summary>
/// <param name="cagt">仮引数スタック</param>
/// <param name="func">コールバック変数</param>
protected void CallCallBack(DummyArgumentsStack cagt, ICbValue func)
{
CallEvent(func, cagt);
}
/// <summary>
/// 引数が異常かをチェックし内容を参照します。
/// </summary>
/// <typeparam name="T">引数の型</typeparam>
/// <param name="variable">引数</param>
/// <returns>値</returns>
protected T GetArgument <T>(ICbValue variable)
{
CheckArgument(variable);
return((T)variable.Data);
}
/// <summary>
/// 可能なら引数付きでコールバックを呼びます。
/// </summary>
/// <param name="dummyArgumentsControl">仮引数コントロール</param>
/// <param name="cagt">仮引数スタック</param>
/// <param name="func">コールバック変数</param>
/// <param name="arg">コールバック引数</param>
protected void TryCallCallBack(DummyArgumentsControl dummyArgumentsControl, DummyArgumentsStack cagt, ICbValue func, object arg)
{
if (CanCallBack(func))
{
CallCallBack(dummyArgumentsControl, cagt, func, arg);
}
}
/// <summary>
/// メソッド呼び出しの実装です。
/// </summary>
/// <param name="col">スクリプトのルートノード</param>
/// <param name="dummyArgumentsControl">仮引数管理オブジェクト</param>
/// <param name="callArguments">引数リスト</param>
/// <param name="dummyArgumentsStack">仮引数スタック</param>
/// <param name="returnValue">返り値</param>
private void ImplCallMethod(
MultiRootConnector col,
Type classType,
DummyArgumentsControl dummyArgumentsControl,
List <ICbValue> callArguments,
DummyArgumentsStack dummyArgumentsStack,
ICbValue returnValue
)
{
try
{
bool isClassInstanceMethod = ArgumentTypeList != null && ArgumentTypeList[0].IsSelf && !IsConstructor;
List <object> methodArguments = null;
methodArguments = SetArguments(
col,
dummyArgumentsControl,
callArguments,
dummyArgumentsStack,
isClassInstanceMethod,
methodArguments
);
object classInstance = null;
if (isClassInstanceMethod)
{
// クラスメソッドの第一引数は、self（this）を受け取るのでクラスインスタンスとして扱う
classInstance = getBindObject(callArguments[0], col, dummyArgumentsControl, dummyArgumentsStack);
if (classInstance is null)
{
throw new Exception($"self(this) is invalid.");
}
// 返却方法が入っていないならセットしておく
var cbVSValue = callArguments[0];
if (!cbVSValue.IsDelegate && !cbVSValue.IsLiteral && cbVSValue.ReturnAction is null)
{
if (cbVSValue.IsList)
{
ICbList cbList = cbVSValue.GetListValue;
cbVSValue.ReturnAction = (value) =>
{
cbList.CopyFrom(value);
};
}
else if (!(cbVSValue is ICbClass))
{
cbVSValue.ReturnAction = (value) =>
{
cbVSValue.Data = value;
};
}
}
}
object result = CallMethod(
classInstance,
col,
classType,
callArguments,
isClassInstanceMethod,
methodArguments);
ProcReturnValue(col, returnValue, result);
}
catch (Exception ex)
{
col.ExceptionFunc(returnValue, ex);
}
}
/// <summary>
/// 仮引数に引数を登録し、有効化します。
/// ※Invokeメソッド用です。
/// </summary>
/// <typeparam name="T">登録する型</typeparam>
/// <param name="dummyArgumentstack">仮引数スタック</param>
/// <param name="argument">引数</param>
public void EnableCbValue(DummyArgumentsStack dummyArgumentstack, ICbValue argument)
{
argumentInvalid = false;
argumentRef[CbFuncArguments.INDEX.ARG_1] = argument;
dummyArgumentstack.Push(owner.PreFunction());
}
/// <summary>
/// 返り値を処理します。
/// </summary>
/// <param name="col">スクリプトのルートノード</param>
/// <param name="returnValue">返り値を格納する変数</param>
/// <param name="result">メソッド呼び出しの返り値</param>
private static void ProcReturnValue(MultiRootConnector col, ICbValue returnValue, object result)
{
if (returnValue.IsList)
{
ICbList retCbList = returnValue.GetListValue;
retCbList.CopyFrom(result);
col.LinkConnectorControl.UpdateValueData();
}
else if (result != null && returnValue is ICbEvent cbEvent)
{
// デリゲート型の返し値
Type resultType = CbSTUtils.GetDelegateReturnType(result.GetType());
if (!CbSTUtils.IsVoid(resultType))
{
// 返し値のあるデリゲート型
cbEvent.Callback = (cagt) =>
{
ICbValue retTypeValue = null;
try
{
// イベントからの返り値を取得
object tempReturnValue = ((dynamic)result).Invoke(cagt.GetValue().Data);
// 直接メソッドを呼ぶため帰ってくるのは通常の値なので Cb タイプに変換する
retTypeValue = CbST.CbCreate(tempReturnValue.GetType());
retTypeValue.Data = tempReturnValue;
}
catch (Exception ex)
{
col.ExceptionFunc(null, ex);
}
return(retTypeValue);
};
}
else
{
// 返し値の無いデリゲート型
cbEvent.Callback = (cagt) =>
{
try
{
var argType = cagt.GetValue();
if (argType is null)
{
((dynamic)result).Invoke(null);
}
else
{
((dynamic)result).Invoke(argType.Data);
}
}
catch (Exception ex)
{
col.ExceptionFunc(null, ex);
}
return(new CbVoid());
};
}
}
else
{
returnValue.Data = result;
}
}
public SingleRootConnector AppendToBox(ICbValue variable, bool openList = false)
{
LinkConnectorControl.AppendArgument(variable, openList);
return(this);
}
public static StackNode Create(
CommandCanvas OwnerCommandCanvas,
string caption,
ObservableCollection <StackGroup> stackList,
bool forcedListTypeSelect,
Point?pos = null)
{
ListSelectWindow selectWindow = new ListSelectWindow();
selectWindow.Caption = caption;
selectWindow.Owner = CommandCanvasList.OwnerWindow;
ControlTools.SetWindowPos(selectWindow, pos);
if (DefaultValue != null)
{
selectWindow.Add("[ New ]");
}
List <string> teble = new List <string>();
foreach (var node in stackList)
{
teble.Add(node.stackNode.ValueData.Name);
if (DefaultValue != null)
{
if (DefaultValue.TypeName != node.stackNode.ValueData.TypeName)
{
continue;
}
}
if (forcedListTypeSelect)
{
if (!node.stackNode.ValueData.IsList)
{
continue;
}
}
selectWindow.Add(node.stackNode.ValueData.Name);
}
selectWindow.ShowDialog();
if (selectWindow.SelectedIndex == -1)
{
return(null);
}
if (selectWindow.SelectedName == "[ New ]")
{
if (DefaultValue is null)
{
return(null);
}
// 新規作成する
DefaultValue.Name = "variable" + (OwnerCommandCanvas.ScriptWorkStack.StackData.Count + 1);
var ret = OwnerCommandCanvas.ScriptWorkStack.Append(DefaultValue).stackNode;
DefaultValue = null;
return(ret);
}
DefaultValue = null;
// 選ばれたアイテムの名前からインデックスを求める
int index = teble.FindIndex((x) => x == selectWindow.SelectedName);
return(stackList[index].stackNode);
}
/// <summary>
/// 引数付きでコールバックを呼びます。
/// </summary>
/// <param name="dummyArgumentsControl">仮引数コントロール</param>
/// <param name="cagt">仮引数スタック</param>
/// <param name="func">コールバック変数</param>
/// <param name="arg">コールバック引数</param>
protected void CallCallBack(DummyArgumentsControl dummyArgumentsControl, DummyArgumentsStack cagt, ICbValue func, object arg)
{
if (arg is ICbValue cbValue)
{
dummyArgumentsControl.EnableCbValue(cagt, cbValue); // 仮引数に引数を登録
}
else
{
dummyArgumentsControl.Enable(cagt, (dynamic)arg); // 仮引数に引数を登録
}
CallEvent(func, cagt);
dummyArgumentsControl.Invalidated(cagt); // 仮引数後処理
}
