encodeTo(FlEncoder) is internal method. Please don't use this method.
962806
@Override
    public void encodeTo(FLEncoder enc) {
        final Encoder encoder = new Encoder(enc);
        internalArray.encodeTo(encoder);
        encoder.release();
    }
2966
def encode(self):
        

        match_id = self.match_id
        if match_id is None:
            match_id = (1 << 11) - 1

        return (self.match_type << 12) | DataStreamSelector.SpecifierEncodings[self.match_spec] | match_id
1081781
def decode(self, encoder):
        
        self.matrix = [
            encoder.inverse_transform(row)
            for row in self.matrix
        ]
445403
public void encode(DerOutputStream out) throws IOException {
        DerValue derValue = new DerValue(nameValue);
        out.putDerValue(derValue);
    }
971271
function TextEncoder(label, options) {
    // Web IDL conventions
    if (!(this instanceof TextEncoder))
      throw TypeError('Called as a function. Did you forget \'new\'?');
    options = ToDictionary(options);

    // A TextEncoder object has an associated encoding and encoder.

    /** @private */
    this._encoding = null;
    /** @private @type {?Encoder} */
    this._encoder = null;

    // Non-standard
    /** @private @type {boolean} */
    this._do_not_flush = false;
    /** @private @type {string} */
    this._fatal = Boolean(options['fatal']) ? 'fatal' : 'replacement';

    // 1. Let enc be a new TextEncoder object.
    var enc = this;

    // 2. Set enc's encoding to UTF-8's encoder.
    if (Boolean(options['NONSTANDARD_allowLegacyEncoding'])) {
      // NONSTANDARD behavior.
      label = label !== undefined ? String(label) : DEFAULT_ENCODING;
      var encoding = getEncoding(label);
      if (encoding === null || encoding.name === 'replacement')
        throw RangeError('Unknown encoding: ' + label);
      if (!encoders[encoding.name]) {
        throw Error('Encoder not present.' +
                    ' Did you forget to include encoding-indexes.js?');
      }
      enc._encoding = encoding;
    } else {
      // Standard behavior.
      enc._encoding = getEncoding('utf-8');

      if (label !== undefined && 'console' in global) {
        console.warn('TextEncoder constructor called with encoding label, '
                     + 'which is ignored.');
      }
    }

    // For pre-ES5 runtimes:
    if (!Object.defineProperty)
      this.encoding = enc._encoding.name.toLowerCase();

    // 3. Return enc.
    return enc;
  }
228042
function isEncoded (bufOrString) {
  if (Buffer.isBuffer(bufOrString)) {
    bufOrString = bufOrString.toString()
  }

  // Ensure bufOrString is a string
  if (Object.prototype.toString.call(bufOrString) !== '[object String]') {
    return false
  }

  const code = bufOrString.substring(0, 1)
  try {
    const base = getBase(code)
    return base.name
  } catch (err) {
    return false
  }
}
866321
private void encodeNonRecursive(final LNGVector<Literal> literals) {
    if (literals.size() > 1)
      for (int i = 0; i < literals.size(); i++)
        for (int j = i + 1; j < literals.size(); j++)
          this.result.addClause(literals.get(i).negate(), literals.get(j).negate());
  }
68108
private void encodeEnum(GeneratorAdapter mg, TypeToken<?> outputType,
                          int value, int encoder, int schemaLocal) {

    // encoder.writeInt(this.schema.getEnumIndex(value.name()));
    mg.loadArg(encoder);
    mg.loadArg(schemaLocal);
    mg.loadArg(value);
    mg.invokeVirtual(Type.getType(outputType.getRawType()), getMethod(String.class, "name"));
    mg.invokeVirtual(Type.getType(Schema.class), getMethod(int.class, "getEnumIndex", String.class));
    mg.invokeInterface(Type.getType(Encoder.class), getMethod(Encoder.class, "writeInt", int.class));
    mg.pop();
  }
417641
private void disposeEncoder(IoSession session) {
        ProtocolEncoder encoder = (ProtocolEncoder) session
                .removeAttribute(ENCODER);
        if (encoder == null) {
            return;
        }

        try {
            encoder.dispose(session);
        } catch (Throwable t) {
            LOGGER.warn(
                    "Failed to dispose: " + encoder.getClass().getName() + " (" + encoder + ')');
        }
    }
909263
@SuppressWarnings({ "unchecked", "rawtypes" })
	protected void encode(BsonWriter writer, Collection<?> coll, EncoderContext encoderContext) {
		writer.writeStartArray();
		Iterator<?> iterator = coll.iterator();
		while(iterator.hasNext()) {
			Object next = iterator.next();
			if (next == null) {
				writer.writeNull();
			} else {
				Codec codec = registry.get(next.getClass());
				encoderContext.encodeWithChildContext(codec, writer, next);
			}
		}
		writer.writeEndArray();
	}
1255861
private void encodeStringLiteral(ByteBuf out, CharSequence string) {
        int huffmanLength = hpackHuffmanEncoder.getEncodedLength(string);
        if (huffmanLength < string.length()) {
            encodeInteger(out, 0x80, 7, huffmanLength);
            hpackHuffmanEncoder.encode(out, string);
        } else {
            encodeInteger(out, 0x00, 7, string.length());
            if (string instanceof AsciiString) {
                // Fast-path
                AsciiString asciiString = (AsciiString) string;
                out.writeBytes(asciiString.array(), asciiString.arrayOffset(), asciiString.length());
            } else {
                // Only ASCII is allowed in http2 headers, so its fine to use this.
                // https://tools.ietf.org/html/rfc7540#section-8.1.2
                out.writeCharSequence(string, CharsetUtil.ISO_8859_1);
            }
        }
    }
1281517
public static long encodeLo(long encoded, int lo) {
        long h = (encoded >> 32) & 0xFFFF_FFFFL;
        long l = ((long) lo) & 0xFFFF_FFFFL;
        return (h << 32) + l;
    }
1368737
public static void encodeSingle(final byte[] input, final int inoff,
                                    final byte[] output, final int outoff) {

        if (input == null) {
            throw new NullPointerException("input");
        }

        if (inoff < 0) {
            throw new IllegalArgumentException("inoff(" + inoff + ") < 0");
        }

        if (inoff >= input.length) {
            throw new IllegalArgumentException(
                "inoff(" + inoff + ") >= input.length(" + input.length + ")");
        }

        encodeSingle(input[inoff], output, outoff);
    }
265428
def encode(self, o, depth=0):
        
        if isinstance(o, OrderedDict):
            return "{" + ",\n ".join([self.encode(k) + ":" +
                                      self.encode(v, depth + 1)
                                      for (k, v) in o.items()]) + "}\n"
        else:
            return simplejson.JSONEncoder.encode(self, o)
805133
function encodeString(string) {
	//it actually accepts any kind of object as input
	if (string === null) {
		return values.NULL;
	} else if (string === "") {
		return values.EMPTY;
	} else {//0 false undefined NaN will pass from here
		return encodeURIComponent(string)
		.replace(/%20/g, "+");
	}
}
468051
def dumps(o, encoder=None):
    

    retval = ""
    if encoder is None:
        encoder = TomlEncoder(o.__class__)
    addtoretval, sections = encoder.dump_sections(o, "")
    retval += addtoretval
    outer_objs = [id(o)]
    while sections:
        section_ids = [id(section) for section in sections]
        for outer_obj in outer_objs:
            if outer_obj in section_ids:
                raise ValueError("Circular reference detected")
        outer_objs += section_ids
        newsections = encoder.get_empty_table()
        for section in sections:
            addtoretval, addtosections = encoder.dump_sections(
                sections[section], section)

            if addtoretval or (not addtoretval and not addtosections):
                if retval and retval[-2:] != "\n\n":
                    retval += "\n"
                retval += "[" + section + "]\n"
                if addtoretval:
                    retval += addtoretval
            for s in addtosections:
                newsections[section + "." + s] = addtosections[s]
        sections = newsections
    return retval
463128
public final CachedData encode(Object o) {
    byte[] b = null;
    int flags = 0;
    if (o instanceof String) {
      b = encodeString((String) o);
    } else if (o instanceof Long) {
      if (this.primitiveAsString) {
        b = encodeString(o.toString());
      } else {
        b = this.transcoderUtils.encodeLong((Long) o);
      }
      flags |= SPECIAL_LONG;
    } else if (o instanceof Integer) {
      if (this.primitiveAsString) {
        b = encodeString(o.toString());
      } else {
        b = this.transcoderUtils.encodeInt((Integer) o);
      }
      flags |= SPECIAL_INT;
    } else if (o instanceof Boolean) {
      if (this.primitiveAsString) {
        b = encodeString(o.toString());
      } else {
        b = this.transcoderUtils.encodeBoolean((Boolean) o);
      }
      flags |= SPECIAL_BOOLEAN;
    } else if (o instanceof Date) {
      b = this.transcoderUtils.encodeLong(((Date) o).getTime());
      flags |= SPECIAL_DATE;
    } else if (o instanceof Byte) {
      if (this.primitiveAsString) {
        b = encodeString(o.toString());
      } else {
        b = this.transcoderUtils.encodeByte((Byte) o);
      }
      flags |= SPECIAL_BYTE;
    } else if (o instanceof Float) {
      if (this.primitiveAsString) {
        b = encodeString(o.toString());
      } else {
        b = this.transcoderUtils.encodeInt(Float.floatToRawIntBits((Float) o));
      }
      flags |= SPECIAL_FLOAT;
    } else if (o instanceof Double) {
      if (this.primitiveAsString) {
        b = encodeString(o.toString());
      } else {
        b = this.transcoderUtils.encodeLong(Double.doubleToRawLongBits((Double) o));
      }
      flags |= SPECIAL_DOUBLE;
    } else if (o instanceof byte[]) {
      b = (byte[]) o;
      flags |= SPECIAL_BYTEARRAY;
    } else {
      b = serialize(o);
      flags |= SERIALIZED;
    }
    assert b != null;
    if (this.primitiveAsString) {
      // It is not be SERIALIZED,so change it to string type
      if ((flags & SERIALIZED) == 0) {
        flags = 0;
      }
    }