Beginner Dart programmer sketching class, that allows objects to
participate in #commonOperation, and connect to other objects there.
Project in early stage, a bunch of inspirational ideas, not meant
to be developed to production app. Learning process.
Structure and documents of Connector class:
/// * Usability: 7%
/// * Hist: hkl 10.9.2017 0.0.1 dawo/lib connector.dart
#name: connector ..is not nice. change to: ______ ??
Connector is in deeply planning state. pp -mission - chore work
together in same sphere, and there must be something, that they
have in common; abstraction layer, in which they must work together.
* Every #little operation is "connector-operation", and connector has
knowledge for all of them and can interact with them.
* Sending messages between objects. Stance, approach
* "Connector-operations" have access to certain up-level variables.
* Using GlobalOpClass might be too heavy.!!
* ADD IS-GLOBAL bool field to Operation-classes.
* Connector classes might have precedence in Mill-op.
Might trig some action in their connected sister-operations.
Find common interests, "I have been here".. follow-me, give-take
Other objects also handle things connected to this. So connector might
be just a simple message (plea) mediator.
Global op does something
NOTE:
devNote: tracking begins.
// ***********************************************************************
/* connector: very weak idea, how to accomplish this. 10 %
Not much of this functionality is yet done.
Name: #connector is not the right one. Not nice.
#clients: = app - mission's - chore's
* Get "service calls" from #members: app - mission - chore; and
solve them.
* Have rules of privilege for precedence of missions - chores.
* Give TO > mill commands, "work-orders".
* Should have access to class-buffers to seek data.
* Special language #dawolang, to force commands to certain shape.
* #baton : to carry only-one-can-have-at-a-same-time magic thing.
*
* COMMAND ROLL:
* 1. get command, handle parameters.
* 2. Check command against rules. Take - return - reject.
* 3. Full-fill command; void obey(sender, receiver, baton, msg, flags)
* 4. Get answer, serve back.
* 5. Mark done.
*
* Questions:
* 1. Where do connector work? Is it upper-level loop?
* .. or is it available all the time. No need to wake it.
* 2. Where, how, and why is #connector invoked?
* 3. ?
*
* IDEA: All (commands) might happen in #mill. ( an order processor system ).
* IDEA: #Callback-like service calls.
* IDEA: #serviceKey #baton, that only one client can have at a time.
* IDEA: Privilege key.
*
* MAYBE: Incoming commands have certain form. Classes? Strings?
* MAYBE: Access to #GOAL aso. variables.
* MAYBE:
* MAYBE:
*
* NOT: Handle #area #resource #time #money aso. properties.
* NOT:
* NOT:
Properties and methods
/// This class gets same structure base, as other important classes.
/// Connecting clients (app-mission-chore) to work together.
class Connector extends BaseStruct {
String name = 'connector class';
String info = 'connecting app - mission - chore together, mediating them';
String motto = 'do my job, connector, mediates';
/// devNote: PLAN: Two fields for to better shape outPut stuff in console.
String seal; // like: ":CONNECTOR:";
/// emblem can be used in flowC
String emblem = ':con:X:'; // or this emblem.
String indent; // like: " "; 3-5-7 empty marks or something visible.
// Like: ":ALLOW X :LOW Y :ROLE Z :GOAL XX :OPEN YY
String clause; // Combination of #LANG words in sentence.
String master; // Object that owns this.
// Buffer inside class for output.
StringBuffer buf = new StringBuffer();
/// Controlling connectors state, working-condition-state values.
bool offB = true;
bool onB = false;
bool pauseB;
bool doneB = false;
/// *****************************************************************
/// GlobalOperation ?* Using GlobalOpClass might be too heavy.!!
/// var msgBus * Sending messages between objects. Stance, approach
/// #New: #Gear Something turns around this.
/// the sail pivots around the axis of a virtually static mast
var pivot;
/// or: void metro() {} for putting messages to move.
/// PING, Putting messages in queue or sending them immediately.
void ping(var sender, var receiver, var key) {
/// code
}
/// Members, that are participating in this connector.
/// Member is a class in base_struct.
Map<String, Member> memberM = {};
/// get / collect bindings
/// Processes, that are bind inside connector.
Map<String, Map<dynamic, dynamic>> bindingM = {};
// Connect Members action to one or many other Members action.
String bind(var senderProcess, var receiverProcess, var thing) {
// Idea: Have some binding-models and types.
// add / find from bindingM Map
return 'binding: #one to: #second';
/// Connector base activity, keep list of Members / their operations.
/// devNote: Or should it be something smaller? abstract class BasePlacard?
List<GlobalOpClass> opL = new List();
/// Join "clients" / Members to opList. placardM mediates necessary info.
void opJoin(Map<String, String> plcM, String caller) {
/// Operations register to Connector with placardM.
// 'actor': 'Chore',
// 'sender': 'Chore instance',
// 'receiver': '',
// 'command': 'Ch-cmd:',
// 'msg': 'Ch-msg:',
// *******************************
/// code:
print('-->>-->>-- :connector: C:$caller -->>-->>--');
print(info);
tl.operationMapPrint(plcM);
print('--<<--<<-- :connector: done C:$caller --<<--<<--');
}
/// Here goes normal init-build-roll-show-done -round. No loop.
/// Method for setting class field values to their run-time-values.
/// Called by: roll.
void init() {
buf.writeln('--- Connector buffer output initialized ---');
// Set fields values.
buf.writeln('init done');
}
/// Method for setting class in working condition.
/// CalledBy: roll.
void build(String _emblem, String _master) {
offB = false; // off-state ends
onB = true; // Connector is in on-state.
buf.writeln('build done');
}
/// #run / roll method
void roll() {
buf.writeln('Connector:: $info :: roll engaged ');
init(); // calling init and build methods in this class.
// TODO connector Build parameters.
build('*CONNECTOR:', 'CONNENCTORS-MASTER:');
// code for roll
// *** code missing, see on top of this file
//
show();
done();
// code here
}
/// Method for #Members to take part in common operations.
void rollCommon() {
}
/// Gives members privileges in common operations..
void sharer() {
}
/// Presentation method.
void show() {
print(buf);
}
/// close method
void done() {
print('Connector:: $info :: engaged ');
// code here
buf.write('--- Connector buffer output app: done ---');
print(buf);
buf.clear(); // empty buffer
}
And now section, that handles last small details:
/// TODO Name for next 3 fields might be opTouche aso.
/// Solve one unambiguous textual find-decide problem.
/// NOTE: might be separate Touche class.
String touch(String sender, String key, String source) {
// TODO problem
return 'solved:toucheStr: ';
}
/// Search big amount of #clay data for #customer:s key / order.
/// .. solve textual problems based on keywords / search in textual data
/// NOTE: might be separate Solver class.
String solve(String sender, String key, String source) {
// TODO problem
return 'solved: solveString';
}
/// TODO: connector one-time calls must have parameters;
/// Sketching one-time commands, coming from clients.
void obey(String sender, receiver, baton, msg) {
/// #baton to carry only-one-can-have-at-a-same-time magic thing
// TODO code, badly missing
// handle command / message
}
// *****************************************************************
/// Calling print/print-to-buffer function from base_lib.
/// Getting local variables; Actor and Buffer right.
void flowC(String msg, bool p) {
/// Call flowServe with #LOCAL variables.
flowServe(':con:', buf, msg, p);
}
/// constructor
Connector(this.name, this.info);
}
/// Create instance of Connector.
var con = new Connector('DawoAppconnector', 'Connection operations');
Chore calls this: con.opJoin(placardM, ':Chr:');
/// Testing placardM inside chore./// Present info for outer process calls.
Map<String, String> placardM = {
'actor': 'Chore',
'sender': 'Chore instance',
'receiver': '',
'command': 'Ch-cmd:',
'msg': 'Ch-msg:',
};
