This will create a list of delorean objects the apply to
    setting possed in.
773256
def stops(freq, interval=1, count=None, wkst=None, bysetpos=None,
          bymonth=None, bymonthday=None, byyearday=None, byeaster=None,
          byweekno=None, byweekday=None, byhour=None, byminute=None,
          bysecond=None, timezone='UTC', start=None, stop=None):
    
    # check to see if datetimees passed in are naive if so process them
    # with given timezone.
    if all([(start is None or is_datetime_naive(start)),
            (stop is None or is_datetime_naive(stop))]):
        pass
    else:
        raise DeloreanInvalidDatetime('Provide a naive datetime object')

    # if no datetimes are passed in create a proper datetime object for
    # start default because default in dateutil is datetime.now() :(
    if start is None:
        start = datetime_timezone(timezone)

    for dt in rrule(freq, interval=interval, count=count, wkst=wkst, bysetpos=bysetpos,
          bymonth=bymonth, bymonthday=bymonthday, byyearday=byyearday, byeaster=byeaster,
          byweekno=byweekno, byweekday=byweekday, byhour=byhour, byminute=byminute,
          bysecond=bysecond, until=stop, dtstart=start):
        # make the delorean object
        # yield it.
        # doing this to make sure delorean receives a naive datetime.
        dt = dt.replace(tzinfo=None)
        d = Delorean(datetime=dt, timezone=timezone)
        yield d
42691
private void marshalFields() {
    Collection<PropertyMetadata> propertyMetadataCollection = entityMetadata
        .getPropertyMetadataCollection();
    for (PropertyMetadata propertyMetadata : propertyMetadataCollection) {
      marshalField(propertyMetadata, entity);
    }
  }
1287103
private void setupTempLists()
    {
        //synchronized(this){   //d173022.2
        //d115597 if necessary create a new tempList
        // and list of currentBeanOs.  Always delay this until actually needed
        //d115597

        if (tempList == null) {
            tempList = new ArrayList<BeanO>();
            currentBeanOs = new HashMap<BeanId, BeanO>();//should release old list
        }
        //}
    }
1316024
protected void populateTasksByStealer(List<StealerBasedRebalanceTask> sbTaskList) {
        // Setup mapping of stealers to work for this run.
        for(StealerBasedRebalanceTask task: sbTaskList) {
            if(task.getStealInfos().size() != 1) {
                throw new VoldemortException("StealerBasedRebalanceTasks should have a list of RebalancePartitionsInfo of length 1.");
            }

            RebalanceTaskInfo stealInfo = task.getStealInfos().get(0);
            int stealerId = stealInfo.getStealerId();
            if(!this.tasksByStealer.containsKey(stealerId)) {
                this.tasksByStealer.put(stealerId, new ArrayList<StealerBasedRebalanceTask>());
            }
            this.tasksByStealer.get(stealerId).add(task);
        }

        if(tasksByStealer.isEmpty()) {
            return;
        }
        // Shuffle order of each stealer's work list. This randomization
        // helps to get rid of any "patterns" in how rebalancing tasks were
        // added to the task list passed in.
        for(List<StealerBasedRebalanceTask> taskList: tasksByStealer.values()) {
            Collections.shuffle(taskList);
        }
    }
1145735
public List<HierarchicalProperty> setList(HierarchicalProperty request)
   {
      HierarchicalProperty set = request.getChild(new QName("DAV:", "set"));
      HierarchicalProperty prop = set.getChild(new QName("DAV:", "prop"));
      List<HierarchicalProperty> setList = prop.getChildren();
      return setList;
   }
724965
def inventory(self):
        

        for chassis in self.chassis_list.values():
            chassis.inventory(modules_inventory=True)
283936
def sets(self):
        """"""
        sets = {}
        for x in self._parents:
            sets.setdefault(self[x], set()).add(x)
        return frozenset(frozenset(v) for v in six.viewvalues(sets))
1311168
def _init_titles(self):
        
        super(ModelRestApi, self)._init_titles()
        class_name = self.datamodel.model_name
        if not self.list_title:
            self.list_title = "List " + self._prettify_name(class_name)
        if not self.add_title:
            self.add_title = "Add " + self._prettify_name(class_name)
        if not self.edit_title:
            self.edit_title = "Edit " + self._prettify_name(class_name)
        if not self.show_title:
            self.show_title = "Show " + self._prettify_name(class_name)
        self.title = self.list_title
1181116
static void addPropertyToDependencyList(List<AccessibleObject> orderedList, Map<String, AccessibleObject> props, Stack<AccessibleObject> stack, AccessibleObject obj) {
    
    	if (orderedList.contains(obj))
    		return ;
    	
    	if (stack.search(obj) > 0) {
    		throw new RuntimeException("Deadlock in @Property dependency processing") ;
    	}
    	// record the fact that we are processing obj
    	stack.push(obj) ;
    	// process dependencies for this object before adding it to the list
    	Property annotation = obj.getAnnotation(Property.class) ;
    	String dependsClause = annotation.dependsUpon() ;
    	StringTokenizer st = new StringTokenizer(dependsClause, ",") ;
    	while (st.hasMoreTokens()) {
    		String token = st.nextToken().trim();
    		AccessibleObject dep = props.get(token) ;
    		// if null, throw exception 
    		addPropertyToDependencyList(orderedList, props, stack, dep) ;
    	}
    	// indicate we're done with processing dependencies
    	stack.pop() ;
    	// we can now add in dependency order
    	orderedList.add(obj) ;
    }
869232
def _attach_fields(obj):
    
    for attr in base_fields.__all__:
        if not hasattr(obj, attr):
            setattr(obj, attr, getattr(base_fields, attr))
    for attr in fields.__all__:
        setattr(obj, attr, getattr(fields, attr))
302836
function(ev, callback, context) {
      var calls = this._callbacks || (this._callbacks = {});
      var list  = calls[ev] || (calls[ev] = []);
      list.push([callback, context]);
      return this;
    }
997540
def populate_obj(obj, attrs):
    
    for k, v in attrs.iteritems():
        setattr(obj, k, v)
976182
private List<String> getObjectList() {
        if (cachedIds != null) return cachedIds;

        SharedPreferences prefs = loadSharedPreferences("objectList");

        String list = prefs.getString("list", null);

        cachedIds = (list == null) ? new ArrayList<String>() : new ArrayList<>(Arrays.asList(list.split(",")));
        return cachedIds;
    }
237205
public void setObjects(Map<String, Object> objects) {
        for (Map.Entry<String, Object> entry: objects.entrySet()) {
            js.put(entry.getKey(), entry.getValue());
        }
    }
381920
def _create_settings(self):
        

        self.settings = {
            "columns": [{"Header": s, "accessor": s} for s in self.settings],
            "port": self.port,
            "docs": construct_trie(self.docs)
        }
728217
def createLists(self):
        ''''''

        self.beforeAssemblyList = {
        'Confirm batteries charged':2,
        'No physical damage to airframe':2,
        'All electronics present and connected':2,
        'Bottle loaded':2,
        'Ground station operational':2
        }

        self.beforeEngineList = {
        'Avionics Power ON':2,
        'Pixhawk Booted':0,
        'Odroid Booted':2,
        'Cameras calibrated and capturing':2,
        'GPS lock':0,
        'Airspeed check':2,
        'Barometer check':2,
        'Compass check':2,
        'Flight mode MANUAL':0,
        'Avionics Power':0,
        'Servo Power':0,
        'IMU Check':0,
        'Aircraft Params Loaded':2,
        'Waypoints Loaded':0,
        'Servo and clevis check':2,
        'Geofence loaded':2,
        'Ignition circuit and battery check':2,
        'Check stabilisation in FBWA mode':2
        }

        self.beforeTakeoffList = {
        'Engine throttle responsive':2,
        'Runway clear':2,
        'Radio links > 6db margin':0,
        'Antenna tracker check':2,
        'GCS stable':2,
        }

        self.beforeCruiseList = {
        'Airspeed > 10 m/s':0,
        'Altitude > 30 m':0,
        '< 100 degrees to 1st Waypoint':2,
        'Airspeed and climb rate nominal':2
        }

        self.bottleDropList = {
        'Joe found':2,
        'Joe waypoint laid in':2,
        '< 100m to Joe waypoint':2,
        'Bottle drop mechanism activated':2
        }

        self.beforeLandingList = {
        'Runway clear':2,
        'APM set to FBWA mode':2,
        '< 100m from airfield home':2
        }

        self.beforeShutdownList = {
        'Taxi to parking':2,
        'Engine cutoff':2,
        'Data downloaded':2,
        'Ignition power off':2,
        'Avionics power off':2
        }
247504
def add2set(self, pid, key, value):
    """"""
    prop = self.property_entries[pid]

    current = prop.objects.get(key, None)
    current_local_key = prop.references.get(key, None)

    if current and current is not value:
        current.detach()

    if current_local_key is None:
        prop.references[key] = prop.next_free_key
        prop.next_free_key += 1

    prop.objects[key] = value

    if prop.parent.dir:
        ref = prop.index_ref_name(key)
        dir_entry = prop.parent.dir.get(ref)
        if dir_entry is None:
            dir_entry = prop.parent.dir.makedir(ref)
        if value.dir != dir_entry:
            value.attach(dir_entry)
        prop.mark_modified()