/// <summary>
/// Helper function for Brfalse/Brtrue: compare stack value with zero using zeroPredicate,
/// and accordingly jump to either target or next block.
/// </summary>
private void EmitBrCommon(StackValue stack, IntPredicate zeroPredicate, BasicBlockRef targetBasicBlock, BasicBlockRef nextBasicBlock)
{
// Compare stack value with zero, and accordingly jump to either target or next block
ValueRef cmpInst;
switch (stack.StackType)
{
case StackValueType.NativeInt:
{
var zero = LLVM.ConstPointerNull(LLVM.TypeOf(stack.Value));
cmpInst = LLVM.BuildICmp(builder, zeroPredicate, stack.Value, zero, string.Empty);
break;
}
case StackValueType.Int32:
{
var zero = LLVM.ConstInt(int32Type, 0, false);
cmpInst = LLVM.BuildICmp(builder, zeroPredicate, stack.Value, zero, string.Empty);
break;
}
case StackValueType.Object:
{
var zero = LLVM.ConstPointerNull(LLVM.TypeOf(stack.Value));
cmpInst = LLVM.BuildICmp(builder, zeroPredicate, stack.Value, zero, string.Empty);
break;
}
default:
throw new NotImplementedException();
}
LLVM.BuildCondBr(builder, cmpInst, targetBasicBlock, nextBasicBlock);
}
public IntList Filter(IntPredicate p)
{
IntList res = new IntList();
foreach (int i in this)
if (p(i))
res.Add(i);
return res;
}
private static System.Predicate <SchemaDescriptor> FilterByEntityAndPropertyComplete(int[] entityTokenIds, int[] propertyKeyIds)
{
return(descriptor =>
{
IntPredicate propertyKeyPredicate = indexPropertyId => contains(propertyKeyIds, indexPropertyId);
bool propertiesAccepted = descriptor.propertySchemaType() == COMPLETE_ALL_TOKENS?stream(descriptor.PropertyIds).allMatch(propertyKeyPredicate) : stream(descriptor.PropertyIds).anyMatch(propertyKeyPredicate);
return stream(descriptor.EntityTokenIds).anyMatch(indexEntityId => contains(entityTokenIds, indexEntityId)) && propertiesAccepted;
});
}
static int[] FilterIntArray(int[] array, IntPredicate test)
{
var result = new List <int>();
foreach (int value in array)
{
if (test(value))
{
result.Add(value);
}
}
return(result.ToArray());
}
//Further, use anonymous methods to write an expression that prints only those list elements that are
//greater than or equal to 25.
public IntList GreaterThan(IntPredicate p)
{
IntList result = new IntList();
foreach (int i in this)
{
if (i >= 25)
{
result.Add(i);
}
}
return(result);
}
public MyList <T> Filter(IntPredicate <T> p)
{
MyList <T> res = new MyList <T>();
foreach (var i in this)
{
if (p(i))
{
res.Add(i);
}
}
return(res);
}
public IntList Filter(IntPredicate p)
{
IntList res = new IntList();
foreach (int i in this)
{
if (p(i))
{
res.Add(i);
}
}
return(res);
}
public IntList Filter(IntPredicate p)
{
var res = new IntList();
ForEach(i =>
{
if (p(i))
{
res.Add(i);
}
});
return(res);
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: private void mockAssignNewTokenIdsInBatch(java.util.concurrent.atomic.AtomicInteger nextId) throws org.neo4j.internal.kernel.api.exceptions.KernelException
private void MockAssignNewTokenIdsInBatch(AtomicInteger nextId)
{
doAnswer(inv =>
{
int[] ids = inv.getArgument(1);
IntPredicate filter = inv.getArgument(2);
for (int i = 0; i < ids.Length; i++)
{
if (filter.test(i))
{
ids[i] = nextId.AndIncrement;
}
}
return(null);
}).when(_creator).createTokens(any(typeof(string[])), any(typeof(int[])), any(typeof(IntPredicate)));
}
/// <summary>
/// Helper function for Brfalse/Brtrue: compare stack value with zero using zeroPredicate,
/// and accordingly jump to either target or next block.
/// </summary>
private void EmitBrCommon(StackValue stack, IntPredicate zeroPredicate, BasicBlockRef targetBasicBlock, BasicBlockRef nextBasicBlock)
{
// Zero constant
var zero = LLVM.ConstInt(int32Type, 0, false);
switch (stack.StackType)
{
case StackValueType.Int32:
// Compare stack value with zero, and accordingly jump to either target or next block
var cmpInst = LLVM.BuildICmp(builder, zeroPredicate, stack.Value, zero, string.Empty);
LLVM.BuildCondBr(builder, cmpInst, targetBasicBlock, nextBasicBlock);
break;
default:
throw new NotImplementedException();
}
}
/// <summary>
/// Emits a branch on condition instruction.
/// </summary>
/// <param name="instruction">The instruction.</param>
/// <param name="context">The context.</param>
/// <param name="builder">The builder.</param>
public void Emit(Instruction instruction, MethodContext context, BuilderRef builder)
{
StackElement element = context.CurrentStack.Pop();
// Note: a zero corresponds to false, but every other value corresponds to true.
Code code = instruction.OpCode.Code;
IntPredicate predicate = ((code == Code.Brtrue || code == Code.Brtrue_S) ? IntPredicate.IntNE : IntPredicate.IntEQ);
ValueRef ret;
if (TypeHelper.IsPointer(element))
{
ValueRef tmp = LLVM.BuildPtrToInt(builder, element.Value, TypeHelper.NativeIntType, "ptr2int");
ret = LLVM.BuildICmp(builder, predicate, tmp, LLVM.ConstInt(TypeHelper.NativeIntType, 0, false), "brcond");
}
else
{
ret = LLVM.BuildICmp(builder, predicate, element.Value, LLVM.ConstInt(element.Type, 0, false), "brcond");
}
Instruction onFalse = instruction.Next;
Instruction onTrue = (Instruction)instruction.Operand;
LLVM.BuildCondBr(builder, ret, context.GetBlockOf(onTrue), context.GetBlockOf(onFalse));
}
public unsafe static ValueRef BuildICmp(BuilderRef arg0, IntPredicate Op, ValueRef LHS, ValueRef RHS, string Name) {
ValueRef ret = new ValueRef(LLVMPINVOKE.BuildICmp(arg0.Value, (int)Op, LHS.Value, RHS.Value, Name));
return ret;
}
public unsafe static ValueRef ConstICmp(IntPredicate Predicate, ValueRef LHSConstant, ValueRef RHSConstant) {
ValueRef ret = new ValueRef(LLVMPINVOKE.ConstICmp((int)Predicate, LHSConstant.Value, RHSConstant.Value));
return ret;
}
delegate bool IntPredicate(int number);// дадох име на всички методи, които приемат int и връщат bool)
static void Main(string[] args)
{
Action action = () => Console.WriteLine("Hello!");
//DoSomethingWithThisString action = () => Console.WriteLine("Hello!"); Така можем да използваме този екшън (с името на делегата, който сме декларирали горе)
Func <int, bool> funcPredicate = x => x % 2 == 0;
IntPredicate intPredicateVariable = x => true;//горе декларирам (делегатите са към класа (декларираме ги в класа Program например, но може и извън него в namespace -а и така ще са видими и за другите класове), не може да ги сложим в метод, дори и в Main -а !!!) и тук вече мога да го изполозвам (Какво постигнах - дадох име на всички методи, които приемат int и връщат bool, като например на funcPredicate името на типа да не е общото Func а IntPredicate)
//По принцип не създаваме делегати (ползваме готови) освен в случаите когато ползваме events (събития)!!!
//във функционалното програмиране (ФП) винаги една функция дава еднакъв резултат, няма стейт (състояние), като в ООП. Променливите са константи!
//ФП е много силно когато едновременно се случват много процеси!
//haskel е много добър език за учене на ФП
//lisp и scala се много известни, ако ни е интересно ФП Виктор би ни насочил към scala!
// F# e майкросовтския, а JS много хора го пишат по функционално и много хора с JS им се отдава функционалното програмиране. JS е много мощен за много неща!!!
// pattern matching в C# e функционална парадигма, която набира скорост напоследък (има базово много хубави неща).
// лампда експрешънса е съкратен запис на метод (анонимна функция) - използват се за писане набързо и когато няма да се ползват повече - много полезни за сортиране и филтриране!!!
// анонимните функции приемат параметър и връщат резултат.
//Lampda:
//int[] numbers = new int[] { 1, 2, 3, 4, 5 };
//numbers = numbers.Where(numbers => numbers % 2 == 0).ToArray();
// а where може и така:
//numbers = numbers.Where(CheckEven).ToArray();
//LinqUsefulMethods - да си видя демото !!!
//Важното за Linq: така можем да пишем и по сериозно твло в Linq
//int[] numbers = new int[] { 1, 2, 3, 4, 5 };
//numbers = numbers.Where(x =>
//{ Console.WriteLine($"X : {x} -> {x % 2 == 0}");
//return x % 2 == 0;
//}).ToArray();
////Важното за Linq:така можем (със скобите) да подадем повече от един параметър
////int[] numbers = new int[] { 1, 2, 3, 4, 5 };
////numbers = numbers.Where((x, index) =>
////{
//// Console.WriteLine($"X : {x} -> {x % 2 == 0}");
//// return x % 2 == 0;
////}).ToArray();
//Console.WriteLine(string.Join(" ", numbers));
//същото като лампдата, но с име и може да се вика:
//static bool CheckEven(int number)
//{
// return number % 2 == 0;
//}
//Делегати Delegates:
//Делегата е тип данни който описва метод (може да се нарече шаблон за метод)!
//Това е референция към функция/поинтер към функция/променлива която държи/сочи към функция. Тази променлива/тип може да бъде извиквана като функция или да я подаваме наляво, надясно както подаваме променлива - това е ключовото нещо за делегата!!!
//Делегата описва каква е сигнатурата на самия метод (какви параметри приема, какви данни връща)
//Func<T,V>, T е параметъра който приема, V е параметъра който връща (може да са различни типове, а при повече параметри return type-a e винаги последния). Това Func е клас, който е така направен че да може да приема методи, които може да използваме.
//Пример: Func<int, string> func = n => n.ToString(); , това с var не работи!
// информацията която ни трябва за да направим от дадена функция(метод) делегат е какви типове приема и връща
//първите два инта са параметрите които приема, а последния в скобите е този който връща.
//Делегатите се декларират извън методи с ключовата думичка delegate и описват метода (една декларация на метод без тяло) като какво приема, какво връща и какво му е името!
//Пример:
//public delegate int Multiplier (int x, int y)
//Multiplier calc = (x, y) => x * y;
//, това е същото като Func<int, int, int> но типа си има име (Multiplier) a не е общото Func.
//Func<int, int, int> sumDelegate = SumNumbers;
//sumDelegate(5, 5);
//Console.WriteLine(sumDelegate(5,5));
//SumNumbers(5,5); e абсолютно същото!
//sumDelegate = MultiplyNumbers;
//може заради същата сигнатура (два инта са параметрите които приема, а един връща)
//Console.WriteLine(sumDelegate(5, 5));
//така един и същи код връща различни резултати!
//Action -> returns void !; Func -> returns something!
//т.e. всички методи(функции), които връщат void (т.е. не връщат стойност) са Action !!! Демо в проект Actions!
//цялата концепция е че вече нашите променливи могат да сочат към методи (функции) и да ги използваме като ги подаваме насам, натам, да ги извикваме когато поискаме.
//Реално правим тип данни за метод и можем в другите методи да казваме тук искам метод от даден тип.
//Това Е МНОГО МОЩНО, постепенно ще осъзнаем това и какви мощни абстракции ще можем да правим с това, но след няколко месеца ще го оценим наистина.
//Predicate всъшност е анонимна функция. Може да се каже че е частен случай на Func защото приема нещо (променлива) и връща bool
//Работи с Overload
//Когато имаме по-сложна анонимна функция, можем да си я сложим на делегат и удобно да си я подаваме насам, натам.
//Пример: Func<string, bool> upperChecker = s => s[0] == s.ToUpper()[0];
//var input = Console.ReadLine().Split(" ", StringSplitOptions.RemoveEmptyEntries)
// .Where(upperChecker)
// .ToArray();
//FP ни го препоръчва за по натам да задълбаем, сега важното е ООП - то да разберем добре - доста по-използвано е!
//Като завършим SoftUni - Learn You a Haskell - това е момента и перфектната книга за ФП!!!
//Има функционален форич - ForEach,
//Пример: Array.ForEach(new int[]{1, 2, 3, 4 }, p=>Console.ReadLine(p.Name));
//Func ползваме когато искаме да напишем по абстрактен код. И без това можем да програмираме, това си иска време за да го разбервм!
//Препоръча ни LINQ който е време да започнем да използваме!!!:
// * First/ FirstOrDefault - връща първия елемент от зададено условие и ако не го намери гърми/връща дефолтната стойност на типа.
// * Last/ LastOrDefault - - връща последния елемент от зададено условие и ако не го намери гърми/връща дефолтната стойност на типа.
// * Single/ SingleOrDefault - - връща един елемент от зададено условие и ако има (намери) повече от един гърми/връща дефолтната стойност на типа.
// * Skip (и производните) - казваме му колко елемента да прескача!
// * Find, Where, Select, Any, All, Average, Max, Min, Sum, OrderBy/Desending да си ги разгледам внимателно.
// //В JS Select e Map!
// Func<int, int, int> sumDelegate = SumNumbers;//Този тип данни Func ни дава възможността при добре написан код много лесно да променим функционалността(работата) на програмата (например сменям SumNumbers с MultiplyNumbers).
// sumDelegate(5, 5);
// Func<int, int, int> multiplyDelegate = SumNumbers;
// Calculate(5, 5, sumDelegate);
// Calculate(5, 5, multiplyDelegate);
// Calculate(5, 5, (a, b) => a / b);
// Calculate(5, 5, (a, b) => a *100 * b *100);
//}
//static int SumNumbers(int a, int b)
//{
// Console.WriteLine("Summing numbers is the best feeling");
// return a + b;
//}
//static int MultiplyNumbers(int a, int b)
//{
// Console.WriteLine("Multiply numbers is the worse feeling");
// return a * b;
//}
////ключово тук е че кода дето пише не се занимава със самите операции!
//static void Calculate(int a, int b,Func<int, int, int> operation)
//{
// //с ,true му казваме да апендва
// using (StreamWriter writer = new StreamWriter("../../../result.txt)",true))
// {
// writer.WriteLine("Start calculating");
// writer.WriteLine(operation(a, b));
// }
//}
//Друг добър пример:
//Func<int, long> operation = Square;//Този тип данни Func ни дава възможността при добре написан код много лесно да променим функционалността(работата) на програмата (например сменям Factorial със Square).
//Console.WriteLine(operation(5));
//PrintResult(5, Square);
//PrintResult(5, Factorial);
//Action<int> action = PrintToConsoleWithLines;//и тук мога следващия момент да кажа PrintToConsole и от едно място да променя функционалността на кода надолу!
// оператора += работи и върху Action и Func (не само с числа), можем да добавим метод със същата сигнатура! Например:
//action += PrintToConsole;
//action += PrintToConsole;
//action += PrintToConsole;
//action(3);//Taka можем да извикаме тези две функции една след дуга (PrintToConsoleWithLines и PrintToConsole (през action)). Така можем да си направим списък от методи които да бъдат извикани колкото пъти поискаме.
/* action -= PrintToConsole;*/// а така мога да премахна функция когато поискам, с -=.
//Това += и -= не се ползва в стандартните програми, но евенти, които ще ползваме по-нататък се ползва (нарича се закачане и откачане на събитие и е част от парадигмата event hendling, която имаме в C#)
//action(100);
//action.GetInvocationList().Length();//така можем да вземем броя на закачените елементи.
}
public static extern IntPtr BuildICmp(IntPtr bldRef, IntPredicate op, IntPtr LHS, IntPtr RHS, string name);
public static extern IntPtr BuildICmp(IntPtr bldRef, IntPredicate op, IntPtr LHS, IntPtr RHS, string name);
public IEnumerable <Vehicle> GetVehiclesByWheels(int wheels, IntPredicate pred)
{
return(Garage.Where(c => pred(c.Wheels, wheels)));
}
public static LLVMIntPredicate Unwrap(this IntPredicate wrapper) => (LLVMIntPredicate)(int)wrapper;
/// <summary>
/// Helper function for Brfalse/Brtrue: compare stack value with zero using zeroPredicate,
/// and accordingly jump to either target or next block.
/// </summary>
private void EmitBrCommon(StackValue stack, IntPredicate zeroPredicate, BasicBlockRef targetBasicBlock, BasicBlockRef nextBasicBlock)
{
// Compare stack value with zero, and accordingly jump to either target or next block
ValueRef cmpInst;
switch (stack.StackType)
{
case StackValueType.NativeInt:
{
var zero = LLVM.ConstPointerNull(LLVM.TypeOf(stack.Value));
cmpInst = LLVM.BuildICmp(builder, zeroPredicate, stack.Value, zero, string.Empty);
break;
}
case StackValueType.Int32:
{
var zero = LLVM.ConstInt(int32LLVM, 0, false);
cmpInst = LLVM.BuildICmp(builder, zeroPredicate, stack.Value, zero, string.Empty);
break;
}
case StackValueType.Object:
{
var zero = LLVM.ConstPointerNull(LLVM.TypeOf(stack.Value));
cmpInst = LLVM.BuildICmp(builder, zeroPredicate, stack.Value, zero, string.Empty);
break;
}
default:
throw new NotImplementedException();
}
LLVM.BuildCondBr(builder, cmpInst, targetBasicBlock, nextBasicBlock);
}