/// <summary>
/// リクエストされた型でジェネリックなパラメータを持つジェネリック型の型を確定します。
/// </summary>
/// <param name="col"></param>
/// <param name="type"></param>
/// <returns></returns>
private Type MakeRequestGenericType(MultiRootConnector col, Type type)
{
List <Type> argTypes = new List <Type>();
foreach (var gat in type.GetGenericArguments())
{
if (gat.IsGenericType)
{
// パラメータがジェネリックだった
var ngt = MakeRequestGenericType(col, gat);
argTypes.Add(ngt);
}
else if (gat.IsGenericParameter)
{
argTypes.Add(GetRequestType(col, gat.Name));
}
else
{
// ジェネリックでないパラメータはそのまま使う
argTypes.Add(gat);
}
}
// 確定した型を返す（repType を使って MakeGenericType しては駄目）
Type nType = CbST.GetTypeEx(type.Namespace + "." + type.Name);
return(nType.MakeGenericType(argTypes.ToArray()));
}
/// <summary>
/// ジェネリックなパラメータを持つジェネリック型を確定した型に変換します。
/// </summary>
/// <param name="col"></param>
/// <param name="gmaType">CbGeneMethArgのインスタンス</param>
/// <returns>確定した型</returns>
private Type GetConfirmedType(MultiRootConnector col, CbGeneMethArg gmaType)
{
Type replaceArgumentType = gmaType.ArgumentType;
if (replaceArgumentType.IsGenericType)
{
replaceArgumentType = MakeRequestGenericType(col, replaceArgumentType);
}
else if (replaceArgumentType.IsGenericParameter)
{
replaceArgumentType = GetRequestType(col, replaceArgumentType.Name);
}
else if (replaceArgumentType.ContainsGenericParameters)
{
if (replaceArgumentType.IsArray)
{
replaceArgumentType = GetRequestType(col, replaceArgumentType.GetElementType().Name).MakeArrayType();
}
}
else
{
Debug.Assert(false);
}
return(replaceArgumentType);
}
public VariableGetter(MultiRootConnector owner, Func <string, string> func = null, int index = 0)
{
this.owner = owner;
try
{
id = (int)(this.owner.GetAttachVariableId(index));
valueName = this.owner.OwnerCommandCanvas.ScriptWorkStack.Find(id).Name;
// 名前生成処理を登録
if (func != null)
{
owner.GetVariableName = func;
}
// 変数アセットは値の編集を禁止
this.owner.LinkConnectorControl.CaptionReadOnly = true;
// 参照関係を登録する
this.owner.OwnerCommandCanvas.ScriptWorkStack.Link(id, this.owner);
is_error = false;
}
catch (Exception ex)
{
this.owner.ExceptionFunc(ex);
}
}
/// <summary>
/// メソッド呼び出し処理を実装する
/// </summary>
/// <param name="col">スクリプトのルートノード</param>
/// <param name="isReBuildMode">再構築か？（保存データからの復帰）</param>
public override bool ImplAsset(MultiRootConnector col, bool isReBuildMode = false)
{
DummyArgumentsControl dummyArgumentsControl = new DummyArgumentsControl(col);
string exTitle = GetGenericArgumentsString(col, isReBuildMode);
return(ImplAsset(col, dummyArgumentsControl, exTitle));
}
protected virtual void Dispose(bool disposing)
{
if (!disposedValue)
{
if (disposing)
{
WriteAction = null;
ReadAction = null;
// 以下、固有定義開放
MultiRootConnector?.Dispose();
MultiRootConnector = null;;
SingleRootConnector?.Dispose();
SingleRootConnector = null;
MultiLinkConnector?.Dispose();
MultiLinkConnector = null;
SingleLinkConnector?.Dispose();
SingleLinkConnector = null;
RunableControl?.Dispose();
RunableControl = null;
GroupAreaControl?.Dispose();
GroupAreaControl = null;
}
disposedValue = true;
}
}
/// <summary>
/// アセットコードでノードを作成します。
/// </summary>
/// <param name="assetCode">アセットコード</param>
/// <returns>ノード</returns>
public static MultiRootConnector CreateFunction(CommandCanvas OwnerCommandCanvas, string assetCode)
{
var ret = new MultiRootConnector(nameof(MultiRootConnector));
ret.AssetFuncType = assetCode;
ret.AssetType = FunctionType.FuncType;
ret.OwnerCommandCanvas = OwnerCommandCanvas;
return(ret);
}
public _AssetXML()
{
ReadAction = (self) =>
{
self.AssetId = AssetId;
self.XPos = XPos;
self.YPos = YPos;
if (MultiRootConnector != null)
{
var obj = new MultiRootConnector(this);
self.SetControl(obj);
obj.AssetXML = MultiRootConnector;
obj.AssetXML.ReadAction?.Invoke(obj);
}
if (RunableControl != null)
{
var obj = new RunableControl();
self.SetControl(obj);
obj.AssetXML = RunableControl;
obj.AssetXML.ReadAction?.Invoke(obj);
}
if (GroupAreaControl != null)
{
var obj = new GroupArea();
self.SetControl(obj);
obj.AssetXML = GroupAreaControl;
obj.AssetXML.ReadAction?.Invoke(obj);
}
if (SingleRootConnector != null)
{
var obj = new SingleRootConnector();
self.SetControl(obj);
obj.AssetXML = SingleRootConnector;
obj.AssetXML.ReadAction?.Invoke(obj);
}
if (MultiLinkConnector != null)
{
var obj = new MultiLinkConnector();
self.SetControl(obj);
obj.AssetXML = MultiLinkConnector;
obj.AssetXML.ReadAction?.Invoke(obj);
}
if (SingleLinkConnector != null)
{
var obj = new SingleLinkConnector();
self.SetControl(obj);
obj.AssetXML = SingleLinkConnector;
obj.AssetXML.ReadAction?.Invoke(obj);
}
// 次回の為の初期化
self.AssetXML = new _AssetXML <Movable>(self);
};
}
protected virtual void Dispose(bool disposing)
{
if (!disposedValue)
{
if (disposing)
{
this.owner = null;
}
disposedValue = true;
}
}
/// <summary>
/// 指定されたアセットコードに対して変数の型を選択しノードを作成します。
/// </summary>
/// <param name="assetCode">アセットコード</param>
/// <param name="cbType">選択された型の格納先</param>
/// <param name="ignoreTypes">選択除外の型を指定</param>
/// <param name="forcedListTypeSelect">リスト型を選択するか？</param>
/// <returns>ノード</returns>
public static MultiRootConnector CreateFreeTypeVariableFunction(
CommandCanvas OwnerCommandCanvas,
string assetCode,
List <TypeRequest> typeRequests,
bool forcedListTypeSelect = false)
{
MultiRootConnector multiRootConnector = null;
StackNode stackNode = null;
return(_CreateFreeTypeVariableFunction(OwnerCommandCanvas, assetCode, typeRequests, multiRootConnector, stackNode, forcedListTypeSelect));
}
public DummyArgumentsControl(MultiRootConnector owner)
{
this.owner = owner;
argumentInvalid = false;
argumentRef = null;
List <ICbValue> convList = new List <ICbValue>();
for (int i = 0; i < Enum.GetNames(typeof(CbFuncArguments.INDEX)).Length; ++i)
{
convList.Add(CbObject.Create());
}
argumentRef = new CbFuncArguments(convList);
owner.PreFunction = () => new DummyArgumentsStack.Node(() => argumentInvalid, argumentRef);
}
private Type GetRequestType(MultiRootConnector col, string name)
{
for (int i = 0; i < typeRequests.Count; i++)
{
TypeRequest typeRequest = typeRequests[i];
if (typeRequest.Name == name)
{
// 対応する型が見つかった
return(col.SelectedVariableType[i]);
}
}
return(null);
}
/// <summary>
/// 引数の型を選択しノードを作成します。
/// </summary>
/// <param name="cbType">選択された型の格納先</param>
/// <param name="ignoreTypes">選択除外の型を指定</param>
/// <returns>ノード</returns>
public static MultiRootConnector SelectVariableType(
CommandCanvas OwnerCommandCanvas,
List <TypeRequest> typeRequests = null)
{
var ret = new MultiRootConnector(nameof(CbScript));
ret.OwnerCommandCanvas = OwnerCommandCanvas;
if (typeRequests != null)
{
List <string> typeNames = OwnerCommandCanvas.RequestTypeName(typeRequests);
if (typeNames is null)
{
return(null);
}
ret.SelectedVariableTypes = typeNames.ToArray();
}
ret.AssetType = FunctionType.LiteralType;
return(ret);
}
/// <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);
}
public static VariableGetter CreateVariableGetter(MultiRootConnector col, string funcTitle, int index)
{
return(new VariableGetter(
col,
(name) =>
{
string title = "";
try
{
title = string.Format(funcTitle, name);
}
catch (Exception)
{
title = "** Name Error **";
}
return title;
},
index
));
}
public string GetGenericArgumentsString(MultiRootConnector col, bool isReBuildMode)
{
if (!isReBuildMode && typeRequests != null)
{
string exTitle = "";
foreach (var geneArg in col.SelectedVariableType)
{
if (geneArg != null)
{
if (exTitle == "")
{
exTitle += "<" + CbSTUtils.GetTypeName(geneArg);
}
else
{
exTitle += ", " + CbSTUtils.GetTypeName(geneArg);
}
}
}
return(exTitle + ">");
}
return(null);
}
/// <summary>
/// メソッド呼び出し処理を実装する
/// </summary>
/// <param name="col">スクリプトのルートノード</param>
/// <param name="isReBuildMode">再構築か？（保存データからの復帰）</param>
public virtual bool ImplAsset(MultiRootConnector col, bool isReBuildMode = false)
{
string exTitle = GetGenericArgumentsString(col, isReBuildMode);
return(ImplAsset(col, null, exTitle));
}
/// <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;
}
}
/// <summary>
/// メソッドを実行します。
/// </summary>
/// <param name="col">スクリプトのルートノード</param>
/// <param name="callArguments">引数リスト</param>
/// <param name="variableIds">スクリプト変数IDリスト</param>
/// <param name="isClassInstanceMethod">インスタンスメソッドか？</param>
/// <param name="methodArguments">メソッド呼び出し引数リスト</param>
/// <returns>メソッドの返り値</returns>
private object CallMethod(
object classInstance,
MultiRootConnector col,
Type classType,
List <ICbValue> callArguments,
bool isClassInstanceMethod,
List <object> methodArguments
)
{
object result;
if (classInstance != null && callArguments.Count == 1)
{
if (FuncCode == "Dispose")
{
// Disposeメソッドを実行するとUI上で破棄された値を表示しようとするので Dispose は無視する
// ※値は Data のリファレンスで繋がっているので、対策として状態を残すのは簡単では無い
Console.WriteLine(CapyCSS.Language.Instance["Help:Dispose"]);
return(null);
}
}
if (IsConstructor)
{
// new されたコンストラクタとして振る舞う
if (methodArguments is null)
{
result = Activator.CreateInstance(classType);
}
else
{
object[] args = methodArguments.ToArray();
result = Activator.CreateInstance(classType, args);
ReturnArgumentsValue(classInstance, callArguments, args);
}
}
else if (GenericMethodParameters != null)
{
// ジェネリックメソッド
List <Type> genericParams = new List <Type>();
foreach (var atype in GenericMethodParameters)
{
genericParams.Add(GetRequestType(col, atype.Name));
}
if (methodArguments is null)
{
// 引数のないメソッドを型で補完して呼ぶ
result = InvokeGenericMethod(classType, genericParams, new object[] { });
}
else
{
// 引数ありのメソッド
object[] args = methodArguments.ToArray();
// 引数の型リストを作成
List <Type> argTypes = new List <Type>();
foreach (var cbArg in callArguments)
{
argTypes.Add(cbArg.OriginalType);
}
if (classType.GetMethod(FuncCode, argTypes.ToArray()) != null)
{
// 同じ型のメソッドが既に定義されているのでそちらを呼ぶ
result = InvokeMethodWithArguments(classType, classInstance, args);
}
else
{
// ジェネリックメソッドを型で補完して呼ぶ
result = InvokeGenericMethod(classType, genericParams, args);
}
ReturnArgumentsValue(classInstance, callArguments, args);
}
}
else if (methodArguments is null)
{
// 引数のないメソッド
result = InvokeMethod(classType, classInstance);
}
else
{
// 引数ありのメソッド
object[] args = methodArguments.ToArray();
result = InvokeMethodWithArguments(classType, classInstance, args);
ReturnArgumentsValue(classInstance, callArguments, args);
}
return(result);
}
/// <summary>
/// 指定されたアセットコードに対してウインドウを表示して変数の型を選択しノードを作成します。
/// </summary>
/// <param name="assetCode">アセットコード</param>
/// <param name="multiRootConnector">対象のMultiRootConnector</param>
/// <param name="stackNode">変数の登録領域</param>
/// <param name="forcedListTypeSelect">リスト型を選択するか？</param>
/// <returns>ノード</returns>
private static MultiRootConnector _CreateFreeTypeVariableFunction(
CommandCanvas OwnerCommandCanvas,
string assetCode,
List <TypeRequest> typeRequests,
MultiRootConnector multiRootConnector,
StackNode stackNode,
bool forcedListTypeSelect)
{
if (multiRootConnector is null)
{
List <string> typeNames;
if (typeRequests == null)
{
if (OwnerCommandCanvas.ScriptWorkStack.StackData.Count != 0)
{
// 既存の変数から選択する
stackNode = ListSelectWindow.Create(
OwnerCommandCanvas,
"Variable",
OwnerCommandCanvas.ScriptWorkStack.StackData,
forcedListTypeSelect,
new Point(Mouse.GetPosition(null).X, Mouse.GetPosition(null).Y));
if (stackNode is null)
{
return(null);
}
typeNames = new List <string>();
typeNames.Add(stackNode.ValueData.OriginalType.FullName);
}
else
{
// 既存の変数が存在しない
return(null);
}
}
else
{
// 変数を新規作成する
typeNames = OwnerCommandCanvas.RequestTypeName(typeRequests);
if (typeNames is null)
{
return(null);
}
int nameIndex = 1;
string name;
do
{
name = "variable" + nameIndex++;
}while (OwnerCommandCanvas.ScriptWorkStack.NameContains(name));
ListSelectWindow.DefaultValue = CbST.CbCreate(CbST.GetTypeEx(typeNames[0]), name);
stackNode = OwnerCommandCanvas.ScriptWorkStack.Append(ListSelectWindow.DefaultValue).stackNode;
ListSelectWindow.DefaultValue = null;
}
multiRootConnector = new MultiRootConnector(nameof(CbScript));
multiRootConnector.OwnerCommandCanvas = OwnerCommandCanvas;
multiRootConnector.SelectedVariableTypes = typeNames.ToArray();
multiRootConnector.AssetFuncType = assetCode;
}
multiRootConnector.AttachParam = new MultiRootConnector.AttachVariableId(stackNode.Id);
multiRootConnector.AssetType = FunctionType.FuncType;
return(multiRootConnector);
}
/// <summary>
/// 引数をメソッドに合わせて調整しリストアップします。
/// </summary>
/// <param name="col">スクリプトのルートノード</param>
/// <param name="dummyArgumentsControl">仮引数管理オブジェクト</param>
/// <param name="callArguments">引数リスト</param>
/// <param name="dummyArgumentsStack">仮引数スタック</param>
/// <param name="variableIds">スクリプト変数IDリスト</param>
/// <param name="isClassInstanceMethod">インスタンスメソッドか？</param>
/// <param name="methodArguments">メソッド呼び出し引数リスト</param>
/// <returns>メソッド呼び出し引数リスト</returns>
private List <object> SetArguments(
MultiRootConnector col,
DummyArgumentsControl dummyArgumentsControl,
List <ICbValue> callArguments,
DummyArgumentsStack dummyArgumentsStack,
bool isClassInstanceMethod,
List <object> methodArguments
)
{
int argumentIndex = 0;
if (callArguments.Count > 0)
{
methodArguments ??= new List <object>();
}
bool isTaskRequest = callArguments.Count(n => n.IsList || n is ICbEvent) > 2; // タスクで処理する条件
if (isTaskRequest)
{
// タスクを使った処理
List <Task <object> > tasks = new List <Task <object> >();
for (int i = 0; i < callArguments.Count; ++i)
{
var node = callArguments[argumentIndex++];
CheckArgument(node);
if (i == 0 && isClassInstanceMethod)
{
// クラスメソッドの第一引数は、self（this）を受け取るのでメソッド呼び出しの引数にしない
continue;
}
tasks.Add(Task.Run(() =>
{
return(getBindObject(node, col, dummyArgumentsControl, dummyArgumentsStack));
}));
}
foreach (var task in tasks)
{
methodArguments.Add(task.Result);
}
}
else
{
// 通常処理
for (int i = 0; i < callArguments.Count; ++i)
{
var node = callArguments[argumentIndex++];
CheckArgument(node);
if (i == 0 && isClassInstanceMethod)
{
// クラスメソッドの第一引数は、self（this）を受け取るのでメソッド呼び出しの引数にしない
continue;
}
methodArguments.Add(getBindObject(node, col, dummyArgumentsControl, dummyArgumentsStack));
}
}
return(methodArguments);
}
/// <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>
/// 指定されたアセットコードに対して引数の型を選択しノードを作成します。
/// </summary>
/// <param name="assetCode">アセットコード</param>
/// <param name="cbType">選択された型の格納先</param>
/// <param name="ignoreTypes">選択除外の型を指定</param>
/// <returns>ノード</returns>
public static MultiRootConnector CreateFreeTypeFunction(
CommandCanvas OwnerCommandCanvas,
string assetCode,
List <TypeRequest> typeRequests = null)
{
var ret = new MultiRootConnector(nameof(CbScript));
ret.OwnerCommandCanvas = OwnerCommandCanvas;
if (typeRequests != null)
{
// 型選択要求用のタイトルを作成する
string methodName = assetCode;
int pos = methodName.LastIndexOf(".");
if (pos != -1 && ret.OwnerCommandCanvas.IsEqualRootConnectorValueType(methodName.Substring(0, pos)))
{
// RootConnector の型と選ばれたメソッドの型が一致するなら RootConnector の型リクエスト情報をコピーする
ret.SelectedVariableTypes = ret.OwnerCommandCanvas.SetRootConnectorValueType(ret);
}
else
{
string className = null;
if (methodName.Contains("`"))
{
className = methodName.Substring(0, methodName.IndexOf("`"));
}
if (methodName.Contains(".."))
{
methodName = methodName.Substring(methodName.LastIndexOf("..") + 1);
}
else
{
methodName = methodName.Substring(methodName.LastIndexOf(".") + 1);
}
if (methodName.Contains("#"))
{
methodName = methodName.Substring(0, methodName.IndexOf('#'));
string args = null;
foreach (var typeRequest in typeRequests)
{
if (args is null)
{
args = "<" + typeRequest.Name;
}
else
{
args += "," + typeRequest.Name;
}
}
methodName += args + ">";
}
else
{
methodName += "<>"; // 本来ジェネリックメソッドには引数がある筈だが、システムの提供するメソッドでそうでない場合がある
}
if (className != null)
{
methodName = className + "." + methodName;
}
List <string> typeNames = OwnerCommandCanvas.RequestTypeName(typeRequests, $"[{methodName}] ");
if (typeNames is null)
{
return(null);
}
ret.SelectedVariableTypes = typeNames.ToArray();
}
}
ret.AssetFuncType = assetCode;
ret.AssetType = FunctionType.FuncType;
return(ret);
}
/// <summary>
/// メソッド呼び出し処理を実装する
/// </summary>
/// <param name="col">スクリプトのルートノード</param>
/// <param name="dummyArgumentsControl">仮引数管理</param>
protected bool ImplAsset(
MultiRootConnector col,
DummyArgumentsControl dummyArgumentsControl,
string exTitle)
{
Type classType = ClassType;
string funcTitle = FuncTitle;
Func <ICbValue> returnType = ReturnType;
if (classType.IsGenericType)
{
// ジェネリッククラスの型を確定する
var data = ReturnType().Data;
if (data is CbGeneMethArg gmaType)
{
List <Type> argTypes = new List <Type>();
for (int i = 0; i < typeRequests.Count; ++i)
{
argTypes.Add(col.SelectedVariableType[i]);
}
//クラスの型を確定した型で差し替える
classType = classType.MakeGenericType(argTypes.ToArray());
if (IsConstructor)
{
returnType = CbST.CbCreateTF(classType);
if (funcTitle.Contains("<"))
{
// 確定した型情報に差し替える
funcTitle = funcTitle.Substring(0, funcTitle.IndexOf("<"));
}
}
}
else if (CbSTUtils.HaveGenericParamater(classType))
{
// ユーザー選択ではなく直接 self からコピーされた型の場合は、そのまま内容を登録する
List <Type> argTypes = new List <Type>();
for (int i = 0; i < typeRequests.Count; ++i)
{
argTypes.Add(col.SelectedVariableType[i]);
}
//クラスの型を確定した型で差し替える
classType = CbST.GetTypeEx(classType.FullName).MakeGenericType(argTypes.ToArray());
}
}
{// 返し値の型を差し替える
var methodReturnType = returnType();
if (methodReturnType.MyType == typeof(CbClass <CbGeneMethArg>))
{
// 未確定なジェネリック型を確定した型で差し替える
// 引数の型を差し替える
Type repType = GetConfirmedType(col, (CbGeneMethArg)methodReturnType.Data);
returnType = CbST.CbCreateTF(repType);
}
}
List <ICbValue> argumentTypeList = new List <ICbValue>();
if (ArgumentTypeList != null)
{
// 引数用の変数を用意する
foreach (var node in ArgumentTypeList)
{
var argumentType = node.CreateArgument();
if (argumentType.MyType == typeof(CbClass <CbGeneMethArg>))
{
// 未確定なジェネリック型を確定した型で差し替える
// 引数の型を差し替える
Type replaceArgumentType = GetConfirmedType(col, (CbGeneMethArg)argumentType.Data);
argumentType = CbST.CbCreate(replaceArgumentType, argumentType.Name);
}
argumentTypeList.Add(argumentType);
}
}
col.OldSpecification = oldSpecification;
col.MakeFunction(
funcTitle + exTitle,
NodeHelpText,
returnType,
argumentTypeList,
new Func <List <ICbValue>, DummyArgumentsStack, ICbValue>(
(arguments, cagt) =>
{
var ret = returnType();
if (dummyArgumentsControl != null && dummyArgumentsControl.IsInvalid(cagt))
{
return(ret); // 実行環境が有効でない
}
ImplCallMethod(col, classType, dummyArgumentsControl, arguments, cagt, ret);
return(ret);
}
)
);
argumentTypeList.Clear();
return(true);
}
