<pre>
Handle describing the feeds and fetches of the step.
</pre>

<code>optional string handle = 2;</code>
2277
public java.lang.String getHandle() {
    java.lang.Object ref = handle_;
    if (ref instanceof java.lang.String) {
      return (java.lang.String) ref;
    } else {
      com.google.protobuf.ByteString bs = 
          (com.google.protobuf.ByteString) ref;
      java.lang.String s = bs.toStringUtf8();
      handle_ = s;
      return s;
    }
  }
360878
private Long handleToId(Object handle) {
        if (handle instanceof Long) {
            return (Long) handle;
        } else {
            throw new IllegalArgumentException("Expected handle to be a Long, but was: " +
                    handle.getClass().getCanonicalName());
        }
    }
1173721
public <T extends XMLReadHandle> T exportQueryDefinition(T handle) {
    return Utilities.exportToHandle(this.queryPayload, handle);
  }
1291738
public static ContentHandler create( ContentHandler[] handlers ) {
		if(handlers.length==0)
			throw new IllegalArgumentException();
		
		ContentHandler result = handlers[0];
		for( int i=1; i<handlers.length; i++ )
			result = new ForkContentHandler( result, handlers[i] );
		return result;
	}
	
	
	private final ContentHandler lhs,rhs;
	
	public void setDocumentLocator (Locator locator) {
		lhs.setDocumentLocator(locator);
		rhs.setDocumentLocator(locator);
	}
	
	public void startDocument() throws SAXException {
		lhs.startDocument();
		rhs.startDocument();
	}
		
	public void endDocument () throws SAXException {
		lhs.endDocument();
		rhs.endDocument();
	}

	public void startPrefixMapping (String prefix, String uri) throws SAXException {
		lhs.startPrefixMapping(prefix,uri);
		rhs.startPrefixMapping(prefix,uri);
	}

	public void endPrefixMapping (String prefix) throws SAXException {
		lhs.endPrefixMapping(prefix);
		rhs.endPrefixMapping(prefix);
	}
	    
	public void startElement (String uri, String localName, String qName, Attributes attributes) throws SAXException {
		lhs.startElement(uri,localName,qName,attributes);
		rhs.startElement(uri,localName,qName,attributes);
	}
	    
	public void endElement (String uri, String localName, String qName) throws SAXException {
		lhs.endElement(uri,localName,qName);
		rhs.endElement(uri,localName,qName);
	}
	    
	public void characters (char ch[], int start, int length) throws SAXException {
		lhs.characters(ch,start,length);
		rhs.characters(ch,start,length);
	}
	    
	public void ignorableWhitespace (char ch[], int start, int length) throws SAXException {
		lhs.ignorableWhitespace(ch,start,length);
		rhs.ignorableWhitespace(ch,start,length);
	}
	    
	public void processingInstruction (String target, String data) throws SAXException {
		lhs.processingInstruction(target,data);
		rhs.processingInstruction(target,data);
	}

	public void skippedEntity (String name) throws SAXException {
		lhs.skippedEntity(name);
		rhs.skippedEntity(name);
	}
	
}
892478
synchronized String registerHandle(AbstractAppHandle handle) {
    String secret = createSecret();
    secretToPendingApps.put(secret, handle);
    return secret;
  }
61889
public void parse(InputSource is, DefaultHandler handler) throws IOException, SAXException{
        setDefaultHandler(handler);
        parse(is);
    }
1189904
public Object getInfoFromHandle(Object bookmark, boolean bGetTable, int iHandleType) throws DBException
    {
        if (iHandleType == DBConstants.OBJECT_ID_HANDLE)
        {
            if (!(bookmark instanceof String))
                return null;
            int iLastColon = ((String)bookmark).lastIndexOf(BaseTable.HANDLE_SEPARATOR);
            if (iLastColon == -1)
                return null;
            if (bGetTable)
                return ((String)bookmark).substring(0, iLastColon);
            else
                return ((String)bookmark).substring(iLastColon+1);
        }
        return bookmark;
    }
25883
protected static StringBuilder handleExceptionStart(Exception e) {
        LOG.warning(ExceptionUtils.getStackTrace(e));
        StringBuilder sb = new StringBuilder();
        if (e.getMessage() != null) {
            sb.append(e.getMessage()).append(". ");
        }
        if (e.getCause() != null && e.getCause().getMessage() != null) {
            sb.append(e.getCause().getMessage()).append(". ");
        }
        return sb;
    }
358846
@Override
  public Response handle() throws Exception {
    JSONObject payload = getRequest().getPayload();
    String type = payload.optString("type");
    if ("page load".equals(type)) {
      long timeout = payload.getLong("ms");
      // meant for driver.get command
      CommandConfiguration conf = getSession().configure(WebDriverLikeCommand.URL);
      conf.set("page load", timeout);
    } else {
      throw new UnsupportedCommandException("timeout " + payload + " NI");
    }
    Response res = new Response();
    res.setSessionId(getSession().getSessionId());
    res.setStatus(0);
    res.setValue(new JSONObject());
    return res;
  }
542413
@Advice.OnMethodExit
	public static void afterGetHandler(@Advice.Return Object handler) {
		SpringMvcRequestNameDeterminerTransformer.setRequestNameByHandler(handler);
	}
218137
private static String reader2String(final Reader reader) throws IOException {

        final StringBuilder stringBuilder = new StringBuilder();

        try (BufferedReader bufferedReader = new BufferedReader(reader)) {
            String line = null;
            while ((line = bufferedReader.readLine()) != null) {
                stringBuilder.append(line);
                stringBuilder.append("\n"); // I know, if the original data
                                            // stream has no ending line feed,
                                            // this will add one...
            }
        }
        return stringBuilder.toString();
    }
371708
public com.google.protobuf.ByteString
      getSessionHandleBytes() {
    java.lang.Object ref = sessionHandle_;
    if (ref instanceof java.lang.String) {
      com.google.protobuf.ByteString b = 
          com.google.protobuf.ByteString.copyFromUtf8(
              (java.lang.String) ref);
      sessionHandle_ = b;
      return b;
    } else {
      return (com.google.protobuf.ByteString) ref;
    }
  }
217012
public Object handle(Parser p, Node n) {
        Bytestring val = new Bytestring();
        if(n.anchor != null) {
            val.append(YAML.BYTE_ANCHOR, bytes(n.anchor), 0, -1);
        }
        if(n.type_id != null) {
            if(p.taguri_expansion) {
                val.append(YAML.BYTE_TRANSFER, bytes(n.type_id), 0, -1);
            } else {
                val.append(YAML.BYTE_TRANSFER, bytes("!" + n.type_id), 0, -1);
            }
        }

        switch(n.kind) {
        case Str: {
            byte nextcode = YAML.BYTE_SCALAR;
            Data.Str dd = (Data.Str)n.data;
            byte[] buf = dd.ptr.buffer;
            int start = dd.ptr.start;
            int finish = start + dd.len - 1;
            int current = start;
            byte ch;
            while(true) {
                ch = buf[current];
                if('\n' == ch || 0 == ch || current > finish) {
                    if(current >= start) {
                        val.append(nextcode, buf, start, current);
                        nextcode = YAML.BYTE_CONTINUE;
                    }
                    start = current + 1;
                    if(current > finish) {
                        break;
                    } else if('\n' == ch ) {
                        val.append(YAML.BYTE_NEWLINE,null,0,-1);
                    } else if(0 == ch) {
                        val.append(YAML.BYTE_NULLCHAR,null,0,-1);
                    }
                }
                current += 1;
            }
            break;
        }
        case Seq: {
            val.append(YAML.BYTE_SEQUENCE,null,0,-1);
            Data.Seq dd = (Data.Seq)n.data;
            for(int i = 0; i < dd.idx; i++) {
                val.extend((Bytestring)n.seqRead(i));
            }
            val.append(YAML.BYTE_END_BRANCH,null,0,-1);
            break;
        }
        case Map: {
            val.append(YAML.BYTE_MAPPING,null,0,-1);
            Data.Map dd = (Data.Map)n.data;
            for(int i = 0; i < dd.idx; i++) {
                val.extend((Bytestring)n.mapRead(MapPart.Key, i));
                val.extend((Bytestring)n.mapRead(MapPart.Value, i));
            }
            val.append(YAML.BYTE_END_BRANCH,null,0,-1);
            break;
        }
        }
        return val;
    }
1344478
@Nonnull
	public final LLongSupplierBuilder withHandling(@Nonnull HandlingInstructions<RuntimeException, RuntimeException> handling) {
		Null.nonNullArg(handling, "handling");
		if (this.handling != null) {
			throw new UnsupportedOperationException("Handling is already set for this builder.");
		}
		this.handling = handling;
		return self();
	}
1330214
public static Function<Object,Byte> b(final String methodName, final Object... optionalParameters) {
        return methodForByte(methodName, optionalParameters);
    }
997149
private static void initStringDefinedHandler(String handler) {
		// split the class name and its label, if defined
		Tuple<String, Class> namedClass = splitClassAndName(handler);

		// create an instance of the handler
		Object handlerOrProviderObject = null;
		try {
			handlerOrProviderObject = namedClass.second.newInstance();
		} catch (Exception e) {
			logger.error("Exception:", e);
			throw new RuntimeException("Could not instantiate handler class: " + namedClass.second);
		}

		HttpHandler resolvedHandler;
		if (handlerOrProviderObject instanceof HttpHandler) {
			resolvedHandler = (HttpHandler) handlerOrProviderObject;
		} else if (handlerOrProviderObject instanceof HandlerProvider) {
			resolvedHandler = ((HandlerProvider) handlerOrProviderObject).getHandler();
		} else {
			throw new RuntimeException("Unsupported type of handler provided: " + handlerOrProviderObject);
		}
		registerMiddlewareHandler(resolvedHandler);
		handlers.put(namedClass.first, resolvedHandler);
		handlerListById.put(namedClass.first, Collections.singletonList(resolvedHandler));
	}
511879
public Optional<String> get(String input) {
        TrieNode currentNode = root;
        int i=0;
        for(char c: input.toCharArray()) {
            TrieNode nextNode = currentNode.getChildren().get(c);
            if(nextNode != null) {
                i++;
                currentNode=nextNode;
            } else {
                if(i>0 && currentNode.isLeaf()) {
                    return Optional.of(input.substring(0, i));
                }
            }
        }
        if(i>0 && currentNode.isLeaf()) {
            return Optional.of(input.substring(0, i));
        }
        return Optional.empty();
   }