Adds the given visit state to the visit-state queue.

<p>This method is used for deserialization only.

@param visitState the visit state that must be added to the visit-state queue.
@see PriorityQueue#add(Object)
964728
public synchronized void add(VisitState visitState) {
		final boolean wasEntirelyBroken = isEntirelyBroken();
		if (visitState.lastExceptionClass != null) brokenVisitStates++;
		visitStates.add(visitState);
		assert brokenVisitStates <= visitStates.size();
		if (wasEntirelyBroken && ! isEntirelyBroken()) workbenchBroken.decrementAndGet();
		if (! wasEntirelyBroken && isEntirelyBroken()) workbenchBroken.incrementAndGet();
	}
246848
@Override
    public void visit(Method obj) {
        state = State.SAW_NOTHING;
        register1_1 = -1;
        register1_2 = -1;
        register2_1 = -1;
        register2_2 = -1;
        super.visit(obj);
    }
1254976
@Override
    public void visit(int version, int access, String name, String signature, String superName, String[] interfaces) {
        this.classVersion = version;
        this.classType = Type.getObjectType(name);
        this.isInterface = (access & Opcodes.ACC_INTERFACE) != 0;
        this.isSynthetic = (access & Opcodes.ACC_SYNTHETIC) != 0;

        super.visit(version, access, name, signature, superName, interfaces);
    }
248743
public void queueStateChange(IState state)
    {
        synchronized(this.stateQueue)
        {
            if (this.stateQueue.size() != 0)
            {
                // The queue is only a method for ensuring the transition is carried out on the correct thread - transitions should
                // never happen so quickly that we end up with more than one state in the queue.
                System.out.println("STATE ERROR - multiple states in the queue.");
            }
            this.stateQueue.add(state);
            System.out.println(getName() + " request state: " + state);
            TCPUtils.Log(Level.INFO, "-------- " + getName() + " request state: " + state + " --------");
        }
    }
698494
private void pushState(int indentation) {
        states.push(state);
        state = new StreamStatus();
        state.setIndentationLevel(indentation);
    }
446592
public boolean add(final VisitState v) {
		// The starting point.
		int pos = (int)(MurmurHash3.hash(v.schemeAuthority) & mask);
		// There's always an unused entry.
		while (visitState[pos] != null) {
			if (Arrays.equals(visitState[pos].schemeAuthority, v.schemeAuthority)) return false;
			pos = (pos + 1) & mask;
		}
		visitState[pos] = v;
		if (++size >= maxFill && n < (1 << 30)) rehash(2 * n);
		return true;
	}
670846
void addState(State<S, L> state) {
        ElementReference ref = states.referencedAdd(state);
        state.setBlockReference(ref);
        state.setBlock(this);
    }
1365174
public void enqueueURL(VisitState visitState, final ByteArrayList url) throws IOException {
		final byte[] urlBuffer = url.elements();
		final int pathQueryStart = BURL.startOfpathAndQuery(urlBuffer);
		byteArrayDiskQueues.enqueue(visitState,  urlBuffer, pathQueryStart, url.size() - pathQueryStart);
	}
698502
public static void setState(ParseState state) {

    if (state == null) {
      System.err.println("Null state found");
      Environment.logInfo("Null state found");
    }

    persData.setProperty(state.filename, state.firstLine + SEPARATOR + state.offset);
  }
1281827
public void setInstanceStates(java.util.Collection<String> instanceStates) {
        if (instanceStates == null) {
            this.instanceStates = null;
            return;
        }

        this.instanceStates = new com.amazonaws.internal.SdkInternalList<String>(instanceStates);
    }
843982
@SuppressWarnings("unchecked")
	static VisitorStatusType visitList(String name, List<Object> list, BindMapListener listener, VisitorStatusType status) {
		int i = 0;
		for (Object item : list) {
			if (item == null || item instanceof String) {
				visit(name + "." + i, (String) item, listener, status);
			} else if (item instanceof List) {
				visitList(name + "." + i, (List<Object>) item, listener, status);
			} else if (item instanceof Map) {
				visitMap(name + "." + i, (Map<String, Object>) item, listener, status);
			}
			i++;

			if (status == VisitorStatusType.STOP)
				return status;
		}

		return status;
	}
597444
public void add(SubjectObserver<T> subjectObserver)
   {
      if (subjectObserver == null)
         throw new RequiredException("subjectObserver in Topic.add");
      
      String id = subjectObserver.getId();
      
      if (id == null || id.length() == 0)
         throw new IllegalArgumentException("Subject observer id required");
      
     //get previous
      SubjectObserver<?> prev = (SubjectObserver<?>)observerMap.get(subjectObserver.getId());
      
      if(prev != null && prev != subjectObserver)
      {
         Debugger.println(this,"Object registered, but observer id already exists "+subjectObserver.getId()+" for subject="+this.name);
      }
      
      //add       
      observerMap.put(subjectObserver.getId(), subjectObserver);
      
   }
299711
@Override
    public void visit(final int version, final int access, final String name,
            final String signature, final String superName,
            final String[] interfaces) {
        computeSVUID = (access & Opcodes.ACC_INTERFACE) == 0;

        if (computeSVUID) {
            this.name = name;
            this.access = access;
            this.interfaces = new String[interfaces.length];
            System.arraycopy(interfaces, 0, this.interfaces, 0,
                    interfaces.length);
        }

        super.visit(version, access, name, signature, superName, interfaces);
    }
711940
@Override
	public void visitType(Decl.Type decl, Set<QualifiedName> visited) {
		QualifiedName name = decl.getQualifiedName();
		if (visited.contains(name)) {
			// recursive type detected!!!
			decl.setRecursive();
		} else {
			visited.add(name);
			visitType(decl.getType(), visited);
			visited.remove(name);
		}
	}
1091784
@Override
	public void accept(Visitor<PlanNode> visitor) {
		if (visitor.preVisit(this)) {
			this.input.getSource().accept(visitor);
			
			for (Channel broadcastInput : getBroadcastInputs()) {
				broadcastInput.getSource().accept(visitor);
			}
			
			visitor.postVisit(this);
		}
	}
802055
protected void addTemporaryDestination(JmsTemporaryDestinationInternal tempDest) {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(this, tc, "addTemporaryDestination", System.identityHashCode(tempDest));

        synchronized (temporaryDestinations) { // synchronize against removeTemporaryDestination
            temporaryDestinations.add(tempDest);
        }

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(this, tc, "addTemporaryDestination");
    }
1237284
protected function addState(StateInterface $state)
    {
        if ($this->targetCollection instanceof StateCollection) {
            $this->targetCollection->addState($state);
        } else {
            throw new \InvalidArgumentException('TargetCollection has to be a StateCollection. Overwrite this method to implement a different type!');
        }
    }