public AssemblyDataType(Type type)
{
Name = type.Name;
accessModificator = DataAccessModificator.GetTypeModifiers(type);
typeAttribute = DataAttribute.GetTypeAtributes(type);
typeClass = DataTypeClass.GetTypeClass(type);
this.type = type;
Fields = new List <AssemblyTypeMember>();
IsGenerated = IsCompilerGenerated(type);
var flags = BindingFlags.Instance |
BindingFlags.Static |
BindingFlags.NonPublic |
BindingFlags.Public |
BindingFlags.DeclaredOnly;
foreach (var fieldInfo in type.GetFields(flags))
{
Fields.Add(new AssemblyTypeMember(fieldInfo, IsCompilerGenerated(fieldInfo)));
}
foreach (var properyInfo in type.GetProperties(flags))
{
Fields.Add(new AssemblyTypeMember(properyInfo, IsCompilerGenerated(properyInfo)));
}
foreach (var methodInfo in type.GetMethods(flags))
{
if (!methodInfo.IsDefined(typeof(ExtensionAttribute), false))
{
Fields.Add(new AssemblyTypeMember(methodInfo, IsCompilerGenerated(methodInfo)));
}
}
}
public RepositoryDataType()
{
DataTypeClass = DataTypeClass.Structure;
Documentation = new List <string>();
Categories = new List <string>();
References = new List <RepositoryReference>();
Fields = new List <RepositoryDataTypeField>();
}
public override IMatched <Unit> ParseStatement(ParseState state, Token[] tokens)
{
var className = tokens[3].Text;
state.Colorize(tokens, Color.Keyword, Color.Whitespace, Color.Class);
var values = new Hash <string, (IObject[], IRangeItem)>();
var dataComparisandNames = new List <string>();
var dataTypeClass = new DataTypeClass(className);
if (Module.Global.RegisterClass(dataTypeClass).If(out _, out var exception))
{
Module.Global.ForwardReference(className);
IRangeItem ordinal = (Int)0;
if (state.Advance().ValueOrOriginal(out _, out var original))
{
while (state.More)
{
var parser = new DataComparisandParser(className, values, ordinal);
if (parser.Scan(state).If(out _, out var anyException))
{
if (dataTypeClass.RegisterDataComparisand(parser.Name, (IObject)parser.Ordinal).If(out _, out var regException))
{
dataComparisandNames.Add(parser.Name);
ordinal = parser.Ordinal.Successor;
}
else
{
return(failedMatch <Unit>(regException));
}
}
else if (anyException.If(out exception))
{
return(failedMatch <Unit>(exception));
}
else
{
break;
}
}
state.Regress();
}
else
{
return(original);
}
state.AddStatement(new DataType(className, values.ToHash(i => i.Key, i =>
{
var(data, rangeItem) = i.Value;
return(data, (IObject)rangeItem);
})));
return(Unit.Matched());
}
public string GetFullName()
{
string accessModificatorString = DataAccessModificator.GetString(accessModificator);
string typeAttributeString = DataAttribute.GetString(typeAttribute);
string typeClassString = DataTypeClass.GetString(typeClass);
return
((accessModificatorString != "" ? (accessModificatorString + " ") : "") +
(typeAttributeString != "" ? (typeAttributeString + " ") : "") +
(typeClassString != "" ? (typeClassString + " ") : "") +
GetTypeGenericName(type));
}
public AssemblyDataType(Type extendedType, MethodInfo[] extensionMethods)
{
Name = extendedType.Name;
accessModificator = DataAccessModificator.GetTypeModifiers(extendedType);
typeAttribute = DataAttribute.GetTypeAtributes(extendedType);
typeClass = DataTypeClass.GetTypeClass(extendedType);
this.type = extendedType;
Fields = new List <AssemblyTypeMember>();
foreach (var methodInfo in extensionMethods)
{
Fields.Add(new AssemblyTypeMember(methodInfo, IsCompilerGenerated(methodInfo), true));
}
}
List <DataTypeClass> selectDataTypeClasses(string connectionString)
{
using (SqlConnection connection = new SqlConnection(GetConnectionString()))
{
List <DataTypeClass> dataTypeClasses = new List <DataTypeClass>();
connection.Open();
SqlCommand command = new SqlCommand("SELECT*FROM[AssignmentDB].[dbo].[DATA_TYPE_CLASS]", connection);
SqlDataReader reader = command.ExecuteReader();
while (reader.Read())
{
DataTypeClass dataTypeClass = new DataTypeClass()
{
ID_DATA_TYPE_CLASS = reader.GetInt32(0),
NAME = reader.GetString(1),
};
dataTypeClasses.Add(dataTypeClass);
}
connection.Close();
return(dataTypeClasses);
}
}
