Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
     Copyright (c) 2013 zuendorf 
  
     Permission is hereby granted, free of charge, to any person obtaining a copy of this software 
     and associated documentation files (the "Software"), to deal in the Software without restriction, 
     including without limitation the rights to use, copy, modify, merge, publish, distribute, 
     sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is 
     furnished to do so, subject to the following conditions: 
  
    The above copyright notice and this permission notice shall be included in all copies or 
    substantial portions of the Software. 
 
    The Software shall be used for Good, not Evil. 
 
    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING 
    BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 
    NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
    DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 
  */
 
 package org.sdmlib.models.pattern;
 
 
 
 
 public class ReachabilityGraph implements PropertyChangeInterface
 {
    //==========================================================================
    private final class OmitRootCondition extends ConditionMap
    {
       private Object root;
 
       public OmitRootCondition(Object root)
       {
          this. = root;
       }
 
       @Override
       public boolean check(ValuesMap values)
       {
          return values.value != ;
       }
    }
 
    public String dumpDiagram(String name)
    {
       OmitRootCondition conditionMap = new OmitRootCondition(this);
 
       Filter filter = new Filter().withFull(true).withPropertyRegard(conditionMap);
       
       JsonArray jsonArray = .toJsonArray(thisfilter);
       
       String imgLink = getAdapter().toImg(namejsonArray);
       
       // also add images for all graph roots
       for (Object graphRoot : getStates().getGraphRoot())
       {
          JsonArray graphRootArray = .toJsonArray(graphRoot);
          
          String rootId = .getId(graphRoot);
          
          String imgName = name + "/" + rootId;
          
          String subLink = getAdapter().toImg(imgNamegraphRootArray);
       }
               
       return imgLink;
    }
    private GuiAdapter adapter;
    
    public GuiAdapter getAdapter(){
 	   if(==null){
 		    = GraphFactory.getAdapter();
 	   }
 	   return ;
    }
 
    //==========================================================================
 
   protected PropertyChangeSupport listeners = new PropertyChangeSupport(this);
   {
      return ;
   }
   //==========================================================================
   public void removeYou()
   {
      removeAllFromStates();
      removeAllFromTodo();
      removeAllFromRules();
      withoutStates(this.getStates().toArray(new ReachableState[this.getStates().size()]));
      withoutTodo(this.getTodo().toArray(new ReachableState[this.getTodo().size()]));
      withoutRules(this.getRules().toArray(new Pattern[this.getRules().size()]));
      getPropertyChangeSupport().firePropertyChange("REMOVE_YOU"thisnull);
   }


   
              one                       many
 ReachabilityGraph ----------------------------------- ReachableState
              parent                   states
 
   public static final String PROPERTY_STATES = "states";
   private TreeMap<StringObjectstateMap = new TreeMap<StringObject>();
   public ReachabilityGraph withStateMap(String certificateReachableState newState)
   {
      Object oldEntry = .get(certificate);
      
      if (oldEntry == null)
      {
         .put(certificatenewState);
      }
      else if (oldEntry instanceof ReachableState && oldEntry != newState)
      {
         ReachableStateSet newStateSet = new ReachableStateSet()
         .with((ReachableStateoldEntry).with(newState);
         .put(certificatenewStateSet);
      }
      else
      {
         ReachableStateSet oldStateSet = (ReachableStateSetoldEntry;
         oldStateSet.with(newState);
      }
      
      return this;
   }
   
   private static ReachableStateSet emptyStatesSet = new ReachableStateSet();
   
   public ReachableStateSet getStateMap(String certificate)
   {
      Object oldEntry = .get(certificate);
      
      if (oldEntry == null)
      {
         return ;
      }
      else if (oldEntry instanceof ReachableState)
      {
         .clear();
         .add((ReachableStateoldEntry);
         return ;
      }
      else
      {
         return (ReachableStateSetoldEntry;
      }
   }
   
   private ReachableStateSet states = null;
   
   {
      if (this. == null)
      {
         return .;
      }
      return this.;
   }
   public boolean addToStates(ReachableState value)
   {
      boolean changed = false;
      if (value != null)
      {
         if (this. == null)
         {
            this. = new ReachableStateSet();
         }
         changed = this..add (value);
         if (changed)
         {
            value.withParent(this);
            getPropertyChangeSupport().firePropertyChange(nullvalue);
         }
      }
      return changed;   
   }
   public boolean removeFromStates(ReachableState value)
   {
      boolean changed = false;
      
      if ((this. != null) && (value != null))
      {
         changed = this..remove(value);
         
         if (changed)
         {
            value.setParent(null);
            getPropertyChangeSupport().firePropertyChange(valuenull);
         }
      }
         
      return changed;   
   }
   {
      addToStates(value);
      return this;
   } 
   {
      removeFromStates(value);
      return this;
   } 
   public void removeAllFromStates()
   {
      LinkedHashSet<ReachableStatetmpSet = new LinkedHashSet<ReachableState>(this.getStates());
      for (ReachableState value : tmpSet)
      {
         this.removeFromStates(value);
      }
   }
   {
      ReachableState value = new ReachableState();
      withStates(value);
      return value;
   } 


   
              one                       many
 ReachabilityGraph ----------------------------------- ReachableState
              master                   todo
 
   public static final String PROPERTY_TODO = "todo";
   private ReachableStateSet todo = null;
   public ReachableStateSet getTodo()
   {
      if (this. == null)
      {
         return .;
      }
      return this.;
   }
   public boolean addToTodo(ReachableState value)
   {
      boolean changed = false;
      if (value != null)
      {
         if (this. == null)
         {
            this. = new ReachableStateSet();
         }
         changed = this..add (value);
         if (changed)
         {
            value.withMaster(this);
            getPropertyChangeSupport().firePropertyChange(nullvalue);
         }
      }
      return changed;   
   }
   public boolean removeFromTodo(ReachableState value)
   {
      boolean changed = false;
      
      if ((this. != null) && (value != null))
      {
         changed = this..remove(value);
         
         if (changed)
         {
            value.setMaster(null);
            getPropertyChangeSupport().firePropertyChange(valuenull);
         }
      }
         
      return changed;   
   }
   {
      addToTodo(value);
      return this;
   } 
   {
      removeFromTodo(value);
      return this;
   } 
   public void removeAllFromTodo()
   {
      LinkedHashSet<ReachableStatetmpSet = new LinkedHashSet<ReachableState>(this.getTodo());
      for (ReachableState value : tmpSet)
      {
         this.removeFromTodo(value);
      }
   }
   public ReachableState createTodo()
   {
      ReachableState value = new ReachableState();
      withTodo(value);
      return value;
   } 


   
              one                       many
 ReachabilityGraph ----------------------------------- Pattern
              rgraph                   rules
 
   public static final String PROPERTY_RULES = "rules";
   private PatternSet rules = null;
   public PatternSet getRules()
   {
      if (this. == null)
      {
         return .;
      }
      return this.;
   }
   public boolean addToRules(Pattern value)
   {
      boolean changed = false;
      if (value != null)
      {
         if (this. == null)
         {
            this. = new PatternSet();
         }
         changed = this..add (value);
         if (changed)
         {
            value.withRgraph(this);
            getPropertyChangeSupport().firePropertyChange(nullvalue);
         }
      }
      return changed;   
   }
   public boolean removeFromRules(Pattern value)
   {
      boolean changed = false;
      
      if ((this. != null) && (value != null))
      {
         changed = this..remove(value);
         
         if (changed)
         {
            value.setRgraph(null);
            getPropertyChangeSupport().firePropertyChange(valuenull);
         }
      }
         
      return changed;   
   }
   public ReachabilityGraph withRules(Pattern value)
   {
      addToRules(value);
      return this;
   } 
   {
      removeFromRules(value);
      return this;
   } 
   public void removeAllFromRules()
   {
      LinkedHashSet<PatterntmpSet = new LinkedHashSet<Pattern>(this.getRules());
      for (Pattern value : tmpSet)
      {
         this.removeFromRules(value);
      }
   }
   public Pattern createRules()
   {
      Pattern value = new Pattern();
      withRules(value);
      return value;
   }
   public long explore()
   {
      return explore(.);
   }
   private long noOfNewStates;
   public long explore(long maxNoOfNewStates)
   {
      long currentStateNum = 1;
      
      // add cloneOps to rules, where missing
      
      // all states without successors become todo states
      
      // take a todo state and apply all rules at all places until maxNoOfNewStates 
      // is reached
       = 0;
      while (!getTodo().isEmpty() &&  < maxNoOfNewStates)
      {
         ReachableState first = getTodo().first();
         
         first.withNumber((intcurrentStateNum);
         
         currentStateNum++;
         this.withoutTodo(first);
         for (Pattern rule : getRules())
         {
            PatternObject firstPO = (PatternObjectrule.getElements().first();
            rule.resetSearch();
            ((PatternObjectfirstPO.withModifier(.)).setCurrentMatch(first.getGraphRoot());
            while (rule.findMatch())
            {
               // for each match get the new reachable state and add it to the reachability graph
               Object newGraphRoot = firstPO.getCurrentMatch();
               
               ReachableState newReachableState = new ReachableState().withGraphRoot(newGraphRoot);
               // is the new graph already known?
               JsonIdMap newJsonIdMap = (JsonIdMapnew JsonIdMap().withCreator(rule.getJsonIdMap());
               newJsonIdMap.withSessionId("s");
               String newCertificate = newReachableState.computeCertificate(newJsonIdMap);
               
               ReachableStateSet candidateStates = this.getStateMap(newCertificate);
               
               LinkedHashMap<StringStringmatch = null;
               
               forReachableState oldState : candidateStates)
               {
                  match = match(oldStatenewReachableState);
                  
                  if (match != null)
                  {
                     // newReachableState is isomorphic to oldState. Just add a link from first to oldState
                     first.createRuleapplications().withDescription("" + rule.getName()).withTgt(oldState);
                     break;
                  }
               }
               
               if (match == null)
               {
                  // no isomorphic old state, add new state
                  this.withStates(newReachableState).withTodo(newReachableState).withStateMap(newCertificatenewReachableState);
                  first.createRuleapplications().withDescription("" + rule.getName()).withTgt(newReachableState);
               }
               
            }
         }
      }
      
      return currentStateNum;
   }
   {
      
      JsonIdMap map1 = (JsonIdMapnew JsonIdMap().withCreator();
      JsonIdMap map2 = (JsonIdMapnew JsonIdMap().withCreator();
      
      map1.withSessionId("s");
      map2.withSessionId("s");
      LinkedHashMap<StringStringfwdmapping = new LinkedHashMap<StringString>();
      LinkedHashMap<StringStringbwdmapping = new LinkedHashMap<StringString>();
      String key1 = map1.getId(s1.getGraphRoot());
      String key2 = map2.getId(s2.getGraphRoot());
      
      fwdmapping.put(key1key2);
      bwdmapping.put(key2key1);
      JsonArray ja1 = map1.toJsonArray(s1.getGraphRoot());
      JsonArray ja2 = map2.toJsonArray(s2.getGraphRoot());
      LinkedHashMap<StringJsonObjectjoMap1 = null;
      LinkedHashMap<StringJsonObjectjoMap2 = null;
      
      joMap1 = new LinkedHashMap<StringJsonObject>();
      for (Object object : ja1)
      {
         JsonObject jo = (JsonObjectobject;
         String key = jo.getString(.);
         joMap1.put(keyjo);
      }
      joMap2 = new LinkedHashMap<StringJsonObject>();
      for (Object object : ja2)
      {
         JsonObject jo = (JsonObjectobject;
         String key = jo.getString(.);
         joMap2.put(keyjo);
      }
      boolean match = match(s1ja1joMap1s2ja2joMap2key1fwdmappingbwdmapping);
      return match ? fwdmapping : null;
   }
   
   public boolean match(ReachableState s1JsonArray ja1LinkedHashMap<StringJsonObjectjoMap1
         ReachableState s2JsonArray ja2LinkedHashMap<StringJsonObjectjoMap2,
         String cn1LinkedHashMap<StringStringfwdmappingLinkedHashMap<StringStringbwdmapping)
   {
      String cn2 = fwdmapping.get(cn1);
      // a mapping for currentNode has just been added. Validate it and compute mappings for neighbors
      JsonObject currentJo1 = joMap1.get(cn1);
      JsonObject currentJo2 = joMap2.get(cn2);
      // certificates are equal, only check refs
      // go through properties
      JsonObject currentProps1 = currentJo1.getJsonObject(.);
      JsonObject currentProps2 = currentJo2.getJsonObject(.);
      for (Iterator<Stringiter = currentProps1.keyIterator(); iter.hasNext();)
      {
         String key = iter.next();
         Object value = currentProps1.get(key);
         if (value instanceof JsonObject)
         {
            JsonObject ref = (JsonObjectvalue;
            String tgt1 = ref.getString(.);
            String tgt2 = currentProps2.getJsonObject(key).getString(.);
            String mappingOfTgt1 = fwdmapping.get(tgt1);
            if (mappingOfTgt1 != null)
            {
               // already mapped. consistent?
                     if ( ! tgt2.equals(mappingOfTgt1))
                     {
                        // inconsistent mapping 
                        return false;
                     }
            }
            else
            {
               // not yet mapped, thus add mapping and check it.
               fwdmapping.put(tgt1tgt2);
               bwdmapping.put(tgt2tgt1);
               boolean match = match(s1ja1joMap1s2ja2joMap2tgt1fwdmappingbwdmapping);
               if ( ! match )
               {
                  // did not work
                  fwdmapping.remove(tgt1);
                  bwdmapping.remove(tgt2);
               }
            }
         }
         else if (value instanceof JsonArray)
         {
            // many refs loop through them, match each
            obj1RefLoop: for (Object object : (JsonArrayvalue)
            {
               JsonObject ref = (JsonObjectobject;
               String tgt1 = ref.getString(.);
               // might already have been matched
               String tgt1Map = fwdmapping.get(tgt1);
               if (tgt1Map != null)
               {
                  // consistent? 
                  for (Object o : currentProps2.getJsonArray(key))
                  {
                     ref = (JsonObjecto;
                     String tgt2 = ref.getString(.);
                     if (tgt2.equals(tgt1Map))
                     {
                        continue obj1RefLoop; // <==================== this ref has a match, handle next ref in outer loop
                     }
                  }
                  // inconsistent
                  return false// <========================== did not work out
               }
               // loop through the  refs of the other object
               for (Object o : currentProps2.getJsonArray(key))
               {
                  ref = (JsonObjecto;
                  String tgt2 = ref.getString(.);
                  // already used for other match?
                  if (bwdmapping.get(tgt2) != null )
                  {
                     continue// <=========================== this one is not a match candidate, try another
                  }
                  // does the certificate match? 
                  String cert1 = s1.getNode2certificates().get(tgt1);
                  String cert2 = s2.getNode2certificates().get(tgt2);
                  if (cert1.equals(cert2))
                  {
                     // might be a candidate, match it
                     fwdmapping.put(tgt1tgt2);
                     bwdmapping.put(tgt2tgt1);
                     boolean match = match(s1ja1joMap1s2ja2joMap2tgt1fwdmappingbwdmapping);
                     if ( ! match )
                     {
                        // did not work
                        fwdmapping.remove(tgt1);
                        bwdmapping.remove(tgt2);
                     }
                     else
                     {
                        continue obj1RefLoop; // <==================== this ref has a match, handle next ref in outer loop
                     }
                  }
               }
               // did not find a match for current ref
               return false;
            }
         }
      }
      return true;
   }
   private JsonIdMap masterMap = null;
   
   public JsonIdMap getMasterMap()
   {
      return ;
   }
   
   public void setMasterMap(JsonIdMap newMasterMap)
   {
       = newMasterMap;
   }
   
   {
      setMasterMap(map);
      
      return this;
   } 
   {
      if(value==null){
         return this;
      }
      for (ReachableState item : value)
      {
         addToStates(item);
      }
      return this;
   }
   {
      for (ReachableState item : value)
      {
         removeFromStates(item);
      }
      return this;
   }
   public ReachabilityGraph withTodo(ReachableState... value)
   {
      if(value==null){
         return this;
      }
      for (ReachableState item : value)
      {
         addToTodo(item);
      }
      return this;
   }
   {
      for (ReachableState item : value)
      {
         removeFromTodo(item);
      }
      return this;
   }
   public ReachabilityGraph withRules(Pattern... value)
   {
      if(value==null){
         return this;
      }
      for (Pattern item : value)
      {
         addToRules(item);
      }
      return this;
   }
   public ReachabilityGraph withoutRules(Pattern... value)
   {
      for (Pattern item : value)
      {
         removeFromRules(item);
      }
      return this;
   }
   {
      Pattern value = new NegativeApplicationCondition();
      withRules(value);
      return value;
   } 
   {
      Pattern value = new OptionalSubPattern();
      withRules(value);
      return value;
   } 
   {
      withRules(value);
      return value;
   } 
   {
      OptionalSubPattern value = new OptionalSubPattern();
      withRules(value);
      return value;
   } 
New to GrepCode? Check out our FAQ X