Restores the state of the adapter from a previous state parcelable. Only effective when root adapter {@link
PowerAdapter#hasStableIds()}
348409
public void restoreInstanceState(@Nullable Parcelable parcelable) {
        mState = parcelable instanceof TreeState ? (TreeState) parcelable : new TreeState();
        rebuildAllEntriesAndRangeTable();
        updateEntryAdapters();
    }
1318996
@Override
    public boolean hasStableIds() {
        Collection<? extends Binder<?, ?>> allBinders = getAllBinders();
        if (allBinders.size() == 1) {
            // Save an allocation by checking for List first.
            if (allBinders instanceof List) {
                //noinspection unchecked
                return ((List<Binder<?, ?>>) allBinders).get(0).hasStableIds();
            }
            return allBinders.iterator().next().hasStableIds();
        }
        // Can't possibly have stable IDs if we have multiple binders.
        return false;
    }
891585
@Override
    public void onRollback()
    {
        onBatchRollBack();

        nodes.clear();
        nodes = null;
        nodes = new ArrayList<Node>();
        isActive = false;
    }
1027717
function () {
            this.backBufferContext2D.restore();
            this.currentColor.glArray[3] = this.backBufferContext2D.globalAlpha;
            this.currentScissor[0] = 0;
            this.currentScissor[1] = 0;
            this.currentScissor[2] = this.backBufferCanvas.width;
            this.currentScissor[3] = this.backBufferCanvas.height;
        }
2417
static void restoreState(Bundle savedState) {
        stateKeeper.bundle = savedState;

        MvcComponent root = getRootComponent();
        doRestoreState(root);

        stateKeeper.bundle = null;
    }
1064544
protected void restoreState(View view, Set<ViewCommand<View>> currentState) {
		if (mViewCommands.isEmpty()) {
			return;
		}

		mViewCommands.reapply(view, currentState);
	}
314742
public void restoreState(FacesContext context, Object state) {

        if (context == null) {
            throw new NullPointerException();
        }
        if (state == null) {
            return;
        }
        
        if (!component.initialStateMarked() && !defaultMap.isEmpty())
        {
            defaultMap.clear();
            if(deltaMap != null && !deltaMap.isEmpty())
            {
                deltaMap.clear();
            }
        }
        
        Object[] savedState = (Object[]) state;
        if (savedState[savedState.length - 1] != null) {
            component.initialState = (Boolean) savedState[savedState.length - 1];
        }
        int length = (savedState.length-1)/2;
        for (int i = 0; i < length; i++) {
           Object value = savedState[i * 2 + 1];
            Serializable serializable = (Serializable) savedState[i * 2];
            if (value != null) {
                if (value instanceof Collection) {
                    value = restoreAttachedState(context, value);
                } else if (value instanceof StateHolderSaver) {
                    value = ((StateHolderSaver) value).restore(context);
                } else {
                    value = (value instanceof Serializable
                             ? value
                             : restoreAttachedState(context, value));
                }
            }
            if (value instanceof Map) {
                for (Map.Entry<String, Object> entry : ((Map<String, Object>) value)
                      .entrySet()) {
                    this.put(serializable, entry.getKey(), entry.getValue());
                }
            } else if (value instanceof List) {
                List<Object> list = (List) get(serializable);
                for (Object o : ((List<Object>) value)) {
                    if (list == null || !list.contains(o)) {
                        this.add(serializable, o);
                    }
                }
            } else {
                put(serializable, value);
            }
        }
    }
577855
public void
restore() {
	if (saved_pos < 0) {
		throw new IllegalStateException("no previous state");
	}
	byteBuffer.position(saved_pos);
	byteBuffer.limit(saved_end);
	saved_pos = -1;
	saved_end = -1;
}
100692
public java.util.List<String> getRestorableByUserIds() {
        if (restorableByUserIds == null) {
            restorableByUserIds = new com.amazonaws.internal.SdkInternalList<String>();
        }
        return restorableByUserIds;
    }
420119
@Override public Parcelable onSaveInstanceState() {
    if (isInEditMode) return null;

    VS viewState = delegateCallback.getViewState();
    if (viewState == null) {
      throw new NullPointerException("ViewState returned from getViewState() is null for MvpView "
          + delegateCallback.getMvpView());
    }

    Parcelable superState = delegateCallback.superOnSaveInstanceState();

    if (keepPresenterDuringScreenOrientationChange) {
      if (viewState instanceof RestorableParcelableViewState) {
        return new MosbyViewStateSavedState(superState, mosbyViewId,
            (RestorableParcelableViewState) viewState);
      }
      return new MosbyViewStateSavedState(superState, mosbyViewId, null);
    } else {
      return superState;
    }
  }
43946
private void restoreData() {
		Map<String, ?> map = preferenceUtils.getAll();
		Set<String> strings = map.keySet();

		for (String string : strings) {
			if (string.startsWith(SharedPreferenceUtils.keyTestMode)) {
				preferenceUtils.restoreKey(string);
			}
		}

		refreshKeyValues();

	}
1211196
protected void restoreFilterAndSorter() {
		final ProblemTreeViewer viewer = getViewer();
		viewer.addFilter(new EmptyInnerPackageFilter());
		viewer.addFilter(new HiddenFileFilter());
	}
187394
public Collection<ItemState> getLastModifyStates(NodeData rootData)
   {
      HashMap<String, ItemState> changes = new HashMap<String, ItemState>();

      for (int i = 0; i < items.size(); i++)
      {
         ItemData item = items.get(i).getData();
         if (item.getIdentifier().equals(rootData.getIdentifier()))
         {
            // the node
            if (items.get(i).isAdded())
            {
               // if a new item - no modify changes can be
               return new ArrayList<ItemState>();
            }

            if (!items.get(i).isDeleted())
            {
               changes.put(item.getIdentifier(), items.get(i));
            }
         }
         else if (item.getParentIdentifier().equals(rootData.getIdentifier()))
         {
            // childs
            changes.put(item.getIdentifier(), items.get(i));
         }
      }

      return changes.values();
   }
97518
public void onRestoreInstanceState(Parcelable state) {
    if (isInEditMode) return;

    if (!(state instanceof MosbySavedState)) {
      delegateCallback.superOnRestoreInstanceState(state);
      return;
    }

    MosbySavedState savedState = (MosbySavedState) state;
    restoreSavedState(savedState);
    delegateCallback.superOnRestoreInstanceState(savedState.getSuperState());
  }
458011
public void setRestorableByUserIds(java.util.Collection<String> restorableByUserIds) {
        if (restorableByUserIds == null) {
            this.restorableByUserIds = null;
            return;
        }

        this.restorableByUserIds = new com.amazonaws.internal.SdkInternalList<String>(restorableByUserIds);
    }
62514
def restore_state(self, state):
        

        super(EmulatedPeripheralTile, self).restore_state(state)

        self.debug_mode = state.get('debug_mode', False)
        self.run_level = state.get('run_level', None)

        if state.get('app_started', False):
            self._hosted_app_running.set()
225097
protected function restoreErroneousMappers() {
        $this->erroneousMappers->rewind();
        while ($this->erroneousMappers->valid()) {
            $this->erroneousMappers->current()->save();
            $this->erroneousMappers->next();
        }
    }