Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package org.jruby.ir.operands;
  
  import org.jruby.Ruby;
  import org.jruby.RubyHash;
 
 import java.util.List;
 import java.util.Map;
 
 // Represents a hash { _ =>_, _ => _ .. } in ruby
 //
 // NOTE: This operand is only used in the initial stages of optimization.
 // Further down the line, this hash could get converted to calls
 // that actually build the hash
 public class Hash extends Operand {
     final public List<KeyValuePairpairs;
 
     public Hash(List<KeyValuePairpairs) {
         this. = pairs;
     }
 
     public boolean isBlank() {
         return  == null || .isEmpty();
     }
 
     @Override
     public boolean hasKnownValue() {
         for (KeyValuePair pair : ) {
             if (!pair.getKey().hasKnownValue() || !pair.getValue().hasKnownValue())
                 return false;
         }
 
         return true;
     }
 
     @Override
     public Operand getSimplifiedOperand(Map<OperandOperandvalueMapboolean force) {
         List<KeyValuePairnewPairs = new java.util.ArrayList<KeyValuePair>();
         for (KeyValuePair pair : ) {
             newPairs.add(new KeyValuePair(pair.getKey().getSimplifiedOperand(valueMapforce), pair
                     .getValue().getSimplifiedOperand(valueMapforce)));
         }
 
         return new Hash(newPairs);
     }

    
Append the list of variables used in this operand to the input list
 
     @Override
     public void addUsedVariables(List<Variablel) {
         for (KeyValuePair pair : ) {
             pair.getKey().addUsedVariables(l);
             pair.getValue().addUsedVariables(l);
         }
     }
 
     @Override
     public Operand cloneForInlining(InlinerInfo ii) {
         if (hasKnownValue())
             return this;
 
         List<KeyValuePairnewPairs = new java.util.ArrayList<KeyValuePair>();
         for (KeyValuePair pair : ) {
             newPairs.add(new KeyValuePair(pair.getKey().cloneForInlining(ii), pair.getValue()
                     .cloneForInlining(ii)));
         }
         return new Hash(newPairs);
     }
 
     @Override
     public Object retrieve(ThreadContext contextIRubyObject selfDynamicScope currDynScope,
             Object[] temp) {
         Ruby runtime = context.runtime;
         RubyHash hash = RubyHash.newHash(runtime);
 
         for (KeyValuePair pair : ) {
             IRubyObject key = (IRubyObjectpair.getKey().retrieve(contextselfcurrDynScope,
                     temp);
             IRubyObject value = (IRubyObjectpair.getValue().retrieve(contextselfcurrDynScope,
                     temp);
 
             hash.fastASetCheckString(runtimekeyvalue);
         }
 
         return hash;
     }
 
     @Override
     public void visit(IRVisitor visitor) {
         visitor.Hash(this);
     }
 
     @Override
     public String toString() {
         StringBuilder builder = new StringBuilder();
         builder.append("{");
        if (!isBlank()) {
            int pairCount = .size();
            for (int i = 0; i < pairCounti++) {
                if (i > 0) {
                    builder.append(", ");
                }
                builder.append(.get(i));
            }
        }
        builder.append("}");
        return builder.toString();
    }
New to GrepCode? Check out our FAQ X