Naive binding implementation

src/SIMDDNA/molecule.py

@@ -39,12 +39,22 @@ class Molecule:
     def addToChain(self, base, chainId):
         self.chains[chainId].append(base)
 
+    def getChain(self, chain):
+        return self.chains[chain]
+
+    def removeChain(self, chainId):
+        del self.chains[chainId]
+
     def maxChainSize(self):
         maxLen = 0
         for chain in self.chains:
             maxLen = max(maxLen, len(chain))
 
         return maxLen
+
+    def chain2chain(self, chainID, chain):
+        for base in chain:
+            self.chains[chainID].append(base)
     
     def padChain(self, chainID, count):
         for _ in range(count):
@@ -114,11 +124,11 @@ def parse(notationStr):
 
         if state == "init":
             
-            if   char == "<":
+            if   char == "{":
                 lastChain = state = "lower"
             elif char == "[":
                 lastChain = state = "double"
-            elif char == "{":
+            elif char == "<":
                 lastChain = state = "upper"
             elif char == ".":
                 if lastChain is not None and lastChain != "lower":
@@ -131,14 +141,14 @@ def parse(notationStr):
                 exit(1)
 
         elif state == "lower":
-            if char == ">":
+            if char == "}":
                 state = "init"
                 continue
 
             newMolecule.charAddBase(lowerChain, char)
 
         elif state == "upper":
-            if char == "}":
+            if char == ">":
                 workingChain = None
                 isBackward   = False
                 state        = "init"

src/SIMDDNA/register.py

@@ -9,7 +9,45 @@ class Register:
         self.mol = mol
 
     def inscription(self, IMols):
-        pass
+        for _ in range(1):
+            used = False
+            for imol in IMols:
+                bindIndex, unbindChain = self.getNearestBinding(imol)
+
+                if unbindChain is not None:
+                    used = True
+                    self.mol.removeChain(unbindChain)
+
+                if bindIndex is not None:
+                    used = True
+                    chain = self.mol.addChain()
+                    self.mol.padChain(chain, bindIndex)
+                    self.mol.chain2chain(chain, imol.getChain(0))
+                    self.mol.endPad()
+
+            if not used:
+                break
+
+    def getNearestBinding(self, imol):
+        for chainI in range(self.mol.chainsCount()):
+            for aligment in range(len(self.mol)):
+                align_score = 0
+                for baseID in range(min(len(imol), len(self.mol) - aligment)):
+                    if molecule.isComplementary(self.mol.getBase(chainI, baseID + aligment), imol.getBase(0, baseID)):
+                        align_score += 1
+                    elif align_score > 0:
+                        break
+
+                # ok now finded binding
+                if align_score >= 2:
+                    if chainI == 0:
+                        return aligment, None
+
+
+        return None, None
+    
+    def show(self):
+        return self.mol.rawPrint()
 
     def asciiShow(self, spaceing = ""):
         return ascii.showMolecule(self.mol, spaceing)
@@ -21,7 +59,7 @@ print("---------------------------------\n")
 
 # create register
 myreg = Register(molecule.parse(
-    "<AB>[CD]"
+    "{EEEBCDEEEBCD}"
 ))
 
 myreg.asciiShow()
@@ -31,9 +69,18 @@ print("After")
 print("---------------------------------\n")
 
 # do inscription
+# mark
+# myreg.inscription([
+#    molecule.parse("<A*B*C*D*E*>")
+# ])
+
+# do instruction
+# remove
 myreg.inscription([
-    molecule.parse("{A*B*C*D*E*}"),
-    molecule.parse("<ABCDE>")
+    molecule.parse("{A*B*C*D*A*}")
 ])
 
+
+myreg.show()
+
 myreg.asciiShow()