public override TypeNode VisitTypeReference(TypeNode type, bool addNonNullWrapperIfNeeded)
{
if (type == null)
{
return(null);
}
// begin change by drunje (allow pointers to managed structures)
if (this.AllowPointersToManagedStructures && (type.NodeType == NodeType.PointerTypeExpression))
{
PointerTypeExpression ptrExpr = (PointerTypeExpression)type;
TypeNode et = this.VisitTypeReference(ptrExpr.ElementType);
if ((et != null) && (et.Name != Looker.NotFound) && (!et.IsUnmanaged) && (et.IsValueType))
{
return(et.GetPointerType());
}
}
// end of change by drunje
ClassParameter cp = this.typeParamToClassParamMap[type.UniqueKey] as ClassParameter;
if (cp != null)
{
return(cp);
}
return(base.VisitTypeReference(type, addNonNullWrapperIfNeeded));
}
public object CreateClass([FromBody] ClassParameter obj)
{
if (obj.UserId == null && obj.Password == null)
{
return(new Result {
IsSucess = false, ResultData = "UserId Requird"
});
}
GRContext db = new GRContext();
tbl_class objcls = new tbl_class();
var result = db.tbl_class.FirstOrDefault(r => r.class_name == obj.ClassName && r.course_name == obj.CourseName);
if (result != null)
{
return(new Error()
{
IsError = true, Message = "Duplicate Entry Not Allowd"
});
}
objcls.class_name = obj.ClassName.ToString();
objcls.course_name = obj.CourseName.ToString();
objcls.Display = 1;
objcls.created_date = DateTime.Now;
db.tbl_class.Add(objcls);
db.SaveChanges();
return(new Result
{
IsSucess = true,
ResultData = "Class Created!"
});
}
public List <ClassParameter> GetInputOrOutputData(XElement dataElement)
{
if (dataElement == null)
{
return(null);
}
IEnumerable <XElement> rows = from element in dataElement.Elements("row")
select element;
if (rows == null)
{
return(null);
}
var datas = new List <ClassParameter>();
foreach (var row in rows)
{
var data = new ClassParameter {
Name = XElementParserUtils.GetStringValue(row.Element("fieldName")),
Type = XElementParserUtils.GetStringValue(row.Element("fieldType"))
};
datas.Add(data);
}
return(datas);
}
public void CanGetParameterValuesForMultiParametersVoidMethod()
{
var classParameter = new ClassParameter();
var structParameter = new StructParameter();
Expression <Action <Component> > expression = c => c.MultiParametersVoid(3, classParameter, structParameter);
var parameterValues = expression.GetParameterValues().ToList();
parameterValues.Should().HaveCount(3);
parameterValues[0].Should().Be(3);
parameterValues[1].Should().Be(classParameter);
parameterValues[2].Should().Be(structParameter);
}
private CodeTypeDeclaration CreateParameterClass(ClassParameter parameter)
{
var parameterClass = new CodeTypeDeclaration();
parameterClass.IsClass = true;
parameterClass.TypeAttributes = TypeAttributes.Public;
parameterClass.Name = parameter.Name;
parameterClass.Members.AddRange(this.GenererateProperties(parameter.ChildProperties));
return(parameterClass);
}
private ClassParameter ConvertToClassParameter(TypeNode typeParameter, InterfaceList interfaces, Class baseClass, ClassExpression cExpr)
{
ClassParameter cParam = typeParameter is MethodTypeParameter ? new MethodClassParameter() : new ClassParameter();
this.typeParamToClassParamMap[typeParameter.UniqueKey] = cParam;
cParam.SourceContext = typeParameter.SourceContext;
cParam.TypeParameterFlags = ((ITypeParameter)typeParameter).TypeParameterFlags;
if (typeParameter.IsUnmanaged)
{
cParam.SetIsUnmanaged();
}
cParam.Name = typeParameter.Name;
cParam.Namespace = StandardIds.ClassParameter;
cParam.BaseClass = baseClass == null ? SystemTypes.Object : baseClass;
cParam.BaseClassExpression = cExpr;
cParam.DeclaringMember = ((ITypeParameter)typeParameter).DeclaringMember;
cParam.DeclaringModule = typeParameter.DeclaringModule;
cParam.DeclaringType = typeParameter is MethodTypeParameter ? null : typeParameter.DeclaringType;
cParam.Flags = typeParameter.Flags & ~TypeFlags.Interface;
cParam.ParameterListIndex = ((ITypeParameter)typeParameter).ParameterListIndex;
MemberList mems = cParam.DeclaringType == null ? null : cParam.DeclaringType.Members;
int n = mems == null ? 0 : mems.Count;
for (int i = 0; i < n; i++)
{
if ((mems[i] as TypeNode) == typeParameter)
{
mems[i] = cParam;
break;
}
}
if (cExpr != null)
{
n = interfaces.Count - 1;
InterfaceList actualInterfaces = new InterfaceList(n);
for (int i = 0; i < n; i++)
{
actualInterfaces.Add(interfaces[i + 1]);
}
cParam.Interfaces = actualInterfaces;
}
else
{
cParam.Interfaces = interfaces;
}
if (cExpr != null)
{
cParam.BaseClass = this.VisitClassExpression(cExpr);
}
return(cParam);
}
public void TestAmend_ExplicitRef()
{
ClassParameter p1 = new ClassParameter {
Print = "Hello"
};
StructParameter p2 = new StructParameter {
Print = "Hello"
};
Amend_Explicit_By_Ref(ref p1);
Amend_Explicit_By_Ref(ref p2);
Assert.AreEqual("Hello World", p1.Print);
Assert.AreEqual("Hello", p2.Print, "Structs are always passed-by-value");
}
public object CreateClass([FromBody] ClassParameter obj)
{
try
{
ClassBusiness classB = new ClassBusiness();
var Result = classB.CreateClass(obj);
return(Result);
}
catch (Exception e)
{
return(new Error()
{
IsError = true, Message = e.Message
});
}
}
public void Should_Generate_Classes_from_Parameters()
{
var expected = @"namespace My.Namespace
{
public class exception
{
public processData processData { get; set; }
public string ExceptionMessage { get; set; }
}
}
";
var parameters = new List <ClassParameter>();
var parameter = new ClassParameter
{
Name = "exception",
Type = "exception",
ChildProperties = new List <ClassParameter>
{
new ClassParameter
{
Name = "processData",
Type = "processData"
},
new ClassParameter
{
Name = "ExceptionMessage",
Type = "string"
}
}
};
parameters.Add(parameter);
var codenamespace = this.xsdBuilder.Build(parameters, "My.Namespace");
var code = TestCodeGeneratorUtils.GenerateCode(codenamespace);
Assert.AreEqual(expected, code);
}
private TypeNode ConvertToClassParameter(TypeNode baseType, TypeNode /*!*/ typeParameter)
{
ClassParameter result;
if (typeParameter is MethodTypeParameter)
{
result = new MethodClassParameter();
}
else if (typeParameter is TypeParameter)
{
result = new ClassParameter
{
DeclaringType = typeParameter.DeclaringType
};
}
else
{
return(typeParameter); //give up
}
result.SourceContext = typeParameter.SourceContext;
result.TypeParameterFlags = ((ITypeParameter)typeParameter).TypeParameterFlags;
result.Name = typeParameter.Name;
result.Namespace = StandardIds.ClassParameter;
result.BaseClass = baseType is Class c ? c : CoreSystemTypes.Object;
result.DeclaringMember = ((ITypeParameter)typeParameter).DeclaringMember;
result.DeclaringModule = typeParameter.DeclaringModule;
result.Flags = typeParameter.Flags & ~TypeFlags.Interface;
//InterfaceList constraints = result.Interfaces = new InterfaceList();
InterfaceList interfaces = typeParameter.Interfaces;
for (int i = 1, n = interfaces == null ? 0 : interfaces.Count; i < n; i++)
{
//^ assert interfaces != null;
interfaces.Add(this.VisitInterfaceReference(interfaces[i]));
}
return(result);
}
public override TypeNodeList VisitTypeParameterList(TypeNodeList typeParameters)
{
typeParameters = base.VisitTypeParameterList(typeParameters);
for (int i = 0, n = typeParameters == null ? 0 : typeParameters.Count; i < n; i++)
{
TypeNode tp = typeParameters[i];
if (tp == null)
{
continue;
}
ClassParameter cp = tp as ClassParameter;
if (cp != null)
{
if (cp.BaseClass == null)
{
cp.BaseClass = this.VisitTypeReference(cp.BaseClassExpression) as Class;
}
}
typeParameters[i] = base.VisitTypeParameter(tp);
}
return(typeParameters);
}
private TypeNode ConvertToClassParameter(TypeNode baseType, TypeNode/*!*/ typeParameter)
{
ClassParameter result;
if (typeParameter is MethodTypeParameter)
{
result = new MethodClassParameter();
}
else if (typeParameter is TypeParameter)
{
result = new ClassParameter();
result.DeclaringType = typeParameter.DeclaringType;
}
else
return typeParameter; //give up
result.SourceContext = typeParameter.SourceContext;
result.TypeParameterFlags = ((ITypeParameter)typeParameter).TypeParameterFlags;
#if ExtendedRuntime
if (typeParameter.IsUnmanaged) { result.SetIsUnmanaged(); }
if (typeParameter.IsPointerFree) { result.SetIsPointerFree(); }
#endif
result.ParameterListIndex = ((ITypeParameter)typeParameter).ParameterListIndex;
result.Name = typeParameter.Name;
result.Namespace = StandardIds.ClassParameter;
result.BaseClass = baseType is Class ? (Class)baseType : CoreSystemTypes.Object;
result.DeclaringMember = ((ITypeParameter)typeParameter).DeclaringMember;
result.DeclaringModule = typeParameter.DeclaringModule;
result.Flags = typeParameter.Flags & ~TypeFlags.Interface;
InterfaceList constraints = result.Interfaces = new InterfaceList();
InterfaceList interfaces = typeParameter.Interfaces;
for (int i = 1, n = interfaces == null ? 0 : interfaces.Count; i < n; i++)
{
//^ assert interfaces != null;
constraints.Add(interfaces[i]);
}
this.forwarding[typeParameter.UniqueKey] = result;
return result;
}
private TypeNode/*!*/ ConstructCorrectTypeNodeSubclass(int i, Identifier/*!*/ namesp, int firstInterfaceIndex, int lastInterfaceIndex,
TypeFlags flags, InterfaceList interfaces, int baseTypeCodedIndex, bool isSystemEnum)
{
TypeNode result;
TypeNode.TypeAttributeProvider attributeProvider = new TypeNode.TypeAttributeProvider(this.GetTypeAttributes);
TypeNode.NestedTypeProvider nestedTypeProvider = new TypeNode.NestedTypeProvider(this.GetNestedTypes);
TypeNode.TypeMemberProvider memberProvider = new TypeNode.TypeMemberProvider(this.GetTypeMembers);
bool isTemplateParameter = false;
if ((flags & TypeFlags.Interface) != 0)
{
if (isTemplateParameter)
result = new TypeParameter(interfaces, nestedTypeProvider, attributeProvider, memberProvider, i);
else
result = new Interface(interfaces, nestedTypeProvider, attributeProvider, memberProvider, i);
}
else if (isTemplateParameter)
{
result = new ClassParameter(nestedTypeProvider, attributeProvider, memberProvider, i);
}
else
{
result = null;
TypeNode baseClass = this.GetTypeIfNotGenericInstance(baseTypeCodedIndex);
if (baseClass != null)
{
if (baseClass == CoreSystemTypes.MulticastDelegate) //TODO: handle single cast delegates
result = new DelegateNode(nestedTypeProvider, attributeProvider, memberProvider, i);
else if (baseClass == CoreSystemTypes.Enum)
result = new EnumNode(nestedTypeProvider, attributeProvider, memberProvider, i);
else if (baseClass == CoreSystemTypes.ValueType &&
!(isSystemEnum && (flags & TypeFlags.Sealed) == 0))
{
result = new Struct(nestedTypeProvider, attributeProvider, memberProvider, i);
}
}
if(result == null)
result = new Class(nestedTypeProvider, attributeProvider, memberProvider, i);
}
result.Flags = flags;
result.Interfaces = interfaces;
return result;
}
public static int Call(ClassParameter p) => p.Value;
public int MultiParametersNonVoid(string text, ClassParameter classParameter,
ReadonlyStructParameter structParameter) => 5;
public void MultiParametersVoid(int id, ClassParameter classParameter, StructParameter structParameter)
{
}
