JCore
Some classes and frameworks I have implemented so far.
- OPF
- Dependency Injection Container
- Expression Parser
OPF
Features being implemented:
- Entities inherits from TObject and declares native data types
- Support of any data type, registering new data mediators for unsupported PTypeInfos
- Auto and manual mapping (object <-> storage mechanism)
- Auto and manual model (class infos; metadata)
- Native drivers -- mapping straight to database: no mediators or conversions
- Bulk retrieve -- instantiate lots of objects with one query
- Lazy loading -- load objects or attributes only on demand
- TDD -- test driven development
- Lazarus wizards for manual mappings, manual model and persistence configuration
- API docs
There are some docs here.
Some missing pieces before stabilize 0.4:
- Support of native data types
- Manual transactions
- Criteria improvement
Dependency Injection Container
Classes which help you separate specifications from implementations, as well as give you the hability to override default implementation from a framework with your own classes.
- Declare your specification using interfaces
- Register at least one implementation
- Inject an implementation
- Support of qualifiers
Samples:
TJCoreDIC.Register(IYourIntf, TYourImpl, jdsApplication);
...
TJCoreDIC.Locate(IYourIntf, VAnIntfVar);
Using qualifier:
TJCoreDIC.Register(IPayment, ‘cash’, TCashPayment, jdsApplication);
TJCoreDIC.Register(IPayment, ‘plastic’, TPlasticPayment, jdsApplication);
TJCoreDIC.Register(IPayment, ‘paypal’, TPaypalPayment, jdsApplication);
...
TJCoreDIC.Locate(IPayment, ‘paypal’, VPayment);
Expression Parser
An expression parser with an extensible function and operation library as well as support to variables.
The library is as fast as it can be: when the formula is changed, it is parsed in order to create an array with all operations, in the correct order. All results are referenced and reused without moves and copies. Point to pointers.
A simple calc:
VExpression := TJCoreExpression.Create('2+2');
try
writeln(VExpression.VarValue);
finally
FreeAndNil(VExpression);
end;
Using vars:
VExpression := TJCoreExpression.Create;
try
VExpression.Vars.Variable['x'] := 2;
VExpression.ParseExpression('2+x');
writeln(VExpression.VarValue);
VExpression.Vars.Variable['x'] := 4;
writeln(VExpression.VarValue);
finally
FreeAndNil(VExpression);
end;
User defined function:
TSinFunction = class(TJCoreExpressionFunction)
public
function MaxParams: Integer; override;
function MinParams: Integer; override;
class function Name: string; override;
procedure VarCalc; override;
end;
function TSinFunction.MaxParams: Integer;
begin
Result := 1;
end;
function TSinFunction.MinParams: Integer;
begin
Result := 1;
end;
class function TSinFunction.Name: string;
begin
Result := 'sin';
end;
procedure TSinFunction.VarCalc;
begin
Res^ := Sin(Params[0]^);
end;
begin
JCoreExpressionLibrary.RegisterFunctions([TSinFunction]);
VExpression := TJCoreExpression.Create('sin(30)');
try
writeln(VExpression.VarValue);
finally
FreeAndNil(VExpression);
end;
end;
User defined operation:
TModOperation = class(TJCoreExpressionOperation)
protected
class function InternalOperatorToken: string; override;
public
function Priority: Byte; override;
procedure VarCalc; override;
end;
class function TModOperation.InternalOperatorToken: string;
begin
Result := 'mod';
end;
function TModOperation.Priority: Byte;
begin
Result := 15;
end;
procedure TModOperation.VarCalc;
begin
Res^ := Val1^ mod Val2^;
end;
begin
JCoreExpressionLibrary.RegisterOperations([TModOperation]);
VExpression := TJCoreExpression.Create('3 mod 1');
try
writeln(VExpression.VarValue);
finally
FreeAndNil(VExpression);
end;
end;