<< lib/philosophers/SLPhilosopherChain.sleela SLeeLa Standard Library Definition. Definition: A Constructor's chain of growths, written with "::" between one growth and the next -- Constructor() :: Patch :: Constructor :: Aim :: Guide. >> #sleela 2.5 material; << Family: philosophers. A chain is the leading Constructor() call followed by a bounded run of Guides, each separated from the next by a double colon "::". The chain owns the Guides in order and enforces the seating register's admitted capacity (base 21, band [-2,+6], so [19,27]). The "::" is a conform token: it joins the identities on either side under one Cause, and renders in the editor between two colored Guides. This class builds a chain by seating named Guides in order and can render the canonical chain text with "::" so an editor or catalog sees exactly what was declared. Char-level string parsing is deliberately avoided (it is a bridged capability); a chain is assembled from names, and renders itself with "+", so check and run stay pure. >> class SLPhilosopherChain { < ---- Descriptive metadata (version 1.11 nested-friendly accessors) ---- > << Eleven catalogued attributes with getter/setter pairs, so a GUI, loader, or catalog can read and (where appropriate) override this record. Values are faithful to the subject's real origin where publicly known. >> String metaVersion = "1.0.0"; int metaId = 11567; String metaAuthor = "Kiro Agent"; String metaDate = "2026-10-24"; String metaCopyright = "SLeeLa project"; String metaTrademark = "none"; String metaCorporation = "none"; < metaOrigin: National | | International | Galactic > String metaOrigin = "International"; String metaBirthDate = "2026-10-24"; < metaScienceRating: maturity/robustness on a 1..10 scale > int metaScienceRating = 6; < metaNationalSchedule: a real, citable instrument or "none" > String metaNationalSchedule = "none"; String getMetaVersion() { return metaVersion; } void setMetaVersion(String v) { metaVersion = v; } int getMetaId() { return metaId; } void setMetaId(int v) { metaId = v; } String getAuthor() { return metaAuthor; } void setAuthor(String v) { metaAuthor = v; } String getDate() { return metaDate; } void setDate(String v) { metaDate = v; } String getCopyright() { return metaCopyright; } void setCopyright(String v) { metaCopyright = v; } String getTrademark() { return metaTrademark; } void setTrademark(String v) { metaTrademark = v; } String getCorporation() { return metaCorporation; } void setCorporation(String v) { metaCorporation = v; } String getOrigin() { return metaOrigin; } void setOrigin(String v) { metaOrigin = v; } String getBirthDate() { return metaBirthDate; } void setBirthDate(String v) { metaBirthDate = v; } int getScienceRating() { return metaScienceRating; } void setScienceRating(int v) { metaScienceRating = v; } String getNationalSchedule() { return metaNationalSchedule; } void setNationalSchedule(String v) { metaNationalSchedule = v; } < the growth separator: one growth :: the next > static final String GROWTH = " :: "; < the base of the chain is always a Constructor() call > static final String ROOT = "Constructor()"; < the seating register governing how many Guides this chain may hold > SLPhilosopherSeating seating; < the Guides of this chain, in order (index 0 is the first after the root) > SLPhilosopherGuide[] guides; < how many Guides have been seated > int count; < 1 if a seat request was refused because the chain was at capacity > int refusedFlag; < Prepare an empty chain at the default (band 0 -> 21) capacity. > void create() { seating = new SLPhilosopherSeating(); seating.create(); < 27 = SLPhilosopherSeating.MAX_CAPACITY (BASE 21 + ADDITIONAL_MAX 6) > guides = new SLPhilosopherGuide[27]; count = 0; refusedFlag = 0; } < Admit a signed band of additional seatings before building the chain. > < Returns the band actually admitted (clamped into [-2,+6]). > int admit(int band) { return seating.admit(band); } int capacity() { return seating.getCapacity(); } int size() { return count; } boolean refused() { return refusedFlag == 1; } < Seat one named Guide onto the given seating ordinal. An approving Guide > < carries favor (Gold); a growing Guide carries Green. Returns the Guide's > < index, or -1 when the chain is already at its admitted capacity. > int seat(String guideName, int seatOrdinal, boolean carriesFavor) { if (count >= seating.getCapacity()) { refusedFlag = 1; return -1; } SLPhilosopherGuide g = new SLPhilosopherGuide(); g.create(); g.sit(guideName, seatOrdinal, carriesFavor); guides[count] = g; int idx = count; count = count + 1; return idx; } SLPhilosopherGuide at(int i) { if (i < 0 || i >= count) { return null; } return guides[i]; } < Broadcast one context/impart to every seated Guide; each matching Guide > < counts the match. Returns how many Guides matched this impart. > int broadcast(String impart) { int hits = 0; int i = 0; while (i < count) { SLPhilosopherGuide g = guides[i]; if (g.listen(impart)) { hits = hits + 1; } i = i + 1; } return hits; } < Dispose every Guide after the object lives free. Idempotent per Guide. > void disposeAll() { int i = 0; while (i < count) { SLPhilosopherGuide g = guides[i]; g.dispose(); i = i + 1; } } < Render the canonical chain text, e.g. > < "Constructor() :: Patch :: Constructor :: Aim :: Guide". Built with "+" so > < no bridged char op is needed; this is the text an editor colors. > String render() { String s = ROOT; int i = 0; while (i < count) { SLPhilosopherGuide g = guides[i]; s = s + GROWTH + g.getName(); i = i + 1; } return s; } < A compact color manifest for the editor: the color impart of each Guide in > < order, joined with "::", e.g. "Gold/Yellow :: Green :: Gold/Yellow". > String colorManifest() { String s = ""; int i = 0; while (i < count) { SLPhilosopherGuide g = guides[i]; if (i == 0) { s = g.colorName(); } else { s = s + GROWTH + g.colorName(); } i = i + 1; } if (count == 0) { return "none"; } return s; } }