Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package org.jruby.util.io;
  
  import org.jruby.Ruby;
  import org.jruby.RubyHash;
  
 public class EncodingOption {
     private Encoding externalEncoding;
     private Encoding internalEncoding;
     private boolean bom;
 
     public EncodingOption(Encoding externalEncodingEncoding internalEncodingboolean bom) {
         this. = externalEncoding;
         this. = internalEncoding;
         this. = bom;
     }
 
     public Encoding getExternalEncoding() {
         return ;
     }
 
     public Encoding getInternalEncoding() {
         return ;
     }
 
     public boolean hasBom() {
         return ;
     }
 
     // c: rb_io_extract_encoding_option
     public static EncodingOption getEncodingOptionFromObject(IRubyObject options) {
         if (options == null || options.isNil() || !(options instanceof RubyHash)) return null;
 
         RubyHash opts = (RubyHashoptions;
 
         Ruby runtime = options.getRuntime();
         IRubyObject encOption = opts.fastARef(runtime.newSymbol("encoding"));
         IRubyObject extOption = opts.fastARef(runtime.newSymbol("external_encoding"));
         IRubyObject intOption = opts.fastARef(runtime.newSymbol("internal_encoding"));
         if (encOption != null && !encOption.isNil()) {
             if (extOption != null) {
                 runtime.getWarnings().warn(
                         "Ignoring encoding parameter '" + encOption
                                 + "': external_encoding is used");
                 encOption = runtime.getNil();
             } else if (intOption != null) {
                 runtime.getWarnings().warn(
                         "Ignoring encoding parameter '" + encOption
                                 + "': internal_encoding is used");
                 encOption = runtime.getNil();
             } else {
                 IRubyObject tmp = encOption.checkStringType19();
                 if (!tmp.isNil()) {
                     return getEncodingOptionFromString(runtimetmp.convertToString().toString());
                 }
                 return createEncodingOption(runtimeruntime.getEncodingService()
                         .getEncodingFromObject(encOption), nullfalse);
             }
         }
         boolean set = false;
         Encoding extEncoding = null;
         Encoding intEncoding = null;
 
         if (extOption != null) {
             set = true;
             if (!extOption.isNil()) {
                 extEncoding = runtime.getEncodingService().getEncodingFromObject(extOption);
             }
         }
         if (intOption != null) {
             set = true;
             if (intOption.isNil()) {
                 // null;
             } else if (intOption.asString().toString().equals("-")) {
                 // null;
             } else {
                 intEncoding = runtime.getEncodingService().getEncodingFromObject(intOption);
             }
         }
         if (!set)
             return null;
 
         return createEncodingOption(runtimeextEncodingintEncodingfalse);
     }
 
     // c: rb_io_ext_int_to_encs
     private static EncodingOption createEncodingOption(Ruby runtimeEncoding extEncoding,
                                                        Encoding intEncodingboolean isBom) {
         boolean defaultExt = false;
         if (extEncoding == null) {
             extEncoding = runtime.getDefaultExternalEncoding();
             defaultExt = true;
         }
         if (intEncoding == null && extEncoding != .) {
             /* If external is ASCII-8BIT, no default transcoding */
             intEncoding = runtime.getDefaultInternalEncoding();
        }
        if (intEncoding == null || intEncoding == extEncoding) {
            /* No internal encoding => use external + no transcoding */
            // JRuby passes extEncoding instead of null for external, since we use this for final encoding of strings
            return new EncodingOption(
                    extEncoding,
                    (defaultExt && intEncoding != extEncoding) ? null : extEncoding,
                    isBom);
        } else {
            return new EncodingOption(
                    extEncoding,
                    intEncoding,
                    isBom);
        }
    }
    // c: parse_mode_enc
    public static EncodingOption getEncodingOptionFromString(Ruby runtimeString option) {
        EncodingService service = runtime.getEncodingService();
        Encoding ascii8bit = service.getAscii8bitEncoding();
        Encoding extEncoding = null;
        Encoding intEncoding = null;
        boolean isBom = false;
        String[] encs = option.split(":", 2);
        if (encs[0].toLowerCase().startsWith("bom|utf-")) {
            isBom = true;
            encs[0] = encs[0].substring(4);
        }
        extEncoding = service.getEncodingFromString(encs[0]);
        if (encs.length > 1) {
            if (encs[1].equals("-")) {
                // null;
            } else {
                intEncoding = service.getEncodingFromString(encs[1]);
            }
        }
        // Duplicating some rb_io_ext_int_to_encs logic here, which is also in RubyIO#setupReadWriteEncodings.
        if (extEncoding == null) {
            extEncoding = runtime.getDefaultExternalEncoding();
        }
        if (intEncoding == null && extEncoding != .) {
            intEncoding = runtime.getDefaultInternalEncoding();
        }
        return new EncodingOption(extEncodingintEncodingisBom);
    }
    // c: parse_mode_enc
    public static EncodingOption getEncodingNoOption(Ruby runtimeModeFlags modeFlags) {
        if (modeFlags.isBinary()) {
            return new EncodingOption(.nullfalse);
        }
        return new EncodingOption(nullnullfalse);
    }
    public String toString() {
        return "EncodingOption(int:" +  + ", ext:" +  + ", bom:" +  + ")";
    }
New to GrepCode? Check out our FAQ X