/// <summary>
/// Obtiene un parámetro con los datos de un tipo (para la definición corta del tipo)
/// </summary>
private StructParameterModel GetTypeStructShort(string name, TypedModel type)
{
if (type != null)
{
return(new StructParameterModel(name, type.Name, type.Name));
}
else
{
return(new StructParameterModel(name, "", ""));
}
}
/// <summary>
/// Obtiene un parámetro con los datos de un tipo (para la definición corta del tipo)
/// </summary>
private StructParameterModel GetTypeStructShort(string strName, TypedModel objType)
{
if (objType != null)
{
return(new StructParameterModel(strName, objType.Name, objType.Name));
}
else
{
return(new StructParameterModel(strName, "", ""));
}
}
/// <summary>
/// Obtiene el vínculo al nombre nombre del tipo
/// </summary>
private MLNode GetLinkTypeName(TypedModel objType)
{
string strType = objType.Name;
// Si se trata de un array, añade los datos
if (objType.IsArray)
{
strType = strType + "[]";
}
// Devuelve la cadena del tipo
return(Document.MLBuilder.GetSearchLink(strType, objType.Name));
}
/// <summary>
/// Obtiene el vínculo al nombre nombre del tipo
/// </summary>
private string GetLinkTypeName(TypedModel typeDef)
{
string type = typeDef.Name;
// Si se trata de un array, añade los datos
if (typeDef.IsArray)
{
type = type + "[]";
}
// Devuelve la cadena del tipo
return(type);
}
/// <summary>
/// Obtiene el nombre del tipo
/// </summary>
internal string GetTypeName(TypedModel objType)
{
string strType = objType.Name;
// Si se trata de un array, añade los datos
if (objType.IsArray)
{
strType = strType + "[]";
}
// Devuelve la cadena del tipo
return(strType);
}
/// <summary>
/// Obtiene el MLNode del valor devuelto
/// </summary>
private MLNode GetListReturnData(BaseMethodModel objMethod, TypedModel objReturnType)
{
MLNode objMLNode = new MLNode("ul");
// Añade los datos al nodo
objMLNode.Nodes.Add(MLBuilder.GetListItem(MLBuilder.GetSpan("Valor de retorno", true),
MLBuilder.GetSpan(MLBuilderHelper.GetTypeName(objReturnType))));
if (!objMethod.RemarksXml.Returns.IsEmpty())
{
objMLNode.Nodes.Add("li").Nodes.AddRange(MLBuilderHelper.GetTagsRemarksXml(objMethod.RemarksXml.Returns));
}
// Devuelve el nodo
return(objMLNode);
}
/// <summary>
/// Obtiene los datos del tipo
/// </summary>
private TypedModel GetTypeData(ITypeSymbol objSymbol)
{
TypedModel objType = new TypedModel();
// Asigna los datos
if (objSymbol != null)
{ // Añade los datos de tipo o array
if (objSymbol is IArrayTypeSymbol)
{
IArrayTypeSymbol objArraySymbol = objSymbol as IArrayTypeSymbol;
// Obtiene los datos del array
objType.Name = objArraySymbol.ElementType.Name;
objType.IsArray = true;
objType.Dimensions = objArraySymbol.Rank;
objType.NameSpace = GetFullNameNameSpace(objArraySymbol);
}
else
{
objType.Name = objSymbol.Name;
objType.NameSpace = GetFullNameNameSpace(objSymbol);
}
// Asigna el tipo base
if (objSymbol.BaseType != null)
{
objType.BaseType = GetTypeData(objSymbol.BaseType);
}
// Añade las restricciones al tipo (para los genéricos)
if (objSymbol is ITypeParameterSymbol)
{
ITypeParameterSymbol objTypeParameter = objSymbol as ITypeParameterSymbol;
foreach (ITypeSymbol objConstraintType in objTypeParameter.ConstraintTypes)
{
objType.Constraints.Add(GetTypeData(objConstraintType.BaseType));
}
}
}
// Devuelve el tipo
return(objType);
}
/// <summary>
/// Obtiene los datos del tipo
/// </summary>
private TypedModel GetTypeData(ITypeSymbol symbol)
{
TypedModel type = new TypedModel();
// Asigna los datos
if (symbol != null)
{
// Añade los datos de tipo o array
if (symbol is IArrayTypeSymbol symbolArray)
{
type.Name = symbolArray.ElementType.Name;
type.IsArray = true;
type.Dimensions = symbolArray.Rank;
type.NameSpace = GetFullNameNameSpace(symbolArray);
}
else
{
type.Name = symbol.Name;
type.NameSpace = GetFullNameNameSpace(symbol);
}
// Asigna el tipo base
if (symbol.BaseType != null)
{
type.BaseType = GetTypeData(symbol.BaseType);
}
// Añade las restricciones al tipo (para los genéricos)
if (symbol is ITypeParameterSymbol typeParameter)
{
foreach (ITypeSymbol constraintType in typeParameter.ConstraintTypes)
{
type.Constraints.Add(GetTypeData(constraintType.BaseType));
}
}
}
// Devuelve el tipo
return(type);
}
/// <summary>
/// Obtiene el prototipo de una función
/// </summary>
internal string GetMethodPrototype(BaseMethodModel objMethod, bool blnIsAsync = false, TypedModel objReturnType = null)
{
string strPrototype = GetMethodPrototypeDefinition(objMethod, blnIsAsync, objReturnType);
// Añade los argumentos
strPrototype += "(" + GetArgumentsPrototype(objMethod) + ")";
// Devuelve el prototipo
return(strPrototype);
}
/// <summary>
/// Obtiene el prototipo de una función
/// </summary>
private MLNodesCollection GetMethodPrototype(BaseMethodModel objMethod, bool blnIsAsync = false, TypedModel objReturnType = null)
{
MLNodesCollection objColMLNodes = GetMethodPrototypeDefinition(objMethod, blnIsAsync, objReturnType);
// Añade los argumentos
objColMLNodes.Add(Document.MLBuilder.GetSpan("("));
objColMLNodes.AddRange(GetArgumentsPrototype(objMethod));
objColMLNodes.Add(Document.MLBuilder.GetSpan(")"));
// Devuelve el prototipo
return(objColMLNodes);
}
/// <summary>
/// Obtiene la definición (el prefijo) de un prototipo de un método
/// </summary>
private string GetMethodPrototypeDefinition(BaseMethodModel method, bool isAsync, TypedModel returnType)
{
string prototype = "";
// Añade los modificadores
prototype += GetModifierText(method.Modifier);
if (isAsync)
{
prototype += " async";
}
if (method.IsAbstract)
{
prototype += " abstract";
}
if (method.IsOverride)
{
prototype += " override";
}
if (method.IsSealed)
{
prototype += " sealed";
}
if (method.IsStatic)
{
prototype += " static";
}
if (method.IsVirtual)
{
prototype += " virtual";
}
// Añade el valor de retorno
if (returnType != null)
{
prototype += " " + GetLinkTypeName(returnType);
}
// Añade el nombre del método
prototype += " " + method.Name;
// Añade los genéricos
prototype += GetMethodPrototypeGenerics(method.TypeParameters);
// Devuelve la definición de prototipo
return(prototype);
}
/// <summary>
/// Obtiene el prototipo de una función
/// </summary>
private string GetMethodPrototype(BaseMethodModel method, bool isAsync = false, TypedModel returnType = null)
{
string prototype = GetMethodPrototypeDefinition(method, isAsync, returnType);
// Añade los argumentos
prototype += "(" + GetArgumentsPrototype(method) + ")";
// Devuelve el prototipo
return(prototype);
}
/// <summary>
/// Obtiene el valor de retorno
/// </summary>
private StructDocumentationModel GetReturnValue(StructDocumentationModel parent, TypedModel objType, string strRemarks)
{
StructDocumentationModel structDoc = new StructDocumentationModel(parent, StructDocumentationModel.ScopeType.Global, "ReturnValue", "ReturnValue", 0);
// Añade el tipo
structDoc.Childs.Add(GetTypeStruct(structDoc, "ReturnValueStruct", objType));
structDoc.Parameters.Add(GetTypeStructShort("Type", objType));
// Añade los valores
structDoc.Parameters.Add("Summary", ConvertRemarks(strRemarks));
// Devuelve el parámetro
return(structDoc);
}
/// <summary>
/// Obtiene el parámetro de un tipo
/// </summary>
private StructDocumentationModel GetTypeStruct(StructDocumentationModel parent, string name, TypedModel type)
{
StructDocumentationModel structDoc = new StructDocumentationModel(parent, StructDocumentationModel.ScopeType.Global, name, "Type", 0);
// Si realmente se le pasa un tipo
if (type != null)
{
// Asigna los datos del tipo
structDoc.Childs.Add(GetTypeStruct(parent, "BaseTypeStruct", type.BaseType));
structDoc.Parameters.Add(GetTypeStructShort("BaseType", type.BaseType));
structDoc.Parameters.Add("NameSpace", type.NameSpace);
structDoc.Parameters.Add("IsVoid", type.IsVoid);
structDoc.Parameters.Add("IsArray", type.IsArray);
structDoc.Parameters.Add("Dimensions", type.Dimensions);
// Añade las restricciones
AddListConstraints(structDoc, type.Constraints);
}
// Devuelve el parámetro
return(structDoc);
}
/// <summary>
/// Obtiene la definición (el prefijo) de un prototipo de un método
/// </summary>
private MLNodesCollection GetMethodPrototypeDefinition(BaseMethodModel objMethod, bool blnIsAsync, TypedModel objReturnType)
{
MLNodesCollection objColMLNodes = new MLNodesCollection();
// Añade los modificadores
objColMLNodes.Add(Document.MLBuilder.GetSpan(GetModifierText(objMethod.Modifier)));
if (blnIsAsync)
{
objColMLNodes.Add(Document.MLBuilder.GetSpan("async"));
}
if (objMethod.IsAbstract)
{
objColMLNodes.Add(Document.MLBuilder.GetSpan("abstract"));
}
if (objMethod.IsOverride)
{
objColMLNodes.Add(Document.MLBuilder.GetSpan("override"));
}
if (objMethod.IsSealed)
{
objColMLNodes.Add(Document.MLBuilder.GetSpan("sealed"));
}
if (objMethod.IsStatic)
{
objColMLNodes.Add(Document.MLBuilder.GetSpan("static"));
}
if (objMethod.IsVirtual)
{
objColMLNodes.Add(Document.MLBuilder.GetSpan("virtual"));
}
// Añade el valor de retorno
if (objReturnType != null)
{
objColMLNodes.Add(GetLinkTypeName(objReturnType));
}
// Añade el nombre del método
objColMLNodes.Add(Document.MLBuilder.GetSpan(objMethod.Name));
// Añade los genéricos
objColMLNodes.AddRange(GetMethodPrototypeGenerics(objMethod.TypeParameters));
// Devuelve la definición de prototipo
return(objColMLNodes);
}
/// <summary>
/// Sets the initial box of the arrow controlled by this arrow control
/// </summary>
/// <param name="box"></param>
public void SetInitialBox(TBoxModel box)
{
TypedModel.SetInitialBox(box);
}
/// <summary>
/// Obtiene la definición (el prefijo) de un prototipo de un método
/// </summary>
private string GetMethodPrototypeDefinition(BaseMethodModel objMethod, bool blnIsAsync, TypedModel objReturnType)
{
string strPrototype = GetModifierText(objMethod.Modifier);
// Añade los modificadores
if (blnIsAsync)
{
strPrototype = strPrototype.AddWithSeparator("async", " ", false);
}
if (objMethod.IsAbstract)
{
strPrototype = strPrototype.AddWithSeparator("abstract", " ", false);
}
if (objMethod.IsOverride)
{
strPrototype = strPrototype.AddWithSeparator("override", " ", false);
}
if (objMethod.IsSealed)
{
strPrototype = strPrototype.AddWithSeparator("sealed", " ", false);
}
if (objMethod.IsStatic)
{
strPrototype = strPrototype.AddWithSeparator("static", " ", false);
}
if (objMethod.IsVirtual)
{
strPrototype = strPrototype.AddWithSeparator("virtual", " ", false);
}
// Añade el valor de retorno
if (objReturnType != null)
{
strPrototype = strPrototype.AddWithSeparator(GetTypeName(objReturnType), " ", false);
}
// Añade el nombre del método
strPrototype = strPrototype.AddWithSeparator(objMethod.Name, " ", false);
// Añade los genéricos
strPrototype += GetMethodPrototypeGenerics(objMethod.TypeParameters);
// Devuelve la definición de prototipo
return(strPrototype);
}
/// <summary>
/// Obtiene el MLNode del valor devuelto
/// </summary>
private void GetMLReturn(MLNode objMLRoot, BaseMethodModel objMethod, TypedModel objReturnType)
{
objMLRoot.Nodes.Add("h3", "Valor devuelto");
objMLRoot.Nodes.Add("p", MLBuilderHelper.GetTypeName(objReturnType));
objMLRoot.Nodes.AddRange(MLBuilderHelper.GetTagsRemarksXml(objMethod.RemarksXml.Returns));
}
/// <summary>
/// Sets the target box of the arrow controlled by this arrow control
/// </summary>
/// <param name="box"></param>
public void SetTargetBox(TBoxModel box)
{
TypedModel.SetTargetBox(box);
}
