Binds to {@code Value.int64Array(values)}
768477
public R toInt64Array(@Nullable Iterable<Long> values) {
    return handle(Value.int64Array(values));
  }
1162091
public static JsonArray array(int... values) {
    if (values == null) {
      throw new NullPointerException(VALUES_IS_NULL);
    }
    JsonArray array = new JsonArray();
    for (int value : values) {
      array.add(value);
    }
    return array;
  }
477685
private void serializeBinds(Map<String, ParameterBindingDTO> bindValues) throws BindException
  {
    List<ColumnTypeDataPair> columns = getColumnValues(bindValues);
    List<String[]> rows = buildRows(columns);
    writeRowsToCSV(rows);
  }
1223992
public static int[] addToIntArray(int[] a, int value) {
		
		if(a == null || a.length == 0) {
			return new int[] {value};
		}
		
		int[] array = new int[a.length + 1];
		array[a.length] = value;
		return array;
	}
663513
public int[] set(ReadablePartial instant, int fieldIndex, int[] values, String text, Locale locale) {
        throw unsupported();
    }
290764
public void setBindValues(Collection<BindAttribute> bindValues) throws CpoException {

    if (bindValues != null) {
      int index = getStartingIndex();

      //runs through the bind attributes and binds them to the prepared statement
      // They must be in correct order.
      for (BindAttribute bindAttr : bindValues) {
        Object bindObject = bindAttr.getBindObject();
        CpoAttribute cpoAttribute = bindAttr.getCpoAttribute();

        // check to see if we are getting a cpo value object or an object that
        // can be put directly in the statement (String, BigDecimal, etc)
        MethodMapEntry<?, ?> jsm = ((MethodMapper<?>)getMethodMapper()).getDataMethodMapEntry(bindObject.getClass());

        if (jsm != null) {
          try {
            if (cpoAttribute == null) {
              localLogger.debug(bindAttr.getName() + "=" + bindObject);
            } else {
              localLogger.debug(cpoAttribute.getDataName() + "=" + bindObject);
            }
            jsm.getBsSetter().invoke(this.getBindableStatement(), index++, bindObject);
          } catch (IllegalAccessException iae) {
            localLogger.error("Error Accessing Prepared Statement Setter: " + ExceptionHelper.getLocalizedMessage(iae));
            throw new CpoException(iae);
          } catch (InvocationTargetException ite) {
            localLogger.error("Error Invoking Prepared Statement Setter: " + ExceptionHelper.getLocalizedMessage(ite));
            throw new CpoException(ite.getCause());
          }
        } else {
          CpoData cpoData = getCpoData(cpoAttribute, index++);
          cpoData.invokeSetter(bindObject);
        }
      }
    }
  }
1214089
public static String arraysToBase64(INDArray[] arrays) throws IOException {
        StringBuilder sb = new StringBuilder();
        //tab separate the outputs for de serialization
        for (INDArray outputArr : arrays) {
            ByteArrayOutputStream bos = new ByteArrayOutputStream();
            DataOutputStream dos = new DataOutputStream(bos);
            Nd4j.write(outputArr, dos);
            String base64 = Base64.encodeBase64String(bos.toByteArray());
            sb.append(base64);
            sb.append("\t");
        }

        return sb.toString();
    }
957353
public void put(Long value) {
		if (value == null) {
			this.compiledStatement.bindNull(compiledStatementBindIndex++);
		} else {
			compiledStatement.bindLong(compiledStatementBindIndex++, (long) value);
		}
	}
1327078
public void insert_u64(final long argIn) {
		attributeValue_5.data_format = AttrDataFormat.FMT_UNKNOWN;
		final long[] values = new long[1];
		values[0] = argIn;
		attributeValue_5.w_dim.dim_x = 1;
		attributeValue_5.w_dim.dim_y = 0;
		if (use_union) {
	    	attributeValue_5.value.ulong64_att_value(values);
		} else {
	    	deviceAttribute_3.insert_u64(argIn);
		}
    }
12666
public static Value int64Array(@Nullable long[] v) {
    return int64Array(v, 0, v == null ? 0 : v.length);
  }
97879
public static Byte[] wrap(byte... values) {
		if (null == values) {
			return null;
		}
		final int length = values.length;
		if (0 == length) {
			return new Byte[0];
		}

		final Byte[] array = new Byte[length];
		for (int i = 0; i < length; i++) {
			array[i] = Byte.valueOf(values[i]);
		}
		return array;
	}
41576
public int setIntegerValue(int newValue) throws IOException, SaneException {
    Preconditions.checkState(getValueCount() == 1, "option is an array");

    // check that this option is readable
    Preconditions.checkState(isWriteable());

    // Send RPC corresponding to:
    //
    // SANE_Status sane_control_option (SANE_Handle h, SANE_Int n,
    // SANE_Action a, void *v,
    // SANE_Int * i);

    ControlOptionResult result = writeOption(ImmutableList.of(newValue));
    Preconditions.checkState(result.getType() == OptionValueType.INT);
    Preconditions.checkState(result.getValueSize() == SaneWord.SIZE_IN_BYTES);

    return SaneWord.fromBytes(result.getValue()).integerValue();
  }
450152
public void put(Byte value) {
		if (value == null) {
			this.compiledStatement.bindNull(compiledStatementBindIndex++);
		} else {
			this.compiledStatement.bindLong(compiledStatementBindIndex++, value);
		}
	}
1056992
public static Value int64(@Nullable Long v) {
    return new Int64Impl(v == null, v == null ? 0 : v);
  }
1189781
public static Value float64Array(@Nullable double[] v) {
    return float64Array(v, 0, v == null ? 0 : v.length);
  }
646162
public void writeUInt64(final int fieldNumber, final long value)
                          throws IOException {
    writeTag(fieldNumber, WireFormat.WIRETYPE_VARINT);
    writeUInt64NoTag(value);
  }
1327504
public static void writeRawVarint64(OutputStream os, long value) throws IOException {
        while (true) {
            if ((value & ~0x7FL) == 0) {
                os.write((int) value);
                return;
            } else {
                os.write(((int) value & 0x7F) | 0x80);
                value >>>= 7;
            }
        }
    }