Package statechum.analysis.learning.experiments.PairSelection

Examples of statechum.analysis.learning.experiments.PairSelection.Cav2014$RedPriorityOverBluePairSelectionRoutine


    final Configuration deepCopy = pta.config.copy();deepCopy.setLearnerCloneGraph(true);
    LearnerGraph ptaCopy = new LearnerGraph(deepCopy);LearnerGraph.copyGraphs(pta, ptaCopy);
   
    LearnerGraph actualAutomaton = learnerOfPairs.learnMachine(new LinkedList<List<Label>>(),new LinkedList<List<Label>>());
    LearnerGraph edsm2Outcome = new EDSMReferenceLearner(learnerEval,ptaCopy,1).learnMachine(new LinkedList<List<Label>>(),new LinkedList<List<Label>>());
    System.out.println("Outcome states: "+edsm2Outcome.getStateNumber());
    Visualiser.updateFrame(actualAutomaton, edsm2Outcome);
    Visualiser.waitForKey();
   
  }
View Full Code Here


    final Configuration deepCopy = pta.config.copy();deepCopy.setLearnerCloneGraph(true);
    LearnerGraph ptaCopy = new LearnerGraph(deepCopy);LearnerGraph.copyGraphs(pta, ptaCopy);
   
    LearnerGraph actualAutomaton = learnerOfPairs.learnMachine(new LinkedList<List<Label>>(),new LinkedList<List<Label>>());
    LearnerGraph edsm2Outcome = new EDSMReferenceLearner(learnerEval,ptaCopy,1).learnMachine(new LinkedList<List<Label>>(),new LinkedList<List<Label>>());
    System.out.println("Outcome states: "+edsm2Outcome.getStateNumber());
    Visualiser.updateFrame(actualAutomaton, edsm2Outcome);
    Visualiser.waitForKey();
   
  }
View Full Code Here

                            for(List<Label> seq:sPlus)
                              pta.paths.augmentPTA(seq,true,false,null);
                            for(List<Label> seq:sMinus)
                              pta.paths.augmentPTA(seq,false,false,null);
                            pta.clearColours();
                            KTailsReferenceLearner learner = new KTailsReferenceLearner(learnerInitConfiguration,pta,true,1) {

                              @Override
                              public Stack<PairScore> ChooseStatePairs(LearnerGraph graph)
                              {
                                reportLearningProgress(graph,message,ref,counter);
                                // resume learning.
                                return super.ChooseStatePairs(graph);
                              }

                            };

                            if (learnerInitConfiguration.graph != null)
                            {
                              learnerInitConfiguration.graph.clearColours();learnerInitConfiguration.graph.getInit().setColour(JUConstants.RED);
                              LearnerGraph.copyGraphs(learnerInitConfiguration.graph,learner.getTentativeAutomaton());
                            }
                            LearnerGraph graphLearnt = learner.learnMachine(new LinkedList<List<Label>>(),new LinkedList<List<Label>>());
                            outcome = new OtpErlangTuple(new OtpErlangObject[]{ref,msgOk,  constructFSM(graphLearnt)});
                          }
                          catch(AskedToTerminateException e)
                          {
                            outcome = new OtpErlangTuple(new OtpErlangObject[]{ref,msgTerminate});
                          }
                          catch(Throwable ex)
                          {
                            ex.printStackTrace();
                            outcome = new OtpErlangTuple(new OtpErlangObject[]{ref,msgFailure,new OtpErlangList(ex.getMessage())});
                          }
                          mbox.send(erlangPartner,outcome);
                         
                        }
                        else
                        // Args: Ref,addTypeInformation,list of pairs containing method names and types.
                        if (command.equals(msgAddTypeInformation) && message.arity() >= 3)
                        {
                          OtpErlangObject outcome = null;
                          try
                          {
                            updateFrom((OtpErlangList)message.elementAt(2), overrides);
                            outcome = new OtpErlangTuple(new OtpErlangObject[]{ref,msgOk,  typeMapToList(overrides)});
                          }
                          catch(Throwable ex)
                          {
                            ex.printStackTrace();
                            outcome = new OtpErlangTuple(new OtpErlangObject[]{ref,msgFailure,new OtpErlangList(ex.getMessage())});
                          }
                          mbox.send(erlangPartner,outcome);
                        }
                        else
                        // Args: Ref,purgeModuleInformation
                        // Since using addTypeInformation followed by learnErlang causes changes to the alphabet modules we are dealing with, independence of tests requires the collection of loaded modules to be purged. This is the purpose of this function.
                        if (command.equals(msgPurgeModuleInformation) && message.arity() >= 2)
                        {
                          OtpErlangObject outcome = null;
                          try
                          {
                            ErlangModule.flushRegistry();
                            outcome = new OtpErlangTuple(new OtpErlangObject[]{ref,msgOk});
                          }
                          catch(Throwable ex)
                          {
                            ex.printStackTrace();
                            outcome = new OtpErlangTuple(new OtpErlangObject[]{ref,msgFailure,new OtpErlangList(ex.getMessage())});
                          }
                          mbox.send(erlangPartner,outcome);
                        }
                        else
                        // Args: Ref,extractTypeInformation,moduleFileFullPath.
                        // Returns a list of pairs of method names and types.
                        if (command.equals(msgExtractTypeInformation) && message.arity() >= 3)
                        {
                          OtpErlangObject outcome = null;
                          try
                          {
                            ErlangModule.setupErlangConfiguration(learnerInitConfiguration.config, new File(((OtpErlangAtom)message.elementAt(2)).atomValue()));
                           
                            // we start a separate Erlang node to run the questions
                            ErlangRunner erlangRunner = ErlangRuntime.getDefaultRuntime().createNewRunner();
                            learnerInitConfiguration.config.setErlangMboxName(erlangRunner.getRunnerName());
                            final ErlangModule mod = ErlangModule.loadModule(learnerInitConfiguration.config);
                            outcome = new OtpErlangTuple(new OtpErlangObject[]{ref,msgOk,  typeMapToList(mod.sigTypes)});
                          }
                          catch(Throwable ex)
                          {
                            ex.printStackTrace();
                            outcome = new OtpErlangTuple(new OtpErlangObject[]{ref,msgFailure,new OtpErlangList(ex.getMessage())});
                          }
                          mbox.send(erlangPartner,outcome);
                        }
                        else
                        // Args: Ref,learnErlang,moduleFileFullPath, pid
                        // pid is optional, where provided, progress messages are reported in a form of {Ref,'status',step}
                        // in the course of learning, the learner is receptive to messages directed at its normal PID, a {Ref,terminate} command will kill it and the response will be {Ref,terminate}.
                        // Response: Ref,ok,fsm
                        // on error: Ref,failure,text_of_the_error (as string)
                        if (command.equals(msgLearnErlang) && message.arity() >= 3)
                        {
                          OtpErlangObject outcome = null;
                          try
                          {
                            ErlangModule.setupErlangConfiguration(learnerInitConfiguration.config, new File(((OtpErlangAtom)message.elementAt(2)).atomValue()));
                           
                            // we start a separate Erlang node to run the questions
                            ErlangRunner erlangRunner = ErlangRuntime.getDefaultRuntime().createNewRunner();
                            learnerInitConfiguration.config.setErlangMboxName(erlangRunner.getRunnerName());
                            final AtomicLong counter = new AtomicLong();
                            final ErlangModule mod = ErlangModule.loadModule(learnerInitConfiguration.config);
                            mod.rebuildSigs(learnerInitConfiguration.config, overrides);mod.behaviour.generateAlphabet(learnerInitConfiguration.config);
                           
                            ErlangOracleLearner learner = new ErlangOracleLearner(null, learnerInitConfiguration) {

                              @Override
                              public Stack<PairScore> ChooseStatePairs(LearnerGraph graph)
                              {
                                // check if we were asked to terminate
                                try {
                                  if (message.arity() > 3 && message.elementAt(3) instanceof OtpErlangPid)
                                    // send the notification if necessary
                                    sendProgress((OtpErlangPid)message.elementAt(3), ref, graph, mod, counter);

                                  OtpErlangObject messageReceived = mbox.receive(0);// do not wait, return null if anything received
                                  if (messageReceived != null && messageReceived instanceof OtpErlangTuple && ((OtpErlangTuple)messageReceived).arity() == 2)
                                  {
                                    OtpErlangTuple cmd = ((OtpErlangTuple)messageReceived);
                                    if (cmd.elementAt(0).equals(ref) && cmd.elementAt(1).equals(msgStop))
                                      throw new AskedToTerminateException();
                                  }
                                } catch (OtpErlangExit e) {
                                  Helper.throwUnchecked("node exited", e);
                                } catch (OtpErlangDecodeException e) {
                                  Helper.throwUnchecked("decode exception", e);
                                }
                               
                                // resume learning.
                                return super.ChooseStatePairs(graph);
                              }

                              @Override
                              public Pair<Integer, String> CheckWithEndUser(
                                  LearnerGraph model,
                                  List<Label> question,
                                  int expectedForNoRestart,
                                  List<Boolean> consistentFacts,
                                  PairScore pairBeingMerged,
                                  Object[] moreOptions) {
                                return super.CheckWithEndUser(model, question, expectedForNoRestart,consistentFacts, pairBeingMerged, moreOptions);
                              }
                             
                            };
                            if (learnerInitConfiguration.config.getAskQuestions()) // only generate initial traces if we are permited to ask questions.
                              learner.init(learner.GenerateInitialTraces(learnerInitConfiguration.config.getErlangInitialTraceLength()),0,0);
                            System.out.println("random trace generation complete");
                            LearnerGraph graphLearnt = learner.learnMachine(),
                                graphWithTrimmedLabels = new LearnerGraph(learnerInitConfiguration.config);
                           
                            if (learnerInitConfiguration.config.getErlangStripModuleNamesFromFunctionsInNonGenModules())
                              convertLabelsToStrings(graphLearnt,graphWithTrimmedLabels);
                            else
View Full Code Here

      {
        LearnerGraph outcomeOfKTailsLearner = new LearnerGraph(evaluationConfig);
        try
        {
          LearnerEvaluationConfiguration referenceLearnerEval = new LearnerEvaluationConfiguration(learnerEval.graph, learnerEval.testSet, evaluationConfig, learnerEval.ifthenSequences, learnerEval.labelDetails);
          outcomeOfKTailsLearner = new KTailsReferenceLearner(referenceLearnerEval,ptaCopy,true,1).learnMachine(new LinkedList<List<Label>>(),new LinkedList<List<Label>>());
          dataSample.ktailsLearner = estimateDifference(referenceGraph, outcomeOfKTailsLearner,testSet);
          dataSample.ktailsLearner.inconsistency = MarkovClassifier.computeInconsistency(outcomeOfKTailsLearner, m, checker,false);
        }
        catch(Cav2014.LearnerAbortedException ex)
        {// the exception is thrown because the learner failed to learn anything completely. Ignore it because the default score is zero assigned via zeroScore.
View Full Code Here

        {
          LearnerGraph outcomeOfKTailsLearner = new LearnerGraph(evaluationConfig);
          try
          {
            LearnerEvaluationConfiguration referenceLearnerEval = new LearnerEvaluationConfiguration(learnerEval.graph, learnerEval.testSet, evaluationConfig, learnerEval.ifthenSequences, learnerEval.labelDetails);
            outcomeOfKTailsLearner = new KTailsReferenceLearner(referenceLearnerEval,ptaCopy,true,1).learnMachine(new LinkedList<List<Label>>(),new LinkedList<List<Label>>());
            System.out.println("K-tails Reference");

            dataSample.ktailsLearner = estimateDifference(referenceGraph, outcomeOfKTailsLearner,testSet);
            dataSample.ktailsLearner.inconsistency = MarkovClassifier.computeInconsistency(outcomeOfKTailsLearner, m, checker,false);
          }
View Full Code Here

        {
          LearnerGraph outcomeOfKTailsLearner = new LearnerGraph(evaluationConfig);
          try
          {
            LearnerEvaluationConfiguration referenceLearnerEval = new LearnerEvaluationConfiguration(learnerEval.graph, learnerEval.testSet, evaluationConfig, learnerEval.ifthenSequences, learnerEval.labelDetails);
            outcomeOfKTailsLearner = new KTailsReferenceLearner(referenceLearnerEval,ptaCopy,true,1).learnMachine(new LinkedList<List<Label>>(),new LinkedList<List<Label>>());
            System.out.println("K-tails Reference K=1");

            dataSample.ktailsLearner = estimateDifference(trimmedReference, outcomeOfKTailsLearner,testSet);
            dataSample.ktailsLearner.inconsistency = MarkovClassifier.computeInconsistency(outcomeOfKTailsLearner, m, checker,false);
          }
View Full Code Here

                            for(List<Label> seq:sPlus)
                              pta.paths.augmentPTA(seq,true,false,null);
                            for(List<Label> seq:sMinus)
                              pta.paths.augmentPTA(seq,false,false,null);
                            pta.clearColours();
                            KTailsReferenceLearner learner = new KTailsReferenceLearner(learnerInitConfiguration,pta,true,1) {

                              @Override
                              public Stack<PairScore> ChooseStatePairs(LearnerGraph graph)
                              {
                                reportLearningProgress(graph,message,ref,counter);
                                // resume learning.
                                return super.ChooseStatePairs(graph);
                              }

                            };

                            if (learnerInitConfiguration.graph != null)
                            {
                              learnerInitConfiguration.graph.clearColours();learnerInitConfiguration.graph.getInit().setColour(JUConstants.RED);
                              LearnerGraph.copyGraphs(learnerInitConfiguration.graph,learner.getTentativeAutomaton());
                            }
                            LearnerGraph graphLearnt = learner.learnMachine(new LinkedList<List<Label>>(),new LinkedList<List<Label>>());
                            outcome = new OtpErlangTuple(new OtpErlangObject[]{ref,msgOk,  constructFSM(graphLearnt)});
                          }
                          catch(AskedToTerminateException e)
                          {
                            outcome = new OtpErlangTuple(new OtpErlangObject[]{ref,msgTerminate});
                          }
                          catch(Throwable ex)
                          {
                            ex.printStackTrace();
                            outcome = new OtpErlangTuple(new OtpErlangObject[]{ref,msgFailure,new OtpErlangList(ex.getMessage())});
                          }
                          mbox.send(erlangPartner,outcome);
                         
                        }
                        else
                        // Args: Ref,addTypeInformation,list of pairs containing method names and types.
                        if (command.equals(msgAddTypeInformation) && message.arity() >= 3)
                        {
                          OtpErlangObject outcome = null;
                          try
                          {
                            updateFrom((OtpErlangList)message.elementAt(2), overrides);
                            outcome = new OtpErlangTuple(new OtpErlangObject[]{ref,msgOk,  typeMapToList(overrides)});
                          }
                          catch(Throwable ex)
                          {
                            ex.printStackTrace();
                            outcome = new OtpErlangTuple(new OtpErlangObject[]{ref,msgFailure,new OtpErlangList(ex.getMessage())});
                          }
                          mbox.send(erlangPartner,outcome);
                        }
                        else
                        // Args: Ref,purgeModuleInformation
                        // Since using addTypeInformation followed by learnErlang causes changes to the alphabet modules we are dealing with, independence of tests requires the collection of loaded modules to be purged. This is the purpose of this function.
                        if (command.equals(msgPurgeModuleInformation) && message.arity() >= 2)
                        {
                          OtpErlangObject outcome = null;
                          try
                          {
                            ErlangModule.flushRegistry();
                            outcome = new OtpErlangTuple(new OtpErlangObject[]{ref,msgOk});
                          }
                          catch(Throwable ex)
                          {
                            ex.printStackTrace();
                            outcome = new OtpErlangTuple(new OtpErlangObject[]{ref,msgFailure,new OtpErlangList(ex.getMessage())});
                          }
                          mbox.send(erlangPartner,outcome);
                        }
                        else
                        // Args: Ref,extractTypeInformation,moduleFileFullPath.
                        // Returns a list of pairs of method names and types.
                        if (command.equals(msgExtractTypeInformation) && message.arity() >= 3)
                        {
                          OtpErlangObject outcome = null;
                          try
                          {
                            ErlangModule.setupErlangConfiguration(learnerInitConfiguration.config, new File(((OtpErlangAtom)message.elementAt(2)).atomValue()));
                           
                            // we start a separate Erlang node to run the questions
                            ErlangRunner erlangRunner = ErlangRuntime.getDefaultRuntime().createNewRunner();
                            learnerInitConfiguration.config.setErlangMboxName(erlangRunner.getRunnerName());
                            final ErlangModule mod = ErlangModule.loadModule(learnerInitConfiguration.config);
                            outcome = new OtpErlangTuple(new OtpErlangObject[]{ref,msgOk,  typeMapToList(mod.sigTypes)});
                          }
                          catch(Throwable ex)
                          {
                            ex.printStackTrace();
                            outcome = new OtpErlangTuple(new OtpErlangObject[]{ref,msgFailure,new OtpErlangList(ex.getMessage())});
                          }
                          mbox.send(erlangPartner,outcome);
                        }
                        else
                        // Args: Ref,learnErlang,moduleFileFullPath, pid
                        // pid is optional, where provided, progress messages are reported in a form of {Ref,'status',step}
                        // in the course of learning, the learner is receptive to messages directed at its normal PID, a {Ref,terminate} command will kill it and the response will be {Ref,terminate}.
                        // Response: Ref,ok,fsm
                        // on error: Ref,failure,text_of_the_error (as string)
                        if (command.equals(msgLearnErlang) && message.arity() >= 3)
                        {
                          OtpErlangObject outcome = null;
                          try
                          {
                            ErlangModule.setupErlangConfiguration(learnerInitConfiguration.config, new File(((OtpErlangAtom)message.elementAt(2)).atomValue()));
                           
                            // we start a separate Erlang node to run the questions
                            ErlangRunner erlangRunner = ErlangRuntime.getDefaultRuntime().createNewRunner();
                            learnerInitConfiguration.config.setErlangMboxName(erlangRunner.getRunnerName());
                            final AtomicLong counter = new AtomicLong();
                            final ErlangModule mod = ErlangModule.loadModule(learnerInitConfiguration.config);
                            mod.rebuildSigs(learnerInitConfiguration.config, overrides);mod.behaviour.generateAlphabet(learnerInitConfiguration.config);
                           
                            ErlangOracleLearner learner = new ErlangOracleLearner(null, learnerInitConfiguration) {

                              @Override
                              public Stack<PairScore> ChooseStatePairs(LearnerGraph graph)
                              {
                                // check if we were asked to terminate
                                try {
                                  if (message.arity() > 3 && message.elementAt(3) instanceof OtpErlangPid)
                                    // send the notification if necessary
                                    sendProgress((OtpErlangPid)message.elementAt(3), ref, graph, mod, counter);

                                  OtpErlangObject messageReceived = mbox.receive(0);// do not wait, return null if anything received
                                  if (messageReceived != null && messageReceived instanceof OtpErlangTuple && ((OtpErlangTuple)messageReceived).arity() == 2)
                                  {
                                    OtpErlangTuple cmd = ((OtpErlangTuple)messageReceived);
                                    if (cmd.elementAt(0).equals(ref) && cmd.elementAt(1).equals(msgStop))
                                      throw new AskedToTerminateException();
                                  }
                                } catch (OtpErlangExit e) {
                                  Helper.throwUnchecked("node exited", e);
                                } catch (OtpErlangDecodeException e) {
                                  Helper.throwUnchecked("decode exception", e);
                                }
                               
                                // resume learning.
                                return super.ChooseStatePairs(graph);
                              }

                              @Override
                              public Pair<Integer, String> CheckWithEndUser(
                                  LearnerGraph model,
                                  List<Label> question,
                                  int expectedForNoRestart,
                                  List<Boolean> consistentFacts,
                                  PairScore pairBeingMerged,
                                  Object[] moreOptions) {
                                return super.CheckWithEndUser(model, question, expectedForNoRestart,consistentFacts, pairBeingMerged, moreOptions);
                              }
                             
                            };
                            if (learnerInitConfiguration.config.getAskQuestions()) // only generate initial traces if we are permited to ask questions.
                              learner.init(learner.GenerateInitialTraces(learnerInitConfiguration.config.getErlangInitialTraceLength()),0,0);
                            System.out.println("random trace generation complete");
                            LearnerGraph graphLearnt = learner.learnMachine(),
                                graphWithTrimmedLabels = new LearnerGraph(learnerInitConfiguration.config);
                           
                            if (learnerInitConfiguration.config.getErlangStripModuleNamesFromFunctionsInNonGenModules())
                              convertLabelsToStrings(graphLearnt,graphWithTrimmedLabels);
                            else
View Full Code Here

    tool.loadConfig(args[0]);
    LearnerGraph pta = tool.getPTA();
   
    new MarkovClassifier(m, pta).updateMarkov(false);
    LearnerEvaluationConfiguration learnerEval = new LearnerEvaluationConfiguration(config);learnerEval.setLabelConverter(converter);
    LearnerMarkovPassive learnerOfPairs = new LearnerMarkovPassive(learnerEval,null,pta);learnerOfPairs.setMarkovModel(m);

    learnerOfPairs.setScoreComputationOverride(new RedPriorityOverBluePairSelectionRoutine(m));
    System.out.println("PTA states: "+pta.getStateNumber());
    System.out.println("Alphabet of "+pta.getCache().getAlphabet().size()+" : "+pta.getCache().getAlphabet());

    final Configuration deepCopy = pta.config.copy();deepCopy.setLearnerCloneGraph(true);
    LearnerGraph ptaCopy = new LearnerGraph(deepCopy);LearnerGraph.copyGraphs(pta, ptaCopy);
   
    LearnerGraph actualAutomaton = learnerOfPairs.learnMachine(new LinkedList<List<Label>>(),new LinkedList<List<Label>>());
    LearnerGraph edsm2Outcome = new EDSMReferenceLearner(learnerEval,ptaCopy,1).learnMachine(new LinkedList<List<Label>>(),new LinkedList<List<Label>>());
    System.out.println("Outcome states: "+edsm2Outcome.getStateNumber());
    Visualiser.updateFrame(actualAutomaton, edsm2Outcome);
    Visualiser.waitForKey();
   
View Full Code Here

    tool.loadConfig(args[0]);
    LearnerGraph pta = tool.getPTA();
   
    new MarkovClassifier(m, pta).updateMarkov(false);
    LearnerEvaluationConfiguration learnerEval = new LearnerEvaluationConfiguration(config);learnerEval.setLabelConverter(converter);
    LearnerMarkovPassive learnerOfPairs = new LearnerMarkovPassive(learnerEval,null,pta);learnerOfPairs.setMarkovModel(m);

    learnerOfPairs.setScoreComputationOverride(new RedPriorityOverBluePairSelectionRoutine(m));
    System.out.println("PTA states: "+pta.getStateNumber());
    System.out.println("Alphabet of "+pta.getCache().getAlphabet().size()+" : "+pta.getCache().getAlphabet());

    final Configuration deepCopy = pta.config.copy();deepCopy.setLearnerCloneGraph(true);
    LearnerGraph ptaCopy = new LearnerGraph(deepCopy);LearnerGraph.copyGraphs(pta, ptaCopy);
   
    LearnerGraph actualAutomaton = learnerOfPairs.learnMachine(new LinkedList<List<Label>>(),new LinkedList<List<Label>>());
    LearnerGraph edsm2Outcome = new EDSMReferenceLearner(learnerEval,ptaCopy,1).learnMachine(new LinkedList<List<Label>>(),new LinkedList<List<Label>>());
    System.out.println("Outcome states: "+edsm2Outcome.getStateNumber());
    Visualiser.updateFrame(actualAutomaton, edsm2Outcome);
    Visualiser.waitForKey();
   
View Full Code Here

      {
        int numberOfTasks = 0;
        for(int states=minStateNumber;states < minStateNumber+rangeOfStateNumbers;states+=stateNumberIncrement)
          for(int sample=0;sample<samplesPerFSM;++sample)
          {
            LearnerRunner learnerRunner = new LearnerRunner(states,sample,numberOfTasks,traceNum, config, converter);
            learnerRunner.setOnlyUsePositives(false);
            learnerRunner.setAlphabetMultiplier(alphabetMultiplierMax);
            learnerRunner.setTraceLengthMultiplier(traceLengthMultiplierMax);
            learnerRunner.setChunkLen(chunkSize);
            learnerRunner.setSelectionID(selection);
            learnerRunner.setPresetLearningParameters(presetForBestResults);
            runner.submit(learnerRunner);
            ++numberOfTasks;
          }
        ProgressIndicator progress = new ProgressIndicator(new Date()+" evaluating "+numberOfTasks+" tasks for "+selection+" trace num: "+traceNum, numberOfTasks);
        for(int count=0;count < numberOfTasks;++count)
View Full Code Here

TOP

Related Classes of statechum.analysis.learning.experiments.PairSelection.Cav2014$RedPriorityOverBluePairSelectionRoutine

Copyright © 2018 www.massapicom. All rights reserved.
All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.