sets this instance ' s data , position and limit to match the provided { @ code parsable byte array } any modifications to the underlying data array will be visible in both instances

public void reset ( parsable byte array parsable byte array ) { reset ( parsable byte array get data ( ) , parsable byte array limit ( ) ) ; set position ( parsable byte array get position ( ) * 8 ) ; }


protected abstract r do work ( ) throws e ;


@ test public void test consumer exception ( ) throws exception { final sink queue < integer > q = new sink queue < integer > ( 1 ) ; final runtime exception ex = new runtime exception ( " expected " ) ; q enqueue ( 1 ) ; try { q consume ( new consumer < integer > ( ) { @ override public void consume ( integer e ) { throw ex ; } } ) ; } catch ( exception expected ) { assert same ( " consumer exception " , ex , expected ) ; } / / the queue should be in consistent state after exception assert equals ( " queue size " , 1 , q size ( ) ) ; assert equals ( " element " , 1 , ( int ) q dequeue ( ) ) ; }


create a loop this automatically adjusts connectivity

public void create loop ( float [ ] vertices , int offset , int length ) { final int vertex count = length / 2 ; vec 2 [ ] v = new vec 2 [ vertex count ] ; for ( int i = offset , vi = 0 ; vi < vertex count ; i + = 2 , vi + + ) { v [ vi ] = new vec 2 ( vertices [ i ] , vertices [ i + 1 ] ) ; } shape create loop ( v , vertex count ) ; is looped = true ; }


creates a time limiter instance using the given executor service to execute method calls < b > warning : < b > using a bounded executor may be counterproductive ! if the thread pool fills up , any time callers spend waiting for a thread may count toward their time limit , and in this case the call may even time out before the target method is ever invoked

public static simple time limiter create ( executor service executor ) { return new simple time limiter ( executor ) ; }


public string get name ( ) { return name ; }


filter attribute values by pattern and return the list

protected list < object > filter attribute values by pattern ( final set < object > attribute values , final pattern pattern ) { return attribute values stream ( ) filter ( v - > regex utils matches ( pattern , v to string ( ) , complete match ) ) collect ( collectors to list ( ) ) ; }


write all changes to the specified out file

private void do save ( buffer file out file , task monitor monitor ) throws i o exception , cancelled exception { int index cnt = index provider get index count ( ) ; int pre save cnt = out file get index count ( ) ; if ( monitor = = null ) { monitor = task monitor dummy ; } monitor initialize ( index cnt ) ; monitor set message ( " saving file " ) ; / / determine number of buffers to be written ( required for remote stream transfer ) / / count non - empty buffers which have been created or modified / / empty buffers will be flushed when out file is closed int buf count = 0 ; for ( int id = 0 ; id < index cnt ; id + + ) { monitor check canceled ( ) ; buffer node node = get cached buffer node ( id ) ; if ( node ! = null ) { / / check nod which resides in cache if ( ! node empty & & ( id > = pre save cnt | | node checkpoint ! = 0 | | node modified ) ) { + + buf count ; } } else if ( id > = pre save cnt & & ! index provider is free ( id ) ) { / / node not in cache , must be copied if not empty / / will cause buffer to be cached for use during output below data buffer buf = get buffer ( id ) ; / / will add to cache for use during output below if ( buf ! = null ) { + + buf count ; release buffer ( buf ) ; } } } / / write / update all non - empty buffers try ( output block stream out = local buffer file get output block stream ( out file , buf count ) ) { for ( int id = 0 ; id < index cnt ; id + + ) { monitor check canceled ( ) ; monitor set progress ( id ) ; / / get buffer node from cache / / if not contained within cache it does not need to be stored buffer node node = get cached buffer node ( id ) ; if ( node ! = null ) { if ( ! node empty & & ( id > = pre save cnt | | node checkpoint ! = 0 | | node modified ) ) { load cached node ( node ) ; buffer file block block = local buffer file get buffer file block ( node buffer , buffer size ) ; out write block ( block ) ; } } } } / / set free id list for output file / / it is important that this is done after the streaming is complete / / so that the change map and free buffers are updated properly out file set free indexes ( index provider get free indexes ( ) ) ; / / copy file parameters from cache file string [ ] parm names = cache file get parameter names ( ) ; for ( int i = 0 ; i < parm names length ; i + + ) { string name = parm names [ i ] ; out file set parameter ( name , cache file get parameter ( name ) ) ; } }


makes a blocking rpc call that publishes a { @ code lifecycle event }

void publish ( publish lifecycle event request lifecycle event ) throws status exception , interrupted exception ;


public static hystrix timer get instance ( ) { return instance ; }


returns true if the a sequence of chars is one of " true " , " false " , " on " , " off " , " yes " , " no " , " 0 " , " 1 "

public static boolean is boolean lenient ( char [ ] text , int offset , int length ) { if ( text = = null | | length = = 0 ) { return false ; } if ( length = = 1 ) { return text [ offset ] = = ' 0 ' | | text [ offset ] = = ' 1 ' ; } if ( length = = 2 ) { return ( text [ offset ] = = ' n ' & & text [ offset + 1 ] = = ' o ' ) | | ( text [ offset ] = = ' o ' & & text [ offset + 1 ] = = ' n ' ) ; } if ( length = = 3 ) { return ( text [ offset ] = = ' o ' & & text [ offset + 1 ] = = ' f ' & & text [ offset + 2 ] = = ' f ' ) | | ( text [ offset ] = = ' y ' & & text [ offset + 1 ] = = ' e ' & & text [ offset + 2 ] = = ' s ' ) ; } if ( length = = 4 ) { return ( text [ offset ] = = ' t ' & & text [ offset + 1 ] = = ' r ' & & text [ offset + 2 ] = = ' u ' & & text [ offset + 3 ] = = ' e ' ) ; } if ( length = = 5 ) { return ( text [ offset ] = = ' f ' & & text [ offset + 1 ] = = ' a ' & & text [ offset + 2 ] = = ' l ' & & text [ offset + 3 ] = = ' s ' & & text [ offset + 4 ] = = ' e ' ) ; } return false ; }


returns true if there ' s a breakpoint at the current location , with a satisfied condition if relevant

private boolean has breakpoint matched at location ( starlark thread thread , location location ) throws conditional breakpoint exception { / / breakpoints is volatile , so taking a local copy immutable map < starlark debugging protos location , starlark debugging protos breakpoint > breakpoints = this breakpoints ; if ( breakpoints is empty ( ) ) { return false ; } starlark debugging protos location location proto = debug event helper get location proto ( location ) ; if ( location proto = = null ) { return false ; } location proto = location proto to builder ( ) clear column number ( ) build ( ) ; starlark debugging protos breakpoint breakpoint = breakpoints get ( location proto ) ; if ( breakpoint = = null ) { return false ; } string condition = breakpoint get expression ( ) ; if ( condition is empty ( ) ) { return true ; } try { return starlark truth ( do evaluate ( thread , condition ) ) ; } catch ( eval exception e ) { throw new conditional breakpoint exception ( e get message with stack ( ) ) ; } catch ( syntax error exception | interrupted exception e ) { throw new conditional breakpoint exception ( e get message ( ) ) ; } }


returns a new instance like { @ code object } that throws on { @ code get kind ( ) }

private type element prevent get kind ( type element object ) { type element spy = mockito spy ( object ) ; when ( spy get kind ( ) ) then throw ( new assertion error ( ) ) ; when ( spy get enclosing element ( ) ) then answer ( invocation - > { object enclosing element = invocation call real method ( ) ; return enclosing element instanceof type element ? prevent get kind ( ( type element ) enclosing element ) : enclosing element ; } ) ; return spy ; }


int argument that matches any of the given argument matchers see examples in javadoc for { @ link additional matchers } class

public static int or ( int first , int second ) { mocking progress ( ) get argument matcher storage ( ) report or ( ) ; return 0 ; }


return true if the method includes the { @ code static } modifier

public boolean is static ( ) { return method is static ( ) ; }


public static int get layout id by name ( string name ) { return utils get app ( ) get resources ( ) get identifier ( name , " layout " , utils get app ( ) get package name ( ) ) ; }


this implementation looks for a method with matching parameter types

protected method find matching method ( ) { method matching method = super find matching method ( ) ; / / second pass : look for method where arguments can be converted to parameter types if ( matching method = = null ) { / / interpret argument array as individual method arguments matching method = do find matching method ( get arguments ( ) ) ; } if ( matching method = = null ) { / / interpret argument array as single method argument of array type matching method = do find matching method ( new object [ ] { get arguments ( ) } ) ; } return matching method ; }


true signals that the client allows null items to be used when this is true , a null value will be stored in this list < b > only as the last item < b > see the javadoc for more info

public void set allow nulls ( boolean allow nulls ) { this allows nulls = allow nulls ; }


add hi16 relocation for deferred processing

void add h i 1 6 relocation ( mips deferred relocation hi 1 6reloc ) { hi 1 6list add ( hi 1 6reloc ) ; }


creates a table with pk and not null constraints

void create table with constraints ( i meta store client client , table table , configuration conf , unique constraint pk , list < byte > pk traits , list < string > not null cols , list < byte > nn traits ) ;


generate an indirect pcodeop operation representing an unknown state for an affected varnode resulting from a function call at the specified seq

private varnode operation get invalidated varnode ( sequence number seq , varnode affect varnode ) { pcode op op = new pcode op ( seq , pcode op indirect , 0 , affect varnode ) ; return new varnode operation ( op , op get inputs ( ) ) ; }


calculates merging strategies for all options it applies options given by a user to the { @ link # default merging strategies } the { @ link merging strategy } specified for { @ link feature option # all } overwrites all the default options those can be further changed with a specific { @ link feature option }

public map < feature option , merging strategy > compute merging strategies ( list < sql table like sql table like option > merging options ) { map < feature option , merging strategy > result = new hash map < > ( default merging strategies ) ; optional < sql table like sql table like option > maybe all option = merging options stream ( ) filter ( option - > option get feature option ( ) = = feature option all ) find first ( ) ; maybe all option if present ( ( all option ) - > { merging strategy strategy = all option get merging strategy ( ) ; for ( feature option feature option : feature option values ( ) ) { if ( feature option ! = feature option all ) { result put ( feature option , strategy ) ; } } } ) ; for ( sql table like sql table like option merging option : merging options ) { result put ( merging option get feature option ( ) , merging option get merging strategy ( ) ) ; } return result ; }


xml external entities attacks benefit from an xml feature to build documents dynamically at the time of processing an xml entity allows inclusion of data dynamically from a given resource external entities allow an xml document to include data from an external uri unless configured to do otherwise , external entities force the xml parser to access the resource specified by the uri , e g , a file on the local machine or remote system this behavior exposes the application to xml external entity ( xxe ) attacks normally , a custom entity resolver implementing org xml sax entity resolver should not return null as it will then default to the sax entity resolver that allows and resolves external entities this test ensures external entities are ignored whether or not a default sax entity resolver is used using the threaded xml pull parser impl constructor which takes an input stream ( rather than resource file ) will use a default entity resolver the xml utilities create secure s a x parser factory factory configurations will disable external entities regardless of which entity resolver is used

public void test x x e xml ( ) throws exception { / / create file with contents string file contents = " foobar " ; file xxe file = create temp file for test ( ) ; files write ( xxe file to path ( ) , file contents get bytes ( ) ) ; / / place file path in xml entity string xxe xml = xxe xml replace ( " @ temp file @ " , xxe file get path ( ) ) ; / / this constructor will use a default entity resolver threaded xml pull parser impl parser = new threaded xml pull parser impl ( new byte array input stream ( xxe xml get bytes ( ) ) , test name get method name ( ) , new test error handler ( ) , false , 3 ) ; parser start ( " foo " ) ; xml element x 1 = parser next ( ) ; assert false ( " file contents ( external entity ) should not be in xml " , x 1 get text ( ) contains ( file contents ) ) ; }


return the ( potentially null ) scope to be reported with the failure

public string failure scope ( ) { return failure scope ; }


given a label ( which has typically , but not necessarily , just been built ) , returns the configured target for it using the request configuration

protected configured target get configured target ( string target ) throws label syntax exception , no such package exception , no such target exception , interrupted exception , transition exception , invalid configuration exception { get package manager ( ) get target ( events reporter ( ) , label parse absolute ( target , immutable map of ( ) ) ) ; return get skyframe executor ( ) get configured target for testing ( events reporter ( ) , label ( target ) , get target configuration ( ) ) ; }


returns the preferred resources of this data sink if no preferred resources have been set , this returns the default resource profile

public resource spec get preferred resources ( ) { return this preferred resources ; }


public void set debug ( boolean debug ) { this debug = debug ; this buffer set debug ( debug ) ; }


test the property ' enum string required '

public void enum string required test ( ) { / / todo : test enum string required }


creates a new blocking - style stub that supports unary and streaming output calls on the service

public static unimplemented service blocking stub new blocking stub ( io grpc channel channel ) { io grpc stub abstract stub stub factory < unimplemented service blocking stub > factory = new io grpc stub abstract stub stub factory < unimplemented service blocking stub > ( ) { @ java lang override public unimplemented service blocking stub new stub ( io grpc channel channel , io grpc call options call options ) { return new unimplemented service blocking stub ( channel , call options ) ; } } ; return unimplemented service blocking stub new stub ( factory , channel ) ; }


should the visitor visit the tree given the bounding box of the tree called before visiting the tree

boolean push ( int min x , int min y , int max x , int max y ) ;


send a handshaker request and return the handshaker response

public handshaker resp send ( handshaker req req ) throws interrupted exception , i o exception { create writer if null ( ) ; maybe throw io exception ( ) ; if ( ! response queue is empty ( ) ) { throw new i o exception ( " received an unexpected response " ) ; } writer on next ( req ) ; optional < handshaker resp > result = response queue take ( ) ; if ( ! result is present ( ) ) { maybe throw io exception ( ) ; } return result get ( ) ; }


transition the worker to a released state

public worker release worker ( ) { return new worker ( task i d , slave i d , hostname , worker state released ) ; }


returns the time spent indexing ( cumulative ) in milliseconds

public long get index time ( ) { return index time ; }


given a constant value accessed as an operand by a particular instruction , calculate a ( level 0 ) hash for ( any ) corresponding constant varnode

public static long [ ] calc constant hash ( instruction instr , long value ) { long [ ] tmp = new long [ 2 ] ; int count = 0 ; for ( pcode op op : instr get pcode ( true ) ) { varnode [ ] inputs = op get inputs ( ) ; for ( int i = 0 ; i < inputs length ; i + + ) { if ( inputs [ i ] is constant ( ) & & match with possible extension ( inputs [ i ] get offset ( ) , inputs [ i ] get size ( ) , value ) ) { if ( count > = tmp length ) { long [ ] newtmp = new long [ count + 10 ] ; for ( int j = 0 ; j < tmp length ; + + j ) { newtmp [ j ] = tmp [ j ] ; } tmp = newtmp ; } dynamic hash dynamic hash = new dynamic hash ( op , i ) ; tmp [ count ] = dynamic hash get hash ( ) ; if ( tmp [ count ] ! = 0 ) { count + = 1 ; } } } } long [ ] res = new long [ count ] ; for ( int i = 0 ; i < count ; + + i ) { res [ i ] = tmp [ i ] ; } return res ; }


initialization method for the schema it is called before the actual working methods { @ link # deserialize } and thus suitable for one time setup work the provided { @ link deserialization schema initialization context } can be used to access additional features such as e g registering user metrics

default void open ( deserialization schema initialization context context ) throws exception { }


sets the message type for the option dialog which will determine the icon that is in the dialog

public option dialog builder set message type ( int message type ) { this message type = message type ; return this ; }


sets the compressed size for this { @ code zip entry }

public void set compressed size ( long value ) { compressed size = value ; }


read a long stored in variable - length format using zig - zag decoding from < a href = " http : code google comapisprotocolbuffersdocsencoding html " > google protocol buffers

public static long read varlong ( byte buffer buffer ) { long value = 0l ; int i = 0 ; long b ; while ( ( ( b = buffer get ( ) ) & 0x 8 0 ) ! = 0 ) { value | = ( b & 0x 7f ) < < i ; i + = 7 ; if ( i > 63 ) throw illegal varlong exception ( value ) ; } value | = b < < i ; return ( value > > > 1 ) ^ - ( value & 1 ) ; }


connects to the remote { @ code m bean server } using the configured service url and environment properties

private void connect ( ) throws i o exception { assert state ( this service url ! = null , " no j m x service u r l set " ) ; this connector = j m x connector factory connect ( this service url , this environment ) ; this connection = this connector get m bean server connection ( ) ; }


public void test dog all of ( ) { / / todo : test dog all of }


utility method for getting a hostname resolved to a node in the network topology this method initializes the class with the right resolver implementation

public static node resolve ( configuration conf , string host name ) { init ( conf ) ; return core resolve ( host name ) ; }


call get metrics on source and get a record builder mock to verify

public static metrics record builder get metrics ( metrics source source , boolean all ) { metrics record builder rb = mock metrics record builder ( ) ; metrics collector mc = rb parent ( ) ; source get metrics ( mc , all ) ; return rb ; }


tests that server accepts connections from a client configured with a valid certificate if client authentication is requested

public void test client authentication requested valid provided ( args args ) throws exception { args ssl server configs put ( broker security configs ssl client auth config , " requested " ) ; verify ssl configs ( args ) ; }


patch another - fakedummy : to test special tags to test special tags and operation id starting with number

response entity < client > call 1 2 3test special tags ( @ api param ( value = " client model " , required = true ) @ valid @ request body client body ) ;


for caching to work correctly , implementations must implement this method and { @ link # hash code ( ) }


returns the builder with copied columns info from the given table schema

private static table schema builder builder with given columns ( list < table column > original columns ) { final table schema builder builder = table schema builder ( ) ; for ( table column column : original columns ) { builder add ( column ) ; } return builder ; }


returns all { @ link request method request methods } contained in this condition

public set < request method > get methods ( ) { return this methods ; }


preprocess the command - line flags that were passed to javac this is called before { @ link # init ( context , log , java compiler , blaze javac statistics builder ) } and { @ link # initialize context ( context ) }

public void process args ( immutable list < string > standard javacopts , immutable list < string > blaze javacopts ) throws invalid command line exception { }


return the list of acceptable { @ linkplain charset charsets } , as specified by the { @ code accept - charset } header

public list < charset > get accept charset ( ) { string value = get first ( accept charset ) ; if ( value ! = null ) { string [ ] tokens = string utils tokenize to string array ( value , " , " ) ; list < charset > result = new array list < > ( tokens length ) ; for ( string token : tokens ) { int param idx = token index of ( ' ; ' ) ; string charset name ; if ( param idx = = - 1 ) { charset name = token ; } else { charset name = token substring ( 0 , param idx ) ; } if ( ! charset name equals ( " * " ) ) { result add ( charset for name ( charset name ) ) ; } } return result ; } else { return collections empty list ( ) ; } }


returns the ghidra language minor version ( used to create the library )

public int get ghidra language minor version ( ) { return record get int value ( ghidra language minor version col ) ; }


executes the given callable after the given delay the result of the callable is returned as a { @ link scheduled future }

< v > scheduled future < v > schedule ( callable < v > callable , long delay , time unit unit ) ;


public static void assert container killed ( final container id container id , final container status status ) { assert equals ( container id , status get container id ( ) ) ; assert equals ( container state complete , status get state ( ) ) ; assert equals ( container exit status preempted , status get exit status ( ) ) ; assert equals ( scheduler utils preempted container , status get diagnostics ( ) ) ; }


returns the { @ link highlighter } registry

public map < string , highlighter > get highlighters ( ) { return highlighters ; }


merge multiple { @ link cc debug info context } s into one

public static cc debug info context merge ( collection < cc debug info context > contexts ) { nested set builder < artifact > transitive dwo files = nested set builder stable order ( ) ; nested set builder < artifact > transitive pic dwo files = nested set builder stable order ( ) ; for ( cc debug info context context : contexts ) { transitive dwo files add transitive ( context get transitive dwo files ( ) ) ; transitive pic dwo files add transitive ( context get transitive pic dwo files ( ) ) ; } return new cc debug info context ( transitive dwo files build ( ) , transitive pic dwo files build ( ) ) ; }


check whether the step size in mapped file queue is correct

public void check self ( ) { this mapped file queue check self ( ) ; }


called to initialize new emitted particles

public void activate particles ( int start index , int count ) { }


static int index for ( int h , int length ) { return h & ( length - 1 ) ; }


constructs a target expression on a node attribute it is satisfied if the specified node attribute has one of the specified values

public static target expression node attribute ( string attribute key , string attribute values ) { return new target expression ( target type node attribute , attribute key , attribute values ) ; }


allows subclasses to vote on the inclusion of a particular attribute accessor

protected abstract boolean include read attribute ( method method , string bean key ) ;


write the status code to the underlying response this method is called once only

protected abstract void apply status code ( ) ;


draws a circle outline with the center at x , y and a radius using the current color and stroke width

public void draw circle ( int x , int y , int radius ) { pixmap draw circle ( x , y , radius , color ) ; }


public void find usages ( ) { if ( field ids = = null | | method ids = = null ) { return ; } for ( class def class def : dex class defs ( ) ) { current class = class def ; current method = null ; if ( class def get class data offset ( ) = = 0 ) { continue ; } class data class data = dex read class data ( class def ) ; for ( class data field field : class data all fields ( ) ) { int field index = field get field index ( ) ; if ( field ids contains ( field index ) ) { out println ( location ( ) + " field declared " + dex field ids ( ) get ( field index ) ) ; } } for ( class data method method : class data all methods ( ) ) { current method = method ; int method index = method get method index ( ) ; if ( method ids contains ( method index ) ) { out println ( location ( ) + " method declared " + dex method ids ( ) get ( method index ) ) ; } if ( method get code offset ( ) ! = 0 ) { code reader visit all ( dex read code ( method ) get instructions ( ) ) ; } } } current class = null ; current method = null ; }


set the coefficient of restitution this will not change the restitution of existing contacts

public void set restitution ( float restitution ) { m restitution = restitution ; }


returns array of dynamic library names defined by dt needed

public string [ ] get dynamic library names ( ) { return dynamic library names ; }


resolves the default value if possible if not , return { @ code null }


validate that source parameters look sane

static void validate source params ( file source , file output ) throws mojo execution exception { string c output = null , c source = null ; try { c output = output get canonical path ( ) ; } catch ( i o exception e ) { throw new mojo execution exception ( " error getting canonical path " + " for output " , e ) ; } try { c source = source get canonical path ( ) ; } catch ( i o exception e ) { throw new mojo execution exception ( " error getting canonical path " + " for source " , e ) ; } / / this doesn ' t catch all the bad cases - - we could be following symlinks or / / hardlinks , etc however , this will usually catch a common mistake if ( c source starts with ( c output ) ) { throw new mojo execution exception ( " the source directory must not be " + " inside the output directory ( it would be destroyed by " + " ' mvn clean ' ) " ) ; } }


in aspect j semantics , after throwing advice that specifies a throwing clause is only invoked if the thrown exception is a subtype of the given throwing type

private boolean should invoke on throwing ( throwable ex ) { return get discovered throwing type ( ) is assignable from ( ex get class ( ) ) ; }


public void indirect map test ( ) { / / todo : test indirect map }


simplifies a boolean expression , always preserving its type and its nullability this is useful if you are simplifying expressions in a { @ link project }

public rex node simplify preserving type ( rex node e ) { return simplify preserving type ( e , default unknown as , true ) ; }


public void set older than ( long older than ) { if ( newer than ! = null ) { throw new unsupported operation exception ( " cannot set ' older than ' ' newer than ' already set " ) ; } this older than = older than ; }


find locations of potential damage from calls to non - returning functions

private address set find potential damaged locations ( program prog , address entry ) { string name = entry to string ( ) ; function func = prog get function manager ( ) get function at ( entry ) ; if ( func ! = null ) { name = func get name ( ) ; } try { monitor set message ( " no return - clearing and repairing flows for : " + name ) ; return find repair locations ( prog , entry ) ; } catch ( cancelled exception e ) { / / a cancel here implies that the entire script has been cancelled } return new address set ( ) ; }


public static boolean delete all in dir ( final file dir ) { return delete files in dir with filter ( dir , new file filter ( ) { @ override public boolean accept ( file pathname ) { return true ; } } ) ; }


accepts an xds client and starts a watch

public void start ( xds client xds client ) { check state ( this xds client = = null , " start ( ) called more than once " ) ; check not null ( xds client , " xds client " ) ; this xds client = xds client ; this listener watcher = new xds client listener watcher ( ) { @ override public void on listener changed ( xds client listener update update ) { cur listener = update get listener ( ) ; report success ( ) ; } @ override public void on resource does not exist ( string resource name ) { logger log ( level warning , " resource { 0 } is unavailable " , resource name ) ; cur listener = null ; report error ( status not found with description ( resource name ) ) ; } @ override public void on error ( status error ) { logger log ( level warning , " listener watcher in xds client wrapper for server sds : { 0 } " , error ) ; report error ( error ) ; } } ; xds client watch listener data ( port , listener watcher ) ; }


return the patterns in this condition if only the first ( top ) pattern is needed use { @ link # get first pattern ( ) }

public set < path pattern > get patterns ( ) { return this patterns ; }


create a new pool and add the filters to it a split cannot have files from different pools

protected void create pool ( list < path filter > filters ) { pools add ( new multi path filter ( filters ) ) ; }


sets the new current nested level and pushes old current nested level down the stack returns that level

public object mapper next level ( object mapper level ) { object mapper previous = level stack peek ( ) ; level stack push ( level ) ; return previous ; }


update the job ' s data counts stats and figures note : this call is synchronous and pauses the calling thread

public void persist data counts ( string job id , data counts counts ) { counts set log time ( instant now ( ) ) ; try { results persister service index with retry ( job id , anomaly detectors index results write alias ( job id ) , counts , to x content empty params , write request refresh policy none , data counts document id ( job id ) , true , ( ) - > true , retry message - > logger debug ( " [ { } ] job data counts { } " , job id , retry message ) ) ; } catch ( i o exception ioe ) { logger error ( ( ) - > new parameterized message ( " [ { } ] failed writing data counts stats " , job id ) , ioe ) ; } catch ( exception ex ) { logger error ( ( ) - > new parameterized message ( " [ { } ] failed persisting data counts stats " , job id ) , ex ) ; auditor error ( job id , " failed persisting data counts stats : " + ex get message ( ) ) ; } }


updated user this can only be done by the logged in user

public void update user ( @ path param ( " username " ) string username , @ valid user body ) ;


add the given class file transformer to the list of transformers that this class loader will apply

public void add transformer ( class file transformer transformer ) { assert not null ( transformer , " transformer must not be null " ) ; this class file transformers add ( transformer ) ; }


send a source event to the source coordinator

void send source event to coordinator ( source event source event ) ;


hook method called by the blaze command dispatcher prior to the dispatch of each command

void before command ( command environment env , common command options options ) { if ( options memory profile path ! = null ) { path memory profile path = env get working directory ( ) get relative ( options memory profile path ) ; memory profiler instance ( ) set stable memory parameters ( options memory profile stable heap parameters ) ; try { memory profiler instance ( ) start ( memory profile path get output stream ( ) ) ; } catch ( i o exception e ) { env get reporter ( ) handle ( event error ( " error while creating memory profile file : " + e get message ( ) ) ) ; } } }


attempts to extract generic parameter type of given type if there is no generic parameter it returns object class

private static class < ? > extract generic ( type type ) { if ( type instanceof parameterized type ) { type [ ] generic types = ( ( parameterized type ) type ) get actual type arguments ( ) ; if ( generic types length > 0 & & generic types [ 0 ] instanceof class ) { return ( class < ? > ) generic types [ 0 ] ; } } return object class ; }


< code > optional org apache dubbo metadata definition protobuf model p b request type c dubbo p b request type = 3 ; < code >


alternative to { @ link # expect body list ( class ) } that accepts information about a target type with generics

< e > list body spec < e > expect body list ( parameterized type reference < e > element type ) ;


create the rpc invocation message for the given rpc

protected rpc invocation create rpc invocation message ( final string method name , final class < ? > [ ] parameter types , final object [ ] args ) throws i o exception { final rpc invocation rpc invocation ; if ( is local ) { rpc invocation = new local rpc invocation ( method name , parameter types , args ) ; } else { try { remote rpc invocation remote rpc invocation = new remote rpc invocation ( method name , parameter types , args ) ; if ( remote rpc invocation get size ( ) > maximum framesize ) { throw new i o exception ( string format ( " the rpc invocation size % d exceeds the maximum akka framesize " , remote rpc invocation get size ( ) ) ) ; } else { rpc invocation = remote rpc invocation ; } } catch ( i o exception e ) { log warn ( " could not create remote rpc invocation message failing rpc invocation because " , e ) ; throw e ; } } return rpc invocation ; } / / - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - / / helper methods / / - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -


this function will do following logic based on the configured sps mode : if the configured mode is { @ link storage policy satisfier mode # external } , then it won ' t do anything administrator requires to start external sps service explicitly if the configured mode is { @ link storage policy satisfier mode # none } , then the service is disabled and won ' t do any action

public void start ( ) { if ( ! storage policy enabled ) { log info ( " disabling storage policy satisfier service as { } set to { } " , d f s config keys dfs storage policy enabled key , storage policy enabled ) ; return ; } switch ( mode ) { case external : log info ( " storage policy satisfier is configured as external , " + " please start external sps service explicitly to satisfy policy " ) ; break ; case none : log info ( " storage policy satisfier is disabled " ) ; break ; default : log info ( " given mode : { } is invalid " , mode ) ; break ; } }


returns the { @ link bpmn model } corresponding with the process definition with the provided process definition id the { @ link bpmn model } is a pojo versions of the bpmn 2 0 xml and can be used to introspect the process definition using regular java

bpmn model get bpmn model ( string process definition id ) ;


return the external factory to use for creating new threads , if any

public final thread factory get thread factory ( ) { return this thread factory ; }


public boolean get my boolean ( ) { return my boolean ; }


construct a composed { @ link converter } that first applies this { @ link converter } to its input , and then applies the { @ code after } { @ link converter } to the result

default < u > converter < s , u > and then ( converter < ? super t , ? extends u > after ) { assert not null ( after , " after converter must not be null " ) ; return ( s s ) - > { t initial result = convert ( s ) ; return ( initial result ! = null ? after convert ( initial result ) : null ) ; } ; }


set a unique name for this service ( mainly for logging purposes )

public void set name ( string name ) { this name = name ; }


fake endpoint to test group parameters ( optional ) fake endpoint to test group parameters ( optional )

public void test group parameters ( integer required string group , boolean required boolean group , long required int 6 4 group , integer string group , boolean boolean group , long int 6 4 group , api client auth info auth info , handler < async result < void > > result handler ) { delegate test group parameters ( required string group , required boolean group , required int 6 4 group , string group , boolean group , int 6 4 group , auth info , result handler ) ; }


the number of failed indexing operations

public long get index failed count ( ) { return index failed count ; }


returns the elements of { @ code unfiltered } that satisfy a predicate the returned set is a live view of { @ code unfiltered } ; changes to one affect the other the resulting set ' s iterator does not support { @ code remove ( ) } , but all other set methods are supported when given an element that doesn ' t satisfy the predicate , the set ' s { @ code add ( ) } and { @ code add all ( ) } methods throw an { @ link illegal argument exception } when methods such as { @ code remove all ( ) } and { @ code clear ( ) } are called on the filtered set , only elements that satisfy the filter will be removed from the underlying set the returned set isn ' t threadsafe or serializable , even if { @ code unfiltered } is many of the filtered set ' s methods , such as { @ code size ( ) } , iterate across every element in the underlying set and determine which elements satisfy the filter when a live view is not needed , it may be faster to copy { @ code iterables filter ( unfiltered , predicate ) } and use the copy < b > warning : < b > { @ code predicate } must be consistent with equals , as documented at { @ link predicate # apply } do not provide a predicate such as { @ code predicates instance of ( array list class ) } , which is inconsistent with equals ( see { @ link iterables # filter ( iterable , class ) } for related functionality ) < b > java 8 users : < b > many use cases for this method are better addressed by { @ link java util stream stream # filter } this method is not being deprecated , but we gently encourage you to migrate to streams

public static < e > set < e > filter ( set < e > unfiltered , predicate < ? super e > predicate ) { if ( unfiltered instanceof sorted set ) { return filter ( ( sorted set < e > ) unfiltered , predicate ) ; } if ( unfiltered instanceof filtered set ) { / / support clear ( ) , remove all ( ) , and retain all ( ) when filtering a filtered / / collection filtered set < e > filtered = ( filtered set < e > ) unfiltered ; predicate < e > combined predicate = predicates < e > and ( filtered predicate , predicate ) ; return new filtered set < e > ( ( set < e > ) filtered unfiltered , combined predicate ) ; } return new filtered set < e > ( check not null ( unfiltered ) , check not null ( predicate ) ) ; }


converts { @ link i o exception } on body byte reading to { @ link push network exception }

private static byte [ ] read body bytes ( response body response ) throws push network exception { if ( response = = null ) { throw new push network exception ( " no body ! " ) ; } try { return response bytes ( ) ; } catch ( i o exception e ) { throw new push network exception ( e ) ; } }


public list < fcg vertex > get vertices by level ( fcg level level ) { / / note : these are sorted , since they are housed in a tree map set < fcg vertex > existing vertices = new vertices by source key set ( ) ; / / @ formatter : off list < fcg vertex > vertices at level = existing vertices stream ( ) filter ( v - > v get level ( ) equals ( level ) ) collect ( collectors to list ( ) ) ; / / @ formatter : on return vertices at level ; }


create user this can only be done by the logged in user

public void create user ( user body , api client auth info auth info , handler < async result < void > > result handler ) { delegate create user ( body , auth info , result handler ) ; }


adds a stored field to load and return as part of the search request if none are specified , the source of the document will be return

public search source builder stored field ( string name ) { return stored fields ( collections singleton list ( name ) ) ; }


public void start observer ( ) throws exception { int client port = port assignment unique ( ) ; string config = " server " + observer 1 + " = localhost : " + port assignment unique ( ) + " : " + client port + " : observer ; " + " localhost : " + port assignment unique ( ) ; main thread observer = new main thread ( observer 1 , client port , config ) ; observer start ( ) ; assert false ( client base wait for server up ( " 127 0 0 1 : " + client port , connection timeout ) , " observer was able to start by itself ! " ) ; }


create a summary of the application ' s runtime

public static summary builder create app summary ( r m app app ) { string tracking url = " n / a " ; string host = " n / a " ; r m app attempt attempt = app get current app attempt ( ) ; if ( attempt ! = null ) { tracking url = attempt get tracking url ( ) ; container master container = attempt get master container ( ) ; if ( master container ! = null ) { node id node id = master container get node id ( ) ; if ( node id ! = null ) { string am host = node id get host ( ) ; if ( am host ! = null ) { host = am host ; } } } } r m app metrics metrics = app get r m app metrics ( ) ; summary builder summary = new summary builder ( ) add ( " app id " , app get application id ( ) ) add ( " name " , app get name ( ) ) add ( " user " , app get user ( ) ) add ( " queue " , app get queue ( ) ) add ( " state " , app get state ( ) ) add ( " tracking url " , tracking url ) add ( " app master host " , host ) add ( " submit time " , app get submit time ( ) ) add ( " start time " , app get start time ( ) ) add ( " launch time " , app get launch time ( ) ) add ( " finish time " , app get finish time ( ) ) add ( " final status " , app get final application status ( ) ) add ( " memory seconds " , metrics get memory seconds ( ) ) add ( " vcore seconds " , metrics get vcore seconds ( ) ) add ( " preempted memory seconds " , metrics get preempted memory seconds ( ) ) add ( " preempted vcore seconds " , metrics get preempted vcore seconds ( ) ) add ( " preempted a m containers " , metrics get num a m containers preempted ( ) ) add ( " preempted non a m containers " , metrics get num non a m containers preempted ( ) ) add ( " preempted resources " , metrics get resource preempted ( ) ) add ( " application type " , app get application type ( ) ) add ( " resource seconds " , string helper get resource seconds string ( metrics get resource seconds map ( ) ) ) add ( " preempted resource seconds " , string helper get resource seconds string ( metrics get preempted resource seconds map ( ) ) ) add ( " application tags " , string helper csv joiner join ( app get application tags ( ) ! = null ? new tree set < > ( app get application tags ( ) ) : collections < string > empty set ( ) ) ) add ( " application node label " , app get application submission context ( ) get node label expression ( ) = = null ? " " : app get application submission context ( ) get node label expression ( ) ) add ( " diagnostics " , app get diagnostics ( ) ) add ( " total allocated containers " , metrics get total allocated containers ( ) ) ; return summary ; }


returns a builder that creates immutable sorted multisets with an explicit comparator if the comparator has a more general type than the set being generated , such as creating a { @ code sorted multiset < integer > } with a { @ code comparator < number > } , use the { @ link builder } constructor instead

public static < e > builder < e > ordered by ( comparator < e > comparator ) { return new builder < e > ( comparator ) ; }


set the message body converters to use these converters are used to convert from and to http requests and responses

public void set message converters ( list < http message converter < ? > > message converters ) { this message converters = message converters ; }


sets the password character for the text field the character must be present in the { @ link bitmap font } default is 149 ( bullet )

public void set password character ( char password character ) { this password character = password character ; if ( password mode ) update display text ( ) ; }


helper method to retrieve the user group information from the http servlet request

public static user group information get caller user group information ( http servlet request hsr , boolean use principal ) { string remote user = hsr get remote user ( ) ; if ( use principal ) { principal princ = hsr get user principal ( ) ; remote user = princ = = null ? null : princ get name ( ) ; } user group information caller u g i = null ; if ( remote user ! = null ) { caller u g i = user group information create remote user ( remote user ) ; } return caller u g i ; }


restore the current state from the stack , must match a call to { @ link # save ( ) }

public void restore ( ) { canvas matrix restore ( ) ; }


peek data from { @ code input } , respecting { @ code quiet } return true if the peek is successful if { @ code quiet = false } then encountering the end of the input ( whether before or after reading some data ) will throw { @ link e o f exception } if { @ code quiet = true } then encountering the end of the input ( even after reading some data ) will return { @ code false } this is slightly different to the behaviour of { @ link extractor input # peek fully ( byte [ ] , int , int , boolean ) } , where { @ code allow end of input = true } only returns false ( and suppresses the exception ) if the end of the input is reached before reading any data

private static boolean peek safely ( extractor input input , byte [ ] output , int offset , int length , boolean quiet ) throws i o exception { try { return input peek fully ( output , offset , length , / * allow end of input = * / quiet ) ; } catch ( e o f exception e ) { if ( quiet ) { return false ; } else { throw e ; } } }


create a panel for all checkboxes related to applying differences

private j panel create diff panel ( ) { j panel panel = new j panel ( ) ; titled border border = new titled border ( " do differences on " ) ; panel set border ( border ) ; panel add ( create diff filter panel ( ) ) ; return panel ; }


returns a pretty - print string of all found windows that are showing , nesting by parent - child relationship

public static string get open windows as string ( ) { set < window > all found windows = get all windows ( ) ; / / @ formatter : off list < window > roots = all found windows stream ( ) filter ( w - > w get parent ( ) = = null ) collect ( collectors to list ( ) ) ; / / @ formatter : on string builder buffy = new string builder ( " \ n " ) ; for ( window w : roots ) { if ( ! is hierarchy showing ( w ) ) { continue ; } window to string ( w , 0 , buffy ) ; } return buffy to string ( ) ; }


creates a { @ link channel } from the given channel builder and command transport this method can be used to allow { @ link computer launcher } s to create channels not based on io streams

public void set channel ( @ non null channel builder cb , @ non null command transport command transport , @ check for null channel listener listener ) throws i o exception , interrupted exception { for ( channel configurator cc : channel configurator all ( ) ) { cc on channel building ( cb , this ) ; } output stream header stream = cb get header stream ( ) ; if ( header stream = = null ) { logger log ( level warning , " no header stream defined when setting channel for computer { 0 } " + " launch log won ' t be printed " , this ) ; } channel channel = cb build ( command transport ) ; set channel ( channel , header stream , listener ) ; }


get current directory corresponding to the datanode as defined in ( @ link storage # storage dir current }

public static string get d n current dir ( file storage dir ) { return storage dir + " / " + storage storage dir current + " / " ; }


convert the given hibernate exception to an appropriate exception from the { @ code org springframework dao } hierarchy will automatically apply a specified s q l exception translator to a hibernate j d b c exception , otherwise rely on hibernate ' s default translation

protected data access exception convert hibernate access exception ( hibernate exception ex ) { if ( this jdbc exception translator ! = null & & ex instanceof j d b c exception ) { j d b c exception jdbc ex = ( j d b c exception ) ex ; data access exception dae = this jdbc exception translator translate ( " hibernate operation : " + jdbc ex get message ( ) , jdbc ex get s q l ( ) , jdbc ex get s q l exception ( ) ) ; if ( dae ! = null ) { throw dae ; } } return session factory utils convert hibernate access exception ( ex ) ; }


public void delete image ( ) { renderer delete image ( ) ; current bitmap = null ; request render ( ) ; }


returns a currently open ghidra { @ link program } that has metadata that links it to the specified { @ code file } parameter ( ie an open program has a md5 or fsrl metadata value that matches the file ) see also { @ link # is file open ( fsrl ) }

public static program find matching open program ( fsrl fsrl , object consumer ) { string expected m d 5 = fsrl get m d 5 ( ) ; / / use a temp consumer to hold the domain object open because the caller - supplied / / consumer might already have been used to open one of the files we are querying object tmp consumer = new object ( ) ; list < domain file > open domain files = app info get active project ( ) get open data ( ) ; for ( domain file df : open domain files ) { domain object opened domain object = df get opened domain object ( tmp consumer ) ; try { if ( opened domain object instanceof program ) { program program = ( program ) opened domain object ; options property list = program get options ( program program info ) ; string fsrl str = property list get string ( program mapping service program source fsrl , null ) ; string md 5 = property list get string ( program mapping service program metadata md5 , null ) ; if ( ( expected m d 5 ! = null & & expected m d 5 equals ( md 5 ) ) | | fsrl is equivalent ( fsrl str ) ) { / / lock the domain file with the caller - supplied consumer now that / / we ' ve found it df get opened domain object ( consumer ) ; return program ; } } } finally { if ( opened domain object ! = null ) { opened domain object release ( tmp consumer ) ; } } } return null ; }


convenience method to create an action which places the application to the default queue

public static mapping rule action create place to default action ( ) { return create place to queue action ( default queue variable , false ) ; }


shrinks the starts and lengths array as items at the end of the list are removed

private void shrink arrays ( int capacity ) { int size = math max ( capacity , 4 ) ; int [ ] new starts = new int [ size ] ; short [ ] new lengths = new short [ size ] ; system arraycopy ( starts , 0 , new starts , 0 , new starts length ) ; system arraycopy ( lengths , 0 , new lengths , 0 , new starts length ) ; starts = new starts ; lengths = new lengths ; }


convert the given object to string with each line indented by 4 spaces ( except the first line )

private string to indented string ( object o ) { if ( o = = null ) { return " null " ; } return o to string ( ) replace ( " \ n " , " \ n " ) ; }


public void test compression ratio standardization ( ) throws exception { assert equals ( 0 55f , compression emulation util standardize compression ratio ( 0 55f ) , 0 0d ) ; assert equals ( 0 65f , compression emulation util standardize compression ratio ( 0 652f ) , 0 0d ) ; assert equals ( 0 78f , compression emulation util standardize compression ratio ( 0 777f ) , 0 0d ) ; assert equals ( 0 86f , compression emulation util standardize compression ratio ( 0 855f ) , 0 0d ) ; }


creates { @ link work processor } from { @ link process } { @ link process } instance will be dereferenced immediately after { @ link work processor } is finished

static < t > work processor < t > create ( process < t > process ) { return work processor utils create ( process ) ; }


public static bitmap get bitmap ( @ non null final string key , @ non null final cache double utils cache double utils ) { return cache double utils get bitmap ( key ) ; }


verifies content of the response when domain is not specified

public void test empty domain ( ) { socks 5 command response socks 5 cmd response = new default socks 5 command response ( socks 5 command status success , socks 5 address type domain ) ; assert null ( socks 5 cmd response bnd addr ( ) ) ; assert equals ( 0 , socks 5 cmd response bnd port ( ) ) ; byte buf buffer = socks 5 common test utils encode server ( socks 5 cmd response ) ; byte [ ] expected = { 0x 0 5 , / / version 0x 0 0 , / / success reply 0x 0 0 , / / reserved 0x 0 3 , / / address type domain 0x 0 0 , / / length of domain 0x 0 0 , / / port value 0x 0 0 } ; assert byte buf equals ( expected , buffer ) ; buffer release ( ) ; }


public void nullable message test ( ) { / / todo : test nullable message }


creates a { @ code tree based table } with the same mappings and sort order as the specified { @ code tree based table }

public static < r , c , v > tree based table < r , c , v > create ( tree based table < r , c , ? extends v > table ) { tree based table < r , c , v > result = new tree based table < > ( table row comparator ( ) , table column comparator ( ) ) ; result put all ( table ) ; return result ; }


template method that allows for manipulating the { @ link image write param } before it is used to write an image the default implementation is empty

protected void process ( image write param iwp ) { }


takes program arguments as a single string , and splits them into a list of string tokenize arguments ( " - - foo bar " ) = [ " - - foo " " bar " ] tokenize arguments ( " - - foo \ " bar baz \ " " ) = [ " - - foo " " bar baz " ] tokenize arguments ( " - - foo ' bar baz ' " ) = [ " - - foo " " bar baz " ] tokenize arguments ( null ) = [ ] warning : this method does not respect escaped quotes

static list < string > tokenize arguments ( @ nullable final string args ) { if ( args = = null ) { return collections empty list ( ) ; } final matcher matcher = arguments tokenize pattern matcher ( args ) ; final list < string > tokens = new array list < > ( ) ; while ( matcher find ( ) ) { tokens add ( matcher group ( ) trim ( ) replace ( " \ " " , " " ) replace ( " \ ' " , " " ) ) ; } return tokens ; }


public void test hang on sink read ( ) throws exception { new config builder ( ) add ( " * period " , 8 ) add ( " test sink test class " , test sink class get name ( ) ) save ( test metrics config get test filename ( " hadoop - metrics 2 - test " ) ) ; metrics system impl ms = new metrics system impl ( " test " ) ; ms start ( ) ; try { count down latch collecting latch = new count down latch ( 1 ) ; metrics sink sink = new test closable sink ( collecting latch ) ; ms register sink ( " closeable sink " , " the sink will be used to test closeability " , sink ) ; / / trigger metric collection first time ms on timer event ( ) ; / / make sure that sink is collecting metrics assert true ( collecting latch await ( 1 , time unit seconds ) ) ; } finally { ms stop ( ) ; } }


removes all vertices and edges from the graph without changing the space allocated

public void clear ( ) { this edges clear ( ) ; this vertices clear ( ) ; this edge attributes clear ( ) ; this vertex attributes clear ( ) ; }


the name of the type this corresponds to the ' type ' part of a full resource name of the form package : typeentry the set of legal type names is listed in resource cpp < code > optional string name = 2 ; < code >

public com google protobuf byte string get name bytes ( ) { return com google protobuf byte string copy from utf 8 ( name ) ; }


if end time & gt ; = 0 the parameter is not set

public influencers query builder end ( string end time ) { influencers query end = end time ; return this ; }


replaces the internal components of this structure with components of the given structure

public void replace with ( data type data type ) { if ( ! ( data type instanceof structure ) ) { throw new illegal argument exception ( ) ; } structure struct = ( structure ) data type ; int old length = struct length ; components clear ( ) ; struct length = 0 ; num components = 0 ; flexible array component = null ; set alignment ( struct ) ; if ( struct is internally aligned ( ) ) { do replace with aligned ( struct ) ; } else { do replace with unaligned ( struct ) ; } data type component flex component = struct get flexible array component ( ) ; if ( flex component ! = null ) { set flexible array component ( flex component get data type ( ) , flex component get field name ( ) , flex component get comment ( ) ) ; } if ( old length ! = struct length ) { notify size changed ( ) ; } }


public void kind test ( ) { / / todo : test kind }


configures the string that starts comments by default comments will be treated as invalid lines this function only recognizes comments which start at the beginning of the line !

public csv reader ignore comments ( string comment prefix ) { if ( comment prefix = = null | | comment prefix length ( ) = = 0 ) { throw new illegal argument exception ( " the comment prefix must not be null or an empty string " ) ; } this comment prefix = comment prefix ; return this ; }


public static < t > t invoke method by name ( final object obj , final string method name , final object [ ] args ) { method method = get accessible method by name ( obj get class ( ) , method name ) ; if ( method = = null ) { throw new illegal argument exception ( " could not find method [ " + method name + " ] on class [ " + obj get class ( ) + ' ] ' ) ; } return invoke method ( obj , method , args ) ; }


invoke to notify all registered listeners of an updated global checkpoint

synchronized void global checkpoint updated ( final long global checkpoint ) { assert global checkpoint > = no ops performed ; assert global checkpoint > last known global checkpoint : " updated global checkpoint [ " + global checkpoint + " ] " + " is not more than the last known global checkpoint [ " + last known global checkpoint + " ] " ; last known global checkpoint = global checkpoint ; notify listeners ( global checkpoint , null ) ; }


returns the full ( the actual ) shape of a vertex this can be used to determine if a mouse point intersects a vertex or to get the real bounding - box of a vertex

default public shape get full shape ( ) { return get compact shape ( ) ; }


adds the specified value to the specified element of this big array

public void add ( long index , int value ) { array [ segment ( index ) ] [ offset ( index ) ] + = value ; }


public offset date time get ship date ( ) { return ship date ; }


create a { @ code repartitioned } instance with provided number of partitions for repartition topic

public static < k , v > repartitioned < k , v > number of partitions ( final int number of partitions ) { return new repartitioned < > ( null , null , null , number of partitions , null ) ; }


check if an exception is isolated to a single stream or the entire connection

public static boolean is stream error ( http 2 exception e ) { return e instanceof stream exception ; }


extract a normalized simple comparison between a qualified name reference and a native value if possible

private optional < normalized simple comparison > to normalized simple comparison ( operator type operator type , row expression left expression , row expression right expression ) { object left ; object right ; if ( left expression instanceof variable reference expression ) { left = left expression ; } else { left = new row expression interpreter ( left expression , metadata , session , optimized ) optimize ( ) ; } if ( right expression instanceof variable reference expression ) { right = right expression ; } else { right = new row expression interpreter ( right expression , metadata , session , optimized ) optimize ( ) ; } if ( left instanceof row expression = = right instanceof row expression ) { / / we expect one side to be row expression and other to be value return optional empty ( ) ; } row expression expression ; operator type comparison operator ; nullable value value ; if ( left instanceof row expression ) { expression = left expression ; comparison operator = operator type ; value = new nullable value ( right expression get type ( ) , right ) ; } else { expression = right expression ; comparison operator = flip ( operator type ) ; value = new nullable value ( left expression get type ( ) , left ) ; } return optional of ( new normalized simple comparison ( expression , comparison operator , value ) ) ; }


execute a query given static sql , mapping each row to a result object via a row mapper , and turning it into an iterable and closeable stream uses a jdbc statement , not a prepared statement if you want to execute a static query with a prepared statement , use the overloaded { @ code query } method with { @ code null } as argument array

< t > stream < t > query for stream ( string sql , row mapper < t > row mapper ) throws data access exception ;


public static set < long > get concurrency map key set ( ) { return now calls map key set ( ) ; }


public void map array integer test ( ) { / / todo : test map array integer }


build the rule map from raw list of parameter flow rules , grouping by provided group function

public static < k > map < k , list < param flow rule > > build param rule map ( list < param flow rule > list , function < param flow rule , k > group function , predicate < param flow rule > filter , boolean should sort ) { assert util not null ( group function , " group function should not be null " ) ; map < k , list < param flow rule > > new rule map = new concurrent hash map < > ( ) ; if ( list = = null | | list is empty ( ) ) { return new rule map ; } map < k , set < param flow rule > > tmp map = new concurrent hash map < > ( ) ; for ( param flow rule rule : list ) { if ( ! param flow rule util is valid rule ( rule ) ) { record log warn ( " [ param flow rule manager ] ignoring invalid rule when loading new rules : " + rule ) ; continue ; } if ( filter ! = null & & ! filter test ( rule ) ) { continue ; } if ( string util is blank ( rule get limit app ( ) ) ) { rule set limit app ( rule constant limit app default ) ; } param flow rule util fill exception flow items ( rule ) ; k key = group function apply ( rule ) ; if ( key = = null ) { continue ; } set < param flow rule > flow rules = tmp map get ( key ) ; if ( flow rules = = null ) { / / use hash set here to remove duplicate rules flow rules = new hash set < > ( ) ; tmp map put ( key , flow rules ) ; } flow rules add ( rule ) ; } for ( entry < k , set < param flow rule > > entries : tmp map entry set ( ) ) { list < param flow rule > rules = new array list < > ( entries get value ( ) ) ; if ( should sort ) { / / todo : sort the rules } new rule map put ( entries get key ( ) , rules ) ; } return new rule map ; }


load directory diff list for a directory with snapshot feature

private void load directory diff list ( input stream in , i node directory dir , int size , final list < i node reference > ref list ) throws i o exception { if ( ! dir is with snapshot ( ) ) { dir add snapshot feature ( null ) ; } directory diff list diffs = dir get diffs ( ) ; final loader context state = parent get loader context ( ) ; for ( int i = 0 ; i < size ; i + + ) { / / load a directory diff snapshot diff section directory diff diff in pb = snapshot diff section directory diff parse delimited from ( in ) ; final int snapshot id = diff in pb get snapshot id ( ) ; final snapshot snapshot = snapshot map get ( snapshot id ) ; int children size = diff in pb get children size ( ) ; boolean use root = diff in pb get is snapshot root ( ) ; i node directory attributes copy = null ; if ( use root ) { copy = snapshot get root ( ) ; } else if ( diff in pb has snapshot copy ( ) ) { i node section i node directory dir copy in pb = diff in pb get snapshot copy ( ) ; final byte [ ] name = diff in pb get name ( ) to byte array ( ) ; permission status permission = load permission ( dir copy in pb get permission ( ) , state get string table ( ) ) ; acl feature acl = null ; if ( dir copy in pb has acl ( ) ) { int [ ] entries = acl entry status format to int ( f s image format p b i node loader load acl entries ( dir copy in pb get acl ( ) , state get string table ( ) ) ) ; acl = new acl feature ( entries ) ; } x attr feature x attrs = null ; if ( dir copy in pb has x attrs ( ) ) { x attrs = new x attr feature ( f s image format p b i node loader load x attrs ( dir copy in pb get x attrs ( ) , state get string table ( ) ) ) ; } long mod time = dir copy in pb get modification time ( ) ; boolean no quota = dir copy in pb get ns quota ( ) = = - 1 & & dir copy in pb get ds quota ( ) = = - 1 & & ( ! dir copy in pb has type quotas ( ) ) ; if ( no quota ) { copy = new i node directory attributes snapshot copy ( name , permission , acl , mod time , x attrs ) ; } else { enum counters < storage type > type quotas = null ; if ( dir copy in pb has type quotas ( ) ) { immutable list < quota by storage type entry > qes = f s image format p b i node loader load quota by storage type entries ( dir copy in pb get type quotas ( ) ) ; type quotas = new enum counters < storage type > ( storage type class , hdfs constants quota reset ) ; for ( quota by storage type entry qe : qes ) { if ( qe get quota ( ) > = 0 & & qe get storage type ( ) ! = null & & qe get storage type ( ) support type quota ( ) ) { type quotas set ( qe get storage type ( ) , qe get quota ( ) ) ; } } } copy = new i node directory attributes copy with quota ( name , permission , acl , mod time , dir copy in pb get ns quota ( ) , dir copy in pb get ds quota ( ) , type quotas , x attrs ) ; } } / / load created list list < i node > clist = load created list ( in , dir , diff in pb get created list size ( ) ) ; / / load deleted list list < i node > dlist = load deleted list ( ref list , in , dir , diff in pb get deleted i node list ( ) , diff in pb get deleted i node ref list ( ) ) ; / / create the directory diff directory diff diff = new directory diff ( snapshot id , copy , null , children size , clist , dlist , use root ) ; diffs add first ( diff ) ; } }


public string to human ( ) { return annotation to human ( ) ; }


ends this comparison chain and returns its result : a value having the same sign as the first nonzero comparison result in the chain , or zero if every result was zero


returns this rule class ' s custom starlark rule implementation

public starlark callable get configured target function ( ) { return configured target function ; }


triggers a ' save as ' dialog that allows the user to save off the tool under a different name this returns true if the user performed a save

public boolean save tool as ( ) { return dialog mgr save tool as ( ) ; }


get the encryption secrets this potentially sensitive information and must be treated with care

public encryption secrets get encryption secrets ( ) { return encryption secrets ; }


public void combine ( aggregator < t , numeric column summary < t > > other same type ) { numeric summary aggregator < t > other = ( numeric summary aggregator < t > ) other same type ; null count + = other null count ; nan count + = other nan count ; infinity count + = other infinity count ; if ( non missing count = = 0 ) { non missing count = other non missing count ; min = other min ; max = other max ; sum = other sum ; mean = other mean ; m 2 = other m 2 ; } else if ( other non missing count ! = 0 ) { long combined count = non missing count + other non missing count ; min combine ( other min ) ; max combine ( other max ) ; sum combine ( other sum ) ; double delta mean = other mean value ( ) - mean value ( ) ; mean = mean add ( delta mean * other non missing count / combined count ) ; m 2 = m 2 add ( other m 2 ) add ( delta mean * delta mean * non missing count * other non missing count / combined count ) ; non missing count = combined count ; } }


returns the portion of the second file that trails the full path of the first file if the paths are the same or unrelated , then null is returned < p > for example , given , in this order , two files with these paths < code > ab < code > and < code > abc < code > , this method will return ' c '

public static string relativize path ( file f 1 , file f 2 ) throws i o exception { string parent path = f 1 get canonical path ( ) replace ( ' \ \ ' , ' / ' ) ; string other path = f 2 get canonical path ( ) replace ( ' \ \ ' , ' / ' ) ; if ( parent path equals ( other path ) ) { return null ; } if ( ! parent path ends with ( " / " ) ) { parent path + = " / " ; } if ( ! other path starts with ( parent path ) ) { return null ; } string child path = other path substring ( parent path length ( ) ) ; return child path ; }


returns the metrics cache to help prevent re - registrations

public static map < string , queue metrics > get queue metrics ( ) { return queue metrics ; }


returns the highest value in the snapshot

public long get max ( ) { if ( values length = = 0 ) { return 0 ; } return values [ values length - 1 ] ; }


public int get num modules ( ) { return module information list size ( ) ; }


see { @ link kafka producer # abort transaction ( ) }

void abort transaction ( ) throws producer fenced exception ;


private static void initialize data ( cake baking service cake baking service ) { cake baking service save new layer ( new cake layer info ( " chocolate " , 1200 ) ) ; cake baking service save new layer ( new cake layer info ( " banana " , 900 ) ) ; cake baking service save new layer ( new cake layer info ( strawberry , 950 ) ) ; cake baking service save new layer ( new cake layer info ( " lemon " , 950 ) ) ; cake baking service save new layer ( new cake layer info ( " vanilla " , 950 ) ) ; cake baking service save new layer ( new cake layer info ( strawberry , 950 ) ) ; cake baking service save new topping ( new cake topping info ( " candies " , 350 ) ) ; cake baking service save new topping ( new cake topping info ( " cherry " , 350 ) ) ; var cake 1 = new cake info ( new cake topping info ( " candies " , 0 ) , list of ( new cake layer info ( " chocolate " , 0 ) , new cake layer info ( " banana " , 0 ) , new cake layer info ( strawberry , 0 ) ) ) ; try { cake baking service bake new cake ( cake 1 ) ; } catch ( cake baking exception e ) { e print stack trace ( ) ; } var cake 2 = new cake info ( new cake topping info ( " cherry " , 0 ) , list of ( new cake layer info ( " vanilla " , 0 ) , new cake layer info ( " lemon " , 0 ) , new cake layer info ( strawberry , 0 ) ) ) ; try { cake baking service bake new cake ( cake 2 ) ; } catch ( cake baking exception e ) { e print stack trace ( ) ; } }


return the bytes of aes decryption for hex string

public static byte [ ] decrypt hex string a e s ( final string data , final byte [ ] key , final string transformation , final byte [ ] iv ) { return decrypt a e s ( utils bridge hex string 2 bytes ( data ) , key , transformation , iv ) ; }


returns whether this is a hole { @ link cache span }

public boolean is hole span ( ) { return ! is cached ; }


exit a parse tree produced by { @ link sql base parser # pattern escape }

void exit pattern escape ( sql base parser pattern escape context ctx ) ;


used to call seccomp ( 2 ) , its too new this is the only way , don ' t use it on some other architecture unless you know wtf you are doing

native long syscall ( native long number , object args ) ;


see { @ link # size of black white black run ( int , int , int , int ) } ; computes the total width of a finder pattern by looking for a black - white - black run from the center in the direction of another point ( another finder pattern center ) , and in the opposite direction too

private float size of black white black run both ways ( int from x , int from y , int to x , int to y ) { float result = size of black white black run ( from x , from y , to x , to y ) ; / / now count other way - - don ' t run off image though of course float scale = 1 0f ; int other to x = from x - ( to x - from x ) ; if ( other to x < 0 ) { scale = from x / ( float ) ( from x - other to x ) ; other to x = 0 ; } else if ( other to x > = image get width ( ) ) { scale = ( image get width ( ) - 1 - from x ) / ( float ) ( other to x - from x ) ; other to x = image get width ( ) - 1 ; } int other to y = ( int ) ( from y - ( to y - from y ) * scale ) ; scale = 1 0f ; if ( other to y < 0 ) { scale = from y / ( float ) ( from y - other to y ) ; other to y = 0 ; } else if ( other to y > = image get height ( ) ) { scale = ( image get height ( ) - 1 - from y ) / ( float ) ( other to y - from y ) ; other to y = image get height ( ) - 1 ; } other to x = ( int ) ( from x + ( other to x - from x ) * scale ) ; result + = size of black white black run ( from x , from y , other to x , other to y ) ; / / middle pixel is double - counted this way ; subtract 1 return result - 1 0f ; }


public abstract set < string > get node labels ( ) ;


returns the child at the specified index

public actor get child ( int index ) { return children get ( index ) ; }


declare that this filesystem connector is always read only { @ inherit doc }

public boolean has path capability ( final path path , final string capability ) throws i o exception { switch ( validate path capability args ( path , capability ) ) { case common path capabilities fs read only connector : return true ; default : return super has path capability ( path , capability ) ; } }


add the given , single header value under the given name

s header ( string header name , string header values ) ;


sets { @ link android net traffic stats } tag to use when accounting socket traffic caused by this channel see { @ link android net traffic stats } for more information if no tag is set ( e g this method isn ' t called ) , then android accounts for the socket traffic caused by this channel as if the tag value were set to 0 < b > note : < b > setting a tag disallows sharing of sockets with channels with other tags , which may adversely effect performance by prohibiting connection sharing in other words use of multiplexed sockets ( e g http2 and quic ) will only be allowed if all channels have the same socket tag

final cronet channel builder set traffic stats tag ( int tag ) { traffic stats tag set = true ; traffic stats tag = tag ; return this ; }


returns a range that contains all values strictly greater than { @ code endpoint }

public static < c extends comparable < ? > > range < c > greater than ( c endpoint ) { return create ( cut above value ( endpoint ) , cut < c > above all ( ) ) ; }


return true if this additional properties array object is equal to o

public boolean equals ( object o ) { if ( this = = o ) { return true ; } if ( o = = null | | get class ( ) ! = o get class ( ) ) { return false ; } additional properties array additional properties array = ( additional properties array ) o ; return objects equals ( this name , additional properties array name ) & & objects equals ( this additional properties , additional properties array additional properties ) ; }


public map < string , integer > get map integer ( ) { return map integer ; }


fails with classpath errors on trying to classload annotation async execution aspect

public void aspect mode aspect j attempts to register async aspect ( ) { @ suppress warnings ( " resource " ) annotation config application context ctx = new annotation config application context ( ) ; ctx register ( aspect j async annotation config class ) ; assert that exception of type ( bean definition store exception class ) is thrown by ( ctx : : refresh ) ; }


convert the given object to string with each line indented by 4 spaces ( except the first line )

private string to indented string ( object o ) { if ( o = = null ) { return " null " ; } return o to string ( ) replace ( " \ n " , " \ n " ) ; }


returns true if the given address does not point to the minimum address of the containing { @ link code unit }

public static boolean is offcut ( program program , address address ) { if ( ! address is memory address ( ) ) { return false ; } listing listing = program get listing ( ) ; code unit cu = listing get code unit containing ( address ) ; if ( cu = = null ) { return false ; } if ( cu instanceof data ) { / / update the code unit for the composite data like structures and arrays , as the / / call to get code unit containing ( ) gets the outermost data , not the inner - most cu = get deepest data containing ( address , program ) ; } if ( cu get min address ( ) equals ( address ) ) { return false ; } return true ; }


register a backup name - node , verifying that it belongs to the correct namespace , and adding it to the set of active journals if necessary

void register backup node ( namenode registration bn reg , namenode registration nn reg ) throws i o exception { write lock ( ) ; try { if ( get f s image ( ) get storage ( ) get namespace i d ( ) ! = bn reg get namespace i d ( ) ) throw new i o exception ( " incompatible namespace i ds : " + " namenode namespace i d = " + get f s image ( ) get storage ( ) get namespace i d ( ) + " ; " + bn reg get role ( ) + " node namespace i d = " + bn reg get namespace i d ( ) ) ; if ( bn reg get role ( ) = = namenode role backup ) { get f s image ( ) get edit log ( ) register backup node ( bn reg , nn reg ) ; } } finally { write unlock ( " register backup node " ) ; } }


verify some stage of a dying sun , but go back in time to test the memento

public void test set memento ( ) { final var star = new star ( star type sun , 1 , 2 ) ; final var first memento = star get memento ( ) ; assert equals ( " sun age : 1 years mass : 2 tons " , star to string ( ) ) ; star time passes ( ) ; final var second memento = star get memento ( ) ; assert equals ( " red giant age : 2 years mass : 16 tons " , star to string ( ) ) ; star time passes ( ) ; final var third memento = star get memento ( ) ; assert equals ( " white dwarf age : 4 years mass : 128 tons " , star to string ( ) ) ; star time passes ( ) ; assert equals ( " supernova age : 8 years mass : 1024 tons " , star to string ( ) ) ; star set memento ( third memento ) ; assert equals ( " white dwarf age : 4 years mass : 128 tons " , star to string ( ) ) ; star time passes ( ) ; assert equals ( " supernova age : 8 years mass : 1024 tons " , star to string ( ) ) ; star set memento ( second memento ) ; assert equals ( " red giant age : 2 years mass : 16 tons " , star to string ( ) ) ; star set memento ( first memento ) ; assert equals ( " sun age : 1 years mass : 2 tons " , star to string ( ) ) ; }


verify the class of an exception if it is not as expected , rethrow it comparison is on the exact class , not subclass - of inference as offered by { @ code instanceof }

public static < e extends throwable > e verify exception class ( class < e > clazz , exception ex ) throws exception { if ( ! ( ex get class ( ) equals ( clazz ) ) ) { throw ex ; } return ( e ) ex ; }


query given sql to create a prepared statement from sql and a list of arguments to bind to the query , expecting a result object the query is expected to be a single rowsingle column query ; the returned result will be directly mapped to the corresponding object type

< t > t query for object ( string sql , sql parameter source param source , class < t > required type ) throws data access exception ;


public static void e ( string tag , string message , exception exception ) { if ( s is log enabled ) { log e ( tag , get content ( get current stack trace element ( ) ) + " \ n > " + exception get message ( ) + " \ n > " + exception get stack trace ( ) + " " + message ) ; exception print stack trace ( ) ; } }


creates a new { @ code session windows } { @ link window assigner } that assigns elements to sessions based on the element timestamp

public static < t > dynamic processing time session windows < t > with dynamic gap ( session window time gap extractor < t > session window time gap extractor ) { return new dynamic processing time session windows < > ( session window time gap extractor ) ; }


copy a script , renaming references to the class name

private void copy script ( resource file source script , resource file destination script ) throws i o exception { string old class name = ghidra script util get base name ( source script ) ; string new class name = ghidra script util get base name ( destination script ) ; resource file parent file = source script get parent file ( ) ; resource file temp = new resource file ( parent file , " ghidra script tmp " ) ; try ( print writer writer = new print writer ( temp get output stream ( ) ) ) { try ( buffered reader reader = new buffered reader ( new input stream reader ( source script get input stream ( ) ) ) ) { while ( true ) { string line = reader read line ( ) ; if ( line = = null ) { break ; } writer println ( line replace all ( old class name , new class name ) ) ; } } } file utilities copy file ( temp , destination script , task monitor dummy ) ; temp delete ( ) ; }


sets whether to use the orientation sensor for rotation during spherical playbacks ( if available )

public void set use sensor rotation ( boolean use sensor rotation ) { if ( this use sensor rotation ! = use sensor rotation ) { this use sensor rotation = use sensor rotation ; if ( surface view instanceof spherical g l surface view ) { ( ( spherical g l surface view ) surface view ) set use sensor rotation ( use sensor rotation ) ; } } }


gets the type handler to use when reading the result set tries to get from the type handler registry by searching for the property type if not found it gets the column jdbc type and tries to get a handler for it

public type handler < ? > get type handler ( class < ? > property type , string column name ) { type handler < ? > handler = null ; map < class < ? > , type handler < ? > > column handlers = type handler map get ( column name ) ; if ( column handlers = = null ) { column handlers = new hash map < > ( ) ; type handler map put ( column name , column handlers ) ; } else { handler = column handlers get ( property type ) ; } if ( handler = = null ) { jdbc type jdbc type = get jdbc type ( column name ) ; handler = type handler registry get type handler ( property type , jdbc type ) ; / / replicate logic of unknown type handler # resolve type handler / / see issue # 59 comment 10 if ( handler = = null | | handler instanceof unknown type handler ) { final int index = column names index of ( column name ) ; final class < ? > java type = resolve class ( class names get ( index ) ) ; if ( java type ! = null & & jdbc type ! = null ) { handler = type handler registry get type handler ( java type , jdbc type ) ; } else if ( java type ! = null ) { handler = type handler registry get type handler ( java type ) ; } else if ( jdbc type ! = null ) { handler = type handler registry get type handler ( jdbc type ) ; } } if ( handler = = null | | handler instanceof unknown type handler ) { handler = new object type handler ( ) ; } column handlers put ( property type , handler ) ; } return handler ; }


prepares python environment to start python process

static python environment prepare python environment ( readable config config , string entry point script , string tmp dir ) throws i o exception { python environment env = new python environment ( ) ; / / 1 set the path of python interpreter string python exec = config get optional ( python client executable ) or else ( system getenv ( pyflink client executable ) ) ; if ( python exec ! = null ) { env python exec = python exec ; } / / 2 setup temporary local directory for the user files tmp dir = new file ( tmp dir ) get absolute path ( ) ; path tmp dir path = new path ( tmp dir ) ; tmp dir path get file system ( ) mkdirs ( tmp dir path ) ; env temp directory = tmp dir ; / / 3 append the internal lib files to pythonpath if ( system getenv ( config constants env flink opt dir ) ! = null ) { string python lib dir = system getenv ( config constants env flink opt dir ) + file separator + " python " ; env python path = get lib files ( python lib dir ) stream ( ) map ( p - > p to file ( ) get absolute path ( ) ) collect ( collectors joining ( file path separator ) ) ; } / / 4 copy relevant python files to tmp dir and set them in pythonpath if ( config get optional ( python files ) is present ( ) ) { list < path > python files = arrays stream ( config get ( python files ) split ( file delimiter ) ) map ( path : : new ) collect ( collectors to list ( ) ) ; add to python path ( env , python files ) ; } if ( entry point script ! = null ) { add to python path ( env , collections singleton list ( new path ( entry point script ) ) ) ; } return env ; }


public void name test ( ) { / / todo : test name }


returns true if these options contain the given { @ link fragment options }

public boolean contains ( class < ? extends fragment options > options class ) { return fragment options map contains key ( options class ) ; }


same as { @ link # regex ( string ) } with full regular expression options see { @ link regex options builder }

public completion suggestion builder regex ( string regex , regex options regex options ) { this regex ( regex ) ; this regex options = regex options ; return this ; }


creates a delete request to be added to a { @ link request indexer } note : the type field has been deprecated since elasticsearch 7 x and it would not take any effort

delete request create delete request ( string index , string doc type , string key ) ;


gets next random integer in [ min , max ] range

public int next int ( ) { return random iterator next int ( ) ; }


startrestart the timer the runs the check can safely be called multiple times

public void start ( ) { if ( task get ( ) = = null ) { timer task timer task = new timer task ( ) { @ override public void run ( ) { try { check containers ( ) ; } catch ( interrupted exception e ) { thread current thread ( ) interrupt ( ) ; log info ( " interrupted " ) ; cancel ( ) ; } catch ( throwable e ) { log error ( " error checking containers " , e ) ; } } } ; if ( task compare and set ( null , timer task ) ) { timer schedule at fixed rate ( timer task , check interval ms , check interval ms ) ; } } }


inserts the specified element at the end of this queue

public boolean offer ( e e ) { return add ( e ) ; }


returns the root of the traversal ; see { @ link direct traversal root }

public abstract direct traversal root get root ( ) ;


check if the given array contains the given value ( with case - insensitive comparison )

public static boolean contains ignore case ( string [ ] array , string value ) { for ( string str : array ) { if ( value = = null & & str = = null ) { return true ; } if ( value ! = null & & value equals ignore case ( str ) ) { return true ; } } return false ; }


public void set prepare method ( method prepare method ) { this prepare method = prepare method ; }


adapts an { @ code iterator } to the { @ code enumeration } interface the { @ code iterable } equivalent of this method is either { @ link collections # enumeration } ( if you have a { @ link collection } ) , or { @ code iterators as enumeration ( collection iterator ( ) ) }

public static < t > enumeration < t > as enumeration ( final iterator < t > iterator ) { check not null ( iterator ) ; return new enumeration < t > ( ) { @ override public boolean has more elements ( ) { return iterator has next ( ) ; } @ override public t next element ( ) { return iterator next ( ) ; } } ; }


returns the value to which the specified key is mapped in this identity hash map , or < tt > null < tt > if the map contains no mapping for this key a return value of < tt > null < tt > does not necessarily indicate that the map contains no mapping for the key ; it is also possible that the map explicitly maps the key to < tt > null < tt > the < tt > contains key < tt > method may be used to distinguish these two cases

public value get ( long key ) { int hash = hash ( key ) ; int i = index for ( hash , table length ) ; long entry < value > e = table [ i ] ; while ( true ) { if ( e = = null ) return null ; if ( e hash = = hash & & key = = e key ) return e value ; e = e next ; } }


gets the system properties of the jvm on this computer if this is the master , it returns the system property of the master computer

public map < object , object > get system properties ( ) throws i o exception , interrupted exception { return remoting diagnostics get system properties ( get channel ( ) ) ; }


public void number item test ( ) { / / todo : test number item }


void add r type resource name ( r type r type , string resource name , string resource value , resource directory resource directory ) { map < string , set < resource directory > > directory resource directory map = null ; if ( this r type resource directory map contains key ( r type ) ) { directory resource directory map = this r type resource directory map get ( r type ) ; } else { directory resource directory map = new hash map < string , set < resource directory > > ( ) ; this r type resource directory map put ( r type , directory resource directory map ) ; } set < resource directory > resource directory set = null ; if ( directory resource directory map contains key ( resource directory directory name ) ) { resource directory set = directory resource directory map get ( resource directory directory name ) ; } else { resource directory set = new hash set < resource directory > ( ) ; directory resource directory map put ( resource directory directory name , resource directory set ) ; } boolean find = false ; resource directory new resource directory = new resource directory ( resource directory directory name , resource directory resource full filename ) ; if ( ! resource directory set contains ( new resource directory ) ) { resource directory set add ( new resource directory ) ; } for ( resource directory old resource directory : resource directory set ) { if ( old resource directory resource entry set contains ( new resource entry ( resource name , resource value ) ) ) { find = true ; string resource key = r type + " / " + resource directory directory name + " / " + resource name ; set < string > full filename set = null ; if ( ! this duplicate resource map contains key ( resource key ) ) { full filename set = new hash set < string > ( ) ; full filename set add ( old resource directory resource full filename ) ; this duplicate resource map put ( resource key , full filename set ) ; } else { full filename set = this duplicate resource map get ( resource key ) ; } full filename set add ( resource directory resource full filename ) ; } } if ( ! find ) { for ( resource directory old resource directory : resource directory set ) { if ( old resource directory equals ( new resource directory ) ) { if ( ! old resource directory resource entry set contains ( new resource entry ( resource name , resource value ) ) ) { old resource directory resource entry set add ( new resource entry ( resource name , resource value ) ) ; } } } } }


public integer get integer item ( ) { return integer item ; }


exit a parse tree produced by { @ link eql base parser # single expression }

void exit single expression ( eql base parser single expression context ctx ) ;


gets symbol id groups for each library symbol that was in the original program < br > note : this method excludes any new library symbols in original whose matching result id has already been placed in the result i ds in a group set otherwise , each id group that has a result id will add it to the result i ds in a group set

private list < i d group > get groups for original libs ( ) { list < i d group > id groups = new array list < > ( ) ; string [ ] original names = original ext mgr get external library names ( ) ; symbol table original symbol table = original pgm get symbol table ( ) ; symbol table latest symbol table = latest pgm get symbol table ( ) ; symbol table my symbol table = my pgm get symbol table ( ) ; for ( string original name : original names ) { symbol original library symbol = original symbol table get library symbol ( original name ) ; long original i d = original library symbol get i d ( ) ; long result i d = get result i d from original i d ( original i d ) ; long latest i d = ( latest symbol table get symbol ( original i d ) ! = null ) ? original i d : - 1 ; long my i d = ( my symbol table get symbol ( original i d ) ! = null ) ? original i d : - 1 ; if ( result i ds in a group contains ( result i d ) ) { continue ; / / already have this result as an i d group } id groups add ( new i d group ( result i d , original i d , latest i d , my i d ) ) ; if ( result i d ! = - 1 ) { result i ds in a group add ( result i d ) ; } } return id groups ; }


public static synchronized void reload existing configurations ( ) { if ( log is debug enabled ( ) ) { log debug ( " reloading " + registry key set ( ) size ( ) + " existing configurations " ) ; } for ( configuration conf : registry key set ( ) ) { conf reload configuration ( ) ; } }


public void add contents ( dex file file ) { for ( offsetted item i : items ) { i add contents ( file ) ; } }


public long get pet id ( ) { return pet id ; }


adds a listener to be notified for various changes that occur in this filter model

public void add listener ( table filter dialog model listener listener ) { this listeners add ( listener ) ; }


public synchronized http response do reload ( ) throws i o exception { check permission ( manage ) ; logger log ( level warning , " reloading jenkins as requested by { 0 } " , get authentication 2 ( ) get name ( ) ) ; / / engage " loading " ui and then run the actual task in a separate thread web app get ( servlet context ) set app ( new hudson is loading ( ) ) ; new thread ( " jenkins config reload thread " ) { @ override public void run ( ) { try ( a c l context ctx = acl as 2 ( acl system2 ) ) { reload ( ) ; } catch ( exception e ) { logger log ( severe , " failed to reload jenkins config " , e ) ; new jenkins reload failed ( e ) publish ( servlet context , root ) ; } } } start ( ) ; return http responses redirect via context path ( " / " ) ; }


public void test dog ( ) { / / todo : test dog }


returns an estimate of the amount of live data in bytes

public void enable estimate live data size ( ) { this properties add ( rocks d b property estimate live data size get rocks d b property ( ) ) ; }


increment the number of messages that have been read for the current read loop

void inc messages read ( int num messages ) ;


returns the index settings for this index

public index settings get index settings ( ) { return index settings ; }


presto ' charges ' the quanta run time to the task and the level it belongs to in an effort to maintain the target thread utilization ratios between levels and to maintain fairness within a level consider an example split where a read hung for several minutes this is either a bug or a failing dependency in either case we do not want to charge the task too much , and we especially do not want to charge the level too much - i e cause other queries in this level to starve

public priority update priority ( priority old priority , long quanta nanos , long scheduled nanos ) { int old level = old priority get level ( ) ; int new level = compute level ( scheduled nanos ) ; long level contribution = math min ( quanta nanos , level contribution cap ) ; if ( old level = = new level ) { add level time ( old level , level contribution ) ; return new priority ( old level , old priority get level priority ( ) + quanta nanos ) ; } long remaining level contribution = level contribution ; long remaining task time = quanta nanos ; / / a task normally slowly accrues scheduled time in a level and then moves to the next , but / / if the split had a particularly long quanta , accrue time to each level as if it had run / / in that level up to the level limit for ( int current level = old level ; current level < new level ; current level + + ) { long time accrued to level = math min ( seconds to nanos ( level threshold seconds [ current level + 1 ] - level threshold seconds [ current level ] ) , remaining level contribution ) ; add level time ( current level , time accrued to level ) ; remaining level contribution - = time accrued to level ; remaining task time - = time accrued to level ; } add level time ( new level , remaining level contribution ) ; long new level min priority = get level min priority ( new level , scheduled nanos ) ; return new priority ( new level , new level min priority + remaining task time ) ; }


test the property ' quadrilateral type '

public void quadrilateral type test ( ) { / / todo : test quadrilateral type }


returns the last stable build , if any otherwise null

public run t get last stable build ( ) { return ( run t ) permalink last stable build resolve ( this ) ; }


specifies a channel option as the underlying channel as well as network implementation may ignore this value applications should consider it a hint

public < t > netty channel builder with option ( channel option < t > option , t value ) { channel options put ( option , value ) ; return this ; }


public kerberos principal get kerberos principal ( ) { return kerberos principal ; }


sets a repeating value to all objects or row fields of the passed vals array

private static void fill column with repeating value ( object [ ] vals , int field idx , object repeating value , int child count ) { if ( field idx = = - 1 ) { / / set value as an object arrays fill ( vals , 0 , child count , repeating value ) ; } else { / / set value as a field of row row [ ] rows = ( row [ ] ) vals ; for ( int i = 0 ; i < child count ; i + + ) { rows [ i ] set field ( field idx , repeating value ) ; } } }


protected static boolean is logout request ( final http servlet request request ) { return request get parameter ( pac 4j constants logout endpoint parameter ) ! = null ; }


returns an immutable multimap containing the given entries , in order

public static < k , v > immutable list multimap < k , v > of ( k k 1 , v v 1 , k k 2 , v v 2 , k k 3 , v v 3 ) { immutable list multimap builder < k , v > builder = immutable list multimap builder ( ) ; builder put ( k 1 , v 1 ) ; builder put ( k 2 , v 2 ) ; builder put ( k 3 , v 3 ) ; return builder build ( ) ; }


returns true if this test subscriber has been cancelled

public final boolean is cancelled ( ) { return cancelled ; }


get the measured lag between current and end offset positions , for this store partition replica

public long offset lag ( ) { return this offset lag ; }


public void set selected index ( int i ) { list set selected index ( i ) ; }