gets the value of the current boolean option boolean options are not required to have explicitly specified values

public boolean get optional boolean value ( boolean default value ) throws options exception { if ( m last option value ! = null ) { / / - - option = value form string string value = m last option value ; m last option value = null ; if ( " true " equals ( string value ) ) { return true ; } else if ( " false " equals ( string value ) ) { return false ; } throw new options exception ( " unsupported value for " + m last option original form + " : " + string value + " only true or false supported " ) ; } / / - - option ( true | false ) form or just - - option if ( m index > = m params length ) { return default value ; } string string value = m params [ m index ] ; if ( " true " equals ( string value ) ) { m index + + ; return true ; } else if ( " false " equals ( string value ) ) { m index + + ; return false ; } else { return default value ; } }


removes all associations from this range map in the specified range ( optional operation ) if { @ code ! range contains ( k ) } , { @ link # get ( comparable ) get ( k ) } will return the same result before and after a call to { @ code remove ( range ) } if { @ code range contains ( k ) } , then after a call to { @ code remove ( range ) } , { @ code get ( k ) } will return { @ code null }


public string get unparsed default value ( ) { return option annotation default value ( ) ; }


recursive method to delete files in the given parent directory

private boolean delete files ( file parent ) { file [ ] f = parent list files ( ) ; for ( file element : f ) { if ( element is directory ( ) ) { if ( ! delete files ( element ) ) { return false ; } element delete ( ) ; } else if ( ! element delete ( ) ) { return false ; } } return true ; }


the method is invoked on the master ( job manager ) before the distributed program execution starts

void initialize global ( int parallelism ) throws i o exception ;


the from part of the range query null indicates unbounded

public range query builder from ( object from ) { return from ( from , this include lower ) ; }


report a bad block which is hosted on the local dn

public void report bad blocks ( extended block block , fs volume spi volume ) throws i o exception { b p offer service bpos = get b p o s for block ( block ) ; bpos report bad blocks ( block , volume get storage i d ( ) , volume get storage type ( ) ) ; }


private void compare colors ( set < string > expected colors , set < string > actual colors ) { assert that ( only black ( actual colors ) ) as ( " only black " ) is false ( ) ; assert that ( only white ( actual colors ) ) as ( " only white " ) is false ( ) ; / / ignore black and white for further comparison set < string > clean actual colors = sets new hash set ( actual colors ) ; clean actual colors remove ( " # 000000 " ) ; clean actual colors remove ( " # ffffff " ) ; if ( ! expected colors contains all ( clean actual colors ) ) { fail ( " there are unexpected colors on the screenshot : " + sets difference ( clean actual colors , expected colors ) ) ; } if ( ! clean actual colors contains all ( expected colors ) ) { fail ( " there are expected colors not present on the screenshot : " + sets difference ( expected colors , clean actual colors ) ) ; } }


return the configured { @ link handler mapping } beans that were detected by type in the { @ link web application context } or initialized based on the default set of strategies from { @ literal dispatcher servlet properties } note : this method may return { @ code null } if invoked prior to { @ link # on refresh ( application context ) }

public final list < handler mapping > get handler mappings ( ) { return ( this handler mappings ! = null ? collections unmodifiable list ( this handler mappings ) : null ) ; }


returns the prerequisite referred to by the specified attribute also checks whether the attribute is marked as executable and that the target referred to can actually be executed

public files to run provider get executable prerequisite ( string attribute name ) { attribute rule definition = attributes ( ) get attribute definition ( attribute name ) ; if ( rule definition = = null ) { throw new illegal state exception ( get rule class name for logging ( ) + " attribute " + attribute name + " is not defined " ) ; } if ( ! rule definition is executable ( ) ) { throw new illegal state exception ( get rule class name for logging ( ) + " attribute " + attribute name + " is not configured to be executable " ) ; } transitive info collection prerequisite = get prerequisite ( attribute name ) ; if ( prerequisite = = null ) { return null ; } files to run provider result = prerequisite get provider ( files to run provider class ) ; if ( result = = null | | result get executable ( ) = = null ) { attribute error ( attribute name , prerequisite get label ( ) + " does not refer to a valid executable target " ) ; } return result ; }


joins test thread ( waiting specified number of ms ) and validates that it has been completed successfully

public void join and assert state ( long timeout ) throws interrupted exception { join ( timeout ) ; throwable exception = this test exception ; if ( is alive ( ) ) { exception = new assertion error ( " test thread " + get name ( ) + " is still alive " ) ; exception set stack trace ( get stack trace ( ) ) ; } if ( exception ! = null ) { assertion error error = new assertion error ( " test thread " + get name ( ) + " failed to execute " ) ; error init cause ( exception ) ; throw error ; } assert with message ( " test thread " + get name ( ) + " has not run successfully " ) that ( is succeeded ) is true ( ) ; }


int get current cwnd ( int default value ) { int bit = 1 < < current cwnd ; return ( bit & set ) ! = 0 ? values [ current cwnd ] : default value ; }


public linker state copy ( ) { linker state cp = new linker state ( ) ; cp which focus = this which focus ; for ( field state fs : field states ) { cp field states add ( fs copy ( ) ) ; } return cp ; }


enables an index block for the specified index

public static void enable index block ( string index , string block ) { if ( index metadata a p i block from setting ( block ) = = index metadata a p i block read only allow delete | | random boolean ( ) ) { / / the read - only - allow - delete block isn ' t supported by the add block api so we must use the update settings api here settings settings = settings builder ( ) put ( block , true ) build ( ) ; client ( ) admin ( ) indices ( ) prepare update settings ( index ) set settings ( settings ) get ( ) ; } else { client ( ) admin ( ) indices ( ) prepare add block ( index metadata a p i block from setting ( block ) , index ) get ( ) ; } }


creates the cie version field at the specified location

private address process version ( address addr ) throws memory access exception { / * * create a new cie version field at the specified address and sets an * appropriate comment for the new structure * / string comment = " ( cie ) version " ; create and comment data ( program , addr , new byte data type ( ) , comment , code unit eol comment ) ; version = gcc analysis utils read byte ( program , addr ) ; cur size + = byte len ; return addr add ( byte len ) ; }


public string get name ( ) { return get xfer addr ( ) ; }


public synchronized text get kind ( ) { return kind ; }


selects the item in the table with the given name

private void select tag in table ( string name , function tag table table ) throws exception { assert tag exists ( name , table ) ; int row = 0 ; for ( int i = 0 ; i < table get row count ( ) ; i + + ) { string tagname = ( string ) table get value at ( i , 0 ) ; if ( tagname equals ( name ) ) { table add row selection interval ( i , i ) ; row = i ; } } click table cell ( table , row , 0 , 1 ) ; wait for swing ( ) ; }


set the parameter name discoverer to use for resolving method parameter names if needed ( e g for constructor names ) default is a { @ link default parameter name discoverer }

public void set parameter name discoverer ( @ nullable parameter name discoverer parameter name discoverer ) { this parameter name discoverer = parameter name discoverer ; }


calls { @ link channel handler context # flush ( ) } to forward to the next { @ link channel outbound handler } in the { @ link channel pipeline } sub - classes may override this method to change behavior

public void flush ( channel handler context ctx ) throws exception { ctx flush ( ) ; }


configure the pipeline for a cleartext upgrade from http to http2 0

private void configure clear text ( socket channel ch ) { final channel pipeline p = ch pipeline ( ) ; final http server codec source codec = new http server codec ( ) ; p add last ( source codec ) ; p add last ( new http server upgrade handler ( source codec , upgrade codec factory ) ) ; p add last ( new simple channel inbound handler < http message > ( ) { @ override protected void channel read 0 ( channel handler context ctx , http message msg ) throws exception { / / if this handler is hit then no upgrade has been attempted and the client is just talking http system err println ( " directly talking : " + msg protocol version ( ) + " ( no upgrade was attempted ) " ) ; channel pipeline pipeline = ctx pipeline ( ) ; pipeline add after ( ctx name ( ) , null , new hello world http 1 handler ( " direct no upgrade attempted " ) ) ; pipeline replace ( this , null , new http object aggregator ( max http content length ) ) ; ctx fire channel read ( reference count util retain ( msg ) ) ; } } ) ; p add last ( new user event logger ( ) ) ; }


return the underlying { @ link resource } for this { @ code resource region }

public resource get resource ( ) { return this resource ; }


applies the given { @ link transformation } for { @ link bitmap bitmaps } to the default types ( { @ link bitmap } , { @ link android graphics drawable bitmap drawable } , and { @ link com bumptech glide load resource gif gif drawable } ) and ignores unknown types this will override previous calls to { @ link # dont transform ( ) }

public t optional transform ( @ non null transformation < bitmap > transformation ) { return transform ( transformation , / * is required = * / false ) ; }


visit a parse tree produced by the { @ code variable } labeled alternative in { @ link painless parser # primary }

t visit variable ( painless parser variable context ctx ) ;


creates a new { @ link big arrays } instance used for this node this method can be overwritten by subclasses to change their { @ link big arrays } implementation for instance for testing

big arrays create big arrays ( page cache recycler page cache recycler , circuit breaker service circuit breaker service ) { return new big arrays ( page cache recycler , circuit breaker service , circuit breaker request ) ; }


specify that value that the dynamic value will be animated from

public animation builder from ( float from ) { m from = from ; return this ; }


public void set health check registry ( object health check registry ) { boolean is already set = get health check registry ( ) ! = null ; super set health check registry ( health check registry ) ; hikari pool p = pool ; if ( p ! = null ) { if ( is already set ) { throw new illegal state exception ( " health check registry can only be set one time " ) ; } else { p set health check registry ( super get health check registry ( ) ) ; } } } / / * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * / / hikari c p - specific methods / / * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *


optional as of 3 2 6 this method is no longer called by the core any locking needed by the cache must be provided internally by the cache provider

default read write lock get read write lock ( ) { return null ; }


completes the current method declaration

public void end method ( ) throws i o exception { scope popped = pop scope ( ) ; if ( popped = = scope non abstract method ) { indent ( ) ; out write ( " } \ n " ) ; } else if ( popped ! = scope abstract method ) { throw new illegal state exception ( ) ; }


sets the { @ link data spec # custom data } the default value is { @ code null }

public builder set custom data ( @ nullable object custom data ) { this custom data = custom data ; return this ; }


determines whether { @ code lane size in bytes } is a valid lane size for this register

public boolean is valid lane size ( int lane size in bytes ) { if ( ! is vector register ( ) ) { return false ; } if ( lane sizes = = null ) { return false ; } return lane sizes contains ( lane size in bytes ) ; }


test serialization of outer number types

public void fake outer number serialize test ( ) { big decimal body = null ; / / big decimal response = api fake outer number serialize ( body ) ; / / todo : test validations }


creates the given number of { @ link io reactivex rxjava 3 core scheduler worker } instances that are possibly backed by distinct threads and calls the specified { @ code consumer } with them

void create workers ( int number , @ non null worker callback callback ) ;


gets type literal for the given { @ code class } instance

public static < t > type literal < t > get ( class < t > type ) { return new type literal < > ( type ) ; }


throws an < code > federation state store retriable exception < code > due to an error in < code > federation state store < code >

public static void log and throw retriable exception ( logger log , string err msg , throwable t ) throws yarn exception { if ( t ! = null ) { log error ( err msg , t ) ; throw new federation state store retriable exception ( err msg , t ) ; } else { log error ( err msg ) ; throw new federation state store retriable exception ( err msg ) ; } }


returns true if we were able to lock the process ' s address space

public static boolean is memory locked ( ) { return natives is memory locked ( ) ; }


builds the { @ link animated image result } the preview bitmap and the decoded frames are closed after build is called , so this should not be called more than once or those fields will be lost after the first call

public animated image result build ( ) { try { return new animated image result ( this ) ; } finally { closeable reference close safely ( m preview bitmap ) ; m preview bitmap = null ; closeable reference close safely ( m decoded frames ) ; m decoded frames = null ; } }


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


tests that the equals and hashcode methods are consistent and copied versions of the instance are equal

public final void test equals and hashcode ( ) { for ( int runs = 0 ; runs < number of test runs ; runs + + ) { equals hash code test utils check equals and hash code ( create test instance ( ) , this : : copy instance , this : : mutate instance ) ; } }


check for errors in " chronological " order ( acknowledge that loading and analysis are interleaved , but sequential on the single target scale )

public static failure detail create failure detail ( target pattern phase value loading result , @ nullable skyframe analysis result skyframe analysis result , @ nullable top level targets and configs result top level targets and configs ) { if ( loading result has error ( ) ) { return failure detail new builder ( ) set message ( " command succeeded , but there were errors parsing the target pattern " ) set target patterns ( target patterns new builder ( ) set code ( code target pattern parse failure ) ) build ( ) ; } if ( loading result has post expansion error ( ) | | ( skyframe analysis result ! = null & & skyframe analysis result has loading error ( ) ) ) { return failure detail new builder ( ) set message ( " command succeeded , but there were loading phase errors " ) set analysis ( analysis new builder ( ) set code ( analysis code generic loading phase failure ) ) build ( ) ; } if ( top level targets and configs ! = null & & top level targets and configs has error ( ) ) { return failure detail new builder ( ) set message ( " command succeeded , but top level configurations could not be created " ) set build configuration ( failure details build configuration new builder ( ) set code ( failure details build configuration code top level configuration creation failure ) ) build ( ) ; } if ( skyframe analysis result ! = null & & skyframe analysis result has analysis error ( ) ) { return failure detail new builder ( ) set message ( " command succeeded , but not all targets were analyzed " ) set analysis ( analysis new builder ( ) set code ( analysis code not all targets analyzed ) ) build ( ) ; } return null ; }


sets the offset value for painting dashed lines this allows clients to animate the lines being drawn for edges in the edge direction

public void set dashing pattern offset ( float dashing patter offset ) { this dashing pattern offset = dashing patter offset ; }


register default methods on interfaces implemented by the configuration class

private void process interfaces ( configuration class config class , source class source class ) throws i o exception { for ( source class ifc : source class get interfaces ( ) ) { set < method metadata > bean methods = retrieve bean method metadata ( ifc ) ; for ( method metadata method metadata : bean methods ) { if ( ! method metadata is abstract ( ) ) { / / a default method or other concrete method on a java 8 + interface config class add bean method ( new bean method ( method metadata , config class ) ) ; } } process interfaces ( config class , ifc ) ; } }


inserts timestamps in order into a linked list if timestamps arrive in order ( as in case of using the rocks d b state backend ) this is just an append with o ( 1 )

private void insert to sorted list ( long record timestamp ) { list iterator < long > list iterator = sorted timestamps list iterator ( sorted timestamps size ( ) ) ; boolean is continue = true ; while ( list iterator has previous ( ) & & is continue ) { long timestamp = list iterator previous ( ) ; if ( record timestamp > = timestamp ) { list iterator next ( ) ; list iterator add ( record timestamp ) ; is continue = false ; } } if ( is continue ) { sorted timestamps add first ( record timestamp ) ; } }


{ @ inherit doc } < b > note : < b > : this throws an exception if this item is not internable

public int compare to 0 ( offsetted item other ) { if ( ! is internable ( ) ) { throw new unsupported operation exception ( " uninternable instance " ) ; } annotations directory item other directory = ( annotations directory item ) other ; return class annotations compare to ( other directory class annotations ) ; }


utility method to evaluate a callable and fill in the future with the result or the exception raised once this method returns , the future will have been evaluated to either a return value or an exception

public static < t > completable future < t > eval ( final completable future < t > result , final callable < t > call ) { try { result complete ( call call ( ) ) ; } catch ( throwable tx ) { result complete exceptionally ( tx ) ; } return result ; }


if true , this is a view that renders the top page of hudson

public boolean is default ( ) { return get owner ( ) get primary view ( ) = = this ; }


public d b p image get plain icon ( ) { return icon plain ; }


parses a sql string as an identifier into a { @ link sql identifier }

public sql identifier parse identifier ( string identifier ) { try { return create flink parser ( identifier ) table api identifier ( ) ; } catch ( exception e ) { throw new sql parser exception ( string format ( " invalid sql identifier % s " , identifier ) ) ; } }


visit a parse tree produced by the { @ code sys columns } labeled alternative in { @ link sql base parser # statement }

t visit sys columns ( sql base parser sys columns context ctx ) ;


installs and returns the defaults for dark lafs

public u i defaults get defaults ( ) { final u i defaults defaults = super get defaults ( ) ; m t laf installer install defaults ( defaults ) ; / / install material defaults m t laf installer install m t defaults ( defaults ) ; return defaults ; }


public void set columns ( list < list view column > columns ) throws i o exception { this columns replace by ( columns ) ; }


merges the sorted runs described by the given channel i ds into a single sorted run the merging process uses the given read and write buffers

private channel with block count merge channels ( list < channel with block count > channel i ds , list < list < memory segment > > read buffers , list < memory segment > write buffers ) throws i o exception { / / the list with the readers , to be closed at shutdown final list < file i o channel > channel accesses = new array list < > ( channel i ds size ( ) ) ; / / the list with the target iterators final merge iterator < e > merge iterator = get merging iterator ( channel i ds , read buffers , channel accesses , null ) ; / / create a new channel writer final file i o channel id merged channel i d = this io manager create channel ( ) ; spill channel manager register channel to be removed at shutdown ( merged channel i d ) ; final block channel writer < memory segment > writer = this io manager create block channel writer ( merged channel i d ) ; spill channel manager register open channel to be removed at shutdown ( writer ) ; final channel writer output view output = new channel writer output view ( writer , write buffers , this mem manager get page size ( ) ) ; open spilling behaviour ( ) ; spilling behaviour merge records ( merge iterator , output ) ; output close ( ) ; final int num blocks written = output get block count ( ) ; / / register merged result to be removed at shutdown spill channel manager unregister open channel to be removed at shutdown ( writer ) ; / / remove the merged channel readers from the clear - at - shutdown list for ( file i o channel access : channel accesses ) { access close and delete ( ) ; spill channel manager unregister open channel to be removed at shutdown ( access ) ; } return new channel with block count ( merged channel i d , num blocks written ) ; }


public final int get access flags ( ) { return access flags ; }


marks the shard with the provided allocation id as in - sync with the primary shard this method will block until the local checkpoint on the specified shard advances above the current global checkpoint

public synchronized void mark allocation id as in sync ( final string allocation id , final long local checkpoint ) throws interrupted exception { assert invariant ( ) ; assert primary mode ; assert handoff in progress = = false ; checkpoint state cps = checkpoints get ( allocation id ) ; if ( cps = = null ) { / / can happen if replica was removed from cluster but recovery process is unaware of it yet throw new illegal state exception ( " no local checkpoint tracking information available for " + allocation id ) ; } assert local checkpoint > = sequence numbers no ops performed : " expected known local checkpoint for " + allocation id + " but was " + local checkpoint ; assert pending in sync contains ( allocation id ) = = false : " shard copy " + allocation id + " is already marked as pending in - sync " ; assert cps tracked : " shard copy " + allocation id + " cannot be marked as in - sync as it ' s not tracked " ; update local checkpoint ( allocation id , cps , local checkpoint ) ; / / if it was already in - sync ( because of a previously failed recovery attempt ) , global checkpoint must have been / / stuck from advancing assert ! cps in sync | | ( cps local checkpoint > = get global checkpoint ( ) ) : " shard copy " + allocation id + " that ' s already in - sync should have a local checkpoint " + cps local checkpoint + " that ' s above the global checkpoint " + get global checkpoint ( ) ; if ( cps local checkpoint < get global checkpoint ( ) ) { pending in sync add ( allocation id ) ; try { while ( true ) { if ( pending in sync contains ( allocation id ) ) { wait for local checkpoint to advance ( ) ; } else { break ; } } } finally { pending in sync remove ( allocation id ) ; } } else { cps in sync = true ; update replication group and notify ( ) ; logger trace ( " marked [ { } ] as in - sync " , allocation id ) ; update global checkpoint on primary ( ) ; } assert invariant ( ) ; }


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


advances through { @ code input } looking for the start of the next ogg page equivalent to { @ link # skip to next page ( extractor input , long ) skip to next page ( input , limit = \ c position unset ) }

public boolean skip to next page ( extractor input input ) throws i o exception { return skip to next page ( input , / * limit = * / c position unset ) ; }


returns the start position of the first occurrence of the specified { @ code target } within { @ code array } , or { @ code - 1 } if there is no such occurrence more formally , returns the lowest index { @ code i } such that { @ code arrays copy of range ( array , i , i + target length ) } contains exactly the same elements as { @ code target }

public static int index of ( int [ ] array , int [ ] target ) { check not null ( array , " array " ) ; check not null ( target , " target " ) ; if ( target length = = 0 ) { return 0 ; } outer : for ( int i = 0 ; i < array length - target length + 1 ; i + + ) { for ( int j = 0 ; j < target length ; j + + ) { if ( array [ i + j ] ! = target [ j ] ) { continue outer ; } } return i ; } return - 1 ; }


this schema never considers an element to signal end - of - stream , so this method returns always false

public boolean is end of stream ( t next element ) { return false ; }


collect all lazily verified behaviour if there were failed verifications , it will throw a mockito assertion error containing all messages indicating the failed verifications normally , users don ' t need to call this method because it is automatically invoked when test finishes ( part of the j unit rule behavior ) however , in some circumstances and edge cases , it might be useful to collect and report verification errors in the middle of the test ( for example : some scenario tests or during debugging ) < pre class = " code " > < code class = " java " > & # 064 ; rule public verification collector collector = mockito j unit collector ( ) ; & # 064 ; test public void should fail ( ) { i methods methods = mock ( i methods class ) ; verify ( methods ) byte returning method ( ) ; verify ( methods ) simple method ( ) ; report all verification errors now : collector collect and report ( ) ; some other test code } < code >

void collect and report ( ) throws mockito assertion error ;


specify fixed - rate tasks as a list of { @ link interval task } objects primarily used by { @ code < task : > } namespace parsing

public void set fixed rate tasks list ( list < interval task > fixed rate tasks ) { this fixed rate tasks = fixed rate tasks ; }


public static list < s d card info > get s d card info ( ) { list < s d card info > paths = new array list < > ( ) ; storage manager sm = ( storage manager ) utils get app ( ) get system service ( context storage service ) ; if ( sm = = null ) return paths ; if ( android os build version sdk int > = android os build version codes n ) { list < storage volume > storage volumes = sm get storage volumes ( ) ; try { / / noinspection java reflection member access method get path method = storage volume class get method ( " get path " ) ; for ( storage volume storage volume : storage volumes ) { boolean is removable = storage volume is removable ( ) ; string state = storage volume get state ( ) ; string path = ( string ) get path method invoke ( storage volume ) ; paths add ( new s d card info ( path , state , is removable ) ) ; } } catch ( no such method exception e ) { e print stack trace ( ) ; } catch ( illegal access exception e ) { e print stack trace ( ) ; } catch ( invocation target exception e ) { e print stack trace ( ) ; } } else { try { class < ? > storage volume clazz = class for name ( " android os storage storage volume " ) ; / / noinspection java reflection member access method get path method = storage volume clazz get method ( " get path " ) ; method is removable method = storage volume clazz get method ( " is removable " ) ; / / noinspection java reflection member access method get volume state method = storage manager class get method ( " get volume state " , string class ) ; / / noinspection java reflection member access method get volume list method = storage manager class get method ( " get volume list " ) ; object result = get volume list method invoke ( sm ) ; final int length = array get length ( result ) ; for ( int i = 0 ; i < length ; i + + ) { object storage volume element = array get ( result , i ) ; string path = ( string ) get path method invoke ( storage volume element ) ; boolean is removable = ( boolean ) is removable method invoke ( storage volume element ) ; string state = ( string ) get volume state method invoke ( sm , path ) ; paths add ( new s d card info ( path , state , is removable ) ) ; } } catch ( class not found exception e ) { e print stack trace ( ) ; } catch ( invocation target exception e ) { e print stack trace ( ) ; } catch ( no such method exception e ) { e print stack trace ( ) ; } catch ( illegal access exception e ) { e print stack trace ( ) ; } } return paths ; }


register a listener that will be called when this model visibility state has changed the listener will contribute to this model ' s hash code state per the { @ link com airbnb epoxy epoxy attribute option # do not hash } rules

public model returning class type with varargs on visibility state changed ( on model visibility state changed listener < model returning class type with varargs , object > listener ) { on mutation ( ) ; this on model visibility state changed listener epoxy generated model = listener ; return this ; }


tells whether there is an overloaded assignment

public boolean has overloaded assignment ( ) { return has overloaded assignment ; }


checks if the current user ( for which we are processing the current request ) has the admin access

public static boolean is admin ( ) { return jenkins get ( ) get a c l ( ) has permission ( administer ) ; }


called after a workspace is deleted successfully

public void after delete ( abstract project project ) { }


returns true if the pattern can support the given number of slots

public boolean supports slots ( int slot count ) { return true ; }


determine if the graphical elements of the editor have been constructed

protected final boolean has editor components ( ) { return inline editor component ! = null | | detail editor component ! = null ; }


set the time the resource was last changed , as specified by the { @ code last - modified } header

public void set if modified since ( zoned date time if modified since ) { set zoned date time ( if modified since , if modified since with zone same instant ( gmt ) ) ; }


add a name of token filter that will be used on top of a tokenizer provided

public analyze request builder add token filter ( string token filter ) { request add token filter ( token filter ) ; return this ; }


public static string local server ( ) { return inet utils get self i p ( ) + i p util ip port spliter + env util get port ( ) ; }


public final path create snapshot ( path path ) throws i o exception { return create snapshot ( path , null ) ; }


visits an instruction which has a branch target argument

public void visit branch ( int opcode , int offset , int length , int target ) ;


returns the code unit whose min address equals the specified address

public code unit get code unit at ( address address ) { long addr = addr map get key ( address , false ) ; / / fixme trying to get data to display for external if ( address is external address ( ) ) { symbol external symbol = program get symbol table ( ) get primary symbol ( address ) ; if ( external symbol = = null ) { return get undefined data d b ( address , addr ) ; } external location external location = program get external manager ( ) get external location ( external symbol ) ; data type data type = external location get data type ( ) ; if ( data type = = null | | data type = = data type default ) { / / for now dummy back an undefined return get undefined data d b ( address , addr ) ; } / / dummy back a data for the data type data d b data d b = new data d b ( this , null , addr , address , addr , data type ) ; return data d b ; } return get code unit at ( addr ) ; }


gets the view of this listing panel ( meant to be used in conjunction with { @ link # set view ( address set view ) }

public address set view get view ( ) { address index map map = layout model get address index map ( ) ; return map get original address set ( ) ; }


possibly adjust a circuit breaker after field data has been loaded , now that the actual amount of memory used by the field data is known

void after load ( terms enum terms enum , long actual used ) ;


the package id of this package , in the range [ 0x 0 0 , 0xff ] the id 0x 0 0 is reserved for shared libraries , or when the id is assigned at run - time the id 0x 0 1 is reserved for the ' android ' package ( framework ) the id range [ 0x 0 2 , 0x 7f ) is reserved for auto - assignment to shared libraries at run - time the id 0x 7f is reserved for the application package i ds & gt ; 0x 7f are reserved for the application as well and are treated as feature splits < code > optional uint 3 2 package id = 1 ; < code >

public int get package id ( ) { return instance get package id ( ) ; }


public void test enum class ( ) { / / todo : test enum class }


returns true if this class has a highlight for the given token

public boolean contains ( clang token t ) { return highlights by token contains key ( get key ( t ) ) ; }


{ @ inherit doc } implementations may or may not support removal when a call to { @ link # peek ( ) } has occurred since the most recent call to { @ link # next ( ) }


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


returns an instance which creates synchronous observables that { @ linkplain observable # subscribe on ( scheduler ) subscribe on } { @ code scheduler } by default

public static rx java call adapter factory create with scheduler ( scheduler scheduler ) { if ( scheduler = = null ) throw new null pointer exception ( " scheduler = = null " ) ; return new rx java call adapter factory ( scheduler , false ) ; }


configure the { @ link server codec configurer } to set on the { @ code web server exchange }

public web http handler builder codec configurer ( server codec configurer codec configurer ) { this codec configurer = codec configurer ; return this ; }


returns a stream for reading this file as bytes @ throw gdx runtime exception if the file handle represents a directory , doesn ' t exist , or could not be read

public input stream read ( ) { if ( type = = file type classpath | | ( type = = file type internal & & ! file exists ( ) ) | | ( type = = file type local & & ! file exists ( ) ) ) { input stream input = file wrapper class get resource as stream ( " / " + file get path ( ) replace ( ' \ \ ' , ' / ' ) ) ; if ( input = = null ) throw new gdx runtime exception ( " file not found : " + file + " ( " + type + " ) " ) ; return input ; } try { return new file input stream ( file ( ) ) ; } catch ( exception ex ) { if ( file ( ) is directory ( ) ) throw new gdx runtime exception ( " cannot open a stream to a directory : " + file + " ( " + type + " ) " , ex ) ; throw new gdx runtime exception ( " error reading file : " + file + " ( " + type + " ) " , ex ) ; } }


returns the value associated with this { @ link context register info } object as a { @ link string }

public big integer get value ( ) { return value ; }


protected boolean select vertex ( v vertex , visualization viewer < v , e > viewer ) { mutable selected state < v > selected vertex state = viewer get selected vertex state ( ) ; if ( selected vertex state = = null ) { return false ; } selected vertex state is selected ( vertex ) ; if ( selected vertex state is selected ( vertex ) = = false ) { selected vertex state clear ( ) ; selected vertex state select ( vertex , true ) ; } return true ; }


get existing constant by name or creates new one if not exists threadsafe

private t get or create ( string name ) { t constant = constants get ( name ) ; if ( constant = = null ) { final t temp constant = new constant ( next id ( ) , name ) ; constant = constants put if absent ( name , temp constant ) ; if ( constant = = null ) { return temp constant ; } } return constant ; }


public string get first name ( ) { return first name ; }


loads a { @ link item } from a config file

public static item load ( item group parent , file dir ) throws i o exception { item item = ( item ) get config file ( dir ) read ( ) ; item on load ( parent , dir get name ( ) ) ; return item ; }


public boolean get executed bit ( int line ) { / / if any of the branch is taken , the branch must have executed otherwise assume it is not return get branch for line ( line ) any ( ) ; }


given tag will be used as tag only once for this method call regardless of the tag that ' s been set during initialization after this invocation , the general tag that ' s been set will be used for the subsequent log calls

public static printer t ( @ nullable string tag ) { return printer t ( tag ) ; }


computes the set of input symbols which could follow the current parser state and context , as given by { @ link # get state } and { @ link # get context } , respectively

public interval set get expected tokens ( ) { return get a t n ( ) get expected tokens ( get state ( ) , get context ( ) ) ; }


returns current { @ link url request } may be null if the data source is not opened

protected url request get current url request ( ) { return current url request ; }


ensure that there is waiting ( sleep duration ! = 0 ) if the metrics have only been updated with both successful and failed requests also ensure that the sleep duration decreases over time

public void test success and errors and waiting ( ) { client throttling analyzer analyzer = new client throttling analyzer ( " test " , analysis period ) ; validate ( 0 , analyzer get sleep duration ( ) ) ; analyzer add bytes transferred ( 8 * megabyte , false ) ; analyzer add bytes transferred ( 2 * megabyte , true ) ; sleep ( analysis period plus 10 percent ) ; nano timer timer = new nano timer ( ) ; analyzer suspend if necessary ( ) ; final int expected elapsed time = 126 ; fuzzy validate ( expected elapsed time , timer elapsed time ms ( ) , max acceptable percent difference ) ; sleep ( 10 * analysis period ) ; final int expected sleep duration = 110 ; validate less than or equal ( expected sleep duration , analyzer get sleep duration ( ) ) ; }


runs an elasticsearch docker container , and checks that it has started up successfully

public static installation run container ( distribution distribution ) { return run container ( distribution , docker run builder ( ) ) ; }


public response get root ( @ context final user group information ugi , @ query param ( delegation param name ) @ default value ( delegation param default ) final delegation param delegation , @ query param ( user param name ) @ default value ( user param default ) final user param username , @ query param ( do as param name ) @ default value ( do as param default ) final do as param do as user , @ query param ( get op param name ) @ default value ( get op param default ) final get op param op , @ query param ( offset param name ) @ default value ( offset param default ) final offset param offset , @ query param ( length param name ) @ default value ( length param default ) final length param length , @ query param ( renewer param name ) @ default value ( renewer param default ) final renewer param renewer , @ query param ( buffer size param name ) @ default value ( buffer size param default ) final buffer size param buffer size , @ query param ( x attr name param name ) @ default value ( x attr name param default ) final list < x attr name param > xattr names , @ query param ( x attr encoding param name ) @ default value ( x attr encoding param default ) final x attr encoding param xattr encoding , @ query param ( exclude datanodes param name ) @ default value ( exclude datanodes param default ) final exclude datanodes param exclude datanodes , @ query param ( fs action param name ) @ default value ( fs action param default ) final fs action param fs action , @ query param ( snapshot name param name ) @ default value ( snapshot name param default ) final snapshot name param snapshot name , @ query param ( old snapshot name param name ) @ default value ( old snapshot name param default ) final old snapshot name param old snapshot name , @ query param ( token kind param name ) @ default value ( token kind param default ) final token kind param token kind , @ query param ( token service param name ) @ default value ( token service param default ) final token service param token service , @ query param ( no redirect param name ) @ default value ( no redirect param default ) final no redirect param noredirect , @ query param ( start after param name ) @ default value ( start after param default ) final start after param start after ) throws i o exception , interrupted exception { return get ( ugi , delegation , username , do as user , root , op , offset , length , renewer , buffer size , xattr names , xattr encoding , exclude datanodes , fs action , snapshot name , old snapshot name , token kind , token service , noredirect , start after ) ; }


protected map < computer , t > monitor ( ) throws interrupted exception { / / bridge method to offer original constrained interface return monitor detailed ( ) get monitoring data ( ) ; }


retrieves , but does not remove , the head of the queue represented by this deque ( in other words , the first element of this deque ) this method differs from { @ link # peek peek } only in that it throws an exception if this deque is empty < p > this method is equivalent to { @ link # get first ( ) get first }


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


returns true if this section has execute permission note : on a real system , sections don ' t have their own permissions , only the segments they live in do however , ghidra needs finer - grained control for analysis to work correctly , so we take control over section permissions to fit our needs

public boolean is execute ( ) { if ( section names text equals ( sectname ) | | segment names seg text exec equals ( segname ) ) { return true ; } boolean pure instr = ( get attributes ( ) & section attributes s attr pure instructions ) ! = 0 ; boolean some instr = ( get attributes ( ) & section attributes s attr some instructions ) ! = 0 ; return pure instr | | some instr ; }


public @ non null group id v2 migrate to v 2 ( long thread id , @ non null group id v1 group id v 1 , @ non null decrypted group decrypted group ) { s q lite database db = database helper get writable database ( ) ; group id v2 group id v 2 = group id v 1 derive v 2 migration group id ( ) ; group master key group master key = group id v 1 derive v 2 migration master key ( ) ; db begin transaction ( ) ; try { group record record = get group ( group id v 1 ) get ( ) ; content values content values = new content values ( ) ; content values put ( group id , group id v 2 to string ( ) ) ; content values put ( v2 master key , group master key serialize ( ) ) ; content values put null ( expected v2 id ) ; list < recipient id > new members = uuids to recipient ids ( decrypted group util members to uuid list ( decrypted group get members list ( ) ) ) ; list < recipient id > pending members = uuids to recipient ids ( decrypted group util pending to uuid list ( decrypted group get pending members list ( ) ) ) ; new members add all ( pending members ) ; list < recipient id > dropped members = new array list < > ( set util difference ( record get members ( ) , new members ) ) ; list < recipient id > unmigrated members = util concatenated list ( pending members , dropped members ) ; content values put ( unmigrated v1 members , unmigrated members is empty ( ) ? null : recipient id to serialized list ( unmigrated members ) ) ; int updated = db update ( table name , content values , group id + " = ? " , sql util build args ( group id v 1 to string ( ) ) ) ; if ( updated ! = 1 ) { throw new assertion error ( ) ; } database factory get recipient database ( context ) update group id ( group id v 1 , group id v 2 ) ; update ( group master key , decrypted group ) ; database factory get sms database ( context ) insert group v 1 migration events ( record get recipient id ( ) , thread id , new group migration membership change ( pending members , dropped members ) ) ; db set transaction successful ( ) ; } finally { db end transaction ( ) ; } return group id v 2 ; }


check if the function body exists , and is a place holder single byte function that needs to be fixed

private boolean is place holder function that should be fixed ( program program , listing listing , symbol func symbol ) { function func = program get function manager ( ) get function at ( func symbol get address ( ) ) ; if ( func = = null ) { return false ; } if ( func get body ( ) get num addresses ( ) > 1 ) { return false ; } instruction instr = listing get instruction at ( func get entry point ( ) ) ; if ( instr = = null ) { return false ; } / / if instruction length longer than the body , or the instruction isn ' t terminal if ( instr get length ( ) > 1 | | ! instr get flow type ( ) is terminal ( ) ) { return true ; } return false ; }


public big decimal get number prop ( ) { return number prop or else ( null ) ; }


public static < e > void forward to rss ( string title , string url , collection < ? extends e > entries , feed adapter < e > adapter , stapler request req , http servlet response rsp ) throws i o exception , servlet exception { req set attribute ( " adapter " , adapter ) ; req set attribute ( " title " , title ) ; req set attribute ( " url " , url ) ; req set attribute ( " entries " , entries ) ; string flavor = req get parameter ( " flavor " ) ; if ( flavor = = null ) flavor = " atom " ; flavor = flavor replace ( ' / ' , ' ' ) ; / / don ' t allow path to any jelly if ( flavor equals ( " atom " ) ) { rsp set content type ( " application / atom + xml ; charset = utf - 8 " ) ; } else { rsp set content type ( " text / xml ; charset = utf - 8 " ) ; } req get view ( jenkins get ( ) , " / hudson / " + flavor + " jelly " ) forward ( req , rsp ) ; }


attempts to pre - handle and throttlestifle the requests based on capacity and configured pools

default boolean throttle ( final http servlet request request , final http servlet response response ) { return false ; }


return true if this cat all of 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 ; } cat all of cat all of = ( cat all of ) o ; return objects equals ( this declawed , cat all of declawed ) ; }


set the default response transformer all requests not using a custom transformer will use this one

public static void default response transformer ( response transformer transformer ) { get instance ( ) default response transformer ( transformer ) ; }


public static nfsproc3 from value ( int value ) { if ( value < 0 | | value > = values ( ) length ) { return null ; } return values ( ) [ value ] ; }


is the decider default on for policies matching the roles ( ) of this decider service ?

default boolean default on ( ) { return true ; }


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 " ) ; }


tests whether retry policy retries on idempotent operations when encountering i o exception

public void test client retries idempotent op with i o exception succeeds second time ( ) throws exception { configuration conf = new configuration ( ) ; final string key name = " test " ; final key provider key version key version = new k m s client provider k m s key version ( key name , " v 1 " , new byte [ 0 ] ) ; / / setting total failover attempts to conf set int ( common configuration keys public kms client failover max retries key , 10 ) ; k m s client provider p 1 = mock ( k m s client provider class ) ; when ( p 1 get current key ( mockito any string ( ) ) ) then throw ( new i o exception ( " p 1 " ) ) then return ( key version ) ; k m s client provider p 2 = mock ( k m s client provider class ) ; when ( p 2 get current key ( mockito any string ( ) ) ) then throw ( new i o exception ( " p 2 " ) ) ; k m s client provider p 3 = mock ( k m s client provider class ) ; when ( p 3 get current key ( mockito any string ( ) ) ) then throw ( new i o exception ( " p 3 " ) ) ; when ( p 1 get k m s url ( ) ) then return ( " p 1 " ) ; when ( p 2 get k m s url ( ) ) then return ( " p 2 " ) ; when ( p 3 get k m s url ( ) ) then return ( " p 3 " ) ; load balancing k m s client provider kp = new load balancing k m s client provider ( new k m s client provider [ ] { p 1 , p 2 , p 3 } , 0 , conf ) ; key provider key version result = kp get current key ( key name ) ; assert equals ( key version , result ) ; verify ( kp get providers ( ) [ 0 ] , mockito times ( 2 ) ) get current key ( mockito eq ( key name ) ) ; verify ( kp get providers ( ) [ 1 ] , mockito times ( 1 ) ) get current key ( mockito eq ( key name ) ) ; verify ( kp get providers ( ) [ 2 ] , mockito times ( 1 ) ) get current key ( mockito eq ( key name ) ) ; }


return a { @ link bind markers factory } for a { @ link connection factory }

bind markers factory get bind markers ( connection factory connection factory ) ;


public static boolean stop service ( @ non null intent intent ) { try { return utils get app ( ) stop service ( intent ) ; } catch ( exception e ) { e print stack trace ( ) ; return false ; } }


this method expects a failure while invoking set permission call and validates whether the failure is as expected

private void execute set permission failure ( user group information test user , path test path , fs permission old permission , fs permission new permission , boolean is invalid setup ) throws throwable { test user do as ( new privileged exception action < void > ( ) { @ override public void run ( ) throws exception { try { / / read access required for get file status fs set permission ( test path , new permission ) ; fail ( " failing test because set permission was expected to throw " ) ; } catch ( illegal argument exception iex ) { if ( ! is invalid setup ) { / / fail if illegal argument exception is not expected fail ( " failing test because illegal argument exception " + " is not expected to throw " ) ; } / / check that the file permission is not modified assert permission equals ( test path , old permission ) ; } catch ( wasb authorization exception wex ) { if ( is invalid setup ) { / / fail if wasb authorization exception is not expected fail ( " failing test because wasb authorization exception " + " is not expected to throw " ) ; } / / check that the file permission is not modified assert permission equals ( test path , old permission ) ; } return null ; } } ) ; }


public list < t > get records ( ) { return this records ; }


public data output buffer get key ( ) { return raw key ; }


collects all the prefix and uri pairs from a start element since { @ link namespaces } represents top level declarations , collect from ignores any prefix that is declared on the element those will be handled by the { @ link xml resource value } individually

public collector collect from ( start element start ) { iterator < attribute > attributes = xml resource values iterate attributes from ( start ) ; iterator < namespace > local namespaces = xml resource values iterate namespaces from ( start ) ; / / collect the local prefixes to make sure a prefix isn ' t declared locally set < string > prefixes = new linked hash set < > ( ) ; while ( local namespaces has next ( ) ) { prefixes add ( local namespaces next ( ) get prefix ( ) ) ; } collect from ( start get name ( ) , prefixes ) ; while ( attributes has next ( ) ) { collect from ( attributes next ( ) get name ( ) , prefixes ) ; } return this ; }


test multiple calls of get application report , to make sure it is idempotent

public void test get application report idempotent ( ) throws exception { / / start two r ms , and transit rm 1 to active , rm 2 to standby start r ms ( ) ; / / submit application / / after submission , the application state will be saved in r m state store r m app app = mock r m app submitter submit with memory ( 200 , rm 1 ) ; application report app report 1 = rm 1 get application report ( app get application id ( ) ) ; assert assert true ( app report 1 get yarn application state ( ) = = yarn application state accepted | | app report 1 get yarn application state ( ) = = yarn application state submitted ) ; / / call get application report again application report app report 2 = rm 1 get application report ( app get application id ( ) ) ; assert assert equals ( app report 1 get application id ( ) , app report 2 get application id ( ) ) ; assert assert equals ( app report 1 get yarn application state ( ) , app report 2 get yarn application state ( ) ) ; / / do the failover explicit failover ( ) ; / / call get application report application report app report 3 = rm 2 get application report ( app get application id ( ) ) ; assert assert equals ( app report 1 get application id ( ) , app report 3 get application id ( ) ) ; assert assert equals ( app report 1 get yarn application state ( ) , app report 3 get yarn application state ( ) ) ; / / call get application report again application report app report 4 = rm 2 get application report ( app get application id ( ) ) ; assert assert equals ( app report 3 get application id ( ) , app report 4 get application id ( ) ) ; assert assert equals ( app report 3 get yarn application state ( ) , app report 4 get yarn application state ( ) ) ; }


public j s o n writer array end ( ) throws i o exception { m writer write ( json rsquare ) ; m state = m stack pop ( ) ; return this ; }


gets the token from the < code > authorization < code > header if the header begins with < code > bearer < code >

private string get from header ( thread context thread context ) { string header = thread context get header ( " authorization " ) ; if ( strings has text ( header ) & & header region matches ( true , 0 , " bearer " , 0 , " bearer " length ( ) ) & & header length ( ) > " bearer " length ( ) ) { return header substring ( " bearer " length ( ) ) ; } return null ; }


sets the priority for new threads created with this thread factory

public thread factory builder set priority ( int priority ) { / / thread # set priority ( ) already checks for validity these error messages / / are nicer though and will fail - fast check argument ( priority > = thread min priority , " thread priority ( % s ) must be > = % s " , priority , thread min priority ) ; check argument ( priority < = thread max priority , " thread priority ( % s ) must be < = % s " , priority , thread max priority ) ; this priority = priority ; return this ; }


public list < object > get pk values by default ( ) throws s q l exception { / / current version 1 2 only support postgresql map < string , column meta > pk meta map = get table meta ( ) get primary key map ( ) ; column meta pk meta = pk meta map values ( ) iterator ( ) next ( ) ; string column def = pk meta get column def ( ) ; / / sample : nextval ( ' test id seq ' : : regclass ) string seq = org apache commons lang string utils substring between ( column def , " ' " , " ' " ) ; string function = org apache commons lang string utils substring between ( column def , " " , " ( " ) ; if ( string utils is blank ( seq ) ) { throw new should never happen exception ( " get primary key value failed , cause column def is " + column def ) ; } return get pk values by sequence ( new sql sequence expr ( " ' " + seq + " ' " , function ) ) ; }


verifies that the original object was sufficiently serializeddeserialized must throw an exception on failure

void verify deserialized ( t original , t deserialized ) throws exception ;


returns a handler for authentication failures , or null to use the default handler only one installed extension may have an authentication failure handler if more than one extension returns a non - null handler , an error is raised

default authentication failure handler get authentication failure handler ( security components components ) { return null ; }


converts an array of { @ link abstract insn node } s to their { @ link instruction filter } counterparts

public static instruction filter [ ] translate ( abstract insn node [ ] ains ) { instruction filter [ ] filters = new instruction filter [ ains length ] ; for ( int i = 0 ; i < ains length ; i + + ) { filters [ i ] = translate ( ains [ i ] ) ; } return filters ; }


public static void put request surrogate authentication ( final request context context , final boolean value ) { context get flow scope ( ) put ( " request surrogate account " , value ) ; }


protected jms message endpoint manager create container instance ( ) { return new jms message endpoint manager ( ) ; }


public void pet id test ( ) { / / todo : test pet id }


public string get status ( ) { return status ; }


< code > required string message = 1 ; < code >

public builder set message bytes ( com google protobuf byte string value ) { if ( value = = null ) { throw new null pointer exception ( ) ; } bit field 0 | = 0x 0 0 0 0 0 0 0 1 ; message = value ; on changed ( ) ; return this ; }


default value for { @ link tool installation # get properties ( ) } used in the form binding

public describable list < tool property < ? > , tool property descriptor > get default properties ( ) throws i o exception { describable list < tool property < ? > , tool property descriptor > r = new describable list < > ( noop ) ; list < ? extends tool installer > installers = get default installers ( ) ; if ( ! installers is empty ( ) ) r add ( new install source property ( installers ) ) ; return r ; }


returns the offset to the name of this resource

public int get name offset ( ) { return name offset ; }


returns a new { @ link ima ads loader } with the specified sideloaded ads response

public ima ads loader build for ads response ( string ads response ) { return new ima ads loader ( context , get configuration ( ) , ima factory , / * ad tag uri = * / null , ads response ) ; }


adds { @ code element } to the { @ code immutable sorted set } if the { @ code immutable sorted set } already contains { @ code element } , then { @ code add } has no effect ( only the previously added element is retained )

public builder < e > add ( e element ) { check not null ( element ) ; copy if necessary ( ) ; if ( n = = elements length ) { sort and dedup ( ) ; / * * sorting operations can only be allowed to occur once every o ( n ) operations to keep * amortized o ( n log n ) performance therefore , ensure there are at least o ( n ) * unused * * spaces in the builder array * / int new length = immutable collection builder expanded capacity ( n , n + 1 ) ; if ( new length > elements length ) { elements = arrays copy of ( elements , new length ) ; } } elements [ n + + ] = element ; return this ; }


reads class files and performs class file metadata collection and analysis

public void process ( ) throws i o exception { for ( file content provider < ? extends input stream > input class file : input file contents ) { if ( input class file is class file ( ) ) { try ( input stream input stream = input class file get ( ) ) { class reader cr = new class reader ( input stream ) ; class metadata collector cv = new class metadata collector ( class member record , class attribute record ) ; cr accept ( cv , custom attributes , 0 ) ; } } } }


tests that { @ link local input channel # request subpartition ( int ) } throws { @ link partition not found exception } if the result partition was not registered in { @ link result partition manager } and no backoff

public void test partition not found exception while requesting partition ( ) throws exception { final single input gate input gate = create single input gate ( 1 ) ; final local input channel local channel = create local input channel ( input gate , new result partition manager ( ) ) ; try { local channel request subpartition ( 0 ) ; fail ( " should throw a partition not found exception " ) ; } catch ( partition not found exception not found ) { assert that ( local channel get partition id ( ) , matchers is ( not found get partition id ( ) ) ) ; } }


gets a model name prefix for generated models this name will be prefixed to a model name this option is often used to circumvent compilation issues where models match keywords example : prefix < code > my < code > applied to < code > object < code > results in a generated class named < code > my object < code >

public string get model name prefix ( ) { return model name prefix ; }


called when the processor is flushed , directly or as part of resetting

protected void on flush ( ) { / / do nothing }


public string get username ( ) { return username ; }


updates the data type from the one in the source archive call can update ( ) to check the state before calling this

public void update ( ) { data type synchronizer update assuming transactions open ( ref dt get data type manager ( ) , source dt ) ; }


checks to see if the user id is the same for the two uids , i e , they belong to the same user @ hide

public static boolean is same user ( int uid 1 , int uid 2 ) { return get user id ( uid 1 ) = = get user id ( uid 2 ) ; }


deserialize the given bytes returned by { @ link # serialize split assignments ( map , simple versioned serializer ) }

public static < split t extends source split , c extends collection < split t > > map < integer , c > deserialize split assignments ( byte [ ] serialized , simple versioned serializer < split t > split serializer , function < integer , c > collection supplier ) throws i o exception { try ( byte array input stream bais = new byte array input stream ( serialized ) ; data input stream in = new data input stream ( bais ) ) { int num subtasks = in read int ( ) ; map < integer , c > splits assignments = new hash map < > ( num subtasks ) ; int serializer version = in read int ( ) ; for ( int i = 0 ; i < num subtasks ; i + + ) { int subtask id = in read int ( ) ; int num assigned splits = in read int ( ) ; c assigned splits = collection supplier apply ( num assigned splits ) ; for ( int j = 0 ; j < num assigned splits ; j + + ) { int serialized split size = in read int ( ) ; byte [ ] serialized split = new byte [ serialized split size ] ; in read fully ( serialized split ) ; split t split = split serializer deserialize ( serializer version , serialized split ) ; assigned splits add ( split ) ; } splits assignments put ( subtask id , assigned splits ) ; } return splits assignments ; } }


returns the architecture for this container either power p c cfm or c fm - 6 8k

public string get architecture ( ) { return architecture ; }


static block factory create factory ( final o b s file system owner , final string name ) { switch ( name ) { case o b s constants fast upload buffer array : return new byte array block factory ( owner ) ; case o b s constants fast upload buffer disk : return new disk block factory ( owner ) ; case o b s constants fast upload bytebuffer : return new byte buffer block factory ( owner ) ; default : throw new illegal argument exception ( " unsupported block buffer " + " \ " " + name + ' " ' ) ; } }


tests if we receive a confirmation when we attempt to open a file that it ' s name is null or an empty string

public void file confirmation when name is null ( ) { stub set file name ( null ) ; presenter start ( ) ; presenter file name changed ( ) ; presenter confirmed ( ) ; assert false ( loader is loaded ( ) ) ; assert equals ( 1 , stub get messages sent ( ) ) ; }


initializes { @ link dubbo metadata service } ' s proxy

private dubbo metadata service create proxy if absent ( string service name , string version ) { return dubbo metadata service cache compute if absent ( service name , name - > create proxy ( name , version ) ) ; }


use the { @ linkplain # set database populator database populator } to set up the database

public void after properties set ( ) { execute ( this database populator ) ; }


{ @ inherit doc } the default implementation does nothing

@ override public void exit query ( sql base parser query context ctx ) { }


like { @ link # resolve ( string , string ) } , but returns a { @ link uri } instead of a { @ link string }

public static uri resolve to uri ( @ nullable string base uri , @ nullable string reference uri ) { return uri parse ( resolve ( base uri , reference uri ) ) ; }


this method creates an internal block at the given index of a block group

public static located block construct internal block ( located striped block bg , int idx in returned locs , int cell size , int data blk num , int idx in block group ) { final extended block blk = construct internal block ( bg get block ( ) , cell size , data blk num , idx in block group ) ; final located block located block ; if ( idx in returned locs < bg get locations ( ) length ) { located block = new located block ( blk , new datanode info [ ] { bg get locations ( ) [ idx in returned locs ] } , new string [ ] { bg get storage i ds ( ) [ idx in returned locs ] } , new storage type [ ] { bg get storage types ( ) [ idx in returned locs ] } , bg get start offset ( ) , bg is corrupt ( ) , null ) ; } else { located block = new located block ( blk , null , null , null , bg get start offset ( ) , bg is corrupt ( ) , null ) ; } token < block token identifier > [ ] block tokens = bg get block tokens ( ) ; if ( idx in returned locs < block tokens length ) { located block set block token ( block tokens [ idx in returned locs ] ) ; } return located block ; }


executed after the query phase successfully finished note : this is not invoked if the query phase execution failed

default void on query phase ( search context search context , long took in nanos ) { }


public static string format ( float value , int min integer digits , int fraction digits , boolean is half up ) { return format ( value , false , min integer digits , fraction digits , is half up ) ; }


return the { @ code series } enum constant for the supplied { @ code http status }

public static series value of ( http status status ) { return status series ; }


method to authenticate a set of credentials

default cas radius response authenticate ( final string username , final string password ) throws exception { return authenticate ( username , password , optional empty ( ) ) ; }


required the ports associated with the external service if the endpoints are unix domain socket addresses , there must be exactly one port < code > repeated istio networking v 1alpha 3 port ports = 3 ; < code >

public builder set ports ( int index , com alibaba nacos istio model port value ) { if ( ports builder = = null ) { if ( value = = null ) { throw new null pointer exception ( ) ; } ensure ports is mutable ( ) ; ports set ( index , value ) ; on changed ( ) ; } else { ports builder set message ( index , value ) ; } return this ; }


compute the minimum , treating the inputs as unsigned

public static int unsigned min ( int a , int b ) { return ( integer compare unsigned ( a , b ) < 0 ) ? a : b ; }


doubles size of table and repacks entries , also adding the given node to new table

private void rehash ( hash entry < k , v > node ) { / * * reclassify nodes in each list to new table because we * are using power - of - two expansion , the elements from * each bin must either stay at same index , or move with a * power of two offset we eliminate unnecessary node * creation by catching cases where old nodes can be * reused because their next fields won ' t change * statistically , at the default threshold , only about * one - sixth of them need cloning when a table * doubles the nodes they replace will be garbage * collectable as soon as they are no longer referenced by * any reader thread that may be in the midst of * concurrently traversing table entry accesses use plain * array indexing because they are followed by volatile * table write * / hash entry < k , v > [ ] old table = table ; int old capacity = old table length ; int new capacity = old capacity < < 1 ; threshold = ( int ) ( new capacity * load factor ) ; hash entry < k , v > [ ] new table = new hash entry [ new capacity ] ; int size mask = new capacity - 1 ; for ( int i = 0 ; i < old capacity ; i + + ) { hash entry < k , v > e = old table [ i ] ; if ( e ! = null ) { hash entry < k , v > next = e next ; int idx = e hash & size mask ; if ( next = = null ) { new table [ idx ] = e ; } else { / / reuse consecutive sequence at same slot hash entry < k , v > last run = e ; int last idx = idx ; for ( hash entry < k , v > last = next ; last ! = null ; last = last next ) { int k = last hash & size mask ; if ( k ! = last idx ) { last idx = k ; last run = last ; } } new table [ last idx ] = last run ; / / clone remaining nodes for ( hash entry < k , v > p = e ; p ! = last run ; p = p next ) { v v = p value ; int h = p hash ; int k = h & size mask ; hash entry < k , v > n = new table [ k ] ; new table [ k ] = new hash entry < k , v > ( h , p key , v , n ) ; } } } } int node index = node hash & size mask ; / / add the new node node set next ( new table [ node index ] ) ; new table [ node index ] = node ; table = new table ; }


public big decimal get name number ( ) { return name number ; }


return the name of the methodconstructor parameter

public string get parameter name ( ) { if ( this parameter index < 0 ) { return null ; } parameter name discoverer discoverer = this parameter name discoverer ; if ( discoverer ! = null ) { string [ ] parameter names = null ; if ( this executable instanceof method ) { parameter names = discoverer get parameter names ( ( method ) this executable ) ; } else if ( this executable instanceof constructor ) { parameter names = discoverer get parameter names ( ( constructor < ? > ) this executable ) ; } if ( parameter names ! = null ) { this parameter name = parameter names [ this parameter index ] ; } this parameter name discoverer = null ; } return this parameter name ; }


get the underlying change map data as a byte array

public byte [ ] get data ( ) { return map data ; }


default response entity < void > test body with query params ( string query , user body ) { return new response entity < > ( http status not implemented ) ; }


model tests for mixed properties and additional properties class

public void test mixed properties and additional properties class ( ) { / / todo : test mixed properties and additional properties class }


set the maximum number of undoable checkpoints maintained by buffer manager existing redo checkpoints are cleared and the stack of undo checkpoints will be reduced if max undos is less than the current setting

public void set max undos ( int max undos ) { synchronized ( snapshot lock ) { synchronized ( this ) { max checkpoints = max undos < 0 ? default checkpoint count : ( max undos + 1 ) ; while ( checkpoint heads size ( ) > max checkpoints ) { pack checkpoints ( ) ; } dispose redo checkpoints ( ) ; } } }


adds an individual resource file to the root directory of the apk this provides the same functionality as { @ code java resource zip } , except much more hacky will most probably won ' t work if there is an input artifact in the same directory as this file

public apk actions builder set java resource file ( artifact java resource file ) { this java resource file = java resource file ; return this ; }


returns the number of linked list being managed

public int get num lists ( ) { return num lists ; }


specify from which offsets the kafka source should start consume from by providing an { @ link offsets initializer } the following { @ link offsets initializer } s are commonly used and provided out of the box users can also implement their own { @ link offsets initializer } for custom behaviors { @ link offsets initializer # earliest ( ) } - starting from the earliest offsets this is also the default { @ link offsets initializer } of the kafka source for starting offsets { @ link offsets initializer # latest ( ) } - starting from the latest offsets { @ link offsets initializer # committed offsets ( ) } - starting from the committed offsets of the consumer group { @ link offsets initializer # committed offsets ( org apache kafka clients consumer offset reset strategy ) } - starting from the committed offsets of the consumer group if there is no committed offsets , starting from the offsets specified by the { @ link org apache kafka clients consumer offset reset strategy offset reset strategy } { @ link offsets initializer # offsets ( map ) } - starting from the specified offsets for each partition { @ link offsets initializer # timestamp ( long ) } - starting from the specified timestamp for each partition note that the guarantee here is that all the records in kafka whose { @ link org apache kafka clients consumer consumer record # timestamp ( ) } is greater than the given starting timestamp will be consumed however , it is possible that some consumer records whose timestamp is smaller than the given starting timestamp are also consumed

public kafka source builder < out > set starting offsets ( offsets initializer starting offsets initializer ) { this starting offsets initializer = starting offsets initializer ; return this ; }


gets the action record from the table for the indicated offset

public l s d a action record get action record at offset ( int action offset ) { / / " records " is a list of action table records that were added in order min to max int current offset = 0 ; for ( l s d a action record lsda action record : records ) { int size = lsda action record get size ( ) ; int next offset = current offset + size ; if ( action offset > = current offset & & action offset < next offset ) { return lsda action record ; } current offset = next offset ; } return null ; / / didn ' t find it }


converts byte to f s edit log op codes enum value

public static f s edit log op codes from byte ( byte op code ) { if ( op code > = 0 & & op code < values length ) { return values [ op code ] ; } return op code = = - 1 ? op invalid : null ; }


public cst string get name ( ) { return spec get local item ( ) get name ( ) ; }


gets the field at the given position the method tries to deserialize the fields into the given target value if the fields has been changed since the last ( de ) serialization , or is null , them the target value is left unchanged and the changed value ( or null ) is returned in all cases , the returned value contains the correct data ( or is correctly null )

public < t extends value > t get field ( int field num , t target ) { / / range check if ( field num < 0 | | field num > = this num fields ) { throw new index out of bounds exception ( ) ; } if ( target = = null ) { throw new null pointer exception ( " the target object may not be null " ) ; } / / get offset and check for null final int offset = this offsets [ field num ] ; if ( offset = = null indicator offset ) { return null ; } else if ( offset = = modified indicator offset ) { / / value that has been set is new or modified / / bring the binary in sync so that the deserialization gives the correct result return ( t ) this write fields [ field num ] ; } final int limit = offset + this lengths [ field num ] ; deserialize ( target , offset , limit , field num ) ; return target ; }


returns one of the something decodabet byte arrays depending on the options specified it ' s possible , though silly , to specify ordered and url safe in which case one of them will be picked , though there is no guarantee as to which one will be picked

private final static byte [ ] get decodabet ( int options ) { if ( ( options & url safe ) = = url safe ) { return url safe decodabet ; } else if ( ( options & ordered ) = = ordered ) { return ordered decodabet ; } else { return standard decodabet ; } }


used on windows to determine if the specified file is a symlink that targets a directory on most platforms , these checks can be done using commons - io on windows , the commons - io implementation is unreliable and always returns false instead , this method checks the output of the dir command after migrating to java 7 , this method can be removed in favor of the new method java nio file files is symbolic link , which is expected to work cross - platform

private static boolean is windows symlinked directory ( file file ) throws i o exception { string dir out = shell exec command ( " cmd " , " / c " , " dir " , file get absolute file ( ) get parent ( ) ) ; string reader sr = new string reader ( dir out ) ; buffered reader br = new buffered reader ( sr ) ; try { string line = br read line ( ) ; while ( line ! = null ) { line = br read line ( ) ; if ( line contains ( file get name ( ) ) & & line contains ( " < symlinkd > " ) ) { return true ; } } return false ; } finally { i o utils close stream ( br ) ; i o utils close stream ( sr ) ; } }


returns all the registered { @ link publisher } descriptors

public static descriptor extension list < publisher , descriptor < publisher > > all ( ) { return jenkins get ( ) get descriptor list ( publisher class ) ; }


validate that test methods and test lifecycle methods in the supplied test class are not annotated with { @ link autowired @ autowired }

private void validate autowired config ( extension context context ) { / / we save the result in the extension context store so that we don ' t / / re - validate all methods for the same test class multiple times store store = context get store ( autowired validation namespace ) ; string error message = store get or compute if absent ( context get required test class ( ) , test class - > { method [ ] methods with errors = reflection utils get unique declared methods ( test class , autowired test or lifecycle method filter ) ; return ( methods with errors length = = 0 ? no autowired violations detected : string format ( " test methods and test lifecycle methods must not be annotated with @ autowired " + " you should instead annotate individual method parameters with @ autowired , " + " @ qualifier , or @ value offending methods in test class % s : % s " , test class get name ( ) , arrays to string ( methods with errors ) ) ) ; } , string class ) ; if ( error message ! = no autowired violations detected ) { throw new illegal state exception ( error message ) ; } }


delete the reference decrease the reference count for the instance , if any on all references removal delete the instance from the map

public void remove ( e key ) { e value = reference map get ( key ) ; if ( value ! = null & & value decrement and get ref count ( ) = = 0 ) { reference map remove ( key ) ; } }


returns an iterator over the elements in this deque the elements will be ordered from first ( head ) to last ( tail ) this is the same order that elements would be dequeued ( via successive calls to { @ link # remove } or popped ( via successive calls to { @ link # pop } )

public iterator < e > iterator ( ) { return new deq iterator ( ) ; }


configure the { @ link exchange strategies } to use for most cases , prefer using { @ link # codecs ( consumer ) } which allows customizing the codecs in the { @ code exchange strategies } rather than replace them that ensures multiple parties can contribute to codecs configuration by default this is set to { @ link exchange strategies # with defaults ( ) }

builder exchange strategies ( exchange strategies strategies ) ;


http post create a new resource by p o s ting the given object to the http request url request params are expanded using the given query { @ link query } { @ code response type } can be an http rest result or http rest result data { @ code t } type

public < t > http rest result < t > post ( string url , header header , query query , object body , type response type ) throws exception { return execute ( url , http method post , new request http entity ( header , query , body ) , response type ) ; }


writes two code units to the given output destination

protected static void write ( annotated output out , short c 0 , short c 1 ) { out write short ( c 0 ) ; out write short ( c 1 ) ; }


reads the object ' s internal data from the given data input view

void read ( data input view in ) throws i o exception ;


defines whether or not given element should be returned from cache on further calls

public abstract boolean is lookup cached ( ) ;


retrieves and removes the first element ( w r t the order ) of this set , or returns { @ code null } if this set is empty


test decompressing a tar gz file with hard link file and symbolic link file inside and stripping a prefix

public void test decompress with prefix ( ) throws exception { test archive descriptor archive descriptor = new test archive descriptor ( archive name , " out " , false ) ; decompressor descriptor builder descriptor builder = archive descriptor create descriptor builder ( ) set prefix ( root folder name ) ; path output dir = decompress ( descriptor builder ) ; archive descriptor assert output files ( output dir , inner folder name ) ; }


public disk balancer volume get destination volume ( ) { return destination volume ; }


public static void create table ( database db , boolean if not exists ) { string constraint = if not exists ? " if not exists " : " " ; db exec s q l ( " create table " + constraint + " \ " simple entity not null \ " ( " + / / " \ " id \ " integer primary key not null , " + / / 0 : id " \ " simple boolean \ " integer not null , " + / / 1 : simple boolean " \ " simple byte \ " integer not null , " + / / 2 : simple byte " \ " simple short \ " integer not null , " + / / 3 : simple short " \ " simple int \ " integer not null , " + / / 4 : simple int " \ " simple long \ " integer not null , " + / / 5 : simple long " \ " simple float \ " real not null , " + / / 6 : simple float " \ " simple double \ " real not null , " + / / 7 : simple double " \ " simple string \ " text not null , " + / / 8 : simple string " \ " simple byte array \ " blob not null ) ; " ) ; / / 9 : simple byte array }


resets this reader ' s position to the last { @ code mark ( ) } location invocations of { @ code read ( ) } and { @ code skip ( ) } will occur from this new location if this reader has not been marked , the behavior of { @ code reset ( ) } is implementation specific this default implementation throws an { @ code i o exception }

public void reset ( ) throws i o exception { throw new i o exception ( ) ; }


checks that the given blob will be deleted at the { @ link blob server } eventually ( waits at most 3 0s )

static void verify deleted eventually ( blob server server , @ nullable job i d job id , blob key keys ) throws i o exception , interrupted exception { long deadline = system current time millis ( ) + 30 000l ; do { thread sleep ( 10 ) ; } while ( check files exist ( job id , arrays as list ( keys ) , server , false ) ! = 0 & & system current time millis ( ) < deadline ) ; for ( blob key key : keys ) { verify deleted ( server , job id , key ) ; } }


public void validate field ( string name , object field ) throws illegal argument exception ;


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 " ) ; }


< code > optional aapt pb primitive prim = 7 ; < code >

public builder clear prim ( ) { copy on write ( ) ; instance clear prim ( ) ; return this ; }


returns the result of subtracting this and { @ code val } if the result would be negative , returns the low 32 bits of the result

public unsigned integer minus ( unsigned integer val ) { return from int bits ( value - check not null ( val ) value ) ; }


format url template using default server variables

public string url ( ) { return url ( null ) ; }


get a query string which removes the passed parameter

public static string remove query params ( http servlet request http request , string parameter name ) { return get u r l encoded query string ( http request , parameter name ) ; }


the time the job was finished or < code > null < code > if not finished

public date get finished time ( ) { return finished time ; }


removes the given field note that removing a field that is still being referenced can cause unpredictable effects

public void remove field ( field field ) { int fields count = target class u 2fields count ; field [ ] fields = target class fields ; int field index = find field index ( field ) ; / / shift the field entries system arraycopy ( fields , field index + 1 , fields , field index , fields count - field index - 1 ) ; / / clear the last entry fields [ - - target class u 2fields count ] = null ; }


if set , a string representing that the segment is part of a merge , with the value representing the group of segments that represent this merge

public string get merge id ( ) { return this merge id ; }


public connection get target connection ( ) { return target connection ; }


returns the minimum length of the input prefix required to apply any edits

public int get fuzzy prefix length ( ) { return fuzzy prefix length ; }


public void test vectors ( ) throws exception { directory dir = new directory ( ) ; index writer config iwc = new index writer config ( null ) ; index writer iw = new index writer ( dir , iwc ) ; / / add document with 2 fields document doc = new document ( ) ; field type ft = new field type ( string field type not stored ) ; ft set store term vectors ( true ) ; doc add ( new field ( " field a " , " test a " , ft ) ) ; doc add ( new field ( " field b " , " test b " , ft ) ) ; iw add document ( doc ) ; / / open reader directory reader ir = field subset reader wrap ( directory reader open ( iw ) , new character run automaton ( automata make string ( " field a " ) ) ) ; / / see only one field fields vectors = ir get term vectors ( 0 ) ; set < string > seen fields = new hash set < > ( ) ; for ( string field : vectors ) { seen fields add ( field ) ; } assert equals ( collections singleton ( " field a " ) , seen fields ) ; test util check reader ( ir ) ; i o utils close ( ir , iw , dir ) ; }


the amazon resource name ( arn ) of the role to assume

public string get role arn ( ) { return this role arn ; }


destroy a fixture this removes the fixture from the broad - phase and destroys all contacts associated with this fixture this will automatically adjust the mass of the body if the body is dynamic and the fixture has positive density all fixtures attached to a body are implicitly destroyed when the body is destroyed

public final void destroy fixture ( fixture fixture ) { assert ( m world is locked ( ) = = false ) ; if ( m world is locked ( ) = = true ) { return ; } assert ( fixture m body = = this ) ; / / remove the fixture from this body ' s singly linked list assert ( m fixture count > 0 ) ; fixture node = m fixture list ; fixture last = null ; / / java change boolean found = false ; while ( node ! = null ) { if ( node = = fixture ) { node = fixture m next ; found = true ; break ; } last = node ; node = node m next ; } / / you tried to remove a shape that is not attached to this body assert ( found ) ; / / java change , remove it from the list if ( last = = null ) { m fixture list = fixture m next ; } else { last m next = fixture m next ; } / / destroy any contacts associated with the fixture contact edge edge = m contact list ; while ( edge ! = null ) { contact c = edge contact ; edge = edge next ; fixture fixture a = c get fixture a ( ) ; fixture fixture b = c get fixture b ( ) ; if ( fixture = = fixture a | | fixture = = fixture b ) { / / this destroys the contact and removes it from / / this body ' s contact list m world m contact manager destroy ( c ) ; } } if ( ( m flags & e active flag ) = = e active flag ) { broad phase broad phase = m world m contact manager m broad phase ; fixture destroy proxies ( broad phase ) ; } fixture destroy ( ) ; fixture m body = null ; fixture m next = null ; fixture = null ; - - m fixture count ; / / reset the mass data reset mass data ( ) ; }


public void set s s l context ( s s l context ssl context ) { if ( ssl context ! = null ) { https u r l connection set default s s l socket factory ( ssl context get socket factory ( ) ) ; } }


removes the value mapped under the current key


return a composed routing function that routes to the given handler function if this route does not match and the given request predicate applies this method is a convenient combination of { @ link # and ( router function ) } and { @ link router functions # route ( request predicate , handler function ) }

default router function < t > and route ( request predicate predicate , handler function < t > handler function ) { return and ( router functions route ( predicate , handler function ) ) ; }


returns the appropriate < code > class visitor < code >

private class visitor class file visitor ( clazz clazz ) { return class pool get class ( clazz get name ( ) ) ! = null ? present class visitor : missing class visitor ; }


the version of the response data < code > string version info = 1 ; < code >

public com google protobuf byte string get version info bytes ( ) { java lang object ref = version info ; if ( ref instanceof string ) { com google protobuf byte string b = com google protobuf byte string copy from utf 8 ( ( java lang string ) ref ) ; version info = b ; return b ; } else { return ( com google protobuf byte string ) ref ; } }


whether content type resolution must produce a value that matches one of the supported mime types

public boolean is strict content type match ( ) { return this strict content type match ; }


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


generate a json snapshot of current beans and their dependencies


sets the ' short ' value at the specified address

public final void set short ( address address , short value ) throws memory access exception { current program get memory ( ) set short ( address , value ) ; }


public static void unregister ( ) { class filter set default ( class filter standard ) ; }


compare and verify if erased chunks are equal to recovered chunks

protected void compare and verify ( e c chunk [ ] erased chunks , e c chunk [ ] recovered chunks ) { byte [ ] [ ] erased = to arrays ( erased chunks ) ; byte [ ] [ ] recovered = to arrays ( recovered chunks ) ; boolean result = arrays deep equals ( erased , recovered ) ; if ( ! result ) { assert true ( " decoding and comparing failed " , result ) ; } }


public void add data type ( data type dt ) { if ( dt = = null ) { return ; } if ( ! exists ( dt ) ) { data list add ( dt ) ; } }


get the optional id corresponding to the original { @ code resource request { @ link # get allocation request id ( ) } } s which is satisfied by this allocated { @ code container } the scheduler may return multiple { @ code allocate response } s corresponding to the same id as and when scheduler allocates { @ code container } s < b > applications < b > can continue to completely ignore the returned id in the response and use the allocation for any of their outstanding requests

public long get allocation request id ( ) { throw new unsupported operation exception ( ) ; }


performs initial creation of output instructions based on the original blocks

private void output instructions ( ) { basic block list blocks = method get blocks ( ) ; int [ ] order = this order ; int len = order length ; / / process the blocks in output order for ( int i = 0 ; i < len ; i + + ) { int next i = i + 1 ; int next label = ( next i = = order length ) ? - 1 : order [ next i ] ; output block ( blocks label to block ( order [ i ] ) , next label ) ; } }


public list < ? extends probable threat > threats ( ) { return threats ; }


set the location of a resource , as specified by the { @ code location } header


matches java logging configuration behavior ; " true " and " 1 " are true , " false " and " 0 " are false

private static boolean get configured boolean property ( boolean builder value , string configured name , boolean fallback value ) { boolean value = get configured property ( builder value , configured name , val - > { val = val trim ( ) to lower case ( ) ; if ( " true " equals ( val ) | | " 1 " equals ( val ) ) { return true ; } else if ( " false " equals ( val ) | | " 0 " equals ( val ) ) { return false ; } else if ( val length ( ) = = 0 ) { return null ; } throw new illegal argument exception ( " cannot parse boolean property value " ) ; } , null ) ; return value ! = null ? value boolean value ( ) : fallback value ; }


public final boolean is modified ( ) { set modified ( check modified ( form , get config ( ) ) ) ; return super is modified ( ) ; }


execute the http method to the given uri template , writing the given request entity to the request , and returns the response as { @ link response entity } the given { @ link parameterized type reference } is used to pass generic type information : < pre class = " code " > parameterized type reference & lt ; list & lt ; my bean & gt ; & gt ; my bean = new parameterized type reference & lt ; list & lt ; my bean & gt ; & gt ; ( ) { } ; response entity & lt ; list & lt ; my bean & gt ; & gt ; response = template exchange ( & quot ; https : example com & quot ; , http method get , null , my bean ) ;

< t > response entity < t > exchange ( uri url , http method method , @ nullable http entity < ? > request entity , parameterized type reference < t > response type ) throws rest client exception ;


public static void put ( @ non null final string key , final drawable value , final int save time ) { put ( key , value , save time , get default cache disk utils ( ) ) ; }


public void set parallelism ( int parallelism ) { if ( parallelism < 1 ) { throw new illegal argument exception ( " the parallelism must be at least one " ) ; } this parallelism = parallelism ; }


uses the index templates api to determine if index templates exist

public boolean exists template ( index templates exist request index templates request , request options options ) throws i o exception { return rest high level client perform request ( index templates request , indices request converters : : templates exist , options , rest high level client : : convert exists response , empty set ( ) ) ; }


gets the maximum allowed message size acceptable from the remote peer

public integer get max inbound message size ( ) { return max inbound message size ; }


checks whether a field is directly readable without a getter

public static boolean is structured field directly readable ( field field ) { final int m = field get modifiers ( ) ; / / field is directly readable return modifier is public ( m ) ; }


regression test for case where the user requests that we delete nodes that are already in the queue to be dirtied we should handle that gracefully and not complain

public void deleting dirty nodes ( ) throws exception { sky key node 0 = graph tester non hermetic key ( " node 0 " ) ; sky key key = make test key ( node 0 ) ; / / seed the graph assert that ( ( ( string value ) tester eval and get ( / * keep going = * / false , key ) ) get value ( ) ) is equal to ( " node 0 " ) ; / / start the dirtying process tester set ( node 0 , new string value ( " new " ) ) ; tester invalidate ( ) ; / / interrupt current thread on a next invalidate call final thread thread = thread current thread ( ) ; tester progress receiver set next invalidation callback ( thread : : interrupt ) ; assert throws ( interrupted exception class , ( ) - > tester eval ( / * keep going = * / false , key ) ) ; / / cleanup + paranoid check tester progress receiver set next invalidation callback ( null ) ; / / now delete all the nodes the node that was going to be dirtied is also deleted , which we / / should handle tester evaluator delete ( predicates always true ( ) ) ; assert that ( ( ( string value ) tester eval and get ( / * keep going = * / false , key ) ) get value ( ) ) is equal to ( " new " ) ; }


should only be called by { @ link org thoughtcrime securesms migrations registration pin v 2 migration job }

public static synchronized void on migrate to registration lock v 2 ( @ non null context context , @ non null string pin ) throws i o exception , unauthenticated response exception , invalid key exception { log i ( tag , " on migrate to registration lock v 2 ( ) " ) ; kbs values kbs values = signal store kbs values ( ) ; master key master key = kbs values get or create master key ( ) ; key backup service key backup service = application dependencies get key backup service ( kbs enclaves current ( ) ) ; key backup service pin change session pin change session = key backup service new pin change session ( ) ; hashed pin hashed pin = pin hashing hash pin ( pin , pin change session ) ; kbs pin data kbs data = pin change session set pin ( hashed pin , master key ) ; pin change session enable registration lock ( master key ) ; kbs values set kbs master key ( kbs data , pin ) ; text secure preferences clear registration lock v 1 ( context ) ; update state ( build inferred state from other fields ( ) ) ; }


a sequence of requests followed by one response ( streamed upload ) the server returns the aggregated size of client payload as the result

public io grpc stub stream observer < io grpc testing integration messages streaming input call request > streaming input call ( io grpc stub stream observer < io grpc testing integration messages streaming input call response > response observer ) { return io grpc stub server calls async unimplemented streaming call ( get streaming input call method ( ) , response observer ) ; }


cancels all currently running vertex executions

public completable future < void > cancel with future ( ) { return future utils wait for all ( map execution vertices ( execution vertex : : cancel ) ) ; }


gets the column family of the index table based on the given column family and qualifier

public static byte buffer get index column family ( byte [ ] column family , byte [ ] column qualifier ) { return wrap ( array utils add all ( array utils add ( column family , underscore ) , column qualifier ) ) ; }


set a list of topics the kafka source should consume from all the topics in the list should have existed in the kafka cluster otherwise an exception will be thrown to allow some of the topics to be created lazily , please use { @ link # set topic pattern ( pattern ) } instead

public kafka source builder < out > set topics ( string topics ) { return set topics ( arrays as list ( topics ) ) ; }


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