Extract an value array of the given {@link ValueContainer} array.
@param containers
@return An object array
169850
public Object[] extractValueArray(ValueContainer[] containers)
    {
        Object[] result = new Object[containers.length];
        for(int i = 0; i < containers.length; i++)
        {
            result[i] = containers[i].getValue();
        }
        return result;
    }
936909
public float[] extractFloatArray() {
	float[] argout;
	argout = new float[values.length];
	for (int i = 0; i < values.length; i++) {
	    argout[i] = new Float(values[i]);
	}
	return argout;
    }
1210846
protected ValueContainer[] getKeyValues(PersistenceBroker broker, ClassDescriptor cld, Identity oid) throws PersistenceBrokerException
    {
        return broker.serviceBrokerHelper().getKeyValues(cld, oid);
    }
186548
public ValueContainer[] getValuesForObject(FieldDescriptor[] fields, Object obj, boolean convertToSql, boolean assignAutoincrement) throws PersistenceBrokerException
    {
        ValueContainer[] result = new ValueContainer[fields.length];

        for(int i = 0; i < fields.length; i++)
        {
            FieldDescriptor fd = fields[i];
            Object cv = fd.getPersistentField().get(obj);

            /*
            handle autoincrement attributes if
            - is a autoincrement field
            - field represents a 'null' value, is nullified
            and generate a new value
            */
            if(assignAutoincrement && fd.isAutoIncrement() && representsNull(fd, cv))
            {
                /*
                setAutoIncrementValue returns a value that is
                properly typed for the java-world.  This value
                needs to be converted to it's corresponding
                sql type so that the entire result array contains
                objects that are properly typed for sql.
                */
                cv = setAutoIncrementValue(fd, obj);
            }
            if(convertToSql)
            {
                // apply type and value conversion
                cv = fd.getFieldConversion().javaToSql(cv);
            }
            // create ValueContainer
            result[i] = new ValueContainer(cv, fd.getJdbcType());
        }
        return result;
    }
1214397
public static java.util.Collection<?> values(Struct sct) {
	ArrayList<Object> arr = new ArrayList<Object>();
	// Key[] keys = sct.keys();
	Iterator<Object> it = sct.valueIterator();
	while (it.hasNext()) {
	    arr.add(it.next());
	}
	return arr;
    }
915580
public MappeableArrayContainer toArrayContainer() {
    final MappeableArrayContainer ac = new MappeableArrayContainer(cardinality);
    ac.loadData(this);
    if (ac.getCardinality() != cardinality) {
      throw new RuntimeException("Internal error.");
    }
    return ac;
  }
728033
private function buildValueTypes(ContainerBuilder $container, array $valueTypes): Generator
    {
        foreach ($valueTypes as $identifier => $valueType) {
            $this->validateBrowserType($container, $identifier);

            $serviceIdentifier = sprintf('netgen_block_manager.item.value_type.%s', $identifier);

            $container->register($serviceIdentifier, ValueType::class)
                ->setArguments([$identifier, $valueType])
                ->setLazy(true)
                ->setPublic(true)
                ->setFactory([ValueTypeFactory::class, 'buildValueType']);

            yield $identifier => new Reference($serviceIdentifier);
        }
    }
785798
@Override
    public Map<String, String> getValues(final String variableContains) {
        final Map<String, String> valueMap = new HashMap<>();
        for (final VariableProvider variableProvider : variableProviderPool) {
            valueMap.putAll(variableProvider.getValues(variableContains));
        }
        return valueMap;
    }
1074842
public Container ior(Container x) {
    if (x instanceof ArrayContainer) {
      return ior((ArrayContainer) x);
    } else if (x instanceof BitmapContainer) {
      return ior((BitmapContainer) x);
    }
    return ior((RunContainer) x);
  }
1081789
public static Iterator<Object> getValues(Object[] array)
    {
        if (array == null)
        {
            return null;
        }
        ArrayList<Object> valueList = new ArrayList<Object>();
        int i = array.length - 1;
        while (i >= 0)
        {
            valueList.add(array[i]);
            i = i - 2;
        }
        return valueList.iterator();
    }
840151
protected ValueContainer[] getNonKeyValues(PersistenceBroker broker, ClassDescriptor cld, Object obj) throws PersistenceBrokerException
    {
        return broker.serviceBrokerHelper().getNonKeyRwValues(cld, obj);
    }
954603
public static <T> List<T> getList(final ContentValues[] values, final Class<T> klass) {
        final List<T> objects = new ArrayList<T>();
        for (int i = 0; i < values.length; i++) {
            final T object = getObject(values[i], klass);
            if (object != null) {
                objects.add(object);
            }
        }
        return objects;
    }
333560
private List<String> findVolumesFromContainers(List<String> images) throws DockerAccessException {
        List<String> list = new ArrayList<>();
        if (images != null) {
            for (String image : images) {
                String id = findContainerId(image, true);
                if (id == null) {
                    throw new DockerAccessException("No container found for image/alias '%s', unable to mount volumes", image);
                }

                list.add(queryService.getContainerName(id));
            }
        }
        return list;
    }
790142
public ValueContainer[] getKeyValues(ClassDescriptor cld, Identity oid, boolean convertToSql) throws PersistenceBrokerException
    {
        FieldDescriptor[] pkFields = cld.getPkFields();
        ValueContainer[] result = new ValueContainer[pkFields.length];
        Object[] pkValues = oid.getPrimaryKeyValues();

        try
        {
            for(int i = 0; i < result.length; i++)
            {
                FieldDescriptor fd = pkFields[i];
                Object cv = pkValues[i];
                if(convertToSql)
                {
                    // BRJ : apply type and value mapping
                    cv = fd.getFieldConversion().javaToSql(cv);
                }
                result[i] = new ValueContainer(cv, fd.getJdbcType());
            }
        }
        catch(Exception e)
        {
            throw new PersistenceBrokerException("Can't generate primary key values for given Identity " + oid, e);
        }
        return result;
    }
1116994
public static double[][] getMatrix(IAtomContainer container) {
        IBond bond = null;
        int indexAtom1;
        int indexAtom2;
        double[][] conMat = new double[container.getAtomCount()][container.getAtomCount()];
        for (int f = 0; f < container.getBondCount(); f++) {
            bond = container.getBond(f);
            indexAtom1 = container.indexOf(bond.getBegin());
            indexAtom2 = container.indexOf(bond.getEnd());
            conMat[indexAtom1][indexAtom2] = BondManipulator.destroyBondOrder(bond.getOrder());
            conMat[indexAtom2][indexAtom1] = BondManipulator.destroyBondOrder(bond.getOrder());
        }
        return conMat;
    }
380880
public Container ixor(Container x) {
    if (x instanceof ArrayContainer) {
      return ixor((ArrayContainer) x);
    } else if (x instanceof BitmapContainer) {
      return ixor((BitmapContainer) x);
    }
    return ixor((RunContainer) x);
  }
485690
public void setContainers(java.util.Collection<Container> containers) {
        if (containers == null) {
            this.containers = null;
            return;
        }

        this.containers = new java.util.ArrayList<Container>(containers);
    }