void GenerateToString(Class @class, Block block, Method method)
{
needsStreamInclude = true;
block.WriteLine("std::ostringstream os;");
block.WriteLine("os << *NativePtr;");
block.Write("return clix::marshalString<clix::E_UTF8>(os.str());");
}
/// <summary>
/// Initializes a new instance of the <see cref="Field"/> class.
/// </summary>
/// <param name="fieldDefinition">The field definition.</param>
public Field (FieldDefinition fieldDefinition, Class type, Class _class, InternalType internalType)
{
this.type = type;
this.internalType = internalType;
this.fieldDefinition = fieldDefinition;
this._class = _class;
}
private static void HandleMissingOperatorOverloadPair(Class @class, CXXOperatorKind op1,
CXXOperatorKind op2)
{
foreach (var op in @class.Operators.Where(
o => o.OperatorKind == op1 || o.OperatorKind == op2).ToList())
{
int index;
var missingKind = CheckMissingOperatorOverloadPair(@class, out index, op1, op2,
op.Parameters.First().Type, op.Parameters.Last().Type);
if (missingKind == CXXOperatorKind.None || !op.IsGenerated)
continue;
var method = new Method()
{
Name = Operators.GetOperatorIdentifier(missingKind),
Namespace = @class,
SynthKind = FunctionSynthKind.ComplementOperator,
Kind = CXXMethodKind.Operator,
OperatorKind = missingKind,
ReturnType = op.ReturnType,
Parameters = op.Parameters
};
@class.Methods.Insert(index, method);
}
}
public static void Main(string[] args)
{
var trung = new Student() {
Name = "Trung",
ID = 5
};
var c1203l = new Class() {
ID = 1,
Name = "C1203L",
Teacher = "NhatNK"
};
var lab1 = new Room() {
Name = "Lab1"
};
var late = new TimeSlot() {
StartTime = DateTime.MinValue.AddDays(4).AddHours(17).AddMinutes(30),
EndTime = DateTime.MinValue.AddDays(4).AddHours(19).AddMinutes(30)
};
var m = new Manager();
m.Students.Add(trung);
m.Classes.Add(c1203l);
m.TimeSlots.Add(late);
m.Rooms.Add(lab1);
m.RegisterStudentWithClass(trung, c1203l);
m.RegisterClassRoomTimeSlot(c1203l, lab1, late);
foreach (var a in m.Allocation)
{
Console.WriteLine("{0} {1} {2}", a.Item1.Name, a.Item2.Name, a.Item3.StartTime.DayOfWeek);
}
}
public static Boolean addClass(int cCode, int semester_id, int max_enrollment, int enrollment, DateTime Class_time, int prof_id)
{
GradingSys_DataClassesDataContext db = new GradingSys_DataClassesDataContext();
Class classObj = new Class
{
Course_code = cCode,
Semester_id = semester_id,
Max_enrollment = max_enrollment,
Enrollment = enrollment,
Class_time = Class_time,
Professor_id = prof_id
};
db.Classes.InsertOnSubmit(classObj);
// Submit the change to the database.
try
{
db.SubmitChanges();
return true;
}
catch (Exception e)
{
Console.WriteLine(e);
return false;
}
}
public override bool VisitClassDecl(Class @class)
{
if (@class.CompleteDeclaration != null)
return VisitClassDecl(@class.CompleteDeclaration as Class);
if (!VisitDeclarationContext(@class))
return false;
// Check for C++ operators that cannot be represented in C#.
CheckInvalidOperators(@class);
if (Driver.Options.IsCSharpGenerator)
{
// The comparison operators, if overloaded, must be overloaded in pairs;
// that is, if == is overloaded, != must also be overloaded. The reverse
// is also true, and similar for < and >, and for <= and >=.
HandleMissingOperatorOverloadPair(@class, CXXOperatorKind.EqualEqual,
CXXOperatorKind.ExclaimEqual);
HandleMissingOperatorOverloadPair(@class, CXXOperatorKind.Less,
CXXOperatorKind.Greater);
HandleMissingOperatorOverloadPair(@class, CXXOperatorKind.LessEqual,
CXXOperatorKind.GreaterEqual);
}
return false;
}
static CXXOperatorKind CheckMissingOperatorOverloadPair(Class @class, out int index,
CXXOperatorKind op1, CXXOperatorKind op2, Type typeLeft, Type typeRight)
{
var first = @class.Operators.FirstOrDefault(o => o.OperatorKind == op1 &&
o.Parameters.First().Type.Equals(typeLeft) && o.Parameters.Last().Type.Equals(typeRight));
var second = @class.Operators.FirstOrDefault(o => o.OperatorKind == op2 &&
o.Parameters.First().Type.Equals(typeLeft) && o.Parameters.Last().Type.Equals(typeRight));
var hasFirst = first != null;
var hasSecond = second != null;
if (hasFirst && (!hasSecond || !second.IsGenerated))
{
index = @class.Methods.IndexOf(first);
return op2;
}
if (hasSecond && (!hasFirst || !first.IsGenerated))
{
index = @class.Methods.IndexOf(second);
return op1;
}
index = 0;
return CXXOperatorKind.None;
}
public void TestCloneNewRoot()
{
var obj1 = new Class { ClassMember = new Class(), ListMember = { new Class(), new Class(), new Class() } };
var obj2 = new Class { ClassMember = new Class(), ListMember = { new Class(), new Class(), new Class() } };
var nodeContainer = new NodeContainer();
var newRoot = nodeContainer.GetOrCreateNode(obj2);
var path1 = new GraphNodePath(nodeContainer.GetOrCreateNode(obj1));
var clone = path1.Clone(newRoot);
Assert.AreNotEqual(newRoot, path1.RootNode);
Assert.AreEqual(newRoot, clone.RootNode);
Assert.AreEqual(path1.IsValid, clone.IsValid);
Assert.AreEqual(path1.IsEmpty, clone.IsEmpty);
var path2 = path1.PushMember(nameof(Class.ClassMember)).PushTarget().PushMember(nameof(Class.IntMember));
clone = path2.Clone(newRoot);
Assert.AreNotEqual(newRoot, path2.RootNode);
Assert.AreEqual(newRoot, clone.RootNode);
Assert.AreEqual(path2.IsValid, clone.IsValid);
Assert.AreEqual(path2.IsEmpty, clone.IsEmpty);
var path3 = path1.PushMember(nameof(Class.ListMember)).PushIndex(new Index(1)).PushMember(nameof(Class.IntMember));
clone = path3.Clone(newRoot);
Assert.AreNotEqual(newRoot, path3.RootNode);
Assert.AreEqual(newRoot, clone.RootNode);
Assert.AreEqual(path3.IsValid, clone.IsValid);
Assert.AreEqual(path3.IsEmpty, clone.IsEmpty);
}
public override bool VisitClassDecl(Class @class)
{
if (@class.CompleteDeclaration != null)
return VisitClassDecl(@class.CompleteDeclaration as Class);
return base.VisitClassDecl(@class);
}
/// <summary>
/// This method is used to match the specified type to primitive
/// transform implementations. If this is given a primitive then
/// it will always return a suitable <c>Transform</c>. If
/// however it is given an object type an exception is thrown.
/// </summary>
/// <param name="type">
/// this is the primitive type to be transformed
/// </param>
/// <returns>
/// this returns a stock transform for the primitive
/// </returns>
public Transform Match(Class type) {
if(type == int.class) {
return new IntegerTransform();
}
if(type == bool.class) {
return new BooleanTransform();
}
if(type == long.class) {
return new LongTransform();
}
if(type == double.class) {
return new DoubleTransform();
}
if(type == float.class) {
return new FloatTransform();
}
if(type == short.class) {
return new ShortTransform();
}
if(type == byte.class) {
return new ByteTransform();
}
if(type == char.class) {
return new CharacterTransform();
}
return null;
}
public static Schema.KRPC.Services GetServices()
{
var services = new Schema.KRPC.Services ();
foreach (var serviceSignature in Services.Instance.Signatures.Values) {
var service = new Schema.KRPC.Service ();
service.Name = serviceSignature.Name;
foreach (var procedureSignature in serviceSignature.Procedures.Values) {
var procedure = new Procedure ();
procedure.Name = procedureSignature.Name;
if (procedureSignature.HasReturnType)
{
procedure.HasReturnType = true;
procedure.ReturnType = TypeUtils.GetTypeName (procedureSignature.ReturnType);
}
foreach (var parameterSignature in procedureSignature.Parameters) {
var parameter = new Parameter ();
parameter.Name = parameterSignature.Name;
parameter.Type = TypeUtils.GetTypeName (parameterSignature.Type);
if (parameterSignature.HasDefaultArgument)
{
parameter.HasDefaultArgument = true;
parameter.DefaultArgument = parameterSignature.DefaultArgument;
}
procedure.Parameters.Add (parameter);
}
foreach (var attribute in procedureSignature.Attributes) {
procedure.Attributes.Add (attribute);
}
if (procedureSignature.Documentation != "")
procedure.Documentation = procedureSignature.Documentation;
service.Procedures.Add (procedure);
}
foreach (var clsSignature in serviceSignature.Classes.Values) {
var cls = new Class ();
cls.Name = clsSignature.Name;
if (clsSignature.Documentation != "")
cls.Documentation = clsSignature.Documentation;
service.Classes.Add (cls);
}
foreach (var enmSignature in serviceSignature.Enumerations.Values) {
var enm = new Enumeration ();
enm.Name = enmSignature.Name;
if (enmSignature.Documentation != "")
enm.Documentation = enmSignature.Documentation;
foreach (var enmValueSignature in enmSignature.Values) {
var enmValue = new EnumerationValue ();
enmValue.Name = enmValueSignature.Name;
enmValue.Value = enmValueSignature.Value;
if (enmValueSignature.Documentation != "")
enmValue.Documentation = enmValueSignature.Documentation;
enm.Values.Add (enmValue);
}
service.Enumerations.Add (enm);
}
if (serviceSignature.Documentation != "")
service.Documentation = serviceSignature.Documentation;
services.Services_.Add (service);
}
return services;
}
static void Main()
{
//Student test
//Console.WriteLine("Student test");
List<Student> studentsList = new List<Student>();
studentsList.Add(new Student("Vesi", 1231532));
studentsList.Add(new Student("Natalia", 462346));
studentsList.Add(new Student("Mitko", 0982374));
//Console.WriteLine(studentsList.Print());
//Teacher test
//Console.WriteLine("Teacher test");
List<Teacher> teachersList = new List<Teacher>();
teachersList.Add(new Teacher("prof. Petrov"));
teachersList.Add(new Teacher("doc. Hristov"));
teachersList.Add(new Teacher("as. Doneva"));
teachersList[0].AddDiscipline("Computer sciense", 4, 5);
teachersList[0].AddDiscipline("Hardware basics", 3, 2);
teachersList[1].AddDiscipline("C# Basics", 4, 4);
teachersList[1].AddDiscipline("C# OOP", 5, 5);
teachersList[2].AddDiscipline("Operating Systems", 3, 2);
//Console.WriteLine(teachersList.Print());
//Class test
//Console.WriteLine("Class test");
Class classA = new Class('A', teachersList, studentsList);
//Console.WriteLine(classA.ToString());
Class classB = new Class('B', teachersList, studentsList);
classB.Comments = "This is class B";
//School test
Console.WriteLine("School test:");
School TUES = new School();
TUES.AddClass(classA);
TUES.AddClass(classB);
Console.WriteLine(TUES.ToString());
}
public static TsType CreateClass(TsType parent, Type type)
{
var name = type.Name;
var newClass = new Class(parent, name);
if (type.IsGenericType)
{
var genericWartIndex = name.IndexOf("`");
if (genericWartIndex > 0)
{
newClass.Name = name.Substring(0, genericWartIndex);
}
var generics = type.GetGenericArguments();
foreach (var generic in generics)
{
newClass.Generics.Add(new GenericDefinition(generic.Name));
}
}
AddConstructors(type, newClass);
AddFields(type, newClass);
AddProperties(type, newClass);
AddMethods(type, newClass);
return newClass;
}
/// <summary>
/// This is used to acquire a <c>Converter</c> instance from
/// this binder. All instances are cached to reduce the overhead
/// of lookups during the serialization process. Converters are
/// lazily instantiated and so are only created if demanded.
/// </summary>
/// <param name="type">
/// this is the type to find the converter for
/// </param>
/// <returns>
/// this returns the converter instance for the type
/// </returns>
public Converter Lookup(Class type) {
Class result = cache.fetch(type);
if(result != null) {
return Create(result);
}
return null;
}
/// <summary>
/// This is used to match a <c>Transform</c> for the given
/// type. If a transform cannot be resolved this this will throw an
/// exception to indicate that resolution of a transform failed. A
/// transform is resolved by first searching for a transform within
/// the user specified matcher then searching the stock transforms.
/// </summary>
/// <param name="type">
/// this is the type to resolve a transform object for
/// </param>
/// <returns>
/// this returns a transform used to transform the type
/// </returns>
public Transform Match(Class type) {
Transform value = matcher.Match(type);
if(value != null) {
return value;
}
return MatchType(type);
}
public override bool VisitClassDecl(Class @class)
{
if ([email protected] && base.VisitClassDecl(@class))
{
if (@class.IsInterface)
{
@class.Comment = @class.OriginalClass.Comment;
foreach (var method in @class.OriginalClass.Methods)
{
var interfaceMethod = @class.Methods.FirstOrDefault(m => m.OriginalPtr == method.OriginalPtr);
if (interfaceMethod != null)
{
interfaceMethod.Comment = method.Comment;
}
}
foreach (var property in @class.OriginalClass.Properties)
{
var interfaceProperty = @class.Properties.FirstOrDefault(p => p.Name == property.Name);
if (interfaceProperty != null)
{
interfaceProperty.Comment = property.Comment;
}
}
}
else
{
this.documentation.DocumentType(@class);
}
return true;
}
return false;
}
public void FromManaged()
{
NSObject s = new Class("Subclass1").Call("alloc").Call("init").To<NSObject>();
try
{
Managed.LogException = (e) => {};
s.Call("BadValue");
Assert.Fail("should have been an exception");
}
catch (TargetInvocationException e)
{
Assert.IsTrue(e.Message.Contains("Exception has been thrown by the (managed) target of an Objective-C method call"));
Assert.IsNotNull(e.InnerException);
ArgumentException ae = e.InnerException as ArgumentException;
Assert.IsNotNull(ae);
Assert.IsTrue(ae.Message.Contains("my error"));
Assert.IsTrue(ae.Message.Contains("alpha"));
Assert.AreEqual("alpha", ae.ParamName);
}
finally
{
Managed.LogException = null;
}
}
public override bool VisitClassDecl(Class @class)
{
if (!base.VisitClassDecl(@class))
return false;
// dependent types with virtuals have no own virtual layouts
// so virtuals are considered different objects in template instantiations
// therefore the method itself won't be visited, so let's visit it through the v-table
if (Context.ParserOptions.IsMicrosoftAbi)
{
foreach (var method in from vfTable in @class.Layout.VFTables
from component in vfTable.Layout.Components
where component.Method != null
select component.Method)
VisitMethodDecl(method);
}
else
{
if (@class.Layout.Layout == null)
return false;
foreach (var method in from component in @class.Layout.Layout.Components
where component.Method != null
select component.Method)
VisitMethodDecl(method);
}
return true;
}
internal void updateInfor(Class.MyClient myClient, MyGroupQuestion groupQuestion)
{
lbUsername.Text = myClient.Username;
lvListQuestionAnswer.Items.Clear();
for (int i = 0; i < myClient.ListQuestionAnswereds.Count; i++)
{
ListViewItem item = new ListViewItem();
item.Text = i.ToString();
item.SubItems.Add(groupQuestion.questions[i].Question);
switch (groupQuestion.questions[i].type)
{
case MyQuestionType.MyMissingFieldQuestion:
item.SubItems.Add("Điền khuyết");
break;
case MyQuestionType.MyMultiChoiceQuestion:
item.SubItems.Add("Nhiều đáp án");
break;
case MyQuestionType.MyOneChoiceQuestion:
item.SubItems.Add("Chọn duy nhất");
break;
}
item.SubItems.Add(myClient.ListQuestionAnswereds[i]);
item.SubItems.Add(groupQuestion.questions[i].Answer);
checkClientAnswer(myClient, groupQuestion, i, item);
lvListQuestionAnswer.Items.Add(item);
}
}
public void Execute(Class testClass, Action next)
{
//Behavior chooses not to invoke next().
//Since the test classes are never intantiated,
//their cases don't have the chance to throw exceptions,
//resulting in all 'passing'.
}
public Class Parse(String json, String className)
{
Class result = new Class(AccessModifier.Public, className);
var oo = JsonConvert.DeserializeObject(json);
var c = new ClassInfo(className);
if (oo is JArray)
{
foreach (var jo in (JArray)oo)
{
if (jo is JObject)
{
SetProperties(c, (JObject)jo);
}
else if (jo is JValue)
{
var pi = new PropertyInfo();
pi.Validate(jo);
return new Class(AccessModifier.Public, pi.GetCSharpTypeName());
}
}
}
else if (oo is JObject)
{
SetProperties(c, (JObject)oo);
}
SetProperties(result, c);
return result;
}
public override bool VisitClassDecl(Class @class)
{
if (!base.VisitClassDecl(@class) || @class.IsIncomplete || [email protected])
return false;
@class.Specializations.RemoveAll(
s => s.Fields.Any(f => f.Type.IsPrimitiveType(PrimitiveType.Void)));
if (@class.Specializations.Count == 0)
return false;
var groups = (from specialization in @class.Specializations
group specialization by specialization.Arguments.All(
a => a.Type.Type != null && a.Type.Type.IsAddress()) into @group
select @group).ToList();
foreach (var group in groups.Where(g => g.Key))
foreach (var specialization in group.Skip(1))
@class.Specializations.Remove(specialization);
for (int i = @class.Specializations.Count - 1; i >= 0; i--)
if (@class.Specializations[i] is ClassTemplatePartialSpecialization)
@class.Specializations.RemoveAt(i);
return true;
}
public override bool VisitClassDecl(Class @class)
{
if (!VisitDeclaration(@class))
return false;
if ([email protected])
goto Out;
if (@class.CompleteDeclaration != null)
goto Out;
@class.CompleteDeclaration =
AstContext.FindCompleteClass(@class.QualifiedName);
if (@class.CompleteDeclaration == null)
{
@class.IsGenerated = false;
Driver.Diagnostics.EmitWarning(DiagnosticId.UnresolvedDeclaration,
"Unresolved declaration: {0}", @class.Name);
}
Out:
return base.VisitClassDecl(@class);
}
public IJavaProxy CreateProxy(Type expectedProxyType, Class clazz, IntPtr nativePtr)
{
Debug.Assert(expectedProxyType != null);
Debug.Assert(clazz != null);
if (nativePtr == IntPtr.Zero)
return null;
IJavaProxy result;
if (WrapperHelpers.IsObjectArrayClass(clazz.InternalClassName))
{
result = NonAbstractProxyActivator.Instance.CreateInstance(expectedProxyType);
}
else
{
if (!TryActivateProxy(clazz, expectedProxyType, out result))
{
var expectedClazz = _jniEnvWrapper.Classes.FindClass(expectedProxyType);
if (!TryActivateProxy(expectedClazz, expectedProxyType, out result))
throw new InvalidJavaProxyException(expectedProxyType);
}
}
result.ProxyState = new JavaProxyState(nativePtr, clazz);
return result;
}
public static List<BaseClassSpecifier> ComputeClassPath(Class from, Class to)
{
var path = new List<BaseClassSpecifier>();
ComputeClassPath(from, to, path);
return path;
}
/// <summary>
/// Initializes a new instance of the <see cref="Argument"/> class.
/// </summary>
/// <param name="index">The index.</param>
/// <param name="type">The type.</param>
/// <param name="internalType">Type of the internal.</param>
public Argument (int index, Class type, InternalType internalType)
: base ("Arg", index)
{
this.type = type;
this.internalType = internalType;
this.forceSpill = true;
}
public void CheckNonVirtualInheritedFunctions(Class @class, Class originalClass = null)
{
if (originalClass == null)
originalClass = @class;
foreach (BaseClassSpecifier baseSpecifier in @class.Bases)
{
var @base = baseSpecifier.Class;
if (@base.IsInterface) continue;
var nonVirtualOffset = ComputeNonVirtualBaseClassOffset(originalClass, @base);
if (nonVirtualOffset == 0)
continue;
foreach (var method in @base.Methods.Where(method =>
!method.IsVirtual && (method.Kind == CXXMethodKind.Normal)))
{
Console.WriteLine(method);
var adjustedMethod = new Method(method)
{
SynthKind = FunctionSynthKind.AdjustedMethod,
AdjustedOffset = nonVirtualOffset,
};
originalClass.Methods.Add(adjustedMethod);
}
CheckNonVirtualInheritedFunctions(@base, originalClass);
}
}
public App(string nibName)
{
NSObject app = (NSObject) new Class("NSApplication").Call("sharedApplication");
// Load our nib. This will instantiate all of the native objects and wire them together.
// The C# SimpleLayoutView will be created the first time Objective-C calls one of the
// methods SimpleLayoutView added or overrode.
NSObject dict = new Class("NSMutableDictionary").Call("alloc").Call("init").To<NSObject>();
NSObject key = new Class("NSString").Call("stringWithUTF8String:", Marshal.StringToHGlobalAuto("NSOwner")).To<NSObject>();
dict.Call("setObject:forKey:", app, key);
NSObject bundle = new Class("NSBundle").Call("mainBundle").To<NSObject>();
NSObject nib = new Class("NSString").Call("stringWithUTF8String:", Marshal.StringToHGlobalAuto(nibName)).To<NSObject>();
sbyte loaded = (sbyte) bundle.Call("loadNibFile:externalNameTable:withZone:", nib, dict, null);
if (loaded != 1)
throw new InvalidOperationException("Couldn't load the nib file");
// We need an NSAutoreleasePool to do Native.Call, but we don't want to have one
// hanging around while we're in the main event loop because that may hide bugs.
// So, we'll instantiate a Native instance here and call Invoke later which can
// be done without an NSAutoreleasePool.
m_run = new Native(app, new Selector("run"));
dict.release();
}
public static void Main()
{
Class mathClass = new Class("0013");
Student studentKircho = new Student("Kircho", "0013");
Student studentNasko = new Student("Nasko", "0013");
Teacher teacherPencho = new Teacher("Pencho");
Teacher teacherIvan = new Teacher("Ivan");
mathClass.Teachers.Add(teacherPencho);
mathClass.Teachers.Add(teacherIvan);
mathClass.Students.Add(studentKircho);
mathClass.Students.Add(studentNasko);
mathClass.Comments = "This is a comment for the class";
teacherPencho.Disciplines.Add(new Disciplines("Math", 3, 5));
teacherPencho.Disciplines.Add(new Disciplines("Biology", 2, 3));
teacherPencho.Disciplines.Add(new Disciplines("Literature", 6, 3));
teacherPencho.Comments = "This is a comments for the teacher";
teacherIvan.Disciplines.Add(new Disciplines("Informatics", 5, 10));
teacherIvan.Disciplines.Add(new Disciplines("Robotics", 3, 5));
teacherIvan.Disciplines.Add(new Disciplines("Networking", 7, 5));
}
static void Main()
{
Discipline math = new Discipline("Math", 15, 15);
Discipline biology = new Discipline("Biology", 10, 10);
Discipline history = new Discipline("History", 5, 5);
history.Comment = "Optional comment"; // add comment
Student firstStudent = new Student("Borislav Borislavov", 2);
firstStudent.Comment = "Optional comment"; // add comment
Student secondStudent = new Student("Vasil Vasilev", 4);
Teacher firstTeacher = new Teacher("Ivan Ivanov");
firstTeacher.AddDicipline(math);
Teacher secondTeacher = new Teacher("Peter Petrov");
secondTeacher.AddDicipline(biology);
secondTeacher.AddDicipline(history);
secondTeacher.Comment = "Optional comment"; // add comment
Class firstClass = new Class("12B");
firstClass.Comment = "Optional comment"; // add comment
firstClass.AddStudent(firstStudent);
firstClass.AddStudent(secondStudent);
firstClass.AddTeacher(firstTeacher);
firstClass.AddTeacher(secondTeacher);
Console.WriteLine(firstClass);
}
public Property GetProperty(string className, string propertyName, Frameworks framework, out Class @class)
{
@class = GetClass(className);
if (@class == null)
{
return(null);
}
IEnumerable <Property> propertyFinder = @class.Properties
.Where(x => propertyName.Equals(x.Name, StringComparison.InvariantCultureIgnoreCase));
if (framework == Frameworks.NotSet)
{
propertyFinder = propertyFinder.OrderByDescending(x => x.Frameworks);
}
else
{
propertyFinder = propertyFinder.Where(x => x.Frameworks.HasFlag(framework));
}
return(propertyFinder.FirstOrDefault());
}
public void CreateNewClass(Class c)
{
m_classRepository.Insert(c);
// save changes
m_classRepository.SaveChanges();
}
public Method GetMethod(string className, string methodName, Frameworks framework, out Class @class, int overload)
{
@class = GetClass(className);
if (@class == null)
{
return(null);
}
if (overload < 0)
{
return(null);
}
IEnumerable <Method> methodFinder = @class.Methods
.Where(x => methodName.Equals(x.Name, StringComparison.InvariantCultureIgnoreCase));
if (framework == Frameworks.NotSet)
{
methodFinder = methodFinder.OrderByDescending(x => x.Frameworks);
}
else
{
methodFinder = methodFinder.Where(x => x.Frameworks.HasFlag(framework));
}
if (overload > 0)
{
methodFinder = methodFinder.Skip(overload);
}
return(methodFinder.FirstOrDefault());
}
public void UpdateClass(Class newClass)
{
this.UpdateClass(newClass);
}
public void DeleteClass(Class c)
{
m_classRepository.Delete(c);
// save changes
m_classRepository.SaveChanges();
}
public async System.Threading.Tasks.Task CreateNewClassAsync(Class c)
{
await Task.Run(() => CreateNewClass(c));
}
public async Task UpdateClassAsync(Class newClass)
{
await Task.Run(() => UpdateClass(newClass));
}
public override void FunctionalTest()
{
Class.Method(5).Should().Be(10);
}
public async System.Threading.Tasks.Task DeleteClassAsync(Class c)
{
await Task.Run(() => DeleteClass(c));
}
public byte GetMaxLevelByClass(Class castableClass)
{
var maxLevelProperty = MaxLevel.GetType().GetProperty(castableClass.ToString());
return((byte)(maxLevelProperty != null ? maxLevelProperty.GetValue(MaxLevel, null) : 0));
}
public RemoveModifiersFromClassAction(Class classToChange)
{
ClassToChange = classToChange;
}
