schedule the given { @ link runnable } , starting as soon as possible and invoking it with the given period execution will end once the scheduler shuts down or the returned { @ link scheduled future } gets cancelled

default scheduled future < ? > schedule at fixed rate ( runnable task , duration period ) { return schedule at fixed rate ( task , period to millis ( ) ) ; }


increments the xmits in progress count xmits in progress count represents the number of data replicationreconstruction tasks running currently

public void increment xmits in progress ( ) { xmits in progress get and increment ( ) ; }


whether to include inner hits in the search response hits if required mappings is missing

public boolean is ignore unmapped ( ) { return ignore unmapped ; }


return the path of storageemulated 0 androiddatapackagefiles

public static string get external app files path ( ) { if ( ! utils bridge is s d card enable by environment ( ) ) return " " ; return get absolute path ( utils get app ( ) get external files dir ( null ) ) ; }


get the post - tag for the highlighter set with { @ link # highlight ( string , string ) }

public string post tag ( ) { return this post tag ; }


returns a new instance with the specified ad set to the specified { @ code state } the ad specified must currently either be in { @ link # ad state unavailable } or { @ link # ad state available } this instance ' s ad count may be unknown , in which case { @ code index } must be less than the ad count specified later otherwise , { @ code index } must be less than the current ad count

public ad group with ad state ( @ ad state int state , int index ) { assertions check argument ( count = = c length unset | | index < count ) ; @ ad state int [ ] states = copy states with space for ad count ( this states , index + 1 ) ; assertions check argument ( states [ index ] = = ad state unavailable | | states [ index ] = = ad state available | | states [ index ] = = state ) ; long [ ] durations us = this durations us length = = states length ? this durations us : copy durations us with space for ad count ( this durations us , states length ) ; @ nullable type uri [ ] uris = this uris length = = states length ? this uris : arrays copy of ( this uris , states length ) ; states [ index ] = state ; return new ad group ( count , states , uris , durations us ) ; }


asynchronously fulfills the request without a { @ link image view } or { @ link bitmap target } , and invokes the target { @ link callback } with the result this is useful when you want to warm up the cache with an image note : the { @ link callback } param is a strong reference and will prevent your { @ link android app activity } or { @ link android app fragment } from being garbage collected until the request is completed

public void fetch ( @ nullable callback callback ) { long started = system nano time ( ) ; if ( deferred ) { throw new illegal state exception ( " fit cannot be used with fetch " ) ; } if ( data has image ( ) ) { / / fetch requests have lower priority by default if ( ! data has priority ( ) ) { data priority ( priority low ) ; } request request = create request ( started ) ; if ( should read from memory cache ( request memory policy ) ) { bitmap bitmap = picasso quick memory cache check ( request key ) ; if ( bitmap ! = null ) { if ( picasso logging enabled ) { log ( owner main , verb completed , request plain id ( ) , " from " + memory ) ; } if ( callback ! = null ) { callback on success ( ) ; } return ; } } action action = new fetch action ( picasso , request , callback ) ; picasso submit ( action ) ; } }


returns an immutable sorted multiset containing the elements of a sorted multiset , sorted by the same { @ code comparator } that behavior differs from { @ link # copy of ( iterable ) } , which always uses the natural ordering of the elements despite the method name , this method attempts to avoid actually copying the data when it is safe to do so the exact circumstances under which a copy will or will not be performed are undocumented and subject to change this method is safe to use even when { @ code sorted multiset } is a synchronized or concurrent collection that is currently being modified by another thread

public static < e > immutable sorted multiset < e > copy of sorted ( sorted multiset < e > sorted multiset ) { return copy of sorted entries ( sorted multiset comparator ( ) , lists new array list ( sorted multiset entry set ( ) ) ) ; }


returns true if this contains an entry matching the given key an acl entry ' s key consists of scope , type and name ( but not permission )

public boolean contains key ( acl entry key ) { return collections binary search ( acl spec , key , acl entry comparator ) > = 0 ; }


private void op read block ( ) throws i o exception { op read block proto proto = op read block proto parse from ( vint prefixed ( in ) ) ; trace scope trace scope = continue trace span ( proto get header ( ) , proto get class ( ) get simple name ( ) ) ; try { read block ( p b helper client convert ( proto get header ( ) get base header ( ) get block ( ) ) , p b helper client convert ( proto get header ( ) get base header ( ) get token ( ) ) , proto get header ( ) get client name ( ) , proto get offset ( ) , proto get len ( ) , proto get send checksums ( ) , ( proto has caching strategy ( ) ? get caching strategy ( proto get caching strategy ( ) ) : caching strategy new default strategy ( ) ) ) ; } finally { if ( trace scope ! = null ) trace scope close ( ) ; } }


load fsimage files assuming only local names are stored used when snapshots are not supported by the layout version

private void load local name i nodes ( long num files , data input in , counter counter ) throws i o exception { assert name node layout version supports ( layout version feature fsimage name optimization , get layout version ( ) ) ; assert num files > 0 ; / / load root load root ( in , counter ) ; / / have loaded the first file ( the root ) num files - - ; / / load rest of the nodes directory by directory while ( num files > 0 ) { num files - = load directory ( in , counter ) ; } if ( num files ! = 0 ) { throw new i o exception ( " read unexpect number of files : " + - num files ) ; } }


if this recipient is missing crucial data , this will return a populated copy otherwise it returns itself

public @ non null recipient resolve ( ) { if ( resolving ) { return live ( ) resolve ( ) ; } else { return this ; } }


does this renewer have nothing to renew ?

public boolean is empty ( ) { return dfsclients is empty ( ) ; }


return true if the operator overloader supports the specified operation between the two operands and so should be invoked to handle it

boolean overrides operation ( operation operation , @ nullable object left operand , @ nullable object right operand ) throws evaluation exception ;


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


public int get register count ( ) { return 3 ; }


downloads the blob identified by the given blob key from the blob server

input stream get internal ( @ nullable job i d job id , blob key blob key ) throws i o exception { if ( this socket is closed ( ) ) { throw new illegal state exception ( " blob client is not connected " + " client has been shut down or encountered an error before " ) ; } if ( log is debug enabled ( ) ) { log debug ( " get blob { } / { } from { } " , job id , blob key , socket get local socket address ( ) ) ; } try { output stream os = this socket get output stream ( ) ; input stream is = this socket get input stream ( ) ; / / send get header send get header ( os , job id , blob key ) ; receive and check get response ( is ) ; return new blob input stream ( is , blob key , os ) ; } catch ( throwable t ) { blob utils close silently ( socket , log ) ; throw new i o exception ( " get operation failed : " + t get message ( ) , t ) ; } }


public void add ( iterator < e > iterator ) { assert state ( ! this in use , " you can no longer add iterators to a composite iterator that ' s already in use " ) ; if ( this iterators contains ( iterator ) ) { throw new illegal argument exception ( " you cannot add the same iterator twice " ) ; } this iterators add ( iterator ) ; }


public float first ( ) { if ( size = = 0 ) throw new illegal state exception ( " array is empty " ) ; return items [ 0 ] ; }


sets the doc to use for updates when a script is not specified , the doc provided is a field and value pairs

public update request builder set doc ( x content type x content type , object source ) { request doc ( x content type , source ) ; return this ; }


construct the command line for running the debug script

static string build debug script command line ( list < string > cmd , string debugout ) throws i o exception { string builder merged cmd = new string builder ( ) ; merged cmd append ( " exec " ) ; boolean is executable = true ; for ( string s : cmd ) { if ( is executable ) { / / the executable name needs to be expressed as a shell path for the / / shell to find it merged cmd append ( file util make shell path ( new file ( s ) ) ) ; is executable = false ; } else { merged cmd append ( s ) ; } merged cmd append ( " " ) ; } merged cmd append ( " < / dev / null " ) ; merged cmd append ( " > " ) ; merged cmd append ( debugout ) ; merged cmd append ( " 2 > & 1 " ) ; return merged cmd to string ( ) ; }


fake endpoint for testing various parameters 가짜 엔드 포인트 fake endpoint for testing various parameters 가짜 엔드 포인트

public void test endpoint parameters ( big decimal number , double double , string pattern without delimiter , byte [ ] byte , integer integer , integer int 3 2 , long int 6 4 , float float , string string , async file binary , local date date , offset date time date time , string password , string param callback , handler < async result < void > > result handler ) { test endpoint parameters ( number , double , pattern without delimiter , byte , integer , int 3 2 , int 6 4 , float , string , binary , date , date time , password , param callback , null , result handler ) ; }


the { @ link topic name extractor } class that this sink node uses to dynamically extract the topic name to write to could be { @ code null } if the topic name is not dynamically determined

topic name extractor topic name extractor ( ) ;


build cookie header keeps a single value per cookie ( as per < a href = " https : tools ietf orghtmlrfc 6 2 6 5 # section - 5 3 " > rfc6265 section 5 3 )

private string build cookie header ( multi value map < string , string > cookies ) { final string builder cookie value = new string builder ( ) ; string delimiter = " " ; for ( final map entry < string , list < string > > entry : cookies entry set ( ) ) { final string value = entry get value ( ) get ( entry get value ( ) size ( ) - 1 ) ; cookie value append ( string format ( " % s % s = % s " , delimiter , entry get key ( ) , value ) ) ; delimiter = " ; " ; } return cookie value to string ( ) ; }


setter for the { @ link federation state store facade }

public void set federation state store facade ( federation state store facade federation state store facade ) { this federation state store facade = federation state store facade ; }


protected void reset sample ( double hit rate ) { previous hit rate = hit rate ; misses in sample = 0 ; hits in sample = 0 ; hits in window = 0 ; hits in main = 0 ; }


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


public csvout newline ( ) throws i o exception { out write ( eol ) ; is start of line = true ; return this ; }


shift buckets by random offset between [ 2 interval ] from setup we have 1 doc per values from 1 numdocs special care needs to be taken for expecations on counts in first and last bucket

public void test single valued field with random offset ( ) throws exception { int offset = random int between ( 2 , interval ) ; search response response = client ( ) prepare search ( " idx " ) add aggregation ( histogram ( " histo " ) field ( single valued field name ) interval ( interval ) offset ( offset ) ) get ( ) ; assert search response ( response ) ; / / shifting by offset > 2 creates new extra bucket [ 0 , offset - 1 ] / / if offset is > = number of values in original last bucket , that effect is canceled int expected number of buckets = ( offset > = ( num docs % interval + 1 ) ) ? num value buckets : num value buckets + 1 ; histogram histo = response get aggregations ( ) get ( " histo " ) ; assert that ( histo , not null value ( ) ) ; assert that ( histo get name ( ) , equal to ( " histo " ) ) ; assert that ( histo get buckets ( ) size ( ) , equal to ( expected number of buckets ) ) ; int docs counted = 0 ; for ( int i = 0 ; i < expected number of buckets ; + + i ) { histogram bucket bucket = histo get buckets ( ) get ( i ) ; assert that ( bucket , not null value ( ) ) ; assert that ( ( ( number ) bucket get key ( ) ) long value ( ) , equal to ( ( long ) ( ( i - 1 ) * interval + offset ) ) ) ; if ( i = = 0 ) { / / first bucket long expected first bucket count = offset - 1 ; assert that ( bucket get doc count ( ) , equal to ( expected first bucket count ) ) ; docs counted + = expected first bucket count ; } else if ( i < expected number of buckets - 1 ) { assert that ( bucket get doc count ( ) , equal to ( ( long ) interval ) ) ; docs counted + = interval ; } else { assert that ( bucket get doc count ( ) , equal to ( ( long ) num docs - docs counted ) ) ; } } }


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

t visit false ( painless parser false context ctx ) ;


assert that these fields sort in the same order no matter which order they start in

private static void assert sort consistently ( field a , field b , field c ) { field [ ] [ ] initial orderings = { { a , b , c } , { a , c , b } , { b , a , c } , { b , c , a } , { c , a , b } , { c , b , a } } ; set < list < field > > results = new hash set < list < field > > ( ) ; for ( field [ ] o : initial orderings ) { results add ( sort super types last ( arrays as list ( o ) ) ) ; } assert that ( results ) has size ( 1 ) ; }


don ' t use this if false , turns off incremental mount for all subviews of this recycler

public builder incremental mount ( boolean incremental mount ) { this incremental mount = incremental mount ; return this ; }


constructs a new json builder that will output the result into the provided output stream

public static x content builder smile builder ( output stream os ) throws i o exception { return new x content builder ( smile x content smile x content , os ) ; }


get the version id of the status object ; may be null

public string get version id ( ) { return status get version id ( ) ; }


precondition is that { @ code buffer ! = null }

private int add component 0 ( boolean increase writer index , int c index , byte buf buffer ) { assert buffer ! = null ; boolean was added = false ; try { check component index ( c index ) ; / / no need to consolidate - just add a component to the list component c = new component ( ensure accessible ( buffer ) , 0 ) ; int readable bytes = c length ( ) ; / / check if we would overflow / / see https : / / github com / netty / netty / issues / 10194 check for overflow ( capacity ( ) , readable bytes ) ; add comp ( c index , c ) ; was added = true ; if ( readable bytes > 0 & & c index < component count - 1 ) { update component offsets ( c index ) ; } else if ( c index > 0 ) { c reposition ( components [ c index - 1 ] end offset ) ; } if ( increase writer index ) { writer index + = readable bytes ; } return c index ; } finally { if ( ! was added ) { buffer release ( ) ; } } }


update the consumer ' s program with the new program

public void set program ( program program ) ;


controls the choice of algorithm used to select interesting terms the default value is true which means terms are selected based on significance ( see the { @ link significant terms } aggregation ) rather than popularity ( using the { @ link terms aggregator } )

public void use significance ( boolean value ) { this use significance = value ; }


returns the appropriate instantiation of a local folder item based upon a specified property file which resides within a local file system

static local folder item get folder item ( local file system file system , property file property file ) { int file type = property file get int ( file type , unknown file type ) ; try { if ( file type = = datafile file type ) { return new local data file ( file system , property file ) ; } else if ( file type = = database file type ) { return new local database item ( file system , property file ) ; } } catch ( file not found exception e ) { log error ( " item may be corrupt due to missing file : " + property file get path ( ) , e ) ; } catch ( i o exception e ) { log error ( " item may be corrupt : " + property file get path ( ) , e ) ; } return new unknown folder item ( file system , property file ) ; }


returns the type of the nal unit in { @ code data } that starts at { @ code offset }

public static int get nal unit type ( byte [ ] data , int offset ) { return data [ offset + 3 ] & 0x 1 f ; }


template method which can be overridden to add servlet - specific refresh work called after successful context refresh this implementation is empty

protected void on refresh ( application context context ) { / / for subclasses : do nothing by default }


resizes internal data structures if necessary to store the specified number of distinct elements

private void ensure capacity ( int min capacity ) { if ( min capacity > deduped elements length ) { int new capacity = immutable collection builder expanded capacity ( deduped elements length , min capacity ) ; deduped elements = arrays copy of ( deduped elements , new capacity ) ; } }


public void register ( long raw , long offset start , long offset end ) ;


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


get the text to insert when the item is activated

public string get text ( ) { return text ; }


set the http status of the default block page

public static void set block page http status ( int http status ) { if ( http status < = 0 ) { throw new illegal argument exception ( " invalid http status code : " + http status ) ; } sentinel config set config ( block page http status conf key , string value of ( http status ) ) ; }


append to the path using path segments for example : < pre class = " code " > builder path segment ( " first - value " , " second - value " , " { id } " ) build ( " 123 " ) results is " first - valuesecond - value 1 2 3 " if slashes are present in a path segment , they are encoded : < pre class = " code " > builder path segment ( " baz " , " { id } " ) build ( " ab " ) results is " ba % 2 fza % 2 fb " to insert a trailing slash , use the { @ link # path } builder method : < pre class = " code " > builder path segment ( " first - value " , " second - value " ) path ( " " ) results is " first - valuesecond - value "

uri builder path segment ( string path segments ) throws illegal argument exception ;


applies network disruption for requests send from the node represented by the source transport service to the node represented by the target transport service

public abstract void apply disruption ( mock transport service source transport service , mock transport service target transport service ) ;


verify that stateful image results , both intermediate and final , are never cached

public void test do not cache stateful image ( ) { when ( m closeable image 1 is stateful ( ) ) then return ( true ) ; when ( m closeable image 2 is stateful ( ) ) then return ( true ) ; setup bitmap memory cache get not found ( ) ; setup input producer streaming success ( ) ; when ( m memory cache get ( m bitmap memory cache key ) ) then return ( null ) ; m bitmap memory cache producer produce results ( m consumer , m producer context ) ; verify ( m consumer ) on new result ( m intermediate image reference , consumer no flags ) ; verify ( m consumer ) on new result ( m final image reference , consumer is last ) ; verify ( m memory cache , never ( ) ) cache ( any ( bitmap memory cache key class ) , any ( closeable reference class ) ) ; }


pseudo - randomly maps a long ( 64 - bit ) to an integer ( 32 - bit ) using some bit - mixing for better distribution

public static int long to int with bit mixing ( long in ) { in = ( in ^ ( in > > > 30 ) ) * 0xbf 5 8 4 7 6d 1ce 4e 5b 9 l ; in = ( in ^ ( in > > > 27 ) ) * 0x 9 4d 0 4 9bb 1 3 3 1 1 1eb l ; in = in ^ ( in > > > 31 ) ; return ( int ) in ; }


returns an immutable set of the values for the given key if no mappings in the multimap have the provided key , an empty immutable set is returned the values are in the same order as the parameters used to build this multimap

public immutable set < v > get ( @ nullable decl k key ) { / / this cast is safe as its type is known in constructor immutable set < v > set = ( immutable set < v > ) map get ( key ) ; return more objects first non null ( set , empty set ) ; }


whether member key represents a constructor

public final boolean is constructor ( ) { return " < init > " equals ( name ( ) ) ; }


return a read - only list with the configured handlers

public list < handler method return value handler > get return value handlers ( ) { return collections unmodifiable list ( this return value handlers ) ; }


returns < code > true < code > iff the given cluster is configured as a remote cluster otherwise < code > false < code >

boolean is remote cluster registered ( string cluster name ) { return remote clusters contains key ( cluster name ) ; }


public string [ ] get menu path ( ) { return menu path ; }


{ @ inherit doc } all insns that are not move or phi insns have their source registers mapped ot the current mapping their result registers are then renamed to a new ssa register which is then added to the current register mapping

public void visit non move insn ( normal ssa insn insn ) { / * for each use of some variable x in s * / insn map source registers ( mapper ) ; process result reg ( insn ) ; }


find the fields constant that matches name , or null if its not found

public static fields find by name ( string name ) { return by name get ( name ) ; }


whether to ignore requests with path extension that cannot be resolved to any media type setting this to { @ code false } will result in an { @ code http media type not acceptable exception } if there is no match by default this is set to { @ code true }

public void set ignore unknown path extensions ( boolean ignore ) { this ignore unknown path extensions = ignore ; }


this method can reset the generator to a specific value

public void reset container id counter ( long container id start ) { this container id counter set ( container id start ) ; }


processes each model ' s property mapped to boolean type and adds related vendor extensions

public void process boolean type property ( codegen model model , codegen property property , string description , ktorm schema ktorm schema ) { map < string , object > column definition = new hash map < string , object > ( ) ; string base name = property get base name ( ) ; string col name = to column name ( base name ) ; string data type = property get data type ( ) ; string data format = property get data format ( ) ; string actual type = to column type ( data type , data format ) ; ktorm schema put ( " column definition " , column definition ) ; column definition put ( " col name " , col name ) ; column definition put ( " col type " , actual type ) ; column definition put ( " col kotlin type " , data type ) ; process type args ( data type , data format , 0 , 1 , column definition ) ; process null and default ( model , property , description , column definition ) ; }


loads a cache directory if the root directory is passed , also loads any subdirectories

private void load directory ( file directory , boolean is root , @ nullable file [ ] files , @ nullable map < string , cache file metadata > file metadata ) { if ( files = = null | | files length = = 0 ) { / / either ( a ) directory isn ' t really a directory ( b ) it ' s empty , or ( c ) listing files failed if ( ! is root ) { / / for ( a ) and ( b ) deletion is the desired result for ( c ) it will be a no - op if the / / directory is non - empty , so there ' s no harm in trying directory delete ( ) ; } return ; } for ( file file : files ) { string file name = file get name ( ) ; if ( is root & & file name index of ( ' ' ) = = - 1 ) { load directory ( file , / * is root = * / false , file list files ( ) , file metadata ) ; } else { if ( is root & & ( cached content index is index file ( file name ) | | file name ends with ( uid file suffix ) ) ) { / / skip expected uid and index files in the root directory continue ; } long length = c length unset ; long last touch timestamp = c time unset ; @ nullable cache file metadata metadata = file metadata ! = null ? file metadata remove ( file name ) : null ; if ( metadata ! = null ) { length = metadata length ; last touch timestamp = metadata last touch timestamp ; } @ nullable simple cache span span = simple cache span create cache entry ( file , length , last touch timestamp , content index ) ; if ( span ! = null ) { add span ( span ) ; } else { file delete ( ) ; } } } }


resource definitions corresponding to an android package < code > repeated aapt pb package package = 2 ; < code >

private void add package ( com android aapt resources package value ) { if ( value = = null ) { throw new null pointer exception ( ) ; } ensure package is mutable ( ) ; package add ( value ) ; }


this is here to verify role and path setup

public void test cannot touch under r o dir ( ) throws throwable { forbidden ( " touching the empty child " + read only child , " " , ( ) - > { touch ( role f s , read only child ) ; return read only child ; } ) ; }


brings the window to front and sets input focus the window should already be visible and not iconified

public void focus window ( ) { glfw glfw focus window ( window handle ) ; }


add or update an domain if the domain already exists , only the owner and the admin can update it

public void put domain ( timeline domain domain , user group information caller u g i ) throws yarn exception , i o exception { long start time = time monotonic now ( ) ; metrics incr put domain ops ( ) ; try { do put domain ( domain , caller u g i ) ; } finally { metrics add put domain time ( time monotonic now ( ) - start time ) ; } }


set owner of a path ( i e a file or a directory ) the parameters owner and group cannot both be null

public void set owner ( final path path , final string owner , final string group ) throws i o exception { statistics increment write ops ( 1 ) ; adl client set owner ( to relative file path ( path ) , owner , group ) ; }


generating the same output from two targets is ok if we build them on successive builds and invalidate the first target before we build the second target this is a strictly weaker test than if we didn ' t invalidate the first target , but since skyframe can ' t pass then , this test could be useful for it actually , since skyframe makes multiple update calls , it manages to unregister actions even when it shouldn ' t , and so this test can incorrectly pass however , { @ code skyframe executor test # test no action conflict with invalidated target } tests it more rigorously

public void test no action conflict with invalidated target ( ) throws exception { use configuration ( " - - cpu = k 8 " ) ; scratch file ( " conflict / build " , " cc library ( name = ' x ' , srcs = [ ' foo cc ' ] ) " , " cc binary ( name = ' objs / x / foo o ' , srcs = [ ' bar cc ' ] ) " ) ; update ( " / / conflict : x " ) ; configured target conflict = get configured target ( " / / conflict : x " ) ; action old action = get generating action ( get bin artifact ( " objs / x / foo o " , conflict ) ) ; assert that ( old action get owner ( ) get label ( ) to string ( ) ) is equal to ( " / / conflict : x " ) ; scratch overwrite file ( " conflict / build " , " cc library ( name = ' newx ' , srcs = [ ' foo cc ' ] ) " , / / rename target " cc binary ( name = ' objs / x / foo o ' , srcs = [ ' bar cc ' ] ) " ) ; update ( default flags ( ) , " / / conflict : objs / x / foo o " ) ; configured target objs conflict = get configured target ( " / / conflict : objs / x / foo o " ) ; action new action = get generating action ( get bin artifact ( " objs / x / foo o " , objs conflict ) ) ; assert that ( new action get owner ( ) get label ( ) to string ( ) ) is equal to ( " / / conflict : objs / x / foo o " ) ; }


returns the value of pcr base - first 33 bits in big endian order from the pcr bytes we ignore pcr ext , because it ' s too small to have any significance

private static long read pcr value from pcr bytes ( byte [ ] pcr bytes ) { return ( pcr bytes [ 0 ] & 0x f f l ) < < 25 | ( pcr bytes [ 1 ] & 0x f f l ) < < 17 | ( pcr bytes [ 2 ] & 0x f f l ) < < 9 | ( pcr bytes [ 3 ] & 0x f f l ) < < 1 | ( pcr bytes [ 4 ] & 0x f f l ) > > 7 ; }


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


register fields that should not be allowed for binding default is none mark fields as disallowed for example to avoid unwanted modifications by malicious users when binding http request parameters supports " xxx " , " xxx " and " xxx " patterns more sophisticated matching can be implemented by overriding the { @ code is allowed } method alternatively , specify a list of allowed fields

public void set disallowed fields ( @ nullable string disallowed fields ) { this disallowed fields = property accessor utils canonical property names ( disallowed fields ) ; }


public boolean is null parameter ( final int index ) { return ( null bitmap [ get byte position ( index ) ] & ( 1 < < get bit position ( index ) ) ) ! = 0 ; }


returns an encoding that behaves equivalently to this encoding , but uses an alternate character for padding

public abstract base encoding with pad char ( char pad char ) ;


returns the ast of the specified table api and sql queries and the execution plan to compute the result of the given { @ link table }


bind view annotated fields and methods in the specified { @ code target } using the { @ code source } { @ link activity } as the view root

public static unbinder bind ( @ non null object target , @ non null activity source ) { view source view = source get window ( ) get decor view ( ) ; return bind ( target , source view ) ; }


create a new aws { @ code client configuration } all clients to aws services must use this for consistent setup of connectivity , ua , proxy settings

public static client configuration create aws conf ( configuration conf , string bucket ) throws i o exception { return create aws conf ( conf , bucket , null ) ; }


returns the md5 content hash of the blaze binary ( includes deploy jar , embedded binaries , and anything else that ends up in the install base )

public hash code get install m d 5 ( ) { return server directories get install m d 5 ( ) ; }


public void visit switch ( int opcode , int offset , int length , switch list cases , int padding ) { / / this space intentionally left blank }


get the currently installed client authenticator if one has not been installed , this will trigger the installation of a default instance

public static client authenticator get client authenticator ( ) { if ( client authenticator = = null ) { if ( system utilities is in headless mode ( ) ) { set client authenticator ( new headless client authenticator ( ) ) ; } else { set client authenticator ( new default client authenticator ( ) ) ; } } return client authenticator ; }


returns true if folder has complete list of children

boolean visited ( ) { return visited ; }


returns a writer for writing to this file using the default charset parent directories will be created if necessary

public writer writer ( boolean append ) { throw new gdx runtime exception ( " stub " ) ; }


creates an answer from a functional interface - allows for a strongly typed answer to be created idiomatically in java 8

public static < t , a , b , c , d , e , f > answer < t > answer ( answer 6 < t , a , b , c , d , e , f > answer ) { return to answer ( answer ) ; }


return true if the object at the location in the drag gesture event is draggable

public boolean is start drag ok ( drag gesture event e ) { return false ; / / boolean drag ok = false ; / / / / need to check that the location is on a component / / point point = e get drag origin ( ) ; / / int index = table row at point ( point ) ; / / / / if we are on a component then drag is allowed / / if ( ( index > = 0 ) & & ( index < model get num components ( ) ) ) { / / drag ok = true ; / / } / / return drag ok ; }


headers to be added to the { @ link script exception } for structured rendering

public map < string , list < string > > get headers ( painless lookup painless lookup ) { map < string , list < string > > headers = new tree map < > ( ) ; string to string = " null " ; string java class name = null ; string painless class name = null ; if ( object to explain ! = null ) { to string = object to explain to string ( ) ; java class name = object to explain get class ( ) get name ( ) ; painless class struct = painless lookup lookup painless class ( object to explain get class ( ) ) ; if ( struct ! = null ) { painless class name = painless lookup utility type to canonical type name ( object to explain get class ( ) ) ; } } headers put ( " es to string " , singleton list ( to string ) ) ; if ( painless class name ! = null ) { headers put ( " es painless class " , singleton list ( painless class name ) ) ; } if ( java class name ! = null ) { headers put ( " es java class " , singleton list ( java class name ) ) ; } return headers ; }


client receives a listener with listener address and mismatched port

public void lds response with listener address port mismatch ( ) { xds client watch listener data ( port , listener watcher ) ; stream observer < discovery response > response observer = response observers poll ( ) ; stream observer < discovery request > request observer = request observers poll ( ) ; / / client sends an lds request with null in lds resource name verify ( request observer ) on next ( eq ( build discovery request ( get node to verify ( ) , " " , resource type lds type url v 2 ( ) , " " ) ) ) ; assert that ( fake clock get pending tasks ( listener resource fetch timeout task filter ) ) has size ( 1 ) ; final filter chain filter chain outbound = build filter chain ( build filter chain match ( 8000 ) , null ) ; final filter chain filter chain inbound = build filter chain ( build filter chain match ( port , cidr range new builder ( ) set address prefix ( local ip ) set prefix len ( u int 3 2 value of ( 32 ) ) build ( ) ) , / / server is still speaking xds v 2 common tls context tests util build test downstream tls context v 2 ( " google - sds - config - default " , " rootca " ) , build test filter ( " envoy http connection manager " ) ) ; list < any > listeners = immutable list of ( any pack ( build listener v 2 ( " bar googleapis com " , any pack ( http connection manager new builder ( ) set route config ( build route configuration v 2 ( " route - bar googleapis com " , immutable list of ( build virtual host v 2 ( immutable list of ( " bar googleapis com " ) , " cluster - bar googleapis com " ) ) ) ) build ( ) ) ) ) , any pack ( build listener with filter chain ( listener name , 15002 , " 0 0 0 0 " , filter chain outbound , filter chain inbound ) ) ) ; discovery response response = build discovery response v 2 ( " 0 " , listeners , resource type lds type url v 2 ( ) , " 0000 " ) ; response observer on next ( response ) ; / / client sends an ack lds request verify ( request observer ) on next ( eq ( build discovery request ( get node to verify ( ) , " 0 " , resource type lds type url v 2 ( ) , " 0000 " ) ) ) ; verify ( listener watcher , never ( ) ) on listener changed ( any ( listener update class ) ) ; verify ( listener watcher , never ( ) ) on resource does not exist ( " : " + port ) ; verify ( listener watcher , never ( ) ) on error ( any ( status class ) ) ; fake clock forward time ( server xds client initial resource fetch timeout sec , time unit seconds ) ; verify ( listener watcher ) on resource does not exist ( " : " + port ) ; assert that ( fake clock get pending tasks ( listener resource fetch timeout task filter ) ) is empty ( ) ; }


{ @ code provides with count } indicates the number of entries in the { @ code provides with index } table

public int get provides with count ( ) { return provides with count & 0xffff ; }


< code > required string city = 2 ; < code >

public java lang string get city ( ) { java lang object ref = city ; if ( ! ( ref instanceof java lang string ) ) { java lang string s = ( ( com google protobuf byte string ) ref ) to string utf 8 ( ) ; city = s ; return s ; } else { return ( java lang string ) ref ; } }


perform actual logging : might throw exception if things go wrong

private static void do logging ( ) throws i o exception { string builder msg = new string builder ( ) ; for ( network interface nic : network utils get interfaces ( ) ) { msg append ( system line separator ( ) ) ; / / ordinary name msg append ( nic get name ( ) ) ; msg append ( system line separator ( ) ) ; / / display name ( e g on windows ) if ( ! nic get name ( ) equals ( nic get display name ( ) ) ) { msg append ( indent ) ; msg append ( nic get display name ( ) ) ; msg append ( system line separator ( ) ) ; } / / addresses : v 4 first , then v 6 list < interface address > addresses = nic get interface addresses ( ) ; for ( interface address address : addresses ) { if ( address get address ( ) instanceof inet 6 address = = false ) { msg append ( indent ) ; msg append ( format address ( address ) ) ; msg append ( system line separator ( ) ) ; } } for ( interface address address : addresses ) { if ( address get address ( ) instanceof inet 6 address ) { msg append ( indent ) ; msg append ( format address ( address ) ) ; msg append ( system line separator ( ) ) ; } } / / hardware address byte hardware [ ] = nic get hardware address ( ) ; if ( hardware ! = null ) { msg append ( indent ) ; msg append ( " hardware " ) ; for ( int i = 0 ; i < hardware length ; i + + ) { if ( i > 0 ) { msg append ( " : " ) ; } msg append ( string format ( locale root , " % 02x " , hardware [ i ] ) ) ; } msg append ( system line separator ( ) ) ; } / / attributes msg append ( indent ) ; msg append ( format flags ( nic ) ) ; msg append ( system line separator ( ) ) ; } logger debug ( " configuration : { } { } " , system line separator ( ) , msg ) ; }


return whether the rom is made by smartisan

public static boolean is smartisan ( ) { return rom smartisan [ 0 ] equals ( get rom info ( ) name ) ; }


reset { @ code my s q l binary statement registry }

public static void reset ( ) { field statement id assigner field = my s q l binary statement registry class get declared field ( " statement id assigner " ) ; statement id assigner field set accessible ( true ) ; ( ( map ) statement id assigner field get ( my s q l binary statement registry get instance ( ) ) ) clear ( ) ; field binary statements field = my s q l binary statement registry class get declared field ( " binary statements " ) ; binary statements field set accessible ( true ) ; ( ( map ) binary statements field get ( my s q l binary statement registry get instance ( ) ) ) clear ( ) ; field sequence field = my s q l binary statement registry class get declared field ( " sequence " ) ; sequence field set accessible ( true ) ; ( ( atomic integer ) sequence field get ( my s q l binary statement registry get instance ( ) ) ) set ( 0 ) ; }


return the additional ( undeclared ) property

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


to test the collection format in query parameters

public void test query parameter collection format test ( ) { list < string > pipe = null ; list < string > ioutil = null ; list < string > http = null ; list < string > url = null ; list < string > context = null ; / / api test query parameter collection format ( pipe , ioutil , http , url , context ) ; / / todo : test validations }


find purchase order by id for valid response try integer i ds with value & lt ; & # x 3 d ; 5 or & gt ; 10 other values will generated exceptions

public void get order by id test ( ) { long order id = null ; order response = api get order by id ( order id ) block ( ) ; / / todo : test validations }


gets the reason for an item ' s eviction in eviction events

cache event listener eviction reason get eviction reason ( ) ;


get the next tcp - based peer - - either from the cache or by creating it

private block reader peer next tcp peer ( ) throws i o exception { if ( remaining cache tries > 0 ) { peer peer = client context get peer cache ( ) get ( datanode , false ) ; if ( peer ! = null ) { log trace ( " next tcp peer : reusing existing peer { } " , peer ) ; return new block reader peer ( peer , true ) ; } } try { peer peer = remote peer factory new connected peer ( inet socket address , token , datanode ) ; log trace ( " next tcp peer : created new connected peer { } " , peer ) ; return new block reader peer ( peer , false ) ; } catch ( i o exception | unresolved address exception e ) { log trace ( " next tcp peer : failed to create new connected peer connected to " + " { } " , datanode ) ; throw e ; } }


model tests for additional properties string

public void test additional properties string ( ) { / / todo : test additional properties string }


verify correct container request events sent to localizer

public void test localization request ( ) throws exception { wrapped container wc = null ; try { wc = new wrapped container ( 7 , 314159265358979l , 4344 , " yak " ) ; assert equals ( container state new , wc c get container state ( ) ) ; wc init container ( ) ; / / verify request for public / private resources to localizer resources requested matcher matches req = new resources requested matcher ( wc local resources , enum set of ( local resource visibility public , local resource visibility private , local resource visibility application ) ) ; verify ( wc localizer bus ) handle ( arg that ( matches req ) ) ; assert equals ( container state localizing , wc c get container state ( ) ) ; } finally { if ( wc ! = null ) { wc finished ( ) ; } } }


applies this function to two inputs , or throws an exception if unable to do so any objects that are passed to { @ link deferred closer # eventually close ( closeable , executor ) closer eventually close ( ) } will be closed when the { @ link closing future } pipeline is done ( but not before this method completes ) , even if this method throws or the pipeline is cancelled

u apply ( deferred closer closer , @ nullable decl v1 value 1 , @ nullable decl v2 value 2 ) throws exception ;


returns elements that satisfy the given predicate warning : this method mutates the original list and then returns it

public run list < r > filter ( predicate < r > predicate ) { size = null ; first = null ; base = iterables filter ( base , predicate ) ; return this ; }


encode a { @ link char sequence } in < a href = " https : en wikipedia orgwiki a s c i i " > ascii and write it to a { @ link byte buf } allocated with { @ code alloc }

public static byte buf write ascii ( byte buf allocator alloc , char sequence seq ) { / / ascii uses 1 byte per char byte buf buf = alloc buffer ( seq length ( ) ) ; write ascii ( buf , seq ) ; return buf ; }


returns an { @ link escaper } instance that escapes special characters in a string so it can safely be included in xml document as an attribute value see section < a href = " http : www w 3 org t r 2 0 0 8 r e c - xml - 20081126 # a v normalize " > 3 3 3 of the xml specification this escaper substitutes { @ code 0x f f f d } for non - whitespace control characters and the character values { @ code 0x f f f e } and { @ code 0x f f f f } which are not permitted in xml for more detail see section < a href = " http : www w 3 org t r 2 0 0 8 r e c - xml - 20081126 # charsets " > 2 2 of the xml specification this escaper does not escape non - ascii characters to their numeric character references ( ncr ) however , horizontal tab { @ code ' \ t ' } , line feed { @ code ' \ n ' } and carriage return { @ code ' \ r ' } are escaped to a corresponding ncr { @ code " & # x 9 ; " } , { @ code " & # x a ; " } , and { @ code " & # x d ; " } respectively any other non - ascii characters appearing in the input will be preserved in the output this escaper does not treat surrogate pairs specially and does not perform unicode validation on its input

public static escaper xml attribute escaper ( ) { return xml attribute escaper ; }


return total number of replicated blocks


public void remove ( ) { prev next = next ; next prev = prev ; next = prev = null ; }


{ @ inherit doc } < b > note : < b > this tests exact equality of the calculated statistics , including the floating point values two instances are guaranteed to be considered equal if one is copied from the other using { @ code second = new paired stats accumulator ( ) add all ( first ) snapshot ( ) } , if both were obtained by calling { @ code snapshot ( ) } on the same { @ link paired stats accumulator } without adding any values in between the two calls , or if one is obtained from the other after round - tripping through java serialization however , floating point rounding errors mean that it may be false for some instances where the statistics are mathematically equal , including instances constructed from the same values in a different order or ( in the general case ) even in the same order ( it is guaranteed to return true for instances constructed from the same values in the same order if { @ code strictfp } is in effect , or if the system architecture guarantees { @ code strictfp } - like semantics )

public boolean equals ( @ nullable decl object obj ) { if ( obj = = null ) { return false ; } if ( get class ( ) ! = obj get class ( ) ) { return false ; } paired stats other = ( paired stats ) obj ; return x stats equals ( other x stats ) & & y stats equals ( other y stats ) & & double to long bits ( sum of products of deltas ) = = double to long bits ( other sum of products of deltas ) ; }


build an automaton query accepting all terms with the specified prefix , ascii case insensitive

public static automaton query case insensitive prefix query ( term prefix ) { return new automaton query ( prefix , case insensitive prefix ( prefix text ( ) ) ) ; }


public boolean unlock orientation ( ) { return unlock orientation j s n i ( ) ; }


returns the number of pages found in sequence that compose the { @ link abstract msf free page map } ( for this { @ link abstract msf } ) when on disk

protected int get num sequential free page map pages ( ) { return free page map num sequential page ; }


a single trusted manager for verifying the remote endpoint ' s certificate this is helpful when custom implementation of { @ link trust manager } is needed internally , a simple wrapper of { @ link trust manager factory } that only produces this specified { @ link trust manager } will be created , thus all the requirements specified in { @ link # trust manager ( trust manager factory trust manager factory ) } also apply here

public ssl context builder trust manager ( trust manager trust manager ) { this trust manager factory = new trust manager factory wrapper ( trust manager ) ; trust cert collection = null ; return this ; }


get a generated id for this bit - field which is suitable for reconstruction via the { @ link # get bit field data type ( long ) } method this id encodes the base datatype ( including typedefenum and packing data ) , bit - size and bit - offset the upper byte of the id will always be zero and is reserved for use by the data type manager the ability to reference base datatypes ( e g , type def , enum ) is currently limited ( i e 32 - bit base datatype id )

static final long get id ( bit field data type bitfield dt ) { data type manager dtm = bitfield dt get data type manager ( ) ; if ( ! ( dtm instanceof data type manager d b ) ) { throw new assert exception ( " bitfield dt must first be resolved " ) ; } base datatype kind data type kind = base datatype kind none ; long data type index = 0 ; data type base data type = bitfield dt get base data type ( ) ; if ( base data type instanceof type def ) { data type kind = base datatype kind typedef ; } else if ( base data type instanceof enum ) { data type kind = base datatype kind enum ; } else if ( base data type instanceof abstract integer data type ) { data type kind = base datatype kind integer ; } if ( data type kind ! = base datatype kind none ) { data type index = get resolved data type index ( base data type , ( data type manager d b ) dtm ) ; if ( data type index = = data type manager null datatype id ) { msg debug ( bit field d b data type class , " bit - field data type not resolved : " + base data type get name ( ) ) ; data type index = max datatype index ; data type kind = base datatype kind none ; } else if ( data type index > = max datatype index ) { / / type def index exceeds 32 - bit limit msg debug ( bit field d b data type class , " bit - field data type index out of range : " + base data type get name ( ) ) ; data type index = max datatype index ; data type kind = base datatype kind none ; } } long id = ( data type index < < datatype index shift ) | ( get base type encoded field ( bitfield dt , data type kind ) < < base type shift ) | ( bitfield dt get bit offset ( ) < < bit offset shift ) | bitfield dt get declared bit size ( ) ; return id ; }


returns the u r ls in the class path specified by the { @ code java class path } { @ linkplain system # get property system property }

private static immutable list < url > parse java class path ( ) { immutable list builder < url > urls = immutable list builder ( ) ; for ( string entry : splitter on ( path separator value ( ) ) split ( java class path value ( ) ) ) { try { try { urls add ( new file ( entry ) to u r i ( ) to u r l ( ) ) ; } catch ( security exception e ) { / / file to u r i checks to see if the file is a directory urls add ( new url ( " file " , null , new file ( entry ) get absolute path ( ) ) ) ; } } catch ( malformed u r l exception e ) { assertion error error = new assertion error ( " malformed class path entry : " + entry ) ; error init cause ( e ) ; throw error ; } } return urls build ( ) ; }


public integer request i d ( ) { return req i d ; }


waits for a given persistent task to comply with a given predicate , then call back the listener accordingly

public void wait for persistent task ( final predicate < persistent tasks custom metadata persistent task < ? > > predicate , final @ nullable time value timeout , final persistent tasks service wait for persistent task listener < ? > listener ) { persistent tasks service wait for persistent task condition ( persistent task id , predicate , timeout , listener ) ; }


public api client add default cookie ( string key , string value ) { default cookie map put ( key , value ) ; return this ; }


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


computes a strong hash value for small files note that this method should only be used for files & lt ; 1mb

public static void hash file ( bytes ref builder file hash , input stream in , long size ) throws i o exception { final int len = ( int ) math min ( 1024 * 1024 , size ) ; / / for safety we limit this to 1mb file hash grow ( len ) ; file hash set length ( len ) ; final int read bytes = streams read fully ( in , file hash bytes ( ) , 0 , len ) ; assert read bytes = = len : integer to string ( read bytes ) + " ! = " + integer to string ( len ) ; assert file hash length ( ) = = len : integer to string ( file hash length ( ) ) + " ! = " + integer to string ( len ) ; }


static helper method to easily display an single - option dialog the dialog will remain until the user presses the option 1 button or the cancel button

public static int show option dialog ( component parent , string title , string message , string option 1 , int message type , string default button name ) { return swing run now ( ( ) - > { option dialog info = new option dialog ( title , message , option 1 , message type , null , default button name ) ; return info show ( parent ) ; } ) ; }


to test special tags to test special tags and operation id starting with number

public api response < client > call 1 2 3test special tags with http info ( client body ) throws api exception { http request builder local var request builder = call 1 2 3test special tags request builder ( body ) ; try { http response < input stream > local var response = member var http client send ( local var request builder build ( ) , http response body handlers of input stream ( ) ) ; if ( member var response interceptor ! = null ) { member var response interceptor accept ( local var response ) ; } if ( local var response status code ( ) / 100 ! = 2 ) { throw new api exception ( local var response status code ( ) , " call 1 2 3test special tags call received non - success response " , local var response headers ( ) , local var response body ( ) = = null ? null : new string ( local var response body ( ) read all bytes ( ) ) ) ; } return new api response < client > ( local var response status code ( ) , local var response headers ( ) map ( ) , member var object mapper read value ( local var response body ( ) , new type reference < client > ( ) { } ) ) ; } catch ( i o exception e ) { throw new api exception ( e ) ; } catch ( interrupted exception e ) { thread current thread ( ) interrupt ( ) ; throw new api exception ( e ) ; } }


creates a new builder initialized with data from the given authentication source

public static authentication builder new instance ( final authentication source ) { val builder = new default authentication builder ( source get principal ( ) ) ; builder set authentication date ( source get authentication date ( ) ) ; builder set credentials ( source get credentials ( ) ) ; builder set successes ( source get successes ( ) ) ; builder set failures ( source get failures ( ) ) ; builder set attributes ( source get attributes ( ) ) ; builder set warnings ( source get warnings ( ) ) ; return builder ; }


mostly used by logging to provide more readable messages

public final string get simple name ( ) { return m simple name ; }


returns true if this type is known to be an array type , such as { @ code int [ ] } , { @ code t [ ] } , { @ code < ? extends map < string , integer > [ ] > } etc

public final boolean is array ( ) { return get component type ( ) ! = null ; }


public void prefix integer test ( ) { / / todo : test prefix integer }


returns the { @ link objc provider } which contains information about the transitive dependencies linked into the dylib

public objc provider get deps objc provider ( ) { return deps objc provider ; }


delegate method used from { @ link base codec configurer # register defaults }

void register defaults ( boolean register defaults ) { if ( this register defaults ! = register defaults ) { this register defaults = register defaults ; init readers ( ) ; init writers ( ) ; } }


public boolean contains ( node node ) { if ( node = = null ) return false ; netlock read lock ( ) lock ( ) ; try { node parent = node get parent ( ) ; for ( int level = node get level ( ) ; parent ! = null & & level > 0 ; parent = parent get parent ( ) , level - - ) { if ( parent = = cluster map ) { return true ; } } } finally { netlock read lock ( ) unlock ( ) ; } return false ; }


the text representation of the primary i pv 4 address associated with this a connection ex 192 168 99 100 absent if unknown

@ nullable public string ipv 4 ( ) { return ipv 4 ; }


creates a directory with the name of the current path , not following symbolic links returns normally iff the directory exists after the call : true if the directory was created by this call , false if the directory was already in existence throws an exception if the directory could not be created for any reason

public boolean create directory ( ) throws i o exception { return file system create directory ( this ) ; }


parse a value , ref or collection sub - element of a property or constructor - arg element

public object parse property sub element ( element ele , @ nullable bean definition bd , @ nullable string default value type ) { if ( ! is default namespace ( ele ) ) { return parse nested custom element ( ele , bd ) ; } else if ( node name equals ( ele , bean element ) ) { bean definition holder nested bd = parse bean definition element ( ele , bd ) ; if ( nested bd ! = null ) { nested bd = decorate bean definition if required ( ele , nested bd , bd ) ; } return nested bd ; } else if ( node name equals ( ele , ref element ) ) { / / a generic reference to any name of any bean string ref name = ele get attribute ( bean ref attribute ) ; boolean to parent = false ; if ( ! string utils has length ( ref name ) ) { / / a reference to the id of another bean in a parent context ref name = ele get attribute ( parent ref attribute ) ; to parent = true ; if ( ! string utils has length ( ref name ) ) { error ( " ' bean ' or ' parent ' is required for < ref > element " , ele ) ; return null ; } } if ( ! string utils has text ( ref name ) ) { error ( " < ref > element contains empty target attribute " , ele ) ; return null ; } runtime bean reference ref = new runtime bean reference ( ref name , to parent ) ; ref set source ( extract source ( ele ) ) ; return ref ; } else if ( node name equals ( ele , idref element ) ) { return parse id ref element ( ele ) ; } else if ( node name equals ( ele , value element ) ) { return parse value element ( ele , default value type ) ; } else if ( node name equals ( ele , null element ) ) { / / it ' s a distinguished null value let ' s wrap it in a typed string value / / object in order to preserve the source location typed string value null holder = new typed string value ( null ) ; null holder set source ( extract source ( ele ) ) ; return null holder ; } else if ( node name equals ( ele , array element ) ) { return parse array element ( ele , bd ) ; } else if ( node name equals ( ele , list element ) ) { return parse list element ( ele , bd ) ; } else if ( node name equals ( ele , set element ) ) { return parse set element ( ele , bd ) ; } else if ( node name equals ( ele , map element ) ) { return parse map element ( ele , bd ) ; } else if ( node name equals ( ele , props element ) ) { return parse props element ( ele ) ; } else { error ( " unknown property sub - element : [ " + ele get node name ( ) + " ] " , ele ) ; return null ; } }


take an i o exception and a uri , wrap it where possible with something that includes the uri

public static i o exception wrap exception ( final string dest , final string operation , final i o exception exception ) { string action = operation + " " + dest ; string xref = null ; if ( exception instanceof connect exception ) { xref = " connection refused " ; } else if ( exception instanceof unknown host exception ) { xref = " unknown host " ; } else if ( exception instanceof socket timeout exception ) { xref = " socket timeout " ; } else if ( exception instanceof no route to host exception ) { xref = " no route to host " ; } string msg = action + " failed on exception : " + exception ; if ( xref ! = null ) { msg = msg + " ; " + see ( xref ) ; } return wrap with message ( exception , msg ) ; }


public static void main ( string [ ] args ) throws exception { int count = 1024 * 1024 ; boolean create = true ; boolean check = true ; string file = file ; string compress = " none " ; string usage = " usage : test set file [ - count n ] [ - nocreate ] [ - nocheck ] [ - compress type ] file " ; if ( args length = = 0 ) { system err println ( usage ) ; system exit ( - 1 ) ; } int i = 0 ; path fpath = null ; file system fs = null ; try { for ( ; i < args length ; i + + ) { / / parse command line if ( args [ i ] = = null ) { continue ; } else if ( args [ i ] equals ( " - count " ) ) { count = integer parse int ( args [ + + i ] ) ; } else if ( args [ i ] equals ( " - nocreate " ) ) { create = false ; } else if ( args [ i ] equals ( " - nocheck " ) ) { check = false ; } else if ( args [ i ] equals ( " - compress " ) ) { compress = args [ + + i ] ; } else { / / file is required parameter file = args [ i ] ; fpath = new path ( file ) ; } } fs = fpath get file system ( conf ) ; log info ( " count = " + count ) ; log info ( " create = " + create ) ; log info ( " check = " + check ) ; log info ( " compress = " + compress ) ; log info ( " file = " + file ) ; random datum [ ] data = generate ( count ) ; if ( create ) { write test ( fs , data , file , compression type value of ( compress ) ) ; } if ( check ) { read test ( fs , data , file ) ; } } finally { fs close ( ) ; } }


private string get rpc xid ( sofa request sofa request ) { string rpc xid = ( string ) sofa request get request prop ( root context key xid ) ; if ( rpc xid = = null ) { rpc xid = ( string ) sofa request get request prop ( root context key xid to lower case ( ) ) ; } return rpc xid ; }


void load into ( map < string , route meta > providers ) ;


public void test type holder example ( ) { / / todo : test type holder example }


public string get call string ( ) { return this call string ; }


returns { @ code true } if each element in { @ code iterable } after the first is strictly greater than the element that preceded it , according to this ordering note that this is always true when the iterable has fewer than two elements < b > java 8 users : < b > use the equivalent { @ link comparators # is in strict order ( iterable , comparator ) } instead , since the rest of { @ code ordering } is mostly obsolete ( as explained in the class documentation )

public boolean is strictly ordered ( iterable < ? extends t > iterable ) { iterator < ? extends t > it = iterable iterator ( ) ; if ( it has next ( ) ) { t prev = it next ( ) ; while ( it has next ( ) ) { t next = it next ( ) ; if ( compare ( prev , next ) > = 0 ) { return false ; } prev = next ; } } return true ; }


the list of array elements < code > repeated aapt pb array element element = 1 ; < code >

private void remove element ( int index ) { ensure element is mutable ( ) ; element remove ( index ) ; }


returns < tt > true < tt > if this queue contains the specified element more formally , returns < tt > true < tt > if and only if this queue contains at least one element < tt > e < tt > such that < tt > o equals ( e ) < tt >

public boolean contains ( @ nullable decl object o ) { if ( o = = null ) return false ; final e [ ] items = this items ; final monitor monitor = this monitor ; monitor enter ( ) ; try { int i = take index ; int k = 0 ; while ( k + + < count ) { if ( o equals ( items [ i ] ) ) return true ; i = inc ( i ) ; } return false ; } finally { monitor leave ( ) ; } }


returns the name of the blaze action this action config applies to

string get action name ( ) { return action name ; }


atomically remove { @ code key } from the map iff its associated value is 0

public boolean remove if zero ( k key ) { return remove ( key , 0 ) ; }


post pet { pet id } : updates a pet in the store with form data

default mono < response entity < void > > update pet with form ( @ api param ( value = " id of pet that needs to be updated " , required = true ) @ path variable ( " pet id " ) long pet id , @ api param ( value = " updated name of the pet " ) @ valid @ request part ( value = " name " , required = false ) string name , @ api param ( value = " updated status of the pet " ) @ valid @ request part ( value = " status " , required = false ) string status , @ api ignore final server web exchange exchange ) { return get delegate ( ) update pet with form ( pet id , name , status , exchange ) ; }


creates a compressed url style representation of an inet 6 address this method copies and adopts code from google ' s guava library we re - implement this here in order to reduce dependency on guava the guava library has frequently caused dependency conflicts in the past

private static string get i pv 6 url representation ( byte [ ] address bytes ) { / / first , convert bytes to 16 bit chunks int [ ] hextets = new int [ 8 ] ; for ( int i = 0 ; i < hextets length ; i + + ) { hextets [ i ] = ( address bytes [ 2 * i ] & 0x f f ) < < 8 | ( address bytes [ 2 * i + 1 ] & 0x f f ) ; } / / now , find the sequence of zeros that should be compressed int best run start = - 1 ; int best run length = - 1 ; int run start = - 1 ; for ( int i = 0 ; i < hextets length + 1 ; i + + ) { if ( i < hextets length & & hextets [ i ] = = 0 ) { if ( run start < 0 ) { run start = i ; } } else if ( run start > = 0 ) { int run length = i - run start ; if ( run length > best run length ) { best run start = run start ; best run length = run length ; } run start = - 1 ; } } if ( best run length > = 2 ) { arrays fill ( hextets , best run start , best run start + best run length , - 1 ) ; } / / convert into text form string builder buf = new string builder ( 40 ) ; buf append ( ' [ ' ) ; boolean last was number = false ; for ( int i = 0 ; i < hextets length ; i + + ) { boolean this is number = hextets [ i ] > = 0 ; if ( this is number ) { if ( last was number ) { buf append ( ' : ' ) ; } buf append ( integer to hex string ( hextets [ i ] ) ) ; } else { if ( i = = 0 | | last was number ) { buf append ( " : : " ) ; } } last was number = this is number ; } buf append ( ' ] ' ) ; return buf to string ( ) ; }


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


define the format for datetime with the given { @ link date format } note : setting this property makes the exposed { @ link object mapper } non - thread - safe , according to jackson ' s thread safety rules

public jackson 2 object mapper builder date format ( date format date format ) { this date format = date format ; return this ; }


opens a new buffered { @ link output stream } for writing to this sink the returned stream is not required to be a { @ link buffered output stream } in order to allow implementations to simply delegate to { @ link # open stream ( ) } when the stream returned by that method does not benefit from additional buffering ( for example , a { @ code byte array output stream } ) this method returns a new , independent stream each time it is called the caller is responsible for ensuring that the returned stream is closed

public output stream open buffered stream ( ) throws i o exception { output stream out = open stream ( ) ; return ( out instanceof buffered output stream ) ? ( buffered output stream ) out : new buffered output stream ( out ) ; }


restore all blocks and edges in this container from an xml stream

public void restore xml ( xml pull parser parser , address factory factory ) throws pcode x m l exception { block map resolver = new block map ( factory ) ; restore xml ( parser , resolver ) ; resolver resolve goto references ( ) ; }


public void set ( int n , register spec spec ) { set 0 ( n , spec ) ; }


public static string bytes 2hex ( byte [ ] bs , int off , int len ) { if ( off < 0 ) { throw new index out of bounds exception ( " bytes 2hex : offset < 0 , offset is " + off ) ; } if ( len < 0 ) { throw new index out of bounds exception ( " bytes 2hex : length < 0 , length is " + len ) ; } if ( off + len > bs length ) { throw new index out of bounds exception ( " bytes 2hex : offset + length > array length " ) ; } byte b ; int r = off , w = 0 ; char [ ] cs = new char [ len * 2 ] ; for ( int i = 0 ; i < len ; i + + ) { b = bs [ r + + ] ; cs [ w + + ] = base16 [ b > > 4 & mask4 ] ; cs [ w + + ] = base16 [ b & mask4 ] ; } return new string ( cs ) ; }


gets the latch that is counted down when an exception is thrown in { @ code abstract queue visitor } for use in tests to check if an exception actually was thrown calling { @ code abstract queue visitor # await exception for testing only } can throw a spurious { @ link interrupted exception } because { @ link count down latch # await } checks the interrupted bit before returning , even if the latch is already at 0 see bug " test two errors is flaky "

count down latch get exception latch for testing ( ) { return evaluator context get visitor ( ) get exception latch for testing only ( ) ; }


testing that we cannot close while running exclusively

public void test run exclusively ( ) throws interrupted exception { count down latch exclusive code started = new count down latch ( 1 ) ; final int num mails = 10 ; / / send 10 mails in an atomic operation new thread ( ( ) - > task mailbox run exclusively ( ( ) - > { exclusive code started count down ( ) ; for ( int index = 0 ; index < num mails ; index + + ) { try { task mailbox put ( new mail ( ( ) - > { } , 1 , " mail d " ) ) ; thread sleep ( 1 ) ; } catch ( exception e ) { } } } ) ) start ( ) ; exclusive code started await ( ) ; / / make sure that all 10 messages have been actually enqueued assert equals ( num mails , task mailbox close ( ) size ( ) ) ; }


disposes the state of all local snapshots managed by this object

public completable future < void > dispose ( ) { collection < map entry < long , task state snapshot > > states copy ; synchronized ( lock ) { disposed = true ; states copy = new array list < > ( stored task state by checkpoint i d entry set ( ) ) ; stored task state by checkpoint i d clear ( ) ; } return completable future run async ( ( ) - > { / / discard all remaining state objects sync discard local state for collection ( states copy ) ; / / delete the local state subdirectory that belong to this subtask local recovery directory provider directory provider = local recovery config get local state directory provider ( ) ; for ( int i = 0 ; i < directory provider allocation base dirs count ( ) ; + + i ) { file subtask base directory = directory provider select subtask base directory ( i ) ; try { delete directory ( subtask base directory ) ; } catch ( i o exception e ) { log warn ( " exception when deleting local recovery subtask base directory { } in subtask ( { } - { } - { } ) " , subtask base directory , job i d , job vertex i d , subtask index , e ) ; } } } , discard executor ) ; }


sets whether the tree should show pointers

public void set filter pointers ( boolean filter pointers ) { this filter pointers = filter pointers ; }


public string get small snake ( ) { return small snake ; }


specify that value that the dynamic value will be animated to

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


private void set failure limit ( int limit ) { if ( inconsistent client ! = null ) { inconsistent client set failure limit ( limit ) ; } }


invoke this method to transition the service to the { @ link state # failed } the service will < b > not be stopped < b > if it is running invoke this method when a service has failed critically or otherwise cannot be started nor stopped

protected final void notify failed ( throwable cause ) { check not null ( cause ) ; monitor enter ( ) ; try { state previous = state ( ) ; switch ( previous ) { case new : case terminated : throw new illegal state exception ( " failed while in state : " + previous , cause ) ; case running : case starting : case stopping : snapshot = new state snapshot ( failed , false , cause ) ; enqueue failed event ( previous , cause ) ; break ; case failed : / / do nothing break ; } } finally { monitor leave ( ) ; dispatch listener events ( ) ; } }


inflates a new hierarchy builder from xml the builder can then be modified in order to override xml attributes if necessary

public static generic drawee hierarchy builder inflate builder ( context context , @ nullable attribute set attrs ) { if ( fresco systrace is tracing ( ) ) { fresco systrace begin section ( " generic drawee hierarchy builder # inflate builder " ) ; } resources resources = context get resources ( ) ; generic drawee hierarchy builder builder = new generic drawee hierarchy builder ( resources ) ; builder = update builder ( builder , context , attrs ) ; if ( fresco systrace is tracing ( ) ) { fresco systrace end section ( ) ; } return builder ; }


creates a frame reader with max header table size of 4096 and data frame compression disabled

@ override public frame reader new reader ( buffered source source , boolean client ) { return new reader ( source , 4096 , client ) ; }


projects a pair of joined elements to a { @ link tuple } with the previously selected fields requires the classes of the fields of the resulting tuples

public < t0 , t1 , t2 , t3 , t4 > project join < i1 , i2 , tuple 5 < t0 , t1 , t2 , t3 , t4 > > project tuple 5 ( ) { type information < ? > [ ] f types = extract field types ( field indexes ) ; tuple type info < tuple 5 < t0 , t1 , t2 , t3 , t4 > > t type = new tuple type info < tuple 5 < t0 , t1 , t2 , t3 , t4 > > ( f types ) ; return new project join < i1 , i2 , tuple 5 < t0 , t1 , t2 , t3 , t4 > > ( this ds 1 , this ds 2 , this keys 1 , this keys 2 , this hint , this field indexes , this is field in first , t type , this ) ; }


returns the found serialization version if this instance was not read from serialized bytes but simply instantiated , then the current version is returned

public int get read version ( ) { return ( read version = = integer min value ) ? get version ( ) : read version ; }


returns the addresses that are to indicate the difference of this comparison type for this object

public address set get address set ( object obj , program program ) { address set addrs = new address set ( ) ; if ( obj = = null ) { return addrs ; } address addr = ( address ) obj ; code unit cu = program get listing ( ) get code unit containing ( addr ) ; if ( cu ! = null ) { addrs add range ( cu get min address ( ) , cu get max address ( ) ) ; } return addrs ; }


passes a white - space separated single - string command ( like " cat abc def " ) and parse them as a command argument this method also handles quotes

public proc starter cmd as single string ( string s ) { return cmds ( quoted string tokenizer tokenize ( s ) ) ; }


expose the singleton instance or create a new prototype instance

public final t get object ( ) throws exception { if ( is singleton ( ) ) { return ( this initialized ? this singleton instance : get early singleton instance ( ) ) ; } else { return create instance ( ) ; } }


construct an { @ link element } for a single queue , constructing the inner queue & lt ; name & gt ; , & lt ; properties & gt ; , & lt ; state & gt ; and the inner & lt ; queue & gt ; elements recursively

static element get queue element ( document document , job queue info jqi ) { / / queue element q = document create element ( queue tag ) ; / / queue - name element q name = document create element ( queue name tag ) ; q name set text content ( get simple queue name ( jqi get queue name ( ) ) ) ; q append child ( q name ) ; / / queue - properties properties props = jqi get properties ( ) ; element props element = document create element ( properties tag ) ; if ( props ! = null ) { set < string > prop list = props string property names ( ) ; for ( string prop : prop list ) { element property element = document create element ( property tag ) ; property element set attribute ( key tag , prop ) ; property element set attribute ( value tag , ( string ) props get ( prop ) ) ; props element append child ( property element ) ; } } q append child ( props element ) ; / / queue - state string queue state = jqi get state ( ) get state name ( ) ; if ( queue state ! = null & & ! queue state equals ( queue state undefined get state name ( ) ) ) { element q state element = document create element ( state tag ) ; q state element set text content ( queue state ) ; q append child ( q state element ) ; } / / queue - children list < job queue info > children = jqi get children ( ) ; if ( children ! = null ) { for ( job queue info child : children ) { q append child ( get queue element ( document , child ) ) ; } } return q ; }


public void place order ( order body , handler < async result < order > > result handler ) { place order ( body , null , result handler ) ; }


returns the list of entries which can potentially have the given hash code

private entry get ( final int hash code ) { return entries [ hash code % entries length ] ; }


checks if the data should be classified as " string " in enum e g double in c # needs to be double - quoted ( e g " 2 8 " ) by treating it as a string in the future , we may rename this function to " is enum string "

public boolean is data type string ( string data type ) { return " string " equals ( data type ) ; }


public static stream < arguments > get test parameters ( ) { val params = new array list < arguments > ( ) ; / * test case # 1 : unsupported credential type * / var handler = new x 5 0 9 credentials authentication handler ( regex utils create pattern ( " * " ) ) ; params add ( arguments ( handler , new username password credential ( ) , false , null , null ) ) ; / * test case # 2 : valid certificate / * / handler = new x 5 0 9 credentials authentication handler ( regex utils create pattern ( " * " ) ) ; var credential = new x 5 0 9 certificate credential ( create certificates ( user valid crt ) ) ; params add ( arguments ( handler , credential , true , new default authentication handler execution result ( handler , credential , principal factory utils new principal factory ( ) create principal ( credential get id ( ) ) ) , null ) ) ; / * test case # 3 : expired certificate * / handler = new x 5 0 9 credentials authentication handler ( regex utils create pattern ( " * " ) ) ; params add ( arguments ( handler , new x 5 0 9 certificate credential ( create certificates ( " user - expired crt " ) ) , true , null , new certificate expired exception ( ) ) ) ; / * test case # 4 : untrusted issuer * / handler = new x 5 0 9 credentials authentication handler ( regex utils create pattern ( " cn = \ \ w + , ou = cas , o = jasig , l = westminster , st = colorado , c = us " ) , true , false , false ) ; params add ( arguments ( handler , new x 5 0 9 certificate credential ( create certificates ( " snake - oil crt " ) ) , true , null , new failed login exception ( ) ) ) ; / * test case # 5 : disallowed subject * / handler = new x 5 0 9 credentials authentication handler ( regex utils create pattern ( " * " ) , true , regex utils create pattern ( " cn = \ \ w + , ou = cas , o = jasig , l = westminster , st = colorado , c = us " ) ) ; params add ( arguments ( handler , new x 5 0 9 certificate credential ( create certificates ( " snake - oil crt " ) ) , true , null , new failed login exception ( ) ) ) ; / * test case # 6 : check key usage on a cert without key usage extension * / handler = new x 5 0 9 credentials authentication handler ( regex utils create pattern ( " * " ) , false , true , false ) ; credential = new x 5 0 9 certificate credential ( create certificates ( user valid crt ) ) ; params add ( arguments ( handler , credential , true , new default authentication handler execution result ( handler , credential , principal factory utils new principal factory ( ) create principal ( credential get id ( ) ) ) , null ) ) ; / * test case # 7 : require key usage on a cert without key usage extension * / handler = new x 5 0 9 credentials authentication handler ( regex utils create pattern ( " * " ) , false , true , true ) ; params add ( arguments ( handler , new x 5 0 9 certificate credential ( create certificates ( user valid crt ) ) , true , null , new failed login exception ( ) ) ) ; / * test case # 8 : require key usage on a cert with acceptable key usage extension values * / handler = new x 5 0 9 credentials authentication handler ( regex utils create pattern ( " * " ) , false , true , true ) ; credential = new x 5 0 9 certificate credential ( create certificates ( " user - valid - key usage crt " ) ) ; params add ( arguments ( handler , credential , true , new default authentication handler execution result ( handler , credential , principal factory utils new principal factory ( ) create principal ( credential get id ( ) ) ) , null ) ) ; / * test case # 9 : require key usage on a cert with unacceptable key usage extension values * / handler = new x 5 0 9 credentials authentication handler ( regex utils create pattern ( " * " ) , false , true , true ) ; params add ( arguments ( handler , new x 5 0 9 certificate credential ( create certificates ( " user - invalid - key usage crt " ) ) , true , null , new failed login exception ( ) ) ) ; / * * revocation tests * / / * test case # 10 : valid certificate with crl checking * / var checker = new resource c r l revocation checker ( new class path resource ( " user c a - valid crl " ) ) ; checker init ( ) ; handler = new x 5 0 9 credentials authentication handler ( regex utils create pattern ( " * " ) , checker ) ; credential = new x 5 0 9 certificate credential ( create certificates ( user valid crt ) ) ; params add ( arguments ( handler , new x 5 0 9 certificate credential ( create certificates ( user valid crt ) ) , true , new default authentication handler execution result ( handler , credential , principal factory utils new principal factory ( ) create principal ( credential get id ( ) ) ) , null ) ) ; / * test case # 11 : revoked end user certificate * / checker = new resource c r l revocation checker ( new class path resource ( " user c a - valid crl " ) ) ; checker init ( ) ; handler = new x 5 0 9 credentials authentication handler ( regex utils create pattern ( " * " ) , checker ) ; params add ( arguments ( handler , new x 5 0 9 certificate credential ( create certificates ( " user - revoked crt " ) ) , true , null , new revoked certificate exception ( zoned date time now ( zone offset utc ) , null ) ) ) ; / * test case # 12 : valid certificate on expired crl data * / val zero threshold policy = new threshold expired c r l revocation policy ( 0 ) ; checker = new resource c r l revocation checker ( new class path resource ( " user c a - expired crl " ) , null , zero threshold policy ) ; checker init ( ) ; handler = new x 5 0 9 credentials authentication handler ( regex utils create pattern ( " * " ) , checker ) ; params add ( arguments ( handler , new x 5 0 9 certificate credential ( create certificates ( user valid crt ) ) , true , null , new expired c r l exception ( null , zoned date time now ( zone offset utc ) ) ) ) ; return params stream ( ) ; }


waits for the { @ link service } to reach the { @ linkplain state # running running state } for no more than the given time

default void await running ( duration timeout ) throws timeout exception { await running ( to nanos saturated ( timeout ) , time unit nanoseconds ) ; }


convert { @ link string } into { @ link properties } , considering it as properties content

public void set as text ( @ nullable string text ) throws illegal argument exception { properties props = new properties ( ) ; if ( text ! = null ) { try { / / must use the iso - 8859 - 1 encoding because properties load ( stream ) expects it props load ( new byte array input stream ( text get bytes ( standard charsets iso 8859 1 ) ) ) ; } catch ( i o exception ex ) { / / should never happen throw new illegal argument exception ( " failed to parse [ " + text + " ] into properties " , ex ) ; } } set value ( props ) ; }


the sink node making the request < code > istio mcp v 1alpha 1 sink node sink node = 2 ; < code >

public com alibaba nacos istio model mcp sink node or builder get sink node or builder ( ) { return get sink node ( ) ; }


wrapper for { @ link build options # contains } that throws an { @ link illegal argument exception } if the given { @ link fragment options } isn ' t in the " permitted " set

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


returns a single value the subject currently has or null if no such value exists the method is thread - safe

public t get value ( ) { return buffer get value ( ) ; }


is login form username input disabled boolean

public boolean is login form username input disabled ( final web engine context vars ) { val context = request context holder get request context ( ) ; return context = = null | | ! web utils is cas login form viewable ( context ) | | web utils is graphical user authentication enabled ( context ) | | web utils get passwordless authentication account ( context , serializable class ) ! = null ; }


executes the execution listeners defined on the given element , with the given event type uses the { @ link # execution } of this operation instance as argument for the execution listener

protected void execute execution listeners ( has execution listeners element with execution listeners , string event type ) { execute execution listeners ( element with execution listeners , execution , event type ) ; }


get the address set which makes up a function

synchronized address set view get body ( long function key ) { address set body = new address set ( ) ; index range iterator iter = range map get value range iterator ( function key ) ; while ( iter has next ( ) ) { index range range = iter next ( ) ; body add range ( addr map decode address ( range get start ( ) ) , addr map decode address ( range get end ( ) ) ) ; } return body ; } / / / * * / / * get the function key for the first function containing the specified address / / * @ param addr / / * @ return function key / / * @ throws not found exception if no function exists for the addr specified / / * / / / synchronized long get first function containing ( address addr ) throws not found exception { / / long index = addr map get key ( addr , false ) ; / / iterator < field > iter = range map get value iterator ( index , index ) ; / / if ( ! iter has next ( ) ) { / / throw new not found exception ( ) ; / / } / / return ( ( long field ) iter next ( ) ) get long value ( ) ; / / } / / / / / * * / / * get all function keys whoose body contains the specified address / / * @ param addr / / * @ return a long field function key iterator / / * / / / synchronized iterator < field > get functions containing ( address addr ) { / / long index = addr map get key ( addr , false ) ; / / return range map get value iterator ( index , index ) ; / / } / / / /


sets the priority of the stream the priority must be between 0 and 7 inclusive

spdy syn stream frame set priority ( byte priority ) ;


public void set padding ( int padding ) { if ( m padding ! = padding ) { m padding = padding ; invalidate self ( ) ; } }


apply authentication settings to header and query params

void apply to params ( list < pair > query params , multi map header params , multi map cookie params ) ;


sets this matrix to a rotation matrix that will rotate any vector in counter - clockwise direction around the z - axis

public matrix 3 set to rotation ( float degrees ) { return set to rotation rad ( math utils degrees to radians * degrees ) ; }


call { @ code list located status ( base path ) } the list here returns the marker peer before the dir reason : the listing iterators return the objects before the common prefixes , and the marker dir is coming back as a prefix

public void test list located status base dir ( ) throws throwable { list < file status > statuses = exec ( " list located status " , ( ) - > to list ( get file system ( ) list located status ( base path ) ) ) ; assert contains exactly status of paths ( statuses , marker peer , marker dir ) ; }


test gpu topology allocation and analysis the gpu allocation ' s performance against the actual performance data using tensorflow benchmarks https : github comtensorflowbenchmarks

public void test topology scheduling performance with pack policy with n v link ( ) throws exception { nvidia g p u plugin for runtime v 2 plugin = mock eight g p u plugin ( ) ; nvidia g p u plugin for runtime v 2 spy plugin = spy ( plugin ) ; set < device > all devices = spy plugin get devices ( ) ; map < string , string > env = new hash map < > ( ) ; env put ( nvidia g p u plugin for runtime v 2 topology policy env key , nvidia g p u plugin for runtime v 2 topology policy pack ) ;


an string interner for rule and build statements ' variable names

interner < string > get name interner ( ) ;


replaces all the old strings with the replacement string

public static string replace ( string str , string old str , string replacement ) { return str replace ( old str , replacement ) ; }


records a miss when the cold set is not full

private void on hir warmup miss ( node node ) { node status = status hir resident ; node move to top ( stack type q ) ; }


convenient call for { @ link abstract dao # delete all ( ) }

public < t > void delete all ( class < t > entity class ) { @ suppress warnings ( " unchecked " ) abstract dao < t , ? > dao = ( abstract dao < t , ? > ) get dao ( entity class ) ; dao delete all ( ) ; }


public node heartbeat response node heartbeat ( map < application id , list < container status > > conts , boolean is healthy , int res id ) throws exception { array list < container status > updated stats = new array list < container status > ( ) ; for ( list < container status > stats : conts values ( ) ) { updated stats add all ( stats ) ; } return node heartbeat ( updated stats , collections < container > empty list ( ) , is healthy , res id ) ; }


returns the custom data path that is used to look up information for this shard returns an empty string if no custom data path is used for this index returns null if custom data path information is not available ( due to bwc )

public string get custom data path ( ) { return custom data path ; }


called when the { @ link node provisioner planned node # future } completes

public void on complete ( node provisioner planned node planned node , node node ) { }


provide your own network cache directory by default , animations will be saved in your application ' s cache dirlottie network cache

public builder set network cache dir ( @ non null final file file ) { if ( cache provider ! = null ) { throw new illegal state exception ( " there is already a cache provider ! " ) ; } cache provider = new lottie network cache provider ( ) { @ override @ non null public file get cache dir ( ) { if ( ! file is directory ( ) ) { throw new illegal argument exception ( " cache file must be a directory " ) ; } return file ; } } ; return this ; }


get the running task attempt i ds for this task

public collection < task attempt i d > get running task attempts ( ) { collection < task attempt i d > attempts = new array list < task attempt i d > ( ) ; for ( org apache hadoop mapreduce task attempt i d id : super get running task attempt ids ( ) ) { attempts add ( task attempt i d downgrade ( id ) ) ; } return attempts ; }


return { @ code true } if the reactive type does not produce any values and only provides completion and error signals

public boolean is no value ( ) { return this no value ; }


returns the absolute path of the current log file if a log file is open or { @ code optional # empty ( ) } otherwise since the log file is opened lazily , this method is expected to return { @ code optional # empty ( ) } if no record has yet been published

public synchronized optional < path > get current log file path ( ) { return output is open ( ) ? optional of ( output get path ( ) ) : optional empty ( ) ; }


increases the size of the backing array to accommodate the specified number of additional items load factor useful before adding many items to avoid multiple backing array resizes

public void ensure capacity ( int additional capacity ) { int table size = table size ( size + additional capacity , load factor ) ; if ( key table length < table size ) resize ( table size ) ; }


long argument less than the given value see examples in javadoc for { @ link additional matchers } class

public static long lt ( long value ) { report matcher ( new less than < long > ( value ) ) ; return 0 ; }


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


remove the given component template from the cluster state the component template name supports simple regex wildcards for removing multiple component templates at a time

public void remove component template ( final string name , final time value master timeout , final action listener < acknowledged response > listener ) { validate not in use ( cluster service state ( ) metadata ( ) , name ) ; cluster service submit state update task ( " remove - component - template [ " + name + " ] " , new cluster state update task ( priority urgent , master timeout ) { @ override public void on failure ( string source , exception e ) { listener on failure ( e ) ; } @ override public cluster state execute ( cluster state current state ) { set < string > template names = new hash set < > ( ) ; for ( string template name : current state metadata ( ) component templates ( ) key set ( ) ) { if ( regex simple match ( name , template name ) ) { template names add ( template name ) ; } } if ( template names is empty ( ) ) { / / if its a match all pattern , and no templates are found ( we have none ) , don ' t / / fail with index missing if ( regex is match all pattern ( name ) ) { return current state ; } / / todo : perhaps introduce a component template missing exception ? throw new index template missing exception ( name ) ; } metadata builder metadata = metadata builder ( current state metadata ( ) ) ; for ( string template name : template names ) { logger info ( " removing component template [ { } ] " , template name ) ; metadata remove component template ( template name ) ; } return cluster state builder ( current state ) metadata ( metadata ) build ( ) ; } @ override public void cluster state processed ( string source , cluster state old state , cluster state new state ) { listener on response ( acknowledged response true ) ; } } ) ; }


check that as well as skipping old appenders , logger references to them are also skipped

public void test transform skips old appender refs ( ) { list < string > input = list of ( " logger index indexing slowlog appender ref index indexing slowlog rolling old ref = index indexing slowlog rolling old " ) ; run test ( input , list of ( ) ) ; }


invoke api by sending http request with the given options

public < t > void invoke a p i ( string path , string method , list < pair > query params , object body , multi map header params , multi map cookie params , map < string , object > form params , string [ ] accepts , string [ ] content types , string [ ] auth names , auth info auth info , type reference < t > return type , handler < async result < t > > result handler ) { update params for auth ( auth names , auth info , query params , header params , cookie params ) ; if ( accepts ! = null & & accepts length > 0 ) { header params add ( http headers accept , select header accept ( accepts ) ) ; } if ( content types ! = null ) { header params add ( http headers content type , select header content type ( content types ) ) ; } http method http method = http method value of ( method ) ; http request < buffer > request = get web client ( ) request abs ( http method , base path + path ) ; request timeout ( this timeout ) ; if ( http method = = http method patch ) { request put header ( " x - http - method - override " , " patch " ) ; } query params for each ( entry - > { if ( entry get value ( ) ! = null ) { request add query param ( entry get name ( ) , entry get value ( ) ) ; } } ) ; header params for each ( entry - > { if ( entry get value ( ) ! = null ) { request put header ( entry get key ( ) , entry get value ( ) ) ; } } ) ; default headers for each ( entry - > { if ( entry get value ( ) ! = null ) { request put header ( entry get key ( ) , entry get value ( ) ) ; } } ) ; final multi map cookies = multi map case insensitive multi map ( ) add all ( cookie params ) add all ( default cookies ) ; request put header ( " cookie " , build cookie header ( cookies ) ) ; handler < async result < http response < buffer > > > response handler = build response handler ( return type , result handler ) ; if ( body ! = null ) { send body ( request , response handler , body ) ; } else if ( form params ! = null & & ! form params is empty ( ) ) { map < string , string > form map = form params entry set ( ) stream ( ) collect ( to map ( map entry : : get key , entry - > parameter to string ( entry get value ( ) ) ) ) ; multi map form = multi map case insensitive multi map ( ) add all ( form map ) ; request send form ( form , response handler ) ; } else { request send ( response handler ) ; } }


called for every event fired < b > default implementation : < b > does nothing

public void mark event ( hystrix event type event type , hystrix command key key ) { / / do nothing }


emit a message that can be logged or escalated by the logger implementation

public static void emit message ( log level level , string category key , string message , int sampling frequency , @ nullable map < string , object > metadata ) { error reporter get instance ( ) report ( map ( level ) , category key , message , sampling frequency , metadata ) ; }


creates a new { @ link top level item } for the specified parent

public abstract top level item new instance ( item group parent , string name ) ;


returns a string representation of this code completion

public string to string ( ) { return " code completion : ' " + get description ( ) + " ' ( " + get insertion ( ) + " ) " ; }


gets the maximum length for any frame ' s payload

public int max frame payload length ( ) { return decoder config max frame payload length ( ) ; }


public static void main ( string [ ] args ) throws exception { var aqfc = new app queue fail cases ( ) ; / / aqfc queue payment task database unavailable case ( ) ; / / aqfc queue message task database unavailable case ( ) ; / / aqfc queue employee db task database unavailable case ( ) ; aqfc queue success case ( ) ; }


removes the translational part and transposes the matrix

public matrix 4 to normal matrix ( ) { val [ m03 ] = 0 ; val [ m13 ] = 0 ; val [ m23 ] = 0 ; return inv ( ) tra ( ) ; }


notifies the process engine that a message event with name ' message name ' has been received and has been correlated to an execution with id ' execution id ' the waiting execution is notified synchronously

void message event received ( string message name , string execution id ) ;