test that enabling " search only in accessible memory blocks " only looks for strings in memory blocks that have one or more of the r , w , or x permissions set test that disabling the option allows strings to be made in all memory blocks regardless of permissions

public void test create strings in accessible memory blocks only ( ) throws exception { program test program = build program ( " xtraceroute " , false ) ; listing listing = test program get listing ( ) ; / / these inaccessible strings will be in the comment address space / memory block string [ ] inaccessible strings = new string [ ] { " gcc : ( gnu ) 3 2 20020720 ( red hat linux rawhide 3 2 - 0 1 ) " , " gcc : ( gnu ) 3 2 20020720 ( red hat linux rawhide 3 2 - 0 1 1 ) " } ; int [ ] offsets = new int [ ] { 0x 0 0 0 0 0 0 0 1 , 0x 0 0 0 0 0 2fc } ; string [ ] accessible strings = new string [ ] { " anguilla " , " q80 @ at " , " bosnia and herzegowina " , " kingdom of sweden " } ; int [ ] offsets 2 = new int [ ] { 0x 0 8 0 5 7b 6 0 , 0x 0 8 0 5 7e 3 8 , 0x 0 8 0 5 7fb 0 , 0x 0 8 0 5bc 6c } ; boolean [ ] should exist = new boolean [ ] { true , false , true , true } ; address space space = test program get language ( ) get address factory ( ) get default address space ( ) ; address [ ] inaccessible addresses = new address [ offsets length ] ; address [ ] accessible addresses = new address [ offsets 2 length ] ; for ( int i = 0 ; i < offsets length ; i + + ) { inaccessible addresses [ i ] = addr ( space , offsets [ i ] ) ; } for ( int i = 0 ; i < offsets 2 length ; i + + ) { accessible addresses [ i ] = addr ( space , offsets 2 [ i ] ) ; } data data here ; / / verify none of the strings exist prior to running the strings analyzer for ( address curr address : inaccessible addresses ) { data here = listing get defined data at ( curr address ) ; assert null ( data here ) ; } for ( address curr address : accessible addresses ) { data here = listing get defined data at ( curr address ) ; assert null ( data here ) ; } auto analysis manager manager = auto analysis manager get analysis manager ( test program ) ; / / set to search only accessible memory blocks we don ' t expect to find the / / ' inaccessible ' strings in this case strings analyzer analyzer = new strings analyzer ( ) ; analyzer set search accessible memory blocks ( true ) ; analyzer set string end alignment ( 1 ) ; analyzer set require null termination ( false ) ; analyzer added ( test program , null , monitor , manager get message log ( ) ) ; / / verify the inaccessible strings still don ' t exist for ( address curr address : inaccessible addresses ) { data here = listing get defined data at ( curr address ) ; assert null ( data here ) ; } / / but most of the accessible strings should exist string string here ; for ( int i = 0 ; i < accessible addresses length ; i + + ) { data here = listing get defined data at ( accessible addresses [ i ] ) ; if ( should exist [ i ] ) { assert not null ( data here ) ; string here = data here get default value representation ( ) ; / / string will look something like - - > " my string " , 00 string build my string = " \ " " + accessible strings [ i ] + " \ " " ; assert equals ( build my string , string here ) ; } else { assert null ( data here ) ; } } / / set to search all memory blocks analyzer set search accessible memory blocks ( false ) ; analyzer added ( test program , null , monitor , manager get message log ( ) ) ; for ( int i = 0 ; i < inaccessible strings length ; i + + ) { / / verify formerly inaccessible strings are now there data here = listing get defined data at ( inaccessible addresses [ i ] ) ; assert not null ( data here ) ; string here = data here get default value representation ( ) ; / / string will look something like - - > " my string " , 00 string build my string = " \ " " + inaccessible strings [ i ] + " \ " " ; assert equals ( build my string , string here ) ; } }


the response resources wrapped in the common mcp resource message these are typed resources that match the type url in the request resources message when ` incremental ` is true , this contains an array of resources to addupdate for the specified collection this modifies the existing collection at the sink when ` incremental ` is false , this contains the full set of resources for the specified collection this replaces any previously delivered resources < code > repeated istio mcp v 1alpha 1 resource resources = 3 ; < code >

public com alibaba nacos istio model mcp resource builder add resources builder ( ) { return get resources field builder ( ) add builder ( com alibaba nacos istio model mcp resource get default instance ( ) ) ; }


returns the values of done deps in { @ code dep keys } , by looking in order at : { @ link # bubble error info } { @ link # previously requested deps values } { @ link # newly requested deps values } { @ link # old deps entries } { @ link # evaluator context } ' s graph accessing methods any key whose { @ link node entry } - - or absence thereof - - had to be read from the graph will also be entered into { @ link # newly requested deps values } with its value or a { @ link # null marker } this asserts that only keys in { @ link # newly registered deps } require reading from the graph , because this node is done , and so all other deps must have been previously or newly requested if { @ code assert done } , this asserts that all deps in { @ code dep keys } are done

private collection < sky value > get dep values for done node from error or deps or graph ( iterable < sky key > dep keys , boolean assert done , int key size ) throws interrupted exception { list < sky value > result = new array list < > ( key size ) ; / / dep keys may contain keys in newly registered deps whose values have not yet been retrieved from / / the graph during this environment ' s lifetime int expected missing keys = newly registered deps size ( ) ; array list < sky key > missing keys = expected missing keys > 0 ? new array list < > ( expected missing keys ) : null ; array list < sky key > unexpectedly missing keys = null ; for ( sky key key : dep keys ) { sky value value = maybe get value from error or deps ( key ) ; if ( value = = null ) { if ( key = = error transience value key ) { continue ; } if ( ! newly registered deps contains ( key ) ) { if ( unexpectedly missing keys = = null ) { unexpectedly missing keys = new array list < > ( ) ; } unexpectedly missing keys add ( key ) ; if ( missing keys = = null ) { missing keys = new array list < > ( ) ; } } missing keys add ( key ) ; } else if ( value = = null marker ) { preconditions check state ( ! assert done , " % s had not done % s " , sky key , key ) ; } else { result add ( value ) ; } } if ( unexpectedly missing keys ! = null & & ! unexpectedly missing keys is empty ( ) ) { / / this may still crash below , if the dep is not done in the graph , but at least it gives the / / dep until now to complete its computation , as opposed to the start of this node ' s / / evaluation , which is when most of the structures used by # maybe get value from error or deps were / / created evaluator context get graph inconsistency receiver ( ) note inconsistency and maybe throw ( sky key , unexpectedly missing keys , inconsistency already declared child missing ) ; } if ( missing keys = = null | | missing keys is empty ( ) ) { return result ; } map < sky key , ? extends node entry > missing entries = evaluator context get batch values ( sky key , reason dep requested , missing keys ) ; for ( sky key key : missing keys ) { node entry dep entry = missing entries get ( key ) ; sky value value or null marker = get value or null marker ( dep entry ) ; newly requested deps values put ( key , value or null marker ) ; if ( value or null marker = = null marker ) { / / todo ( mschaller ) : handle registered deps that transitioned from done to dirty during eval / / but how ? restarting the current node may not help , because this dep was * registered * , not / / requested for now , no node that gets registered as a dep is eligible for / / intra - evaluation dirtying , so let it crash preconditions check state ( ! assert done , " % s had not done : % s " , sky key , key ) ; continue ; } maybe update max child version ( dep entry ) ; result add ( value or null marker ) ; } return result ; }


returns the values from each provided array combined into a single array for example , { @ code concat ( new byte [ ] { a , b } , new byte [ ] { } , new byte [ ] { c } } returns the array { @ code { a , b , c } }

public static byte [ ] concat ( byte [ ] arrays ) { int length = 0 ; for ( byte [ ] array : arrays ) { length + = array length ; } byte [ ] result = new byte [ length ] ; int pos = 0 ; for ( byte [ ] array : arrays ) { system arraycopy ( array , 0 , result , pos , array length ) ; pos + = array length ; } return result ; }


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


return the aspect j aspect metadata for this factory ' s aspect

aspect metadata get aspect metadata ( ) ;


< code > optional aapt pb config description config = 1 ; < code >

public builder set config ( com android aapt resources config description builder builder for value ) { copy on write ( ) ; instance set config ( builder for value ) ; return this ; }


same as { @ link application # on trim memory ( int level ) }


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

public void delete user ( @ path param ( " username " ) string username ) ;


adds { @ link align # left } and clears { @ link align # right } for the alignment of all widgets within the vertical group

public vertical group left ( ) { align | = align left ; align & = ~ align right ; return this ; }


calculates and returns the measured value


public show block name get show block name ( ) { return options show block name ; }


if a state was previously saved for this view holder via { @ link # save } it will be restored here

public void restore ( epoxy view holder holder ) { if ( ! holder get model ( ) should save view state ( ) ) { return ; } view state state = get ( holder get item id ( ) ) ; if ( state ! = null ) { state restore ( holder item view ) ; } else { / / the first time a model is bound it won ' t have previous state we need to make sure / / the view is reset to its initial state to clear any changes from previously bound models holder restore initial view state ( ) ; } }


test that default replication values can be retrieved on the client side

public void test get default replication ( ) throws i o exception , u r i syntax exception { try { vfs get default replication ( not in mountpoint path ) ; fail ( " get default replication on view fs did not throw excetion ! " ) ; } catch ( not in mountpoint exception e ) { assert equals ( vfs get default replication ( test file path ) , dfs replication default + 1 ) ; } }


get or create a sensor with the given unique name and zero or more parent sensors all parent sensors will receive every value recorded with this sensor this uses a default recording level of info

public synchronized sensor sensor ( string name , metric config config , sensor parents ) { return this sensor ( name , config , sensor recording level info , parents ) ; }


hash a password using the open b s d bcrypt scheme modified from the original to take a secure string instead of the original

public static string hashpw ( secure string password , string salt ) { b crypt b ; string real salt ; byte passwordb [ ] , saltb [ ] , hashed [ ] ; char minor = ( char ) 0 ; int rounds , off = 0 ; string buffer rs = new string buffer ( ) ; if ( salt char at ( 0 ) ! = ' $ ' | | salt char at ( 1 ) ! = ' 2 ' ) throw new illegal argument exception ( " invalid salt version " ) ; if ( salt char at ( 2 ) = = ' $ ' ) off = 3 ; else { minor = salt char at ( 2 ) ; if ( minor ! = ' a ' | | salt char at ( 3 ) ! = ' $ ' ) throw new illegal argument exception ( " invalid salt revision " ) ; off = 4 ; } / / extract number of rounds if ( salt char at ( off + 2 ) > ' $ ' ) throw new illegal argument exception ( " missing salt rounds " ) ; rounds = integer parse int ( salt substring ( off , off + 2 ) ) ; real salt = salt substring ( off + 3 , off + 25 ) ; / * * * * * * * * * * * * * * * * * * * * * * * * * * * es change start * * * * * * * * * * * * * * * * * * * * * * * * * / / * original code before introducing secure string try { passwordb = ( password + ( minor > = ' a ' ? " \ 000 " : " " ) ) get bytes ( " utf - 8 " ) ; } catch ( unsupported encoding exception uee ) { throw new assertion error ( " utf - 8 is not supported " ) ; } * / / / the next lines are the secure string replacement for the above commented - out section if ( minor > = ' a ' ) { final char [ ] suffix = " \ 000 " to char array ( ) ; final char [ ] result = new char [ password length ( ) + suffix length ] ; system arraycopy ( password get chars ( ) , 0 , result , 0 , password length ( ) ) ; system arraycopy ( suffix , 0 , result , password length ( ) , suffix length ) ; try ( secure string secure string = new secure string ( result ) ) { passwordb = char arrays to utf 8 bytes ( secure string get chars ( ) ) ; } } else { passwordb = char arrays to utf 8 bytes ( password get chars ( ) ) ; }


register , escalate , and configure the standard auto proxy creator ( apc ) against the given registry works by finding the nearest annotation declared on the importing { @ code @ configuration } class that has both { @ code mode } and { @ code proxy target class } attributes if { @ code mode } is set to { @ code proxy } , the apc is registered ; if { @ code proxy target class } is set to { @ code true } , then the apc is forced to use subclass ( cglib ) proxying several { @ code @ enable } annotations expose both { @ code mode } and { @ code proxy target class } attributes it is important to note that most of these capabilities end up sharing a { @ linkplain aop config utils # auto proxy creator bean name single apc } for this reason , this implementation doesn ' t " care " exactly which annotation it finds - - as long as it exposes the right { @ code mode } and { @ code proxy target class } attributes , the apc can be registered and configured all the same

public void register bean definitions ( annotation metadata importing class metadata , bean definition registry registry ) { boolean candidate found = false ; set < string > ann types = importing class metadata get annotation types ( ) ; for ( string ann type : ann types ) { annotation attributes candidate = annotation config utils attributes for ( importing class metadata , ann type ) ; if ( candidate = = null ) { continue ; } object mode = candidate get ( " mode " ) ; object proxy target class = candidate get ( " proxy target class " ) ; if ( mode ! = null & & proxy target class ! = null & & advice mode class = = mode get class ( ) & & boolean class = = proxy target class get class ( ) ) { candidate found = true ; if ( mode = = advice mode proxy ) { aop config utils register auto proxy creator if necessary ( registry ) ; if ( ( boolean ) proxy target class ) { aop config utils force auto proxy creator to use class proxying ( registry ) ; return ; } } } } if ( ! candidate found & & logger is info enabled ( ) ) { string name = get class ( ) get simple name ( ) ; logger info ( string format ( " % s was imported but no annotations were found " + " having both ' mode ' and ' proxy target class ' attributes of type " + " advice mode and boolean respectively this means that auto proxy " + " creator registration and configuration may not have occurred as " + " intended , and components may not be proxied as expected check to " + " ensure that % s has been @ import ' ed on the same class where these " + " annotations are declared ; otherwise remove the import of % s " + " altogether " , name , name , name ) ) ; } }


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


public void test uneven distribution ( ) throws exception { final configuration conf = create conf ( ) ; uneven distribution ( 2 , 2 , new long [ ] { 30 * capacity / 100 , 5 * capacity / 100 } , new long [ ] { capacity , capacity } , new string [ ] { rack0 , rack1 } , conf ) ; }


use < code > do call real method ( ) < code > when you want to call the real implementation of a method as usual you are going to read < b > the partial mock warning < b > : object oriented programming is more less tackling complexity by dividing the complexity into separate , specific , s r py objects how does partial mock fit into this paradigm ? well , it just doesn ' t partial mock usually means that the complexity has been moved to a different method on the same object in most cases , this is not the way you want to design your application however , there are rare cases when partial mocks come handy : dealing with code you cannot change easily ( 3rd party interfaces , interim refactoring of legacy code etc ) however , i wouldn ' t use partial mocks for new , test - driven & well - designed code see also javadoc { @ link mockito # spy ( object ) } to find out more about partial mocks < b > mockito spy ( ) is a recommended way of creating partial mocks < b > the reason is it guarantees real methods are called against correctly constructed object because you ' re responsible for constructing the object passed to spy ( ) method example : < pre class = " code " > < code class = " java " > foo mock = mock ( foo class ) ; do call real method ( ) when ( mock ) some void method ( ) ; this will call the real implementation of foo some void method ( ) mock some void method ( ) ; < code > see examples in javadoc for { @ link mockito } class

public static stubber do call real method ( ) { return mockito core stubber ( ) do call real method ( ) ; }


reevaluates the buffer of the media period at the given renderer position should only be called if this is the loading media period

public void reevaluate buffer ( long renderer position us ) { assertions check state ( is loading media period ( ) ) ; if ( prepared ) { media period reevaluate buffer ( to period time ( renderer position us ) ) ; } }


public static void put next value pointer ( memory segment memory segment , int offset , long next value pointer ) { memory segment put long ( offset + next value pointer offset , next value pointer ) ; }


initializes this state store the implementation of this function must register the root store in the context via the { @ link state store context # register ( state store , state restore callback ) } function , where the first { @ link state store } parameter should always be the passed - in { @ code root } object , and the second parameter should be an object of user ' s implementation of the { @ link state restore callback } interface used for restoring the state store from the changelog note that if the state store engine itself supports bulk writes , users can implement another interface { @ link batching state restore callback } which extends { @ link state restore callback } to let users implement bulk - load restoration logic instead of restoring one record at a time

default void init ( final state store context context , final state store root ) { init ( store to processor context adapter adapt ( context ) , root ) ; }


returns the double at the current position and increases the position by 1


returns the value of an experimental option

public object get experimental option ( string name ) { return experimental options get ( require non null ( " option name " , name ) ) ; }


return the mime message helper that this mime mail message is based on

public final mime message helper get mime message helper ( ) { return this helper ; }


public void set cursor name ( string name ) throws s q l exception { check closed ( ) ; }


notify this analyzer that a run has been canceled

public void run canceled ( ) { / / throw away saved up address sets to be analyzed get added address set ( ) ; get removed address set ( ) ; scheduled = false ; }


the name of this element < code > optional string name = 3 ; < code >

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


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

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


public < t > t execute ( function < response , t > handler ) { return handler apply ( rest assured given ( ) spec ( req spec build ( ) ) expect ( ) spec ( resp spec build ( ) ) when ( ) request ( req method , req uri ) ) ; }


public void grow capacity ( int new capacity ) { if ( new capacity < = capacity ) { return ; } int [ ] temp = new int [ new capacity ] ; system arraycopy ( links , 0 , temp , 0 , capacity ) ; for ( int i = capacity ; i < new capacity ; i + + ) { temp [ i ] = i + 1 ; } temp [ new capacity - 1 ] = end of list ; free ptr = capacity ; capacity = new capacity ; links = temp ; }


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


sets the horizontal position of the status label

public void set status justification ( int justification ) { status label set horizontal alignment ( justification ) ; }


public object get anytype 1 ( ) { return anytype 1 ; }


tests for required field , both null , non - existing and empty strings

public void test binding with required fields ( ) { test bean tb = new test bean ( ) ; tb set spouse ( new test bean ( ) ) ; data binder binder = new data binder ( tb , " person " ) ; binder set required fields ( " touchy " , " name " , " age " , " date " , " spouse name " ) ; mutable property values pvs = new mutable property values ( ) ; pvs add ( " touchy " , " " ) ; pvs add ( " name " , null ) ; pvs add ( " age " , null ) ; pvs add ( " spouse name " , " " ) ; binder bind ( pvs ) ; binding result br = binder get binding result ( ) ; assert that ( br get error count ( ) ) as ( " wrong number of errors " ) is equal to ( 5 ) ; assert that ( br get field error ( " touchy " ) get code ( ) ) is equal to ( " required " ) ; assert that ( br get field value ( " touchy " ) ) is equal to ( " " ) ; assert that ( br get field error ( " name " ) get code ( ) ) is equal to ( " required " ) ; assert that ( br get field value ( " name " ) ) is equal to ( " " ) ; assert that ( br get field error ( " age " ) get code ( ) ) is equal to ( " required " ) ; assert that ( br get field value ( " age " ) ) is equal to ( " " ) ; assert that ( br get field error ( " date " ) get code ( ) ) is equal to ( " required " ) ; assert that ( br get field value ( " date " ) ) is equal to ( " " ) ; assert that ( br get field error ( " spouse name " ) get code ( ) ) is equal to ( " required " ) ; assert that ( br get field value ( " spouse name " ) ) is equal to ( " " ) ; }


public void attribute string test ( ) { / / todo : test attribute string }


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

scheduled future < ? > schedule at fixed rate ( runnable task , long period ) ;


tries to enrich the passed exception or its causes with additional information this method improves error messages for direct and metaspace { @ link out of memory error } it adds descriptions about possible causes and ways of resolution

public static void try enrich cluster entry point error ( @ nullable throwable root ) { try enrich out of memory error ( root , jm metaspace oom error message , jm direct oom error message , jm heap space oom error message ) ; }


public void set object ( object type obj ) { object = obj ; }


returns the x position of the given column takes into account scroll position

private int get column header x position ( @ not null grid column column ) { int x = 0 ; x - = get h scroll selection in pixels ( ) ; if ( row header visible ) { x + = row header width ; } column = column get first leaf ( ) ; for ( grid column column 2 : columns ) { if ( column 2 = = column ) { break ; } x + = column 2 get width ( ) ; } return x ; }


multiplies all components of this color with the given value

public color mul ( float value ) { this r * = value ; this g * = value ; this b * = value ; this a * = value ; return clamp ( ) ; }


returns the provider defined in starlark , or null , if the information is not found the transitive information has to have been added using the starlark framework this method dispatches to either { @ link # get ( provider key ) } or { @ link # get ( string ) } depending on whether { @ link starlark provider identifier } is for legacy or for declared provider

default object get ( starlark provider identifier id ) { if ( id is legacy ( ) ) { return this get ( id get legacy id ( ) ) ; } else { return this get ( id get key ( ) ) ; } }


returns true if field e is set ( has been assigned a value ) and false otherwise

public boolean is set e ( ) { return this e ! = null ; }


file system [ get acl status , modify acl entries , remove acl entries , remove acl remove default acl ] api call should succeed without failure

public void test a c l a p i ( ) throws i o exception { path p = new path ( " / acl test " ) ; fs mkdirs ( p , fs permission create immutable ( ( short ) 0750 ) ) ; list < acl entry > acl spec = lists new array list ( acl entry ( default , user , all ) , acl entry ( default , user , " foo " , all ) , acl entry ( default , group , read execute ) , acl entry ( default , other , none ) ) ; fs set acl ( p , acl spec ) ; acl status as = fs get acl status ( p ) ; for ( acl entry entry : acl spec ) { assert true ( string format ( " as : % s , entry : % s " , as , entry ) , as get entries ( ) contains ( entry ) ) ; } list < acl entry > macl spec = lists new array list ( acl entry ( access , user , " bar " , read execute ) , acl entry ( default , user , " bar " , read execute ) ) ; fs modify acl entries ( p , macl spec ) ; as = fs get acl status ( p ) ; for ( acl entry entry : macl spec ) { assert true ( string format ( " as : % s , entry : % s " , as , entry ) , as get entries ( ) contains ( entry ) ) ; } fs remove acl entries ( p , macl spec ) ; fs remove default acl ( p ) ; fs remove acl ( p ) ; assert equals ( 0 , fs get acl status ( p ) get entries ( ) size ( ) ) ; }


get the leader epoch of the previously consumed record ( if one is known ) log truncation is detected if there exists a leader epoch which is larger than this epoch and begins at an offset earlier than the committed offset

public optional < integer > leader epoch ( ) { if ( leader epoch = = null | | leader epoch < 0 ) return optional empty ( ) ; return optional of ( leader epoch ) ; }


public string get error details ( ) { string builder buf = new string builder ( " < html > " + get error header ( ) ) ; int error count = 0 ; buf append ( " < blockquote > < br > " ) ; for ( string error : errors ) { buf append ( error ) append ( " < br > " ) ; if ( + + error count > max errors ) { buf append ( " and " + ( errors size ( ) - error count ) + " more ! " ) ; break ; } } return buf to string ( ) ; }


issue an update via a prepared statement , binding the given arguments , returning generated keys

int update ( string sql , sql parameter source param source , key holder generated key holder , string [ ] key column names ) throws data access exception ;


returns the { @ link klass } object used for the purpose of loading resources from this descriptor this hook enables other jvm languages to provide more integrated lookup

public klass < ? > get klass ( ) { return klass java ( clazz ) ; }


returns < code > string class < code > regardless of < code > column index < code >

public class < ? > get column class ( int column index ) { if ( column index = = get data type column ( ) ) { return data type instance class ; } return string class ; }


method indicating whether the free page map is a " big " free page map currently , we have at least two types extending this class one is " big " ( the newer v 7 00 ) and the other is not the { @ link # dump ( ) } method makes use of this method


extract private key from resource private key

public static private key extract private key from resource ( final string signing secret key ) { logger debug ( " attempting to extract private key " ) ; val resource = resource utils get resource from ( signing secret key ) ; val factory = new private key factory bean ( ) ; factory set algorithm ( rsa key util rsa ) ; factory set location ( resource ) ; factory set singleton ( false ) ; return factory get object ( ) ; }


public void add item ( string service name , string checksum ) { if ( string utils is empty ( service name ) | | string utils is empty ( checksum ) ) { loggers srv log warn ( " [ domain - checksum ] service name or checksum is empty , service name : { } , checksum : { } " , service name , checksum ) ; return ; } service name 2 checksum put ( service name , checksum ) ; }


delete purchase order by id for valid response try integer i ds with value & lt ; 1000 anything above 1000 or nonintegers will generate api errors < b > 400 < b > - invalid id supplied < b > 404 < b > - order not found

public response entity < void > delete order with http info ( string order id ) throws rest client exception { object post body = null ; / / verify the required parameter ' order id ' is set if ( order id = = null ) { throw new http client error exception ( http status bad request , " missing the required parameter ' order id ' when calling delete order " ) ; } / / create path and map variables final map < string , object > uri variables = new hash map < string , object > ( ) ; uri variables put ( " order id " , order id ) ; string path = api client expand path ( " / store / order / { order id } " , uri variables ) ; final multi value map < string , string > query params = new linked multi value map < string , string > ( ) ; final http headers header params = new http headers ( ) ; final multi value map < string , string > cookie params = new linked multi value map < string , string > ( ) ; final multi value map < string , object > form params = new linked multi value map < string , object > ( ) ; final string [ ] local var accepts = { } ; final list < media type > local var accept = api client select header accept ( local var accepts ) ; final string [ ] content types = { } ; final media type content type = api client select header content type ( content types ) ; string [ ] auth names = new string [ ] { } ; parameterized type reference < void > return type = new parameterized type reference < void > ( ) { } ; return api client invoke a p i ( path , http method delete , query params , post body , header params , cookie params , form params , local var accept , content type , auth names , return type ) ; }


adds an attribute to the aspect since aspects do not appear in build files , the attribute must be either implicit ( not available in the build file , starting with ' $ ' ) or late - bound ( determined after the configuration is available , starting with ' : ' ) aspect definition currently cannot handle { @ link computed default } dependencies ( type label or label list ) , because all the dependencies are resolved from the aspect definition and the defining rule

public builder add ( attribute attribute ) { preconditions check argument ( attribute is implicit ( ) | | attribute is late bound ( ) | | ( attribute get type ( ) = = type string & & attribute check allowed values ( ) ) , " % s : invalid attribute ' % s ' ( % s ) " , aspect class get name ( ) , attribute get name ( ) , attribute get type ( ) ) ; / / attributes specifying dependencies using computed default value are currently not supported / / the limitation is in place because : / / - blaze query requires that all possible values are knowable without build conguration / / - aspects can attach to any rule / / current logic in # for each label dep from all attributes of aspect is not enough , / / however { conservative , precise } aspect resolver can probably be improved to make that work preconditions check argument ( ! ( attribute get type ( ) get label class ( ) = = label class dependency & & ( attribute get default value unchecked ( ) instanceof computed default ) ) , " % s : invalid attribute ' % s ' ( % s ) with computed default dependencies " , aspect class get name ( ) , attribute get name ( ) , attribute get type ( ) ) ; preconditions check argument ( ! attributes contains key ( attribute get name ( ) ) , " % s : an attribute with the name ' % s ' already exists " , aspect class get name ( ) , attribute get name ( ) ) ; attributes put ( attribute get name ( ) , attribute ) ; return this ; }


check whether the given value can be treated as a string value

private static boolean is string value ( class < ? > in value type ) { / / consider any char sequence ( including string buffer and string builder ) as a string return ( char sequence class is assignable from ( in value type ) | | string writer class is assignable from ( in value type ) ) ; }


gets the { @ link loader } { @ link class } that corresponds to the given simple { @ link class } name

public static class < ? extends loader > get loader class by name ( string name ) { return get all loaders ( ) stream ( ) filter ( loader - > loader get class ( ) get simple name ( ) equals ( name ) ) find first ( ) map ( loader - > loader get class ( ) ) or else ( null ) ; }


the buffer size that will be retained in the free list after use

public int poolable size ( ) { return this poolable size ; }


if { @ code after throwing } advice binds the thrown value , the throwing variable name must be specified

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


immediately force a commit or rollback of the transaction for the configured test context , according to the { @ linkplain # is flagged for rollback rollback flag }

void end transaction ( ) { if ( logger is trace enabled ( ) ) { logger trace ( string format ( " ending transaction for test context % s ; transaction status [ % s ] ; rollback [ % s ] " , this test context , this transaction status , this flagged for rollback ) ) ; } assert state ( this transaction status ! = null , ( ) - > " failed to end transaction - transaction does not exist : " + this test context ) ; try { if ( this flagged for rollback ) { this transaction manager rollback ( this transaction status ) ; } else { this transaction manager commit ( this transaction status ) ; } } finally { this transaction status = null ; } if ( logger is info enabled ( ) ) { logger info ( ( this flagged for rollback ? " rolled back " : " committed " ) + " transaction for test : " + this test context ) ; } }


the given block is considered as low redundancy when the block locations length is less than expected replication factor for ec blocks , redundancy is the summation of data + parity blocks

private boolean is low redundancy block ( located block block info , int replication , erasure coding policy ec policy ) { boolean has low redundancy block = false ; if ( block info is striped ( ) ) { / / for ec blocks , redundancy is the summation of data + parity blocks replication = ec policy get num data units ( ) + ec policy get num parity units ( ) ; } / / block is considered as low redundancy when the block locations length is / / less than expected replication factor has low redundancy block = block info get locations ( ) length < replication ? true : false ; return has low redundancy block ; }


public void remove listener ( metric registry listener listener ) { / / nop }


public static void set color for drawer layout diff ( activity activity , drawer layout drawer layout , @ color int int color ) { if ( build version sdk int > = build version codes kitkat ) { activity get window ( ) add flags ( window manager layout params flag translucent status ) ; / / view group content layout = ( view group ) drawer layout get child at ( 0 ) ; view fake status bar view = content layout find view by id ( fake status bar view id ) ; if ( fake status bar view ! = null ) { if ( fake status bar view get visibility ( ) = = view gone ) { fake status bar view set visibility ( view visible ) ; } fake status bar view set background color ( calculate status color ( color , default status bar alpha ) ) ; } else { / / status bar view content layout add view ( create status bar view ( activity , color ) , 0 ) ; } / / linear layout , top if ( ! ( content layout instanceof linear layout ) & & content layout get child at ( 1 ) ! = null ) { content layout get child at ( 1 ) set padding ( 0 , get status bar height ( activity ) , 0 , 0 ) ; } / / set drawer layout property ( drawer layout , content layout ) ; } }


determines if the attributes contain resource and asset attributes

public static boolean defines android resources ( attribute map attributes ) { for ( string attribute : resources attributes ) { if ( attributes is attribute value explicitly specified ( attribute ) ) { return true ; } } return false ; }


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


sets the maximum allowed message size acceptable from the remote peer if unset , this will default to the value set on the { @ link managed channel builder # max inbound message size ( int ) }

public call options with max inbound message size ( int max size ) { check argument ( max size > = 0 , " invalid maxsize % s " , max size ) ; call options new options = new call options ( this ) ; new options max inbound message size = max size ; return new options ; }


the absolute value difference between two weights

private static float abs delta ( float lower , float higher ) { assert higher > = lower : higher + " lt " + lower + " but was expected to be gte " ; return math abs ( higher - lower ) ; }


whether to assume the dexbuilder tool supports local worker mode

public boolean use workers with dexbuilder ( ) { return use workers with dexbuilder ; }


return a read - only map of response cookies received from the server

multi value map < string , response cookie > get cookies ( ) ;


check the { @ link schema # type ( ) schema ' s type } matches the specified type

private void check schema type ( schema schema , type type ) { if ( schema type ( ) ! = type ) { throw new data exception ( " expecting " + type + " but instead found " + schema type ( ) ) ; } }


adds a route to the given handler function that handles all http { @ code put } requests that match the given pattern and predicate for instance , the following example routes put requests for " user " that contain json to the { @ code edit user } method in { @ code user controller } : < pre class = " code " > router function & lt ; server response & gt ; route = router functions route ( ) put ( " user " , request predicates content type ( media type application json ) , user controller : : edit user ) build ( ) ;

builder put ( string pattern , request predicate predicate , handler function < server response > handler function ) ;


a convenience method to start a builder using the given runnable after calling this method you are still required to call { @ link # set title ( string ) } this method allows for a more attractive fluent api usage than does the constructor ( see the javadoc header )

public static task builder with runnable ( monitored runnable r ) { return new task builder ( r ) ; }


override this method to configure the list of { @ link handler exception resolver handler exception resolvers } to use adding resolvers to the list turns off the default resolvers that would otherwise be registered by default also see { @ link # add default handler exception resolvers } that can be used to add the default exception resolvers

protected void configure handler exception resolvers ( list < handler exception resolver > exception resolvers ) { }


cleanup a partial block if this write is for a replication request ( and not from a client )

private void cleanup block ( ) throws i o exception { if ( is datanode ) { datanode data unfinalize block ( block ) ; } }


determines if the cache should operate in read through mode

private boolean is read through ( ) { return config is read through ( ) & & ( config get cache loader factory ( ) ! = null ) ; }


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


return if there are property values values defined for this bean

public boolean has property values ( ) { return ( this property values ! = null & & ! this property values is empty ( ) ) ; }


public static date string 2 date ( final string time , @ non null final date format format ) { try { return format parse ( time ) ; } catch ( parse exception e ) { e print stack trace ( ) ; } return null ; }


clear all state associated with running snapshots to be used on master - failover if the current node stops being master

synchronized void clear ( ) { snapshots to finalize clear ( ) ; running deletions clear ( ) ; latest known meta data = null ; }


public string get property class ( ) { return property class ; }


extract the tgs server principal from the given gssapi kerberos or spnego wrapped token

public static string get token server name ( byte [ ] raw token ) { / / subsequent comments include only relevant portions of the kerberos / / der encoding that will be extracted der token = new der ( raw token ) ; / / initial context token : : = [ application 0 ] implicit sequence { / / mech oid / / mech - token ( negotiation token or inner context token ) / / } der oid = token next ( ) ; if ( oid equals ( der spnego mech oid ) ) { / / negotiation token : : = choice { / / neg - token - init [ 0 ] neg token init / / } / / neg token init : : = sequence { / / mech - token [ 2 ] initial context token / / } token = token next ( ) get ( 0xa 0 , 0x 3 0 , 0xa 2 , 0x 0 4 ) next ( ) ; oid = token next ( ) ; } if ( ! oid equals ( der krb5 mech oid ) ) { throw new illegal argument exception ( " malformed gss token " ) ; } / / inner context token : : = { / / token - id [ 1 ] / / ap - req / / } if ( token next ( ) get tag ( ) ! = 1 ) { throw new illegal argument exception ( " not an ap - req token " ) ; } / / ap - req : : = [ application 14 ] sequence { / / ticket [ 3 ] ticket / / } der ticket = token next ( ) get ( 0x 6e , 0x 3 0 , 0xa 3 , 0x 6 1 , 0x 3 0 ) ; / / ticket : : = [ application 1 ] sequence { / / realm [ 1 ] string / / sname [ 2 ] principal name / / } / / principal name : : = sequence { / / name - string [ 1 ] sequence of string / / } string realm = ticket get ( 0xa 1 , 0x 1b ) get as string ( ) ; der names = ticket get ( 0xa 2 , 0x 3 0 , 0xa 1 , 0x 3 0 ) ; string builder sb = new string builder ( ) ; while ( names has next ( ) ) { if ( sb length ( ) > 0 ) { sb append ( ' / ' ) ; } sb append ( names next ( ) get as string ( ) ) ; } return sb append ( ' @ ' ) append ( realm ) to string ( ) ; }


private list < string > select csv file ( final configuration conf , final string sql , final object args ) throws exception { return parse to lines ( select ( get file system ( ) , csv path , conf , sql , args ) ) ; }


set the name of the service to look up corresponds to the " wsdl : service " name

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


returns the set of superclasses and interfaces that are used in ' instanceof ' tests

private set instanceofed super classes ( clazz clazz ) { set set = new hash set ( ) ; / / visit all superclasses and interfaces , collecting the ones that are / / used in an ' instanceof ' test clazz hierarchy accept ( true , true , true , false , new instanceof class filter ( new class collector ( set ) ) ) ; return set ; }


public boolean equals identity ( object obj ) { if ( obj = = this ) return true ; if ( ! ( obj instanceof array map ) ) return false ; array map other = ( array map ) obj ; if ( other size ! = size ) return false ; k [ ] keys = this keys ; v [ ] values = this values ; for ( int i = 0 , n = size ; i < n ; i + + ) if ( values [ i ] ! = other get ( keys [ i ] , object map dummy ) ) return false ; return true ; }


zooms so that the graph will fit completely into the size of the primary viewer

public void zoom out graph ( ) { view zoom out graph ( ) ; }


reset internal counter this should be performed before disassembling a new block of instructions

public void reset ( ) { repeat pattern cnt = 0 ; }


if { @ code ( key , value ) } is currently in the map , this method removes it and returns true ; otherwise , this method returns false

boolean remove ( k key , long value ) { atomic long atomic = map get ( key ) ; if ( atomic = = null ) { return false ; } long old value = atomic get ( ) ; if ( old value ! = value ) { return false ; } if ( old value = = 0l | | atomic compare and set ( old value , 0l ) ) { / / only remove after setting to zero , to avoid concurrent updates map remove ( key , atomic ) ; / / succeed even if the remove fails , since the value was already adjusted return true ; } / / value changed return false ; }


spr - 6038 : detect hsql and stop illegal locks being taken todo : against quartz 2 2 , this test ' s job doesn ' t actually execute anymore

public void scheduler with hsql data source ( ) throws exception { dummy job param = 0 ; dummy job count = 0 ; try ( class path xml application context ctx = context ( " database persistence xml " ) ) { jdbc template jdbc template = new jdbc template ( ctx get bean ( data source class ) ) ; assert that ( jdbc template query for list ( " select * from qrtz triggers " ) is empty ( ) ) as ( " no triggers were persisted " ) is false ( ) ; / * thread sleep ( 3000 ) ; assert true ( " dummy job should have been executed at least once " , dummy job count > 0 ) ; * / } }


returns the configured { @ link event loop group } or { @ code null } if non is configured yet

public final event loop group group ( ) { return group ; }


public int get major version ( ) { return 0 ; }


counts per forecast status , for example : { " finished " : 2 }

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


splice from this { @ link abstract epoll stream channel } to another { @ link file descriptor } the { @ code offset } is the offset for the { @ link file descriptor } and { @ code len } is the number of bytes to splice if using { @ link integer # max value } it will splice until the { @ link channel future } was canceled or it was failed please note : { @ link epoll channel config # get epoll mode ( ) } must be { @ link epoll mode # level triggered } for this { @ link abstract epoll stream channel } the { @ link file descriptor } will not be closed after the { @ link channel future } is notified this channel must be registered to an event loop or { @ link illegal state exception } will be thrown

public final channel future splice to ( final file descriptor ch , final int offset , final int len ) { return splice to ( ch , offset , len , new promise ( ) ) ; }


public final boolean is wrapper for ( class < ? > iface ) throws s q l exception { return iface is instance ( delegate ) | | ( delegate ! = null & & delegate is wrapper for ( iface ) ) ; }


adds the given value to the configuration object the main key of the config option will be used to map the value

public void set long ( config option < long > key , long value ) { set value internal ( key key ( ) , value ) ; }


< code > optional aapt pb style style = 2 ; < code >

public boolean has style ( ) { return instance has style ( ) ; }


formats the timestamp of this watermark , assuming it is a millisecond timestamp the returned format is " yyyy - mm - dd hh : mm : ss sss "

public string get formatted timestamp ( ) { return ts formatter get ( ) format ( new date ( timestamp ) ) ; }


return a flag that indicates if fast delete is enabled

boolean is enable trash ( ) { return enable trash ; }


sets the internal data structure that keeps the thread local variables bound to this thread note that this method is for internal use only , and thus is subject to change at any time

public final void set thread local map ( internal thread local map thread local map ) { this thread local map = thread local map ; }


add a link element implementation should try to figure out type by the suffix of href so < code > link ( " style css " ) ; < code > is a shortcut of < code > link ( ) $ rel ( " stylesheet " ) $ type ( " textcss " ) $ href ( " style css " ) ( ) ; < code >


gets the { @ link media metadata compat } to be published to the session an app may need to load metadata resources like artwork bitmaps asynchronously in such a case the app should return a { @ link media metadata compat } object that does not contain these resources as a placeholder the app should start an asynchronous operation to download the bitmap and put it into a cache finally , the app should call { @ link # invalidate media session metadata ( ) } this causes this callback to be called again and the app can now return a { @ link media metadata compat } object with all the resources included

media metadata compat get metadata ( player player ) ;


process data types that were changed ( renamed , moved , or edited ) in my program , but are not conflicts , i e , not renamed , moved or edited in latest the corresponding data type in result program is updated

private void process data type changes ( ) throws cancelled exception { for ( int i = 0 ; i < my dt change list size ( ) ; i + + ) { current monitor check canceled ( ) ; current monitor set progress ( + + progress index ) ; long id = my dt change list get ( i ) long value ( ) ; data type dt = dtms [ my ] get data type ( id ) ; if ( ( dt instanceof pointer ) | | ( dt instanceof array ) | | ( dt instanceof built in ) ) { continue ; } process data type renamed ( id ) ; process data type moved ( id ) ; process data type edited ( id ) ; process data type source changed ( id ) ; } }


sets whether format based failures will be ignored

public match query builder lenient ( boolean lenient ) { this lenient = lenient ; return this ; }


public string get user name ( ) { return datum get user name ( ) to string ( ) ; }


acquires a shared memory resource , identified by a type string if the resource already exists , this returns a descriptor to the resource if the resource does not yet exist , the given memory fraction is reserved and the resource is initialized with that size the memory for the resource is reserved from the memory budget of this memory manager ( thus determining the size of the resource ) , but resource itself is opaque , meaning the memory manager does not understand its structure the opaque memory resource object returned from this method must be closed once not used any further once all acquisitions have closed the object , the resource itself is closed < b > important : < b > the failure semantics are as follows : if the memory manager fails to reserve the memory , the external resource initializer will not be called if an exception is thrown when the opaque resource is closed ( last lease is released ) , the memory manager will still un - reserve the memory to make sure its own accounting is clean the exception will need to be handled by the caller of { @ link opaque memory resource # close ( ) } for example , if this indicates that native memory was not released and the process might thus have a memory leak , the caller can decide to kill the process as a result

public < t extends auto closeable > opaque memory resource < t > get shared memory resource for managed memory ( string type , long function with exception < t , exception > initializer , double fraction to initialize with ) throws exception { / / if we need to allocate the resource ( no shared resource allocated , yet ) , this would be / / the size to use final long num bytes = compute memory size ( fraction to initialize with ) ; / / initializer and releaser as functions that are pushed into the shared resources , / / so that the shared resources can decide in ( thread - safely execute ) when initialization / / and release should happen final long function with exception < t , exception > reserve and initialize = ( size ) - > { try { reserve memory ( type , size ) ; } catch ( memory reservation exception e ) { throw new memory allocation exception ( " could not created the shared memory resource of size " + size + " not enough memory left to reserve from the slot ' s managed memory " , e ) ; } return initializer apply ( size ) ; } ; final consumer < long > releaser = ( size ) - > release memory ( type , size ) ; / / this object identifies the lease in this request it is used only to identify the release / / operation / / using the object to represent the lease is a bit nicer safer than just using a reference / / counter final object lease holder = new object ( ) ; final shared resources resource and size < t > resource = shared resources get or allocate shared resource ( type , lease holder , reserve and initialize , num bytes ) ; / / the actual size may theoretically be different from what we requested , if allocated it / / was by / / someone else before with a different value for fraction ( should not happen in practice , / / though ) final long size = resource size ( ) ; final throwing runnable < exception > disposer = ( ) - > shared resources release ( type , lease holder , releaser ) ; return new opaque memory resource < > ( resource resource handle ( ) , size , disposer ) ; }


creates a mutable { @ code hash set } instance initially containing the given elements < b > note : < b > if elements are non - null and won ' t be added or removed after this point , use { @ link immutable set # of ( ) } or { @ link immutable set # copy of ( object [ ] ) } instead if { @ code e } is an { @ link enum } type , use { @ link enum set # of ( enum , enum [ ] ) } instead otherwise , strongly consider using a { @ code linked hash set } instead , at the cost of increased memory footprint , to get deterministic iteration behavior this method is just a small convenience , either for { @ code new hash set ( } { @ link arrays # as list as list } { @ code ( ) ) } , or for creating an empty set then calling { @ link collections # add all } this method is not actually very useful and will likely be deprecated in the future

public static < e > hash set < e > new hash set ( e elements ) { hash set < e > set = new hash set with expected size ( elements length ) ; collections add all ( set , elements ) ; return set ; }


should the block access token be refetched on an exception

protected static boolean token refetch needed ( i o exception ex , inet socket address target addr ) { / * * get a new access token and retry retry is needed in 2 cases 1 ) * when both nn and dn re - started while d f s client holding a cached * access token 2 ) in the case that nn fails to update its * access key at pre - set interval ( by a wide margin ) and * subsequently restarts in this case , dn re - registers itself with * nn and receives a new access key , but dn will delete the old * access key from its memory since it ' s considered expired based on * the estimated expiration date * / if ( ex instanceof invalid block token exception | | ex instanceof invalid token ) { d f s client log debug ( " access token was invalid when connecting to { } : { } " , target addr , ex ) ; return true ; } return false ; }


input toc items are those that we are building for the input help module of this collection

public collection < t o c item > get input t o c items ( ) { collection < t o c item > items = new array list < > ( ) ; ghidra t o c file toc = input help get source t o c file ( ) ; items add all ( toc get all t o c items ( ) ) ; return items ; }


returns the number of bytes in the file region described by this source split

public long length ( ) { return length ; }


returns true if the there is a column filter on the column specified

public default boolean has column filter ( int column model index ) { return false ; }


get the timeout from { @ link url the specified connection url }

protected static long get timeout ( url url ) { return get parameter ( url , timeout param name , - 1l ) ; }


converts the given number of the current units into gigabytes

public long to gigabytes ( long l ) { return gigabytes convert ( l , this ) ; }


public string get id as string ( ) { if ( id = = null ) { throw new illegal argument exception ( " id = = null not allowed " ) ; } if ( " " equals ( id ) ) { throw new illegal argument exception ( " empty id not allowed " ) ; } return id ; }


specify the type that the located jndi object is supposed to be assignable to , if any

public void set expected type ( @ nullable class < ? > expected type ) { this expected type = expected type ; }


gets a { @ link package } from the { @ link recursive package provider } may return a { @ link package } that has errors

private package get package ( package identifier pkg identifier ) throws no such package exception , interrupted exception { return recursive package provider get package ( event handler , pkg identifier ) ; }


take a simple path like " something " and turn it into a qualified path against the test fs

protected path absolutepath ( string filepath ) throws i o exception { return get file system ( ) make qualified ( new path ( filepath ) ) ; }


test the property ' prefix wrapped array '

public void prefix wrapped array test ( ) { / / todo : test prefix wrapped array }


public string get pet type ( ) { return pet type ; }


creates a { @ link field accessor } for the given field position , which can be used to get and set the specified field on instances of this type

public static < t , f > field accessor < t , f > get accessor ( type information < t > type info , int pos , execution config config ) { / / in case of arrays if ( type info instanceof basic array type info | | type info instanceof primitive array type info ) { return new field accessor array field accessor < > ( pos , type info ) ; / / in case of basic types } else if ( type info instanceof basic type info ) { if ( pos ! = 0 ) { throw new composite type invalid field reference exception ( " the " + ( ( integer ) pos ) to string ( ) + " field selected on a " + " basic type ( " + type info to string ( ) + " ) a field expression on a basic type can only select " + " the 0th field ( which means selecting the entire basic type ) " ) ; } @ suppress warnings ( " unchecked " ) field accessor < t , f > result = ( field accessor < t , f > ) new field accessor simple field accessor < > ( type info ) ; return result ; / / in case of case classes } else if ( type info is tuple type ( ) & & ( ( tuple type info base ) type info ) is case class ( ) ) { tuple type info base tuple type info = ( tuple type info base ) type info ; @ suppress warnings ( " unchecked " ) type information < f > field type info = ( type information < f > ) tuple type info get type at ( pos ) ; return new field accessor recursive product field accessor < > ( pos , type info , new field accessor simple field accessor < > ( field type info ) , config ) ; / / in case of tuples } else if ( type info is tuple type ( ) ) { @ suppress warnings ( " unchecked " ) field accessor < t , f > result = new field accessor simple tuple field accessor ( pos , type info ) ; return result ; / / default case , pojo type is directed to this statement } else { throw new composite type invalid field reference exception ( " cannot reference field by position on " + type info to string ( ) + " referencing a field by position is supported on tuples , case classes , and arrays " + " additionally , you can select the 0th field of a primitive / basic type ( e g int ) " ) ; } }


writes a jdom xml { @ link document } to a { @ link file } , with a prettier format than { @ link # write doc to file ( document , file ) }

public static void write pretty doc to file ( document doc , file dest ) throws i o exception { x m l outputter outputter = new x m l outputter ( ) ; outputter set format ( format get pretty format ( ) ) ; try ( file writer fw = new file writer ( dest ) ) { outputter output ( doc , fw ) ; } }


is called for each message of type { @ link i }

protected abstract void channel read 0 ( channel handler context ctx , i msg ) throws exception ;


see { @ link # floor ( long ) } this method modifies the given calendar and returns the same object

public calendar floor ( calendar cal ) { calendar two years ago = ( calendar ) cal clone ( ) ; two years ago add ( calendar year , - 2 ) ; outer : while ( true ) { if ( cal compare to ( two years ago ) < 0 ) { / / we went too far into the past throw new rare or impossible date exception ( ) ; } for ( calendar field f : calendar field adjust order ) { int cur = f value of ( cal ) ; int next = f floor ( this , cur ) ; if ( cur = = next ) continue ; / / this field is already in a good shape move on to next / / we are modifying this field , so clear all the lower level fields for ( calendar field l = f lower field ; l ! = null ; l = l lower field ) l clear ( cal ) ; if ( next < 0 ) { / / we need to borrow from the next field f roll up ( cal , - 1 ) ; / / the problem here , in contrast with the ceil method , is that / / the maximum value of the field is not always a fixed value ( that is , day of month ) / / so we zero - clear all the lower fields , set the desired value + 1 , f set to ( cal , f last ( this ) ) ; f add to ( cal , 1 ) ; / / then subtract a minute to achieve maximum values on all the lower fields , / / with the desired value in ' f ' calendar field minute add to ( cal , - 1 ) ; / / since higher order field is affected by this , we need to restart from all over continue outer ; } else { f set to ( cal , next ) ; f add to ( cal , 1 ) ; calendar field minute add to ( cal , - 1 ) ; if ( f redo adjustment if modified ) continue outer ; / / when we modify day of month and day of week , do it all over from the top } } return cal ; / / all fields adjusted } }


returns the appropriate handler for recursive resolve calls

public abstract data type conflict handler get subsequent handler ( ) ;


< code > optional aapt pb string str = 2 ; < code >

private void set str ( com android aapt resources string value ) { if ( value = = null ) { throw new null pointer exception ( ) ; } str = value ; bit field 0 | = 0x 0 0 0 0 0 0 0 2 ; }


returns a regex pattern which matches task attempt i ds arguments can be given null , in which case that part of the regex will be generic for example to obtain a regex matching all task attempt i ds of any jobtracker , in any job , of the first map task , we would use : task attempt i d get task attempt i ds pattern ( null , null , task type map , 1 , null ) ; which will return : " attempt [ ^ ] [ 0 - 9 ] m 000001 [ 0 - 9 ] "

public static string get task attempt i ds pattern ( string jt identifier , integer job id , task type type , integer task id , integer attempt id ) { string builder builder = new string builder ( attempt ) append ( separator ) ; builder append ( get task attempt i ds pattern w o prefix ( jt identifier , job id , type , task id , attempt id ) ) ; return builder to string ( ) ; }


provide the locale resolver to use this is delegated to { @ link standalone mock mvc builder # set locale resolver ( locale resolver ) }

controller spec locale resolver ( locale resolver locale resolver ) ;


increment the number of times slm retention has been run

public void retention run ( ) { this retention run count inc ( ) ; }


shortcut for calling { @ link # write ( object , channel matcher , boolean ) } and { @ link # flush ( ) } and only act on { @ link channel } s that are matched by the { @ link channel matcher }

channel group future write and flush ( object message , channel matcher matcher , boolean void promise ) ;


order by task owner ( needs to be followed by { @ link # asc ( ) } or { @ link # desc ( ) } )


< code > repeated org apache dubbo metadata definition protobuf model phone number phone = 8 ; < code >

public java util list < org apache dubbo metadata definition protobuf model google p b phone number builder > get phone builder list ( ) { return get phone field builder ( ) get builder list ( ) ; }


returns media period based on the provided filterable manifest

media period create media period ( t manifest , int period index ) ;


using deprecated hdfs admin # list open files ( enum set < > ) to verify open files

private void verify open files old ( hash set < path > closed files , hash map < path , f s data output stream > open file map ) throws i o exception { hdfs admin hdfs admin = new hdfs admin ( file system get default uri ( conf ) , conf ) ; hash set < path > open files = new hash set < > ( open file map key set ( ) ) ; remote iterator < open file entry > open files remote itr = hdfs admin list open files ( enum set of ( open files type all open files ) ) ; verify open files helper ( open files remote itr , closed files , open files ) ; assert true ( " not all open files are listed ! " , open files is empty ( ) ) ; }


single unit test which handles named test group specified during test instantiation

public final void run test ( ) { string test group name = get name ( ) ; / / todo : hack ! must strip " test " prefix which was added to original group name / / to facilitate running single test in eclipse if ( test group name ! = null ) { if ( test group name starts with ( test prefix ) ) { test group name = test group name substring ( test prefix length ( ) ) ; } else { fail ( " expected test name to start with " + test prefix ) ; } } if ( test group name = = null | | test group name length ( ) = = 0 ) { fail ( " empty test group name " ) ; } p code test group test group = test group map get ( test group name ) ; assert not null ( " test group not found for ' " + test group name + " ' " , test group ) ; log ( test group , " prepare for executing group test ' " + test group test group name + " ' at : " + test group function entry ptr to string ( true ) ) ; log ( test group , " loading test binary : " + test group main test control block test file file reference path ) ; log ( test group , " using cached program : " + test group main test control block cached program path ) ; program program = null ; emulator test runner test runner = null ; try { program = get gzf program ( test group main test control block cached program path ) ; assert not null ( " failed to open test program : " + test group main test control block cached program path , program ) ; if ( program is changed ( ) ) { / / update cached program string fpath = test group main test control block test file file reference path ; msg info ( processor emulator test adapter class , " updating cached gzf file following program upgrade : " + fpath ) ; file gzf file = new file ( resources cache dir , fpath + gzf file ext ) ; env get ghidra project ( ) save as packed file ( program , gzf file , true ) ; if ( ! gzf file exists ( ) ) { throw new i o exception ( " failed to cache gzf file : " + gzf file ) ; } } assert false ( " program contains severe disassembly / relocation errors : " + test group main test control block cached program path , log data test results summary has relocation errors | | log data test results summary has disassembly errors ) ; test runner = new emulator test runner ( program , test group , this ) ; / / clear hard - coded stack pointer value established by simple program load data / / if not set by initialize state check stack pointer value will attempt to initialize / / todo : not required if use of simple program load data eliminated test runner set register ( compiler spec get stack pointer ( ) get name ( ) , 0 ) ; / / initialize context register based upon function entry within listing address address = emulator test runner align address ( test group function entry ptr , language get instruction alignment ( ) ) ; program context program context = program get program context ( ) ; register context register = program context get base context register ( ) ; if ( context register ! = null ) { test runner set context register ( program context get register value ( context register , address ) ) ; } initialize state ( test runner , program ) ; check stack pointer value ( test runner ) ; int total expected asserts = 0 ; int num sub tests = test group control block get number functions ( ) ; for ( int i = 1 ; i < num sub tests ; i + + ) { function info function info = test group control block get function info ( i ) ; string name = function info function name ; log data test results declare test ( test group test group name , name , function info number of asserts ) ; total expected asserts + = function info number of asserts ; } / / initialize pass / fail counts at runtime to detect severe failure test group main test control block set number passed ( test runner , integer min value ) ; test group main test control block set number failed ( test runner , integer min value ) ; boolean done ; if ( trace disabled ) { done = test runner execute ( execution timeout ms , task monitor dummy ) ; } else { done = test runner execute single step ( max execution steps ) ; } int pass = test group main test control block get number passed ( test runner ) ; int call other errors = test runner get call other errors ( ) ; int fail = test group main test control block get number failed ( test runner ) ; if ( pass < 0 | | fail < 0 ) { fail test ( test runner , " error invalid pass / fail counts - test may not have run properly or improper test info structure updates occurred : pass " + pass + " fail " + fail ) ; } pass - = call other errors ; string pass fail text = " passed : " + pass + " failed : " + fail ; if ( call other errors ! = 0 ) { pass fail text + = " passed ( w / callother ) : " + call other errors ; } pass fail text + = " expected assertions : " + total expected asserts ; log ( test group , pass fail text ) ; list < string > test failures = test group get test failures ( ) ; if ( ! test failures is empty ( ) ) { log ( test group , " test failures : " ) ; for ( string test failure : test failures ) { log ( test group , " > > > " + test failure ) ; } } if ( ! done ) { string builder msg = new string builder ( " error test execution failed " ) ; / / todo : not currently set until assert function has been emulated / / string last function = test group main test control block get last function name ( test runner ) ; string emu error = test runner get emu error ( ) ; if ( emu error ! = null ) { msg append ( " - " ) ; msg append ( emu error ) ; } address pc addr = test runner get current address ( ) ; string pc str = long to hex string ( pc addr get offset ( ) ) ; if ( ( emu error = = null ) | | ( emu error index of ( pc str ) < 0 ) ) { msg append ( " , pc = 0x " ) ; msg append ( pc str ) ; } fail test ( test runner , msg to string ( ) ) ; } int ran cnt = pass + fail + call other errors ; if ( ( total expected asserts ! = 0 ) & & ( total expected asserts ! = ran cnt ) ) { fail test ( test runner , " error unexpected number of assertions ( " + pass fail text + " ) " ) ; } if ( fail ! = 0 | | call other errors ! = 0 | | test failures size ( ) ! = 0 ) { fail test ( test runner , " error one or more group tests failed ( " + pass fail text + " ) " ) ; } } catch ( exception e ) { log ( test group , " exception occurred during test " , e ) ; fail ( " exception occurred during test : " + e get message ( ) ) ; } finally { if ( test runner ! = null ) { log data unimplemented set add all ( test runner get unimplemented pcodeops ( ) ) ; test runner dispose ( ) ; } if ( program ! = null ) { env release ( program ) ; } } }


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


called when icy stream metadata has been split from the stream

void on icy metadata ( parsable byte array metadata ) ;


tests the { @ link d w a r f data type conflict handler # instance } conflict handler to ensure that adding a conflicting typedef to a conflicting stub structure ( when there is already a typedef to a populated structure ) correctly uses the existing populated structure and existing typedef to the populated structure

public void test typedef to stub use existing typedef to populated structure ( ) { structure data type populated structure = create populated ( data mgr ) ; int orig pop struct len = populated structure get length ( ) ; type def populated t d = new typedef data type ( root , " typedef 1 " , populated structure , data mgr ) ; data mgr add data type ( populated t d , null ) ; structure data type stub structure = create stub ( data mgr , 0 ) ; type def stub t d = new typedef data type ( root , " typedef 1 " , stub structure , data mgr ) ; data type stub t d result = data mgr add data type ( stub t d , d w a r f data type conflict handler instance ) ; assert true ( stub t d result instanceof type def ) ; assert equals ( populated t d get path name ( ) , stub t d result get path name ( ) ) ; data type stub t d result refd d t = ( ( type def ) stub t d result ) get data type ( ) ; assert equals ( stub t d result refd d t get length ( ) , orig pop struct len ) ; }


allows extensions to prevent a cloud from provisioning return null to allow provisioning , or non - null to prevent it

public cause of blockage can provision ( cloud cloud , cloud state state , int num executors ) { return can provision ( cloud , state get label ( ) , num executors ) ; }


start a new tag with the supplied name leaves the tag open so that attributes , inner text or nested tags can be written into it

public void start tag ( string tag name ) throws jsp exception { if ( in tag ( ) ) { close tag and mark as block ( ) ; } push ( tag name ) ; this writer append ( " < " ) append ( tag name ) ; }


returns the logical xor of this long value and the given long value

public long value xor ( long value other ) { return other xor ( this ) ; }


gets the function name for the function stack frame being edited

string get stack name ( ) { return stack model get editor stack ( ) get display name ( ) ; }


public boolean record ( e e ) { return offer ( e ) = = buffer full ; }


public void update row id ( string column label , row id x ) throws s q l exception { }


int get port number ( ) { return server info component get port number ( ) ; }


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


return the timeout to use for receive calls ( in milliseconds )

public long get receive timeout ( ) { return this receive timeout ; }


computes the upcean checksum on a string of digits , and reports whether the checksum is correct or not

static boolean check standard u p c e a n checksum ( char sequence s ) throws format exception { int length = s length ( ) ; if ( length = = 0 ) { return false ; } int check = character digit ( s char at ( length - 1 ) , 10 ) ; return get standard u p c e a n checksum ( s sub sequence ( 0 , length - 1 ) ) = = check ; }


public final void set subscription ( subscription s ) { if ( cancelled ) { s cancel ( ) ; return ; } objects require non null ( s , " s is null " ) ; if ( get ( ) = = 0 & & compare and set ( 0 , 1 ) ) { subscription a = actual ; if ( a ! = null & & cancel on replace ) { a cancel ( ) ; } actual = s ; long r = requested ; if ( decrement and get ( ) ! = 0 ) { drain loop ( ) ; } if ( r ! = 0l ) { s request ( r ) ; } return ; } subscription a = missed subscription get and set ( s ) ; if ( a ! = null & & cancel on replace ) { a cancel ( ) ; } drain ( ) ; }


returns whether the given sphere is in the frustum

public boolean sphere in frustum ( float x , float y , float z , float radius ) { for ( int i = 0 ; i < 6 ; i + + ) if ( ( planes [ i ] normal x * x + planes [ i ] normal y * y + planes [ i ] normal z * z ) < ( - radius - planes [ i ] d ) ) return false ; return true ; }


creates a drawable with the { @ link rounding options } and { @ link border options } applied to it

public drawable rounded drawable ( resources resources , drawable drawable , @ nullable border options border options , @ nullable rounding options rounding options ) { if ( border options ! = null & & border options width > 0 ) { return rounded drawable with border ( resources , drawable , border options , rounding options ) ; } else { return rounded drawable without border ( resources , drawable , rounding options ) ; } }


configure the maximum size allowed for inbound stomp message since a stomp message can be received in multiple web socket messages , buffering may be required and this property determines the maximum buffer size per message by default this is set to 64 1024 ( 64k )

public void set inbound message size limit ( int inbound message size limit ) { this inbound message size limit = inbound message size limit ; }


private void load i o s kernel ( list < fsrl > file list ) { program manager pm = f s b utils get program manager ( get tool ( ) , true ) ; if ( pm ! = null ) { task launcher launch ( new g file system load kernel task ( this , pm , file list ) ) ; } }


public horizontal group wrap reverse ( ) { wrap reverse = true ; return this ; }


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

public builder clear version info ( ) { version info = get default instance ( ) get version info ( ) ; on changed ( ) ; return this ; }


only report metrics which match the given filter

public builder filter ( metric filter filter ) { this filter = filter ; return this ; }


this method is deprecated and will be removed in the future releases handle async db operation in your own logic instead

public static < t > find multi executor < t > find all async ( class < t > model class , long ids ) { return find all async ( model class , false , ids ) ; }


get the project data for the given project view

project data get project data ( project locator project view ) { project data tree panel dtp = read only views get ( project view ) ; if ( dtp ! = null ) { return dtp get project data ( ) ; } return null ; }


invoke the specified validators , if any

public void validate ( ) { object target = get target ( ) ; assert state ( target ! = null , " no target to validate " ) ; binding result binding result = get binding result ( ) ; / / call each validator with the same binding result for ( validator validator : get validators ( ) ) { validator validate ( target , binding result ) ; } }


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


returns whether the given method accesses protected class members

public static boolean accesses protected code ( method method ) { method optimization info info = method optimization info get method optimization info ( method ) ; return info = = null | | info accesses protected code ( ) ; }


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


remove { @ code listener } from the list of parse listeners if { @ code listener } is { @ code null } or has not been added as a parse listener , this method does nothing

public void remove parse listener ( parse tree listener listener ) { if ( parse listeners ! = null ) { if ( parse listeners remove ( listener ) ) { if ( parse listeners is empty ( ) ) { parse listeners = null ; } } } }


public void run request ( @ non null request request ) { requests add ( request ) ; if ( ! is paused ) { request begin ( ) ; } else { request clear ( ) ; if ( log is loggable ( tag , log verbose ) ) { log v ( tag , " paused , delaying request " ) ; } pending requests add ( request ) ; } }


log a message at level fine according to the specified format and arguments this form avoids superfluous object creation when the logger is disabled for the fine level

public void debug ( string format , object arg a , object arg b ) { if ( logger is loggable ( level fine ) ) { formatting tuple ft = message formatter format ( format , arg a , arg b ) ; log ( self , level fine , ft get message ( ) , ft get throwable ( ) ) ; } }


the { @ code to string ( ) } of { @ link component } implementations appear in health check endpoints since these are likely to be exposed in logs and other monitoring tools , care should be taken to ensure { @ code to string ( ) } output is a reasonable length and does not contain sensitive information

@ test public void to string contains only summary information ( ) { try ( cassandra storage cassandra = cassandra storage new builder ( ) contact points ( " 1 1 1 1 " ) build ( ) ) { assert that ( cassandra ) has to string ( " cassandra storage { contact points = 1 1 1 1 , keyspace = zipkin 2 } " ) ; } }


build the next status batch from a listing

private boolean build next status batch ( final object listing objects ) { / / counters for debug logs int added = 0 ; int ignored = 0 ; / / list to fill in with results initial size will be list maximum list < file status > stats = new array list < > ( objects get objects ( ) size ( ) + objects get common prefixes ( ) size ( ) ) ; / / objects for ( obs object summary : objects get objects ( ) ) { string key = summary get object key ( ) ; path key path = o b s common utils key to qualified path ( owner , key ) ; if ( log is debug enabled ( ) ) { log debug ( " { } : { } " , key path , o b s common utils stringify ( summary ) ) ; } / / skip over keys that are ourselves and old obs $ folder $ files if ( acceptor accept ( key path , summary ) & & filter accept ( key path ) ) { file status status = o b s common utils create file status ( key path , summary , owner get default block size ( key path ) , owner get username ( ) ) ; log debug ( " adding : { } " , status ) ; stats add ( status ) ; added + + ; } else { log debug ( " ignoring : { } " , key path ) ; ignored + + ; } } / / prefixes : always directories for ( obs object prefix : objects get extened common prefixes ( ) ) { string key = prefix get object key ( ) ; path key path = o b s common utils key to qualified path ( owner , key ) ; if ( acceptor accept ( key path , key ) & & filter accept ( key path ) ) { long last modified = prefix get metadata ( ) get last modified ( ) = = null ? system current time millis ( ) : o b s common utils date to long ( prefix get metadata ( ) get last modified ( ) ) ; file status status = new o b s file status ( key path , last modified , last modified , owner get username ( ) ) ; log debug ( " adding directory : { } " , status ) ; added + + ; stats add ( status ) ; } else { log debug ( " ignoring directory : { } " , key path ) ; ignored + + ; } } / / finish up batch size = stats size ( ) ; status batch iterator = stats list iterator ( ) ; boolean has next = status batch iterator has next ( ) ; log debug ( " added { } entries ; ignored { } ; has next = { } ; has more objects = { } " , added , ignored , has next , objects is truncated ( ) ) ; return has next ; }


creates a { @ link application class loader } if { @ link m r job config # mapreduce job classloader } is set to true , and the app classpath environment variable is set

public static class loader create job class loader ( configuration conf ) throws i o exception { class loader job class loader = null ; if ( conf get boolean ( m r job config mapreduce job classloader , false ) ) { string app classpath = system getenv ( environment app classpath key ( ) ) ; if ( app classpath = = null ) { log warn ( " not creating job classloader since app classpath is not set " ) ; } else { log info ( " creating job classloader " ) ; if ( log is debug enabled ( ) ) { log debug ( " app classpath = " + app classpath ) ; } string [ ] system classes = get system classes ( conf ) ; job class loader = create job class loader ( app classpath , system classes ) ; } } return job class loader ; }


public static < t > peeking iterator < t > peeking iterator ( peeking iterator < t > iterator ) { return check not null ( iterator ) ; }


determines if the supplied class object represents an abstract type

static public boolean is abstract ( class c ) { return modifier is abstract ( c get modifiers ( ) ) ; }


set the job description updates the { @ link job # description } setting

public builder set description ( string description ) { this description = description ; return this ; }


sets the membership flag for the computed bit location

boolean set at ( int item , int seed index ) { int hash = seeded ( item , seed index ) ; int index = hash > > > table shift ; long previous = table [ index ] ; table [ index ] | = bitmask ( hash ) ; return ( table [ index ] ! = previous ) ; }


the value assigned to this plural < code > optional aapt pb item item = 4 ; < code >

com android aapt resources item get item ( ) ;


{ @ inherit doc } because an inverse of a set multimap cannot contain multiple pairs with the same key and value , this method returns an { @ code immutable set multimap } rather than the { @ code immutable multimap } specified in the { @ code immutable multimap } class

public immutable set multimap < v , k > inverse ( ) { immutable set multimap < v , k > result = inverse ; return ( result = = null ) ? ( inverse = invert ( ) ) : result ; }


https : activiti atlassian netbrowse a c t - 1222

public void test receycling execution with call activity ( ) { runtime service start process instance by key ( " parent - process " ) ; / / after process start we have two tasks , one from the parent and one / / from the sub process task query query = task service create task query ( ) order by task name ( ) asc ( ) ; list < task > tasks = query list ( ) ; assert that ( tasks ) has size ( 2 ) ; assert that ( tasks get ( 0 ) get name ( ) ) is equal to ( " another task " ) ; assert that ( tasks get ( 1 ) get name ( ) ) is equal to ( " some task " ) ; / / we complete the task from the parent process , the root execution is / / receycled , the task in the sub process is still there task service complete ( tasks get ( 1 ) get id ( ) ) ; tasks = query list ( ) ; assert that ( tasks ) has size ( 1 ) ; assert that ( tasks get ( 0 ) get name ( ) ) is equal to ( " another task " ) ; / / we end the task in the sub process and the sub process instance end / / is propagated to the parent process task service complete ( tasks get ( 0 ) get id ( ) ) ; assert that ( task service create task query ( ) count ( ) ) is equal to ( 0 ) ; / / there is a qa config without history , so we cannot work with this : / / assert that ( 1 , / / history service create historic process instance query ( ) process instance id ( process instance id ) finished ( ) count ( ) ) ; }


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

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


int to long conversion with zero - padding

private static long to 6 4 ( int i ) { return i & 0x f f f f f f f f l ; }


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


public static int hash code ( object obj ) { if ( obj = = null ) { / / for consistency with arrays # hash code ( ) and objects # hash code ( ) return 0 ; } final class < ? > clazz = obj get class ( ) ; if ( ! clazz is array ( ) ) { return obj hash code ( ) ; } final class < ? > component type = clazz get component type ( ) ; if ( long class equals ( component type ) ) { return arrays hash code ( ( long [ ] ) obj ) ; } else if ( int class equals ( component type ) ) { return arrays hash code ( ( int [ ] ) obj ) ; } else if ( short class equals ( component type ) ) { return arrays hash code ( ( short [ ] ) obj ) ; } else if ( char class equals ( component type ) ) { return arrays hash code ( ( char [ ] ) obj ) ; } else if ( byte class equals ( component type ) ) { return arrays hash code ( ( byte [ ] ) obj ) ; } else if ( boolean class equals ( component type ) ) { return arrays hash code ( ( boolean [ ] ) obj ) ; } else if ( float class equals ( component type ) ) { return arrays hash code ( ( float [ ] ) obj ) ; } else if ( double class equals ( component type ) ) { return arrays hash code ( ( double [ ] ) obj ) ; } else { return arrays hash code ( ( object [ ] ) obj ) ; } }


adds repositories to the list of repositories to get

public get repositories request builder add repositories ( string repositories ) { request repositories ( array utils concat ( request repositories ( ) , repositories ) ) ; return this ; }


if this range contains every int that ' s in the other range , return true

public boolean contains ( range that ) { return this start < = that start & & that end < = this end ; }


returns the next pseudo - random , uniformly distributed { @ code long } value from this random number generator ' s sequence subclasses should override this , as this is used by all other methods

public long next long ( ) { long s 1 = this seed 0 ; final long s 0 = this seed 1 ; this seed 0 = s 0 ; s 1 ^ = s 1 < < 23 ; return ( this seed 1 = ( s 1 ^ s 0 ^ ( s 1 > > > 17 ) ^ ( s 0 > > > 26 ) ) ) + s 0 ; }


public void join ( ) throws interrupted exception { sucker join ( ) ; }


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


protected void decide attribute release based on service attribute policy ( final map < string , list < object > > attributes , final string attribute value , final string attribute name , final registered service service , final boolean does attribute policy allow ) { if ( string utils is not blank ( attribute value ) ) { logger debug ( " obtained [ { } ] as an authentication attribute " , attribute name ) ; if ( does attribute policy allow ) { logger debug ( " obtained [ { } ] is passed to the cas validation payload " , attribute name ) ; attributes put ( attribute name , collection utils wrap ( attribute value ) ) ; } else { logger debug ( " attribute release policy for [ { } ] does not authorize the release of [ { } ] " , service get service id ( ) , attribute name ) ; attributes remove ( attribute name ) ; } } else { logger trace ( " [ { } ] is not available and will not be released to the validation response " , attribute name ) ; } }


get the function to register the { @ link org elasticsearch search aggregations support values source } to aggregator mappings for this aggregation

public consumer < values source registry builder > get aggregator registrar ( ) { return aggregator registrar ; }


the name of this entry this corresponds to the ' entry ' part of a full resource name of the form package : typeentry < code > optional string name = 2 ; < code >

public java lang string get name ( ) { return name ; }


tests that i o exceptions from read during ssl handshake are not treated as authentication failures

public void test i o exceptions during handshake read ( args args ) throws exception { server = create echo server ( args , security protocol ssl ) ; test i o exceptions during handshake ( args , failure action throw io exception , failure action no op ) ; }


returns the internal state the returned object must be immutable ! the returned state may be used for caching the result of { @ code scale type get transform } if null state is returned , the result will not be cached if non - null state is returned , the old transformation may be used if produced with an equal state


public decoded instruction with index ( int new index ) { return new register range decoded instruction ( get format ( ) , get opcode ( ) , new index , get index type ( ) , get target ( ) , get literal ( ) , a , register count ) ; }


save allocated block at the given pending filename

static void save allocated block ( f s namesystem fsn , string src , i nodes in path inodes in path , block new block , datanode storage info [ ] targets , block type block type ) throws i o exception { assert fsn has write lock ( ) ; block info b = add block ( fsn dir , src , inodes in path , new block , targets , block type ) ; log allocated block ( src , b ) ; datanode storage info increment blocks scheduled ( targets ) ; }


public list < list < big decimal > > get array array number ( ) { return array array number ; }


notification that the options have changed

public void options changed ( options options , string option name , object old value , object new value ) { if ( options = = display options ) { display options changed ( options , option name , old value , new value ) ; } else { field options changed ( options , option name , old value , new value ) ; } }


creates a graph from a data set of tuple 3 objects for edges the first field of the tuple 3 object will become the source id , the second field will become the target id , and the third field will become the edge value vertices are created automatically and their values are set to null value

public static < k , ev > graph < k , null value , ev > from tuple data set ( data set < tuple 3 < k , k , ev > > edges , execution environment context ) { data set < edge < k , ev > > edge data set = edges map ( new tuple 3 to edge map < > ( ) ) name ( " type conversion " ) ; return from data set ( edge data set , context ) ; }


attempts to start the timer immediately prior to the service being started via { @ link service # start async ( ) }

void try start timing ( service service ) { monitor enter ( ) ; try { stopwatch stopwatch = startup timers get ( service ) ; if ( stopwatch = = null ) { startup timers put ( service , stopwatch create started ( ) ) ; } } finally { monitor leave ( ) ; } }


discards entities with start timestamp less than or equal to the given timestamp

void discard old entities ( long timestamp ) throws i o exception , interrupted exception { byte [ ] reverse timestamp = write reverse ordered long ( timestamp ) ; long total count = 0 ; long t 1 = system current time millis ( ) ; try { list < string > entity types = get entity types ( ) ; for ( string entity type : entity types ) { leveldb iterator iterator = null ; leveldb iterator pf iterator = null ; long type count = 0 ; delete lock write lock ( ) lock ( ) ; try { iterator = get db iterator ( false ) ; pf iterator = get db iterator ( false ) ; if ( deletion thread ! = null & & deletion thread is interrupted ( ) ) { throw new interrupted exception ( ) ; } boolean seeked = false ; while ( delete next entity ( entity type , reverse timestamp , iterator , pf iterator , seeked ) ) { type count + + ; total count + + ; seeked = true ; if ( deletion thread ! = null & & deletion thread is interrupted ( ) ) { throw new interrupted exception ( ) ; } } } catch ( i o exception e ) { log error ( " got i o exception while deleting entities for type " + entity type + " , continuing to next type " , e ) ; } finally { i o utils cleanup with logger ( log , iterator , pf iterator ) ; delete lock write lock ( ) unlock ( ) ; if ( type count > 0 ) { log info ( " deleted " + type count + " entities of type " + entity type ) ; } } } } finally { long t 2 = system current time millis ( ) ; log info ( " discarded " + total count + " entities for timestamp " + timestamp + " and earlier in " + ( t 2 - t 1 ) / 1000 0 + " seconds " ) ; } }


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

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


public list < big decimal > get array number ( ) { return array number ; }


add a shift ( sn ) entry to the given cell

public boolean put shift ( int from state , assembly terminal next , int new state ) { return put ( from state , next , new shift action ( new state ) ) ; }


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


this test is to verify the deprecated { @ link metric # value ( ) } method

public void test deprecated metric value method ( ) { verify stats ( kafka metric : : value ) ; }