Mark objects for saving. The order of these objects cannot change as
the GUI grows. When remembering new objects, append them to the end
of the list.

@param {Object...} objects
@throws {Error} if not called on a top level GUI.
@instance
769343
function() {

          if (common.isUndefined(SAVE_DIALOGUE)) {
            SAVE_DIALOGUE = new CenteredDiv();
            SAVE_DIALOGUE.domElement.innerHTML = saveDialogueContents;
          }

          if (this.parent) {
            throw new Error("You can only call remember on a top level GUI.");
          }

          var _this = this;

          common.each(Array.prototype.slice.call(arguments), function(object) {
            if (_this.__rememberedObjects.length == 0) {
              addSaveMenu(_this);
            }
            if (_this.__rememberedObjects.indexOf(object) == -1) {
              _this.__rememberedObjects.push(object);
            }
          });

          if (this.autoPlace) {
            // Set save row width
            setWidth(this, this.width);
          }

        }
788701
public static void init(Object object)
	{
		if (object instanceof Collection)
		{
			initCollection((Collection<?>)object);
		}
		else if (object instanceof Marshalizable)
		{
			Marshalizable m = (Marshalizable)object;
			m.marshallize();
		}
	}
567797
public <T> void setObjectList(ListDataKey<T> key, List<T> objects) {
        if (key == null) {
            throw new IllegalArgumentException("key must not be null");
        }
        if (objects == null && !key.allowNull()) {
            throw new IllegalArgumentException("list key \"" + key.getName() + "\" disallows null values but object was null");
        }
        data.put(key.getName(), deepListCopy(objects));
    }
1111223
function(key, object) {

          // Convert object to JSON and store in localStorage
          var json = JSON.stringify(object);
          persistenceStrategy.set(key, json);

          // Then store it in the object cache
          objectCache[key] = object;
        }
812304
@Override
    @SuppressWarnings("unchecked")
    protected void restoreState(Object[] objects) {
        if (objects != null && objects.length != 0) {
            variable = (Variable) objects[0];
            constants = (List<Variable>) objects[1];
            lastObjectHash = (Map<String, Object>) objects[2];
        }
    }
200681
public function markClean()
    {
        foreach ($this as $model) {
            if (is_object($model)) {
                $model->markClean();
            }
        }
        $this->_original = count($this);
    }
1163151
function each(object, callback) {
    var index = -1,
        length = object ? object.length : 0;

    if (typeof length == 'number' && length > -1 && length <= maxSafeInteger) {
      while (++index < length) {
        callback(object[index], index, object);
      }
    } else {
      forOwn(object, callback);
    }
  }
32334
public static void notNull(Object... objects) {
        notNull((Object) objects);
        for (Object object : objects) {
            notNull(object);
        }
    }
1328458
protected void print(Object... objects) throws IOException {
        for (Object object : objects) {
            pageContext.getOut().print(object);
        }
    }
1270398
@Override
  public void persist(Object obj) {
    if (null == obj) {
      throw new IllegalArgumentException("object to save cannot be null");
    }
    objMapper.saveObj(keyspace, obj);
  }
764771
def mark
      classes = Set.new
      marked_objects = 0
      @progressmeter.start("Marking linked objects", @db.item_counter) do
        each do |obj|
          classes.add(obj.class)
          @progressmeter.update(marked_objects += 1)
        end
      end
      @class_map.keep(classes.map { |c| c.to_s })

      # The root_objects object is included in the count, but we only want to
      # count user objects here.
      PEROBS.log.debug "#{marked_objects - 1} of #{@db.item_counter} " +
        "objects marked"
      @stats.marked_objects = marked_objects - 1
    end
460636
function (obj) {
                shared.utils.dassert(shared.tracker.isTracked(obj));
                if(obj instanceof Array) {
                    this.arrayChanges(obj);
                } else {
                    this.objectChanges(obj);
                }
            }
90484
public JSONObject saveObjects(List<JSONObject> objects) throws AlgoliaException {
    return this.saveObjects(objects, RequestOptions.empty);
  }
1321560
public void put(DBObject key, Object object) {
        //noinspection unchecked
        objectCache.put(flatten(key.toMap()), new WeakReference(object));
    }
152629
protected void setObjects(PreparedStatement ps, Object... objects)
            throws SQLException {
        int index = 1;
        for (Object obj : objects) {
            ps.setObject(index, obj);
            index++;
        }
    }
469966
public void rollbackOdmgAbort(List objects)
    {
        log.info("rollbackOdmgAbort method was called");
        storeObjects(objects);
        getImplementation().currentTransaction().abort();
    }
888528
def _save(self, objects, old_pos, new_pos):
        """"""
        to_shift = objects.exclude(pk=self.pk) if self.pk else objects

        # If not set, insert at end.
        if self.sort_order is None:
            self._move_to_end(objects)

        # New insert.
        elif not self.pk and not old_pos:
            # Increment `sort_order` on objects with:
            #     sort_order > new_pos.
            to_shift = to_shift.filter(sort_order__gte=self.sort_order)
            self._update(to_shift)
            self.sort_order = new_pos

        # self.sort_order decreased.
        elif old_pos and new_pos < old_pos:
            self._move_to_end(objects)
            super(Orderable, self).save()
            # Increment `sort_order` on objects with:
            #     sort_order >= new_pos and sort_order < old_pos
            to_shift = to_shift.filter(sort_order__gte=new_pos, sort_order__lt=old_pos)
            self._update(to_shift)
            self.sort_order = new_pos

        # self.sort_order increased.
        elif old_pos and new_pos > old_pos:
            self._move_to_end(objects)
            super(Orderable, self).save()
            # Decrement sort_order on objects with:
            #     sort_order <= new_pos and sort_order > old_pos.
            to_shift = to_shift.filter(sort_order__lte=new_pos, sort_order__gt=old_pos)
            to_shift.update(sort_order=models.F('sort_order') - 1)
            self.sort_order = new_pos