WebSVN – distributed – Path Comparison – / – /ViaThinkSoft Distributed/src/ Rev 1 and /ViaThinkSoft Distributed/src/ Rev 2

Regard whitespace Rev 1 → Rev 2

 /ViaThinkSoft Distributed/src/de/viathinksoft/distributed/apps/immortal/ImmortalJob.java
 ,0 → 1,69
+package de.viathinksoft.distributed.apps.immortal;
+import java.io.IOException;
+import java.security.NoSuchAlgorithmException;
+import de.viathinksoft.distributed.apps.immortal.deepcheck.DeepImmortalCheckIterator;
+import de.viathinksoft.distributed.apps.immortal.deepcheck.DeepImmortalCheckState;
+import de.viathinksoft.distributed.apps.immortal.exception.FileContentsBadException;
+import de.viathinksoft.distributed.apps.immortal.exception.InitialNumberIsOneException;
+import de.viathinksoft.distributed.apps.immortal.exception.InitialNumberNotImmortableException;
+import de.viathinksoft.distributed.apps.immortal.iterator.marschall.MarschallSectionIterator;
+import de.viathinksoft.distributed.apps.immortal.iterator.marschall.SectionImmortableNumber;
+import de.viathinksoft.distributed.apps.immortal.iterator.sequential.ImmortalSequenceList;
+import de.viathinksoft.distributed.apps.immortal.iterator.sequential.SequentialIterator;
+public class ImmortalJob {
+        public static void continueDeepImmortableCheck(String filename, int numCount) throws IOException, NoSuchAlgorithmException, FileContentsBadException {
+                DeepImmortalCheckState rs = new DeepImmortalCheckState(filename);
+                System.out.println(rs);
+                DeepImmortalCheckIterator x = new DeepImmortalCheckIterator(rs);
+                for (int i = 0; i < numCount; i++) {
+                        rs = x.next();
+                }
+                System.out.println(rs);
+                System.out.println("result-immortal-deepMultiplyInitial-"+rs.getInitialNumber()+"-"+rs.getCount()+".txt");
+                rs.saveToFile(filename);
+        }
+        public static void continueMarschallSectionIteration(String filename, int numCount) throws IOException, NoSuchAlgorithmException, FileContentsBadException, InitialNumberNotImmortableException, InitialNumberIsOneException {
+//              System.out.println((new File(filename)).getParent());
+                SectionImmortableNumber se = new SectionImmortableNumber(filename);
+                MarschallSectionIterator mi = new MarschallSectionIterator(se);
+                System.out.println(se);
+                for (int i = 0; i < numCount; i++) {
+                        se = mi.next();
+                }
+                System.out.println(se);
+                System.out.println("result-immortal-marschallIteration-"+se.getInitialElement()+"-"+se.getCalculatedAmount()+".txt");
+                se.saveToFile(filename);
+        }
+        public static void continueSequencialIteration(String filename, int numCount) throws NoSuchAlgorithmException, IOException, FileContentsBadException {
+                ImmortalSequenceList sl = new ImmortalSequenceList();
+                sl.loadFromFile(filename);
+                System.out.println(sl);
+                SequentialIterator x = new SequentialIterator(sl.getLastNumber());
+                for (int i = 0; i < numCount; i++) {
+                        sl.add(x.next());
+                }
+                System.out.println(sl);
+                System.out.println("result-immortal-sequencialSearch-"+sl.getFirstNumber()+"-"+sl.getLastNumber()+".txt");
+                sl.saveToFile(filename);
+        }
+        private ImmortalJob() {
+        }
+}
 Property changes:
 Added: svn:mime-type
 +text/plain
 \ No newline at end of property

 /ViaThinkSoft Distributed/src/de/viathinksoft/distributed/apps/immortal/Test.java
 ,0 → 1,53
+package de.viathinksoft.distributed.apps.immortal;
+import java.io.IOException;
+import java.math.BigInteger;
+import java.security.NoSuchAlgorithmException;
+import de.viathinksoft.distributed.apps.immortal.deepcheck.DeepImmortalCheckBootStrap;
+import de.viathinksoft.distributed.apps.immortal.exception.FileContentsBadException;
+import de.viathinksoft.distributed.apps.immortal.exception.InitialNumberIsOneException;
+import de.viathinksoft.distributed.apps.immortal.exception.InitialNumberNotImmortableException;
+import de.viathinksoft.distributed.apps.immortal.iterator.marschall.SectionImmortableBootStrap;
+import de.viathinksoft.distributed.apps.immortal.iterator.sequential.ImmortalSequenceList;
+import de.viathinksoft.distributed.apps.immortal.iterator.sequential.ImmortalSequenceListBootStrap;
+@SuppressWarnings("unused")
+public class Test {
+        /**
+         * @param args
+         * @throws InitialNumberIsOneException
+         * @throws InitialNumberNotImmortableException
+         * @throws FileContentsBadException
+         * @throws IOException
+         * @throws NoSuchAlgorithmException
+         */
+        // TODO: Auch mal über Exceptions mit Cause nachdenken (Nested)
+        public static void main(String[] args) throws NoSuchAlgorithmException, IOException, FileContentsBadException, InitialNumberNotImmortableException, InitialNumberIsOneException {
+//              MarschallSectionIterator b = new MarschallSectionIterator(new BigInteger("5"));
+//              for (SectionImmortableNumber i : b) {
+//                      System.out.println(i);
+//              }
+//              SequencialIterator c = new SequencialIterator(new BigInteger("5"));
+//              for (BigInteger i : c) {
+//                      System.out.println(i);
+//              }
+//              MarschallIterator b = new MarschallIterator(new BigInteger("5"));
+//              for (BigInteger i : b) {
+//                      System.out.println(i);
+//              }
+                SectionImmortableBootStrap.initializeSectionImmortableChain5File("c:/bermarxaliter.txt");
+                ImmortalJob.continueMarschallSectionIteration("c:/bermarxaliter.txt", 1000);
+//              DeepImmortalCheckBootStrap.initializeDeepCheckFile("c:/beren.txt", new BigInteger("25"));
+//              ImmortalJob.continueDeepImmortableCheck("c:/beren.txt", 2);
+                //ImmortalSequenceListBootStrap.initializeEmptySequenceFile("c:/be.txt", new BigInteger("27"));
+//              ImmortalJob.continueSequencialIteration("c:/be.txt", 3);
+        }
+}
 Property changes:
 Added: svn:mime-type
 +text/plain
 \ No newline at end of property

 /ViaThinkSoft Distributed/src/de/viathinksoft/distributed/apps/immortal/iterator/marschall/legacy/MarschallIterator.java
 ,0 → 1,51
+package de.viathinksoft.distributed.apps.immortal.iterator.marschall.legacy;
+import java.math.BigInteger;
+import java.util.Iterator;
+import de.viathinksoft.distributed.apps.immortal.exception.InitialNumberNotImmortableException;
+import de.viathinksoft.distributed.apps.immortal.iterator.QuickImmortableCheck;
+//TODO: Iterable aufspalten?
+public class MarschallIterator implements Iterator<BigInteger>, Iterable<BigInteger> {
+        private BigInteger position;
+        public MarschallIterator(BigInteger start) throws InitialNumberNotImmortableException {
+                if (!QuickImmortableCheck.check(start)) {
+                        throw new InitialNumberNotImmortableException();
+                }
+                this.position = start;
+        }
+        @Override
+        public boolean hasNext() {
+                return true;
+        }
+        @Override
+        public BigInteger next() {
+                String s = position.toString();
+                BigInteger prefixTrial = BigInteger.ZERO;
+                BigInteger chk;
+                do {
+                        prefixTrial = prefixTrial.add(BigInteger.ONE);
+                        chk = new BigInteger(prefixTrial.toString().concat(s));
+                } while (!QuickImmortableCheck.check(chk));
+                position = chk;
+                return position;
+        }
+        @Override
+        public void remove() {
+                throw new UnsupportedOperationException();
+        }
+        @Override
+        public Iterator<BigInteger> iterator() {
+                return this;
+        }
+}
 Property changes:
 Added: svn:mime-type
 +text/plain
 \ No newline at end of property

 /ViaThinkSoft Distributed/src/de/viathinksoft/distributed/apps/immortal/iterator/marschall/MarschallSectionIterator.java
 ,0 → 1,67
+package de.viathinksoft.distributed.apps.immortal.iterator.marschall;
+import java.math.BigInteger;
+import java.util.Iterator;
+import de.viathinksoft.distributed.apps.immortal.exception.InitialNumberIsOneException;
+import de.viathinksoft.distributed.apps.immortal.exception.InitialNumberNotImmortableException;
+import de.viathinksoft.distributed.apps.immortal.iterator.QuickImmortableCheck;
+public class MarschallSectionIterator implements
+                Iterator<SectionImmortableNumber>, Iterable<SectionImmortableNumber> {
+        private SectionImmortableNumber position;
+        public MarschallSectionIterator(SectionImmortableNumber start)
+                        throws InitialNumberNotImmortableException {
+                if (!QuickImmortableCheck.check(start.toBigInteger())) {
+                        throw new InitialNumberNotImmortableException();
+                }
+                this.position = start;
+        }
+        public MarschallSectionIterator(BigInteger start)
+                        throws InitialNumberNotImmortableException,
+                        InitialNumberIsOneException {
+                this(new SectionImmortableNumber(start));
+        }
+        public MarschallSectionIterator(int start)
+                        throws InitialNumberNotImmortableException,
+                        InitialNumberIsOneException {
+                this(new SectionImmortableNumber(start));
+        }
+        @Override
+        public boolean hasNext() {
+                return true;
+        }
+        @Override
+        public SectionImmortableNumber next() {
+                String s = position.toBigInteger().toString();
+                BigInteger prefixTrial = BigInteger.ZERO;
+                BigInteger chk;
+                do {
+                        prefixTrial = prefixTrial.add(BigInteger.ONE);
+                        chk = new BigInteger(prefixTrial.toString().concat(s));
+                } while (!QuickImmortableCheck.check(chk));
+                SectionImmortableNumber neu = (SectionImmortableNumber) position.clone();
+                neu.add(prefixTrial);
+                position = neu;
+                return position;
+        }
+        @Override
+        public void remove() {
+                throw new UnsupportedOperationException();
+        }
+        @Override
+        public Iterator<SectionImmortableNumber> iterator() {
+                return this;
+        }
+}
 Property changes:
 Added: svn:mime-type
 +text/plain
 \ No newline at end of property

 /ViaThinkSoft Distributed/src/de/viathinksoft/distributed/apps/immortal/iterator/marschall/SectionImmortableNumber.java
 ,0 → 1,137
+package de.viathinksoft.distributed.apps.immortal.iterator.marschall;
+import java.io.BufferedReader;
+import java.io.BufferedWriter;
+import java.io.FileReader;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.math.BigInteger;
+import java.security.NoSuchAlgorithmException;
+import java.util.ArrayList;
+import de.viathinksoft.distributed.apps.immortal.exception.FileContentsBadException;
+import de.viathinksoft.distributed.apps.immortal.exception.InitialNumberIsOneException;
+import de.viathinksoft.distributed.apps.immortal.exception.InitialNumberNotImmortableException;
+import de.viathinksoft.distributed.apps.immortal.iterator.QuickImmortableCheck;
+import de.viathinksoft.utils.security.MD5;
+//TODO: Gewisse zahl anwählen
+public class SectionImmortableNumber extends ArrayList<BigInteger> {
+        private static final long serialVersionUID = 251721127226195138L;
+        protected static final String SEPARATOR = ",";
+        public SectionImmortableNumber(BigInteger initialElement)
+                        throws InitialNumberNotImmortableException,
+                        InitialNumberIsOneException {
+                // TODO: initialnumberisone: soll das auch bei "0" passieren? (unendlichschleife)
+                if (initialElement.equals(BigInteger.ONE)) {
+                        throw new InitialNumberIsOneException();
+                }
+                if (!QuickImmortableCheck.check(initialElement)) {
+                        throw new InitialNumberNotImmortableException();
+                }
+                this.add(initialElement);
+        }
+        // public SectionImmortableNumber(String initialElement)
+        // throws InitialNumberNotImmortableException,
+        // InitialNumberIsOneException {
+        // this(new BigInteger(initialElement));
+        // }
+        public SectionImmortableNumber(int initialElement)
+                        throws InitialNumberNotImmortableException,
+                        InitialNumberIsOneException {
+                // this(Integer.toString(initialElement));
+                this(new BigInteger(Integer.toString(initialElement)));
+        }
+        public SectionImmortableNumber(String filename)
+                        throws NoSuchAlgorithmException, IOException,
+                        FileContentsBadException {
+                loadFromFile(filename);
+        }
+        public BigInteger getInitialElement() {
+                return this.get(0);
+        }
+        public int getCalculatedAmount() {
+                return this.size() - 1;
+        }
+        @Override
+        public String toString() {
+                String s = "";
+                for (BigInteger m : this) {
+                        if (s.equals("")) {
+                                s = m.toString();
+                        } else {
+                                s = m.toString().concat(SEPARATOR).concat(s);
+                        }
+                }
+                return s;
+        }
+        public BigInteger toBigInteger() {
+                String s = "";
+                for (BigInteger m : this) {
+                        s = m.toString().concat(s);
+                }
+                return new BigInteger(s);
+        }
+        // TODO equals, clone
+        private final String SIGNATURE = "Immortal Sectioned Marschall Number V001";
+        private final String SALT = "AFFAüüü+++MSKGM ignsdg nkoi ajp894jfocwrvw  AFAFAü324§$§$%$&WQ";
+        public void saveToFile(String filename) throws IOException,
+                        NoSuchAlgorithmException {
+                BufferedWriter x = new BufferedWriter(new FileWriter(filename));
+                String s;
+                x.write(SIGNATURE);
+                x.write("\r\n");
+                s = this.toString();
+                x.write(s);
+                x.write("\r\n");
+                x.write(MD5.digest(s, SALT));
+                x.write("\r\n");
+                x.close();
+        }
+        public void loadFromFile(String filename) throws IOException,
+                        NoSuchAlgorithmException, FileContentsBadException {
+                BufferedReader r = new BufferedReader(new FileReader(filename));
+                String f_sig = r.readLine();
+                if ((f_sig == null) || (!f_sig.equals(SIGNATURE))) {
+                        throw new FileContentsBadException();
+                }
+                String f_commatext = r.readLine();
+                if ((f_commatext == null)
+                                || (!MD5.digest(f_commatext, SALT).equals(r.readLine()))) {
+                        throw new FileContentsBadException();
+                }
+                r.close();
+                this.clear();
+                        String[] ary = f_commatext.split(SEPARATOR);
+                        for (int i = ary.length - 1; i >= 0; i--) {
+                                this.add(new BigInteger(ary[i]));
+                        }
+                        // for (String s : ary) {
+                        // this.add(new BigInteger(s));
+                        // }
+        }
+}
 Property changes:
 Added: svn:mime-type
 +text/plain
 \ No newline at end of property

 /ViaThinkSoft Distributed/src/de/viathinksoft/distributed/apps/immortal/iterator/marschall/SectionImmortableBootStrap.java
 ,0 → 1,27
+package de.viathinksoft.distributed.apps.immortal.iterator.marschall;
+import java.io.IOException;
+import java.math.BigInteger;
+import java.security.NoSuchAlgorithmException;
+import de.viathinksoft.distributed.apps.immortal.exception.InitialNumberIsOneException;
+import de.viathinksoft.distributed.apps.immortal.exception.InitialNumberNotImmortableException;
+public class SectionImmortableBootStrap {
+        protected static void initializeSectionImmortableNumberFile(String filename, BigInteger initialNumber) throws InitialNumberNotImmortableException, InitialNumberIsOneException, NoSuchAlgorithmException, IOException {
+                SectionImmortableNumber rs = new SectionImmortableNumber(initialNumber);
+                rs.saveToFile(filename);
+        }
+        public static void initializeSectionImmortableChain5File(String filename) throws NoSuchAlgorithmException, InitialNumberNotImmortableException, InitialNumberIsOneException, IOException {
+                initializeSectionImmortableNumberFile(filename, new BigInteger("5"));
+        }
+        public static void initializeSectionImmortableChain6File(String filename) throws NoSuchAlgorithmException, InitialNumberNotImmortableException, InitialNumberIsOneException, IOException {
+                initializeSectionImmortableNumberFile(filename, new BigInteger("6"));
+        }
+        private SectionImmortableBootStrap() {
+        }
+}
 Property changes:
 Added: svn:mime-type
 +text/plain
 \ No newline at end of property

 /ViaThinkSoft Distributed/src/de/viathinksoft/distributed/apps/immortal/iterator/QuickImmortableCheck.java
 ,0 → 1,25
+package de.viathinksoft.distributed.apps.immortal.iterator;
+import java.math.BigInteger;
+import de.viathinksoft.distributed.apps.immortal.deepcheck.DeepImmortalCheckIterator;
+import de.viathinksoft.distributed.apps.immortal.deepcheck.DeepImmortalCheckState;
+public class QuickImmortableCheck {
+        public static final int iterationCount = 5;
+        public static boolean check(BigInteger number) {
+                DeepImmortalCheckState cs = new DeepImmortalCheckState(false, BigInteger.ZERO, number, number);
+                DeepImmortalCheckIterator x = new DeepImmortalCheckIterator(cs);
+                for (int i = 0; i < iterationCount; i++) {
+                        cs = x.next();
+                }
+                return cs.isImmortal();
+        }
+        private QuickImmortableCheck() {
+        }
+}
 Property changes:
 Added: svn:mime-type
 +text/plain
 \ No newline at end of property

 /ViaThinkSoft Distributed/src/de/viathinksoft/distributed/apps/immortal/iterator/sequential/SequentialIterator.java
 ,0 → 1,44
+package de.viathinksoft.distributed.apps.immortal.iterator.sequential;
+import java.math.BigInteger;
+import java.util.Iterator;
+import de.viathinksoft.distributed.apps.immortal.iterator.QuickImmortableCheck;
+//TODO: Iterable aufspalten?
+public class SequentialIterator implements Iterator<BigInteger>, Iterable<BigInteger> {
+        private BigInteger position = BigInteger.ZERO;
+        public SequentialIterator(BigInteger start) {
+                this.position = start;
+        }
+        @Override
+        public boolean hasNext() {
+                return true;
+        }
+        @Override
+        public BigInteger next() {
+                BigInteger chk = position;
+                do {
+                        chk = chk.add(BigInteger.ONE);
+                } while (!QuickImmortableCheck.check(chk));
+                position = chk;
+                return position;
+        }
+        @Override
+        public void remove() {
+                throw new UnsupportedOperationException();
+        }
+        @Override
+        public Iterator<BigInteger> iterator() {
+                return this;
+        }
+}
 Property changes:
 Added: svn:mime-type
 +text/plain
 \ No newline at end of property

 /ViaThinkSoft Distributed/src/de/viathinksoft/distributed/apps/immortal/iterator/sequential/ImmortalSequenceListBootStrap.java
 ,0 → 1,20
+package de.viathinksoft.distributed.apps.immortal.iterator.sequential;
+import java.io.IOException;
+import java.math.BigInteger;
+import java.security.NoSuchAlgorithmException;
+public class ImmortalSequenceListBootStrap {
+        public static void initializeEmptySequenceFile(String filename,
+                        BigInteger beginningNumber) throws NoSuchAlgorithmException,
+                        IOException {
+                ImmortalSequenceList rs = new ImmortalSequenceList();
+                rs.add(beginningNumber);
+                rs.saveToFile(filename);
+        }
+        private ImmortalSequenceListBootStrap() {
+        }
+}
 Property changes:
 Added: svn:mime-type
 +text/plain
 \ No newline at end of property

 /ViaThinkSoft Distributed/src/de/viathinksoft/distributed/apps/immortal/iterator/sequential/ImmortalSequenceList.java
 ,0 → 1,99
+package de.viathinksoft.distributed.apps.immortal.iterator.sequential;
+import java.io.BufferedReader;
+import java.io.BufferedWriter;
+import java.io.FileReader;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.math.BigInteger;
+import java.security.NoSuchAlgorithmException;
+import java.util.ArrayList;
+import de.viathinksoft.distributed.apps.immortal.exception.FileContentsBadException;
+import de.viathinksoft.utils.security.MD5;
+public class ImmortalSequenceList extends ArrayList<BigInteger> {
+        private static final long serialVersionUID = 3701716850542275075L;
+        protected static final String SEPARATOR = ";";
+        public ImmortalSequenceList() {
+                super();
+        }
+        public ImmortalSequenceList(String filename)
+                        throws NoSuchAlgorithmException, IOException,
+                        FileContentsBadException {
+                loadFromFile(filename);
+        }
+        @Override
+        public String toString() {
+                String s = "";
+                for (BigInteger m : this) {
+                        if (s.equals("")) {
+                                s = m.toString();
+                        } else {
+                                s = s.concat(SEPARATOR).concat(m.toString());
+                        }
+                }
+                return s;
+        }
+        public BigInteger getLastNumber() {
+                return this.get(this.size() - 1);
+        }
+        public BigInteger getFirstNumber() {
+                return this.get(0);
+        }
+        // TODO equals, clone
+        private final String SIGNATURE = "Immortal Number Sequence List V001";
+        private final String SALT = "AFasoifjsiugdaskdgnakjsdmoi2jtuijwqoikoafojdnsvhfbqimlkwmfkSFSDFADFA>SFasfAQ";
+        public void saveToFile(String filename) throws IOException,
+                        NoSuchAlgorithmException {
+                BufferedWriter x = new BufferedWriter(new FileWriter(filename));
+                String s;
+                x.write(SIGNATURE);
+                x.write("\r\n");
+                s = this.toString();
+                x.write(s);
+                x.write("\r\n");
+                x.write(MD5.digest(s, SALT));
+                x.write("\r\n");
+                x.close();
+        }
+        public void loadFromFile(String filename) throws IOException,
+                        NoSuchAlgorithmException, FileContentsBadException {
+                BufferedReader r = new BufferedReader(new FileReader(filename));
+                String f_sig = r.readLine();
+                if ((f_sig == null) || (!f_sig.equals(SIGNATURE))) {
+                        throw new FileContentsBadException();
+                }
+                String f_commatext = r.readLine();
+                if ((f_commatext == null)
+                                || (!MD5.digest(f_commatext, SALT).equals(r.readLine()))) {
+                        throw new FileContentsBadException();
+                }
+                r.close();
+                this.clear();
+                String[] ary = f_commatext.split(SEPARATOR);
+                for (String s : ary) {
+                        this.add(new BigInteger(s));
+                }
+        }
+}
 Property changes:
 Added: svn:mime-type
 +text/plain
 \ No newline at end of property

 /ViaThinkSoft Distributed/src/de/viathinksoft/distributed/apps/immortal/deepcheck/DeepImmortalCheckState.java
 ,0 → 1,135
+package de.viathinksoft.distributed.apps.immortal.deepcheck;
+import java.io.BufferedReader;
+import java.io.BufferedWriter;
+import java.io.FileReader;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.io.Serializable;
+import java.math.BigInteger;
+import java.security.NoSuchAlgorithmException;
+import de.viathinksoft.distributed.apps.immortal.exception.FileContentsBadException;
+import de.viathinksoft.utils.security.MD5;
+public class DeepImmortalCheckState implements Serializable {
+        private static final long serialVersionUID = -813320779387593520L;
+        private boolean immortal;
+        private BigInteger count;
+        private BigInteger initialNumber;
+        // Warning: There will be no check that continueAt is a valid
+        // part of the last result which myint did create.
+        private BigInteger lastResult;
+        public boolean isImmortal() {
+                return immortal;
+        }
+        public BigInteger getCount() {
+                return count;
+        }
+        public BigInteger getInitialNumber() {
+                return initialNumber;
+        }
+        public BigInteger getLastResult() {
+                return lastResult;
+        }
+        public DeepImmortalCheckState(boolean immortal, BigInteger count, BigInteger initialNumber, BigInteger lastResult) {
+                super();
+                this.immortal = immortal;
+                this.count = count;
+                this.initialNumber = initialNumber;
+                this.lastResult = lastResult;
+        }
+        public DeepImmortalCheckState(String filename) throws IOException, NoSuchAlgorithmException, FileContentsBadException {
+                super();
+                loadFromFile(filename);
+        }
+        @Override
+        public String toString() {
+                return "["+initialNumber+"] " + immortal + " (#" + count + ": " + lastResult + ")";
+        }
+        // TODO equals, clone
+        private final String SIGNATURE = "Immortal Result Set V001";
+        private final String SALT = "omrtjsdflmaeafuinalafm4iosaFFA$§Eeqoqw09kfslmflafnASFmgalm092k928jlamrnln";
+        public void saveToFile(String filename) throws IOException, NoSuchAlgorithmException {
+                BufferedWriter x = new BufferedWriter(new FileWriter(filename));
+                String s;
+                x.write(SIGNATURE);
+                x.write("\r\n");
+                s = this.initialNumber.toString();
+                x.write(s);
+                x.write("\r\n");
+                x.write(MD5.digest(s, SALT));
+                x.write("\r\n");
+                s = Boolean.toString(this.immortal);
+                x.write(s);
+                x.write("\r\n");
+                x.write(MD5.digest(s, SALT));
+                x.write("\r\n");
+                s = this.count.toString();
+                x.write(s);
+                x.write("\r\n");
+                x.write(MD5.digest(s, SALT));
+                x.write("\r\n");
+                s = this.lastResult.toString();
+                x.write(s);
+                x.write("\r\n");
+                x.write(MD5.digest(s, SALT));
+                x.write("\r\n");
+                x.close();
+        }
+        public void loadFromFile(String filename) throws IOException, NoSuchAlgorithmException, FileContentsBadException {
+                BufferedReader r = new BufferedReader(new FileReader(filename));
+                String f_sig = r.readLine();
+                if ((f_sig == null) || (!f_sig.equals(SIGNATURE))) {
+                        throw new FileContentsBadException();
+                }
+                String f_initialnumber = r.readLine();
+                if ((f_initialnumber == null) || (!MD5.digest(f_initialnumber, SALT).equals(r.readLine()))) {
+                        throw new FileContentsBadException();
+                }
+                String f_immortal = r.readLine();
+                if ((f_immortal == null) || (!MD5.digest(f_immortal, SALT).equals(r.readLine()))) {
+                        throw new FileContentsBadException();
+                }
+                String f_count = r.readLine();
+                if ((f_count == null) || (!MD5.digest(f_count, SALT).equals(r.readLine()))) {
+                        throw new FileContentsBadException();
+                }
+                String f_lastresult = r.readLine();
+                if ((f_lastresult == null) || (!MD5.digest(f_lastresult, SALT).equals(r.readLine()))) {
+                        throw new FileContentsBadException();
+                }
+                r.close();
+                this.initialNumber = new BigInteger(f_initialnumber);
+                this.immortal = Boolean.valueOf(f_immortal);
+                this.count = new BigInteger(f_count);
+                this.lastResult = new BigInteger(f_lastresult);
+        }
+}
 Property changes:
 Added: svn:mime-type
 +text/plain
 \ No newline at end of property

 /ViaThinkSoft Distributed/src/de/viathinksoft/distributed/apps/immortal/deepcheck/DeepImmortalCheckIterator.java
 ,0 → 1,48
+package de.viathinksoft.distributed.apps.immortal.deepcheck;
+import java.math.BigInteger;
+import java.util.Iterator;
+// TODO: Iterable aufspalten?
+public class DeepImmortalCheckIterator implements Iterator<DeepImmortalCheckState>,
+                Iterable<DeepImmortalCheckState> {
+        private DeepImmortalCheckState position;
+        public DeepImmortalCheckIterator(DeepImmortalCheckState start) {
+                this.position = start;
+        }
+        @Override
+        public boolean hasNext() {
+                return true;
+        }
+        @Override
+        public DeepImmortalCheckState next() {
+                if (!position.isImmortal() && (position.getCount().compareTo(BigInteger.ZERO) > 0)) return position;
+                BigInteger lastResult = position.getLastResult();
+                BigInteger initialNumber = position.getInitialNumber();
+                BigInteger counter = position.getCount().add(BigInteger.ONE);
+                lastResult = lastResult.multiply(initialNumber);
+                boolean isImmortable = lastResult.toString().endsWith(initialNumber.toString());
+                position = new DeepImmortalCheckState(isImmortable, counter, initialNumber, lastResult);
+                return position;
+        }
+        @Override
+        public void remove() {
+                throw new UnsupportedOperationException();
+        }
+        @Override
+        public Iterator<DeepImmortalCheckState> iterator() {
+                return this;
+        }
+}
 Property changes:
 Added: svn:mime-type
 +text/plain
 \ No newline at end of property

 /ViaThinkSoft Distributed/src/de/viathinksoft/distributed/apps/immortal/deepcheck/DeepImmortalCheckBootStrap.java
 ,0 → 1,16
+package de.viathinksoft.distributed.apps.immortal.deepcheck;
+import java.io.IOException;
+import java.math.BigInteger;
+import java.security.NoSuchAlgorithmException;
+public class DeepImmortalCheckBootStrap {
+        public static void initializeDeepCheckFile(String filename, BigInteger initialNumber) throws NoSuchAlgorithmException, IOException {
+                DeepImmortalCheckState rs = new DeepImmortalCheckState(false, BigInteger.ZERO, initialNumber, initialNumber);
+                rs.saveToFile(filename);
+        }
+        private DeepImmortalCheckBootStrap() {
+        }
+}
 Property changes:
 Added: svn:mime-type
 +text/plain
 \ No newline at end of property

/ViaThinkSoft Distributed/src/de/viathinksoft/distributed/apps/immortal/exception/InitialNumberIsOneException.java
0,0 → 1,7
package de.viathinksoft.distributed.apps.immortal.exception;

public class InitialNumberIsOneException extends Exception {

private static final long serialVersionUID = 6300960287601572636L;

}
Property changes:
Added: svn:mime-type
+text/plain
\ No newline at end of property

/ViaThinkSoft Distributed/src/de/viathinksoft/distributed/apps/immortal/exception/FileContentsBadException.java
0,0 → 1,7
package de.viathinksoft.distributed.apps.immortal.exception;

public class FileContentsBadException extends Exception {

private static final long serialVersionUID = 2673597842443711595L;

}
Property changes:
Added: svn:mime-type
+text/plain
\ No newline at end of property

/ViaThinkSoft Distributed/src/de/viathinksoft/distributed/apps/immortal/exception/InitialNumberNotImmortableException.java
0,0 → 1,7
package de.viathinksoft.distributed.apps.immortal.exception;

public class InitialNumberNotImmortableException extends Exception {

private static final long serialVersionUID = -4172437830103673699L;

}
Property changes:
Added: svn:mime-type
+text/plain
\ No newline at end of property

Subversion Repositories distributed

Compare Revisions

Regard whitespace Rev 1 → Rev 2