aboutsummaryrefslogtreecommitdiffhomepage
path: root/src/sdp/ao/conf_make_meta_native.d
diff options
context:
space:
mode:
Diffstat (limited to 'src/sdp/ao/conf_make_meta_native.d')
-rw-r--r--src/sdp/ao/conf_make_meta_native.d330
1 files changed, 330 insertions, 0 deletions
diff --git a/src/sdp/ao/conf_make_meta_native.d b/src/sdp/ao/conf_make_meta_native.d
new file mode 100644
index 0000000..8954c9a
--- /dev/null
+++ b/src/sdp/ao/conf_make_meta_native.d
@@ -0,0 +1,330 @@
+/++
+ native headers using<br>@title:<BR>:subtitle:<BR>type tags<BR>
+ extract native/orig header return associative array
++/
+module sdp.ao.conf_make_meta_native;
+template SiSUheaderExtractNative() {
+ import
+ std.exception,
+ std.regex,
+ std.stdio,
+ std.string,
+ std.traits,
+ std.typecons,
+ std.utf,
+ std.conv : to;
+ import
+ sdp.ao.defaults,
+ sdp.ao.rgx;
+ struct HeaderDocMetadataAndMakeNativeToAA {
+ mixin SiSUregisters;
+ mixin SiSUrgxInitFlags;
+ mixin SiSUrgxInit;
+ auto rgx = Rgx();
+ enum State { off, on }
+ string hm, hs;
+ auto header_metadata_and_make_aa(H,Me,Ma)(
+ H header,
+ Me dochead_meta,
+ Ma dochead_make
+ )
+ in {
+ debug(asserts){
+ static assert(is(typeof(header) == string));
+ static assert(is(typeof(dochead_meta) == string[string][string]));
+ static assert(is(typeof(dochead_make) == string[string][string]));
+ }
+ }
+ body {
+ scope(exit) {
+ destroy(header);
+ destroy(dochead_meta);
+ destroy(dochead_make);
+ }
+ if (auto t = header.match(rgx.native_header_main)) {
+ char[][] header_obj_spl =
+ (cast(char[]) header).split(rgx.line_delimiter_ws_strip);
+ auto hm = to!string(t.captures[1]);
+ if (hm.match(rgx.main_headers)) {
+ foreach (line; header_obj_spl) {
+ if (auto m = line.match(rgx.native_header_main)) {
+ if (!empty(m.captures[2])) {
+ if (hm == "creator") {
+ dochead_meta[hm]["author"] =
+ to!string(m.captures[2]);
+ } else if (hm == "title") {
+ dochead_meta[hm]["main"] =
+ to!string(m.captures[2]);
+ } else if (hm == "publisher") {
+ dochead_meta[hm]["name"] =
+ to!string(m.captures[2]);
+ }
+ }
+ } else if (auto s = match(line, rgx.native_header_sub)) {
+ if (!empty(s.captures[2])) {
+ auto hs = to!string(s.captures[1]);
+ if ((hm == "make" )
+ && (dochead_make[hm])) {
+ switch (hm) {
+ case "make":
+ if (hs.match(rgx.native_subhead_make)) {
+ if (dochead_make[hm][hs]) {
+ dochead_make[hm][hs] = to!string(s.captures[2]);
+ }
+ } else {
+ writeln("not a valid header type:", hm, ":", hs);
+ destroy(hm);
+ destroy(hs);
+ }
+ break;
+ default:
+ break;
+ }
+ } else if (dochead_meta[hm]) {
+ switch (hm) {
+ case "creator":
+ if (hs.match(rgx.native_subhead_creator)) {
+ if (dochead_meta[hm][hs]) {
+ dochead_meta[hm][hs] =
+ to!string(s.captures[2]);
+ }
+ } else {
+ writeln("not a valid header type:", hm, ":", hs);
+ destroy(hm);
+ destroy(hs);
+ }
+ break;
+ case "title":
+ if (hs.match(rgx.native_subhead_title)) {
+ if ((hs == "subtitle")
+ && (dochead_meta[hm]["sub"])) {
+ dochead_meta[hm]["sub"] =
+ to!string(s.captures[2]);
+ } else if (dochead_meta[hm][hs]) {
+ dochead_meta[hm][hs] =
+ to!string(s.captures[2]);
+ }
+ } else {
+ writeln("not a valid header type:", hm, ":", hs);
+ destroy(hm);
+ destroy(hs);
+ }
+ break;
+ case "rights":
+ if (hs.match(rgx.native_subhead_rights)) {
+ if (dochead_meta[hm][hs]) {
+ dochead_meta[hm][hs] =
+ to!string(s.captures[2]);
+ }
+ } else {
+ writeln("not a valid header type:", hm, ":", hs);
+ destroy(hm);
+ destroy(hs);
+ }
+ break;
+ case "date":
+ if (hs.match(rgx.native_subhead_date)) {
+ if (dochead_meta[hm][hs]) {
+ dochead_meta[hm][hs] =
+ to!string(s.captures[2]);
+ }
+ } else {
+ writeln("not a valid header type:", hm, ":", hs);
+ destroy(hm);
+ destroy(hs);
+ }
+ break;
+ case "original":
+ if (hs.match(rgx.native_subhead_original)) {
+ if (dochead_meta[hm][hs]) {
+ dochead_meta[hm][hs] =
+ to!string(s.captures[2]);
+ }
+ } else {
+ writeln("not a valid header type:", hm, ":", hs);
+ destroy(hm);
+ destroy(hs);
+ }
+ break;
+ case "classify":
+ if (hs.match(rgx.native_subhead_classify)) {
+ if (dochead_meta[hm][hs]) {
+ dochead_meta[hm][hs] =
+ to!string(s.captures[2]);
+ }
+ } else {
+ writeln("not a valid header type:", hm, ":", hs);
+ destroy(hm);
+ destroy(hs);
+ }
+ break;
+ case "identifier":
+ if (hs.match(rgx.native_subhead_identifier)) {
+ if (dochead_meta[hm][hs]) {
+ dochead_meta[hm][hs] =
+ to!string(s.captures[2]);
+ }
+ } else {
+ writeln("not a valid header type:", hm, ":", hs);
+ destroy(hm);
+ destroy(hs);
+ }
+ break;
+ case "notes":
+ if (hs.match(rgx.native_subhead_notes)) {
+ if (dochead_meta[hm][hs]) {
+ dochead_meta[hm][hs] =
+ to!string(s.captures[2]);
+ }
+ } else {
+ writeln("not a valid header type:", hm, ":", hs);
+ destroy(hm);
+ destroy(hs);
+ }
+ break;
+ case "publisher":
+ if (hs.match(rgx.native_subhead_publisher)) {
+ if (dochead_meta[hm][hs]) {
+ dochead_meta[hm][hs] =
+ to!string(s.captures[2]);
+ }
+ } else {
+ writeln("not a valid header type:", hm, ":", hs);
+ destroy(hm);
+ destroy(hs);
+ }
+ break;
+ case "links":
+ destroy(hm);
+ destroy(hs);
+ break;
+ default:
+ break;
+ }
+ }
+ }
+ }
+ }
+ } else {
+ writeln("not a valid header type:", hm);
+ }
+ }
+ auto t = tuple(dochead_meta, dochead_make);
+ static assert(t.length==2);
+ return t;
+ }
+ private auto native_header_extract(L,Lo,O,T)(
+ L line,
+ return ref Lo line_occur,
+ return ref O an_object,
+ return ref T type
+ ) {
+ debug(asserts){
+ static assert(is(typeof(line) == char[]));
+ static assert(is(typeof(line_occur) == int[string]));
+ static assert(is(typeof(an_object) == string[string]));
+ static assert(is(typeof(type) == int[string]));
+ }
+ if (line.matchFirst(rgx.native_header_make)) { /+ matched header_make +/
+ debug(header1) { /+ writeln(line); +/ }
+ type["header"] = State.on;
+ type["header_make"] = State.on;
+ type["header_meta"] = State.off;
+ ++line_occur["header_make"];
+ an_object["body_nugget"] ~= line ~= "\n";
+ } else if (line.matchFirst(rgx.native_header)) { /+ matched header_metadata +/
+ /+ (generic header match and not previously caught by header_make) +/
+ debug(header1) { /+ writeln(line); +/ }
+ type["header"] = State.on;
+ type["header_make"] = State.off;
+ type["header_meta"] = State.on;
+ ++line_occur["header_meta"];
+ an_object["body_nugget"] ~= line ~= "\n";
+ } else if (type["header_make"] == State.on
+ && (line_occur["header_make"] > State.off)) { /+ header_make flag set +/
+ if (line.matchFirst(rgx.native_header_sub)) { /+ sub-header +/
+ debug(header1) { /+ writeln(line); +/ }
+ ++line_occur["header_make"];
+ an_object["body_nugget"] ~= line ~= "\n";
+ }
+ } else if (type["header_meta"] == State.on
+ && (line_occur["header_meta"] > State.off)) { /+ header_metadata flag set +/
+ if (line.matchFirst(rgx.native_header_sub)) { /+ sub-header +/
+ debug(header1) { /+ writeln(line); +/ }
+ ++line_occur["header_meta"];
+ an_object["body_nugget"] ~= line ~= "\n";
+ }
+ }
+ return an_object;
+ }
+ auto header_reset_states_common(Lo,O,T)(
+ return ref Lo line_occur,
+ return ref O an_object,
+ return ref T type
+ ) {
+ debug(asserts){
+ static assert(is(typeof(line_occur) == int[string]));
+ static assert(is(typeof(an_object) == string[string]));
+ static assert(is(typeof(type) == int[string]));
+ }
+ line_occur["header_make"] = State.off;
+ line_occur["header_meta"] = State.off;
+ type["header"] = State.off;
+ an_object.remove("body_nugget");
+ an_object.remove("is");
+ an_object.remove("attrib");
+ }
+ private auto headerNativeToAA(Hn)(Hn src_header) {
+ debug(asserts){
+ static assert(is(typeof(src_header) == char[]));
+ }
+ auto type = flags_type_init;
+ type = [
+ "header" : State.off,
+ "header_make" : State.off,
+ "header_meta" : State.off,
+ ];
+ string[string] an_object;
+ int[string] line_occur;
+ auto dochead_make = make_aa;
+ auto dochead_meta = meta_aa;
+ auto set_header = HeaderDocMetadataAndMakeNativeToAA();
+ char[][] source_header_arr =
+ (cast(char[]) src_header).split(rgx.newline_eol_delimiter);
+ foreach(header_line; source_header_arr) {
+ if (auto m = header_line.matchFirst(rgx.comment)) {
+ /+ matched comment +/
+ debug(comment) {
+ }
+ header_reset_states_common(line_occur, an_object, type);
+ } else if ((header_line.matchFirst(rgx.native_header))
+ || (type["header_make"] == State.on
+ && (line_occur["header_make"] > State.off))
+ || (type["header_meta"] == State.on
+ && (line_occur["header_meta"] > State.off))) {
+ if (header_line.length == 0) {
+ /+ header_make instructions (current line empty) +/
+ auto dochead_metadata_and_make =
+ set_header.header_metadata_and_make_aa(strip(an_object["body_nugget"]), dochead_meta, dochead_make);
+ static assert(!isTypeTuple!(dochead_metadata_and_make));
+ dochead_meta = dochead_metadata_and_make[0];
+ dochead_make = dochead_metadata_and_make[1];
+ header_reset_states_common(line_occur, an_object, type);
+ type["header_make"] = State.off;
+ type["header_meta"] = State.off;
+ debug(headersdlang) {
+ writeln(dochead_metadata_and_make);
+ }
+ } else {
+ an_object = native_header_extract(header_line, line_occur, an_object, type);
+ }
+ }
+ }
+ auto t = tuple(
+ dochead_make,
+ dochead_meta,
+ );
+ return t;
+ }
+ }
+}
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-04 22:12:26 +0000