load array with property ids
775917
private void addLoadPropertyIds(Object[] properties, int count) {
        addNewObjectArray(count);
        for (int i = 0; i != count; ++i) {
            cfw.add(ByteCode.DUP);
            cfw.addPush(i);
            Object id = properties[i];
            if (id instanceof String) {
                cfw.addPush((String)id);
            } else {
                cfw.addPush(((Integer)id).intValue());
                addScriptRuntimeInvoke("wrapInt", "(I)Ljava/lang/Integer;");
            }
            cfw.add(ByteCode.AASTORE);
        }
    }
1347205
function( array, newItem, nextSiblingId, recurse, nullIfNotFound ) {
			if ( nextSiblingId ) {
				for ( var i = 0, item;
				( item = array[ i ] ); i++ ) {
					if ( item.id == nextSiblingId ) {
						array.splice( i, 0, newItem );
						return newItem;
					}

					if ( recurse && item[ recurse ] ) {
						var retval = addById( item[ recurse ], newItem, nextSiblingId, recurse, true );
						if ( retval )
							return retval;
					}
				}

				if ( nullIfNotFound )
					return null;
			}

			array.push( newItem );
			return newItem;
		}
575202
def parse_property_array(parser, event, node): #pylint: disable=unused-argument
    """"""

    name = _get_required_attribute(node, 'NAME')
    cim_type = _get_required_attribute(node, 'TYPE')

    # TODO 2/16 KS: array_size here is unused. It is valid attribute.
    array_size = _get_attribute(node, 'ARRAYSIZE')
    class_origin = _get_attribute(node, 'CLASSORIGIN')
    propagated = _get_attribute(node, 'PROPAGATED')

    # TODO 1/16 KS: The qualifier processing could be common.
    qualifiers = []
    value = None

    (next_event, next_node) = six.next(parser)

    if _is_start(next_event, next_node, 'QUALIFIER'):

        qualifiers.append(parse_qualifier(parser, next_event, next_node))

        while 1:

            (next_event, next_node) = six.next(parser)

            if _is_start(next_event, next_node, 'VALUE.ARRAY'):
                break

            if _is_start(next_event, next_node, 'QUALIFIER'):
                qualifiers.append(
                    parse_qualifier(parser, next_event, next_node))
            else:
                raise ParseError('Expecting QUALIFIER')

    if _is_start(next_event, next_node, 'VALUE.ARRAY'):

        value = parse_value_array(parser, next_event, next_node)
        (next_event, next_node) = six.next(parser)

    if not _is_end(next_event, next_node, 'PROPERTY.ARRAY'):
        raise ParseError('Expecting end PROPERTY.ARRAY')

    return CIMProperty(
        name,
        tocimobj(type, value),
        type=cim_type,
        class_origin=class_origin,
        propagated=propagated,
        is_array=True,
        qualifiers=dict([(x.name, x) for x in qualifiers]))
602338
function getColumnPropertiesFromColumnArray(columnProperties, columns) {
  return columns.reduce((previous, current, i) => {
    previous[current] = { id: current, order: offset + i };
    return previous;
  },
  columnProperties);
}
361323
public static void loadArrayA(
			Object[] arr,
			int idx,
			Object val,
			String calleeClass,
			String callerMethod,
			String callerClass,
			int callerValKind,
			Object caller) {
		final String elementType = calleeClass.substring(1);	
		NativeInterface.loadFieldA(val, SPECIAL_VAL_NORMAL, arr, calleeClass, "_"+idx, elementType, callerClass, callerMethod, callerValKind, caller);
	}
693882
function(obj) {
        var arr = [];
        for (var prop in obj) {
            if (obj.hasOwnProperty(prop)) {
                arr.push(prop);
            }
        }
        return arr;
    }
706484
@Override
    public void loadFromProperties(Properties props) {
        String strValue = props.getProperty(container.getSimpleName() + "." + name);
        if (strValue == null)
            return;

        try {
            int intValue = Integer.parseInt(strValue);
            set(intValue);
        } catch (NumberFormatException nfe) {
        }
    }
426947
def loadImgs(self, ids=[]):
        
        if _isArrayLike(ids):
            return [self.imgs[id] for id in ids]
        elif type(ids) == int:
            return [self.imgs[ids]]
1321108
function getIdColumns(idColumnNames, columns) {
  if (!defined(idColumnNames)) {
    return [];
  }
  return idColumnNames.map(name => getColumnWithNameIdOrIndex(name, columns));
}
1346542
def from_array(cls, arr):
        """"""
        return cls().with_columns([(f, arr[f]) for f in arr.dtype.names])
434455
function getPropertyArrayFromObjArray(arrayObj, property) {
  let temp = [];

  for (let i = 0; i < arrayObj.length; ++i) {
    temp.push(arrayObj[i][property]);
  }
  return temp;
}
346074
public static void loadCustomerProperties(Properties props){
        for(Entry<Object, Object> entry : props.entrySet()){
            setProperty((String)entry.getKey(), entry.getValue());
        }
    }
343513
function(item) {
  var result;

  if (_.isArray(item)) {
    result = [];
    _.each(item, function(value) {
      result.push(parseItem(value));
    });
    return result;
  }

  /* otherwise */
  if (_.isObject(item)) {
    return parseObject(item);
  }

  /* otherwise -- just a normal (non-compound) item */
  return item;
}
563324
function( array, id, recurse ) {
			for ( var i = 0, item;
			( item = array[ i ] ); i++ ) {
				if ( item.id == id )
					return item;
				if ( recurse && item[ recurse ] ) {
					var retval = getById( item[ recurse ], id, recurse );
					if ( retval )
						return retval;
				}
			}
			return null;
		}
99957
public function loadObjectById($objectId, $properties = array())
    {

        $results = $this->getObjectById($objectId, $properties);
        //If success, store the object id in
        $n = 0;
        $object = new Entity($this->database, $this->container);
        $object->definePropertyModel($this->propertyModel);
        //$object->defineValueGroup($this->valueGroup);

        while ($row = $results->fetchAssoc()) {
            foreach ($row as $property => $value):
                if (strtolower($property) == "object_type") {
                    $object->setObjectType($value);
                    continue;
                }
                if (strtolower($property) == "object_id") {
                    $object->setObjectId($value);
                    continue;
                }
                if (strtolower($property) == "object_uri") {
                    $object->setObjectURI($value);
                    continue;
                }
                $object->setPropertyValue($property, $value);
            endforeach;
            $n++;
        }
        return $object;
    }
1036009
function load($data = [])
    {
        foreach ($this as $k => $v) {
            if ($k == 'table' || $k == 'where') {
                continue;
            }
            if (isset($data[$k])) {
                $this->$k = $data[$k];
            }
        }
    }
429043
function (events) {
        "use strict";
    
        var loaded = {};
        this.loaded = loaded;
    
        var items = {};
        var keys = [];
        Object.defineProperty(this, 'items', {
            'get': function () {
                return items;
            }
        });
        Object.defineProperty(this, 'keys', {
            'get': function () {
                return keys;
            }
        });
        Object.defineProperty(this, 'length', {
            'get': function () {
                return keys.length;
            }
        });
    
        // List of modules that are multilanguage
        var multilanguage = new Map();
        Object.defineProperty(this, 'multilanguage', {
            'get': function () {
                return multilanguage;
            }
        });
    
        this.get = function (moduleID, extendedID) {
    
            var done = function () {
    
                events.trigger(moduleID + ':done');
                events.trigger('done', moduleID);
    
                loaded[moduleID] = true;
    
            };
    
            var extended;
            if (extendedID) {
                extended = items[extendedID];
                if (!extended) {
                    extended = new Module(moduleID, events);
                    items[extendedID] = extended;
                    keys.push(extendedID);
                }
            }
    
            var module = items[moduleID];
            if (!module) {
                module = new Module(moduleID, events);
                items[moduleID] = module;
                keys.push(moduleID);
            }
    
    
            if (extended) return [module, extended];
            else return [module, done];
    
        };
    
    }