Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * To change this template, choose Tools | Templates
   * and open the template in the editor.
   */
  
  package org.jruby.util;
  
 import org.jruby.Ruby;
 
 public class RegexpOptions implements Cloneable {
     private static ByteList WINDOWS31J = new ByteList(new byte[] {'W''i''n''d''o''w''s''-''3''1''J'});    
     public static final RegexpOptions NULL_OPTIONS = new RegexpOptions(.true);
     
     public RegexpOptions() {
         this(.true);
     }
     
     public RegexpOptions(KCode kcodeboolean isKCodeDefault) {
         this. = kcode;
         this. = isKCodeDefault;
         
         assert kcode != null : "kcode must always be set to something";
     }
 
     public boolean isExtended() {
         return ;
     }
 
     public void setExtended(boolean extended) {
         this. = extended;
     }
 
     public boolean isIgnorecase() {
         return ;
     }
 
     public void setIgnorecase(boolean ignorecase) {
         this. = ignorecase;
     }
 
     public boolean isFixed() {
         return ;
     }
 
     public void setFixed(boolean fixed) {
         this. = fixed;
     }
 
     public KCode getKCode() {
         return ;
     }
     
     public String getKCodeName() {
         return isKcodeDefault() ? null : getKCode().name().toLowerCase();
     }    

    
This regexp has an explicit encoding flag or 'nesu' letter associated with it.

Parameters:
kcode to be set
 
     public void setExplicitKCode(KCode kcode) {
         this. = kcode;
          = false;
     }
     
     private KCode getExplicitKCode() {
         if ( == truereturn null;
         
         return ;
     }

    
Whether the kcode associated with this regexp is implicit (aka default) or is specified explicitly (via 'nesu' syntax postscript or flags to Regexp.new.
 
     public boolean isKcodeDefault() {
         return ;
     }
 
     public boolean isMultiline() {
         return ;
     }
 
     public void setMultiline(boolean multiline) {
         this. = multiline;
     }
 
     public boolean isOnce() {
         return ;
     }
 
    public void setOnce(boolean once) {
        this. = once;
    }
    public boolean isJava() {
        return ;
    }
    public void setJava(boolean java) {
        this. = java;
    }
    public boolean isEncodingNone() {
        return ;
    }
    public void setEncodingNone(boolean encodingNone) {
        this. = encodingNone;
    }
    public boolean isLiteral() {
        return ;
    }
    public void setLiteral(boolean literal) {
        this. = literal;
    }
    public boolean isEmbeddable() {
        return  &&  && ;
    }
    
    
    
Calculate the encoding based on kcode option set via 'nesu'. Also as side-effects: 1.set whether this marks the soon to be made regexp as 'fixed'. 2.kcode.none will set 'none' option

Returns:
null if no explicit encoding is specified.
    public Encoding setup19(Ruby runtime) {
        KCode explicitKCode = getExplicitKCode();
        
        // None will not set fixed
        if (explicitKCode == .) {
            setEncodingNone(true);
            return .;
        }
        
        if (explicitKCode == .) {
            setFixed(true);
            return .;
        } else if (explicitKCode == .) {
            setFixed(true);
            return runtime.getEncodingService().loadEncoding();
        } else if (explicitKCode == .) {
            setFixed(true);
            return .;
        }
        
        return null;
    }
    
    
This int value can be used by compiler or any place where we want an integer representation of the state of this object.
    public int toEmbeddedOptions() {
        int options = toJoniOptions();
        if (options |= .;
        if (options |= .;
        if (options |= .;
        if (options |= .;
        return options;
    }

    
This int value is meant to only be used when dealing directly with the joni regular expression library. It differs from embeddedOptions in that it only contains bit values which Joni cares about.
    public int toJoniOptions() {
        int options = 0;
        // Note: once is not an option that is pertinent to Joni so we exclude it.
        if (options |= .;
        if (options |= .;
        if (options |= .;
        if (!isKcodeDefault()) options |= .bits();
        return options;
    }
    
    public static RegexpOptions fromEmbeddedOptions(int embeddedOptions) {
        RegexpOptions options = fromJoniOptions(embeddedOptions);
        options.kcodeDefault = (embeddedOptions & .) != 0;        
        options.setOnce((embeddedOptions & .) != 0);
        options.setLiteral((embeddedOptions & .) != 0);
        options.setFixed((embeddedOptions & .) != 0);        
        
        return options;
    }
    public static RegexpOptions fromJoniOptions(int joniOptions) {
        KCode kcode = KCode.fromBits(joniOptions);
        RegexpOptions options = new RegexpOptions(kcodekcode == .);
        options.setMultiline((joniOptions & .) != 0);
        options.setIgnorecase((joniOptions & .) != 0);
        options.setExtended((joniOptions & .) != 0);
        options.setOnce((joniOptions & .) != 0);
        return options;
    }
    public RegexpOptions withoutOnce() {
        RegexpOptions options = (RegexpOptions)clone();
        options.setOnce(false);
        return options;
    }
    @Override
    public int hashCode() {
        int hash = 7;
        hash = 11 * hash + (this. != null ? this..hashCode() : 0);
        hash = 11 * hash + (this. ? 1 : 0);
        hash = 11 * hash + (this. ? 1 : 0);
        hash = 11 * hash + (this. ? 1 : 0);
        hash = 11 * hash + (this. ? 1 : 0);
        hash = 11 * hash + (this. ? 1 : 0);
        hash = 11 * hash + (this. ? 1 : 0);
        hash = 11 * hash + (this. ? 1 : 0);
        hash = 11 * hash + (this. ? 1 : 0);
        hash = 11 * hash + (this. ? 1 : 0);
        return hash;
    }
    @Override
    public Object clone() {
        try {
            return super.clone();
        } catch (CloneNotSupportedException cnse) {throw new RuntimeException(cnse);}
    }
    @Override
    public boolean equals(Object other) {
        if (!(other instanceof RegexpOptions)) return false;
        // Note: literal and once can be different in this object but for the
        // sake of equality we ignore those two fields since those flags do
        // not affect Ruby equality.
        RegexpOptions o = (RegexpOptions)other;
        return o.encodingNone ==  &&
               o.extended ==  &&
               o.fixed ==  &&
               o.ignorecase ==  &&
               o.java ==  &&
               o.kcode ==  &&
               o.kcodeDefault ==  &&
               o.multiline == 
    }
    
    @Override
    public String toString() {
        return "RegexpOptions(kcode: " +  + 
                ( == true ? ", encodingNone" : "") +
                ( == true ? ", extended" : "") +
                ( == true ? ", fixed" : "") +
                ( == true ? ", ignorecase" : "") +
                ( == true ? ", java" : "") +
                ( == true ? ", kcodeDefault" : "") +
                ( == true ? ", literal" : "") +
                ( == true ? ", multiline" : "") +
                ( == true ? ", once" : "") +                
                ")";
    }
    
    private KCode kcode;
    private boolean fixed;
    private boolean once;
    private boolean extended;
    private boolean multiline;
    private boolean ignorecase;
    private boolean java;
    private boolean encodingNone;
    private boolean kcodeDefault;
    private boolean literal;
New to GrepCode? Check out our FAQ X