returns the index of the first local symbol

public int get local symbol index ( ) { return ilocalsym ; }


declares that this transformation contains certain operator scope managed memory use case

public optional < integer > declare managed memory use case at operator scope ( managed memory use case managed memory use case , int weight ) { preconditions check not null ( managed memory use case ) ; preconditions check argument ( managed memory use case scope = = managed memory use case scope operator , " use case is not operator scope " ) ; preconditions check argument ( weight > 0 , " weights for operator scope use cases must be greater than 0 " ) ; return optional of nullable ( managed memory operator scope use case weights put ( managed memory use case , weight ) ) ; }


{ @ inherit doc } this implementation is empty

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


public static class < ? > class for name ( string class name ) throws class not found exception { return class loader wrapper class for name ( class name ) ; }


public static string get name ( ) { return " # blob " ; }


perform url verification checks to ensure that it satisfies this connector implementation requirements

protected void check protocol ( ) throws malformed u r l exception { if ( ! ghidra u r l protocol equals ( url get protocol ( ) ) ) { throw new malformed u r l exception ( " expected ghidra url protocol " ) ; } }


public final short get opcode unit ( ) { return ( short ) opcode ; }


scan blocks in { @ link # needed reconstruction } and assign reconstruction ( replication or erasure coding ) work to data - nodes they belong to the number of process blocks equals either twice the number of live data - nodes or the number of low redundancy blocks whichever is less

int compute block reconstruction work ( int blocks to process ) { list < list < block info > > blocks to reconstruct = null ; namesystem write lock ( ) ; try { boolean reset = false ; if ( repl queue reset to head threshold > 0 ) { if ( repl queue calls since reset > = repl queue reset to head threshold ) { reset = true ; repl queue calls since reset = 0 ; } else { repl queue calls since reset + + ; } } / / choose the blocks to be reconstructed blocks to reconstruct = needed reconstruction choose low redundancy blocks ( blocks to process , reset ) ; } finally { namesystem write unlock ( ) ; } return compute reconstruction work for blocks ( blocks to reconstruct ) ; }


reset one analysis option to its default value

public void reset analysis option ( program program , string analysis option ) { options options = program get options ( program analysis properties ) ; options restore default value ( analysis option ) ; }


sets the { @ link rule context } for the calling target

public builder set rule context ( rule context rule context ) { this rule context = rule context ; return this ; }


returns whether arrays need to be allocated

boolean needs alloc arrays ( ) { return table = = null ; }


from a set of statements , create a policy

public static policy policy ( statement statements ) { return new policy ( statements ) ; }


the implicit output function that generates files based on a set of template substitutions using rule attribute values this is not , actually , safe , and any use of configurable attributes will cause a hard failure

public static safe implicit outputs function from templates ( final iterable < string > templates ) { return new template implicit outputs function ( templates ) ; }


public void int 6 4 test ( ) { / / todo : test int 6 4 }


global option to specify a cookie to be added to every request , if the request does not already contain such a cookie

builder default cookie ( string cookie , string values ) ;


extract a filtered set of property descriptors from the given bean wrapper , excluding ignored dependency types or properties defined on ignored dependency interfaces

protected property descriptor [ ] filter property descriptors for dependency check ( bean wrapper bw , boolean cache ) { property descriptor [ ] filtered = this filtered property descriptors cache get ( bw get wrapped class ( ) ) ; if ( filtered = = null ) { filtered = filter property descriptors for dependency check ( bw ) ; if ( cache ) { property descriptor [ ] existing = this filtered property descriptors cache put if absent ( bw get wrapped class ( ) , filtered ) ; if ( existing ! = null ) { filtered = existing ; } } } return filtered ; }


gets called when the user clicks on the cancel action for the dialog

protected void cancel callback ( ) { cancelled = true ; close ( ) ; }


gets whether the drawable can use worker threads to optimistically prefetch frames

public boolean get allow prefetching ( ) { return m allow prefetching ; }


get file data for child specified by file name

ghidra file data get file data ( string file name , boolean lazy ) throws i o exception { synchronized ( file system ) { if ( lazy | | contains file ( file name ) ) { ghidra file data file data = file data cache get ( file name ) ; if ( file data = = null ) { file data = add file data ( file name ) ; } return file data ; } } return null ; } / / / / todo : examine ! / / private void remove folder x ( string folder name ) { / / folder list remove ( folder name ) ; / / folder data cache remove ( folder name ) ; / / listener domain folder removed ( get domain folder ( ) , folder name ) ; / / } / / / / / / todo : examine ! / / void remove file x ( string file name ) { / / file list remove ( file name ) ; / / ghidra file v 2 data file data = file data cache remove ( file name ) ; / / if ( file data ! = null ) { / / file data dispose ( ) ; / / } / / / / todo : may need to eliminate presence of file i d in callback / / listener domain file removed ( get domain folder ( ) , file name , null / * file i d * / ) ; / / } / / / /


add the specified dynamic entry type to the specified map

public static void add dynamic type ( elf dynamic type type , map < integer , elf dynamic type > dynamic type map ) throws duplicate name exception { elf dynamic type conflict type = dynamic type map get ( type value ) ; if ( conflict type ! = null ) { throw new duplicate name exception ( " elf dynamic type conflict during initialization ( " + type name + " / " + conflict type name + " ) , value = 0x " + integer to hex string ( type value ) ) ; } for ( elf dynamic type existing type : dynamic type map values ( ) ) { if ( type name equals ignore case ( existing type name ) ) { throw new duplicate name exception ( " elf dynamic type conflict during initialization , name = " + type name ) ; } } dynamic type map put ( type value , type ) ; }


note that this method is not expected to be overridden

default < r > i thenable < r > then ( @ js optional then on fulfilled callback fn < ? super v , ? extends r > on fulfilled , @ js optional then on rejected callback fn < ? extends r > on rejected ) { return new promise < v > ( ( resolve , reject ) - > { futures add callback ( this , new future callback < v > ( ) { @ override public void on success ( v value ) { resolve on invoke ( value ) ; } @ override public void on failure ( throwable throwable ) { reject on invoke ( throwable get backing js object ( ) ) ; } } , more executors direct executor ( ) ) ; } ) then ( ( i thenable then on fulfilled callback fn ) on fulfilled , ( i thenable then on rejected callback fn ) on rejected ) ; } / / todo ( b / 141673833 ) : if this would work , it would allow us to implement i thenable properly : / / default < r > promise < r > then ( i thenable then on fulfilled callback fn < ? super v , ? extends r > / / on fulfilled ) { / / return then ( on fulfilled , null ) ; / / }


returns the mock that was used for this stub it allows to create a stub in one line of code this can be helpful to keep test code clean for example , some boring stub can be created & stubbed at field initialization in a test : < pre class = " code " > < code class = " java " > public class car test { car boring stubbed car = when ( mock ( car class ) shift gear ( ) ) then throw ( engine not started class ) get mock ( ) ; & # 064 ; test public void should { } < code >


dumps this module this method is for debugging only

string dump ( ) { string builder builder = new string builder ( ) ; builder append ( " module information - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - \ n " ) ; builder append ( " module pointer : " ) ; builder append ( module pointer ) ; builder append ( " \ n " ) ; builder append ( section contribution dump ( ) ) ; builder append ( " \ nwritten since open : " ) ; builder append ( written since open ) ; builder append ( " \ nec symbolic information enabled : " ) ; builder append ( ec symbolic information enabled ) ; builder append ( " \ nspare : " ) ; builder append ( spare ) ; builder append ( " \ nindex to t s m list : " ) ; builder append ( index to t s m list ) ; builder append ( " \ nstream number debug information : " ) ; builder append ( stream number debug information ) ; builder append ( " \ nsize local symbols debug information : " ) ; builder append ( size local symbols debug information ) ; builder append ( " \ nsize line number debug information : " ) ; builder append ( size line number debug information ) ; builder append ( " \ nsize c 1 3 style line number information : " ) ; builder append ( size c 1 3 style line number information ) ; builder append ( " \ nnum files contributing : " ) ; builder append ( num files contributing ) ; builder append ( dump additionals ( ) ) ; builder append ( " \ nmodule name : " ) ; builder append ( module name ) ; builder append ( " \ nobject file name : " ) ; builder append ( object file name ) ; builder append ( " \ n end module information - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - \ n " ) ; return builder to string ( ) ; }


void expand node ( program node node ) { expand path ( node get tree path ( ) ) ; int nchild = node get child count ( ) ; for ( int i = 0 ; i < nchild ; i + + ) { program node child = ( program node ) node get child at ( i ) ; if ( child equals ( node ) | | child is leaf ( ) ) { continue ; } expand node ( child ) ; } }


returns the current leader information if available otherwise it returns an empty optional

public optional < tuple 2 < string , uuid > > get leader now ( ) throws exception { completable future < tuple 2 < string , uuid > > leader future = this atomic leader future get ( ) ; if ( leader future ! = null ) { if ( leader future is done ( ) ) { return optional of ( leader future get ( ) ) ; } else { return optional empty ( ) ; } } else { return optional empty ( ) ; } }


get the refresh check delay for the given { @ link script factory } { @ link bean definition } if the { @ link bean definition } has a { @ link org springframework core attribute accessor metadata attribute } under the key { @ link # refresh check delay attribute } which is a valid { @ link number } type , then this value is used otherwise , the { @ link # default refresh check delay } value is used

protected long resolve refresh check delay ( bean definition bean definition ) { long refresh check delay = this default refresh check delay ; object attribute value = bean definition get attribute ( refresh check delay attribute ) ; if ( attribute value instanceof number ) { refresh check delay = ( ( number ) attribute value ) long value ( ) ; } else if ( attribute value instanceof string ) { refresh check delay = long parse long ( ( string ) attribute value ) ; } else if ( attribute value ! = null ) { throw new bean definition store exception ( " invalid refresh check delay attribute [ " + refresh check delay attribute + " ] with value ' " + attribute value + " ' : needs to be of type number or string " ) ; } return refresh check delay ; }


public static boolean is signed ( int operand type ) { return ( operand type & signed ) ! = 0 ; }


public void namespace boolean test ( ) { / / todo : test namespace boolean }


return the delivery delay to use for send calls ( in milliseconds )

public long get delivery delay ( ) { return this delivery delay ; }


locate file that is linked to the service

default optional < file > locate ( final registered service service ) { return file extensions stream ( ) map ( ext - > determine ( service , ext ) ) filter ( file : : exists ) find first ( ) ; }


returns the first eight bytes of { @ linkplain # as bytes ( ) this hashcode ' s bytes } , converted to a { @ code long } value in little - endian order


when add mount table entry , it needs write permission of the nearest parent entry if exist , and execute permission of other ancestor entries

public add mount table entry response add mount table entry ( add mount table entry request request ) throws i o exception { mount table mount table = request get entry ( ) ; if ( mount table ! = null ) { mount table validate ( ) ; final string src = mount table get source path ( ) ; check mount table permission ( src ) ; boolean status = get driver ( ) put ( mount table , false , true ) ; add mount table entry response response = add mount table entry response new instance ( ) ; response set status ( status ) ; update cache all routers ( ) ; return response ; } else { add mount table entry response response = add mount table entry response new instance ( ) ; response set status ( false ) ; return response ; } }


detects the socket mode , see comments at the top of the class for more details this operation will block for up to { @ link x 5 0 9 util # get ssl handshake timeout millis ( ) } milliseconds and should not be called in the accept ( ) thread if possible

private void detect mode ( ) throws i o exception { byte [ ] litmus = new byte [ 5 ] ; int old timeout = - 1 ; int bytes read = 0 ; int new timeout = x 5 0 9 util get ssl handshake timeout millis ( ) ; try { old timeout = prependable socket get so timeout ( ) ; prependable socket set so timeout ( new timeout ) ; bytes read = prependable socket get input stream ( ) read ( litmus , 0 , litmus length ) ; } catch ( socket timeout exception e ) { / / didn ' t read anything within the timeout , fallthrough and assume the connection is plaintext log warn ( " socket mode detection timed out after { } ms , assuming plaintext " , new timeout ) ; } finally { / / restore socket timeout to the old value try { if ( old timeout ! = - 1 ) { prependable socket set so timeout ( old timeout ) ; } } catch ( exception e ) { log warn ( " failed to restore old socket timeout value of { } ms " , old timeout , e ) ; } } if ( bytes read < 0 ) { / / got a eof right away , definitely not using tls fallthrough bytes read = 0 ; } if ( bytes read = = litmus length & & ssl handler is encrypted ( unpooled wrapped buffer ( litmus ) ) ) { try { ssl socket = x 5 0 9 util create s s l socket ( prependable socket , litmus ) ; } catch ( x 5 0 9 exception e ) { throw new i o exception ( " failed to create ssl context " , e ) ; } prependable socket = null ; mode = mode tls ; log info ( " accepted tls connection from { } - { } - { } " , ssl socket get remote socket address ( ) , ssl socket get session ( ) get protocol ( ) , ssl socket get session ( ) get cipher suite ( ) ) ; } else if ( allow insecure connection ) { prependable socket prepend to input stream ( litmus , 0 , bytes read ) ; mode = mode plaintext ; log info ( " accepted plaintext connection from { } " , prependable socket get remote socket address ( ) ) ; } else { prependable socket close ( ) ; mode = mode plaintext ; throw new i o exception ( " blocked insecure connection attempt " ) ; } }


set whether to allow non - serializable types as hessian arguments and return values default is " true "

public void set allow non serializable ( boolean allow non serializable ) { this serializer factory set allow non serializable ( allow non serializable ) ; }


gets the list of assigned user jar paths

public list < path > get user jars ( ) { return user jars ; }


locate mdui for entity id simple metadata ui info

public static saml metadata u i info locate metadata user interface for entity id ( final entity descriptor entity descriptor , final string entity id , final registered service registered service , final http servlet request request context ) { val mdui = new saml metadata u i info ( registered service , request context get locale ( ) get language ( ) ) ; if ( entity descriptor = = null ) { logger trace ( " entity descriptor not found for [ { } ] " , entity id ) ; return mdui ; } val spsso descriptor = get s p sso descriptor ( entity descriptor ) ; if ( spsso descriptor = = null ) { logger trace ( " sp sso descriptor not found for [ { } ] " , entity id ) ; return mdui ; } val extensions = spsso descriptor get extensions ( ) ; if ( extensions = = null ) { logger trace ( " no extensions in the sp sso descriptor are found for [ { } ] " , u i info default element name get namespace u r i ( ) ) ; return mdui ; } val sp extensions = extensions get unknown x m l objects ( u i info default element name ) ; if ( sp extensions is empty ( ) ) { logger trace ( " no extensions in the sp sso descriptor are located for [ { } ] " , u i info default element name get namespace u r i ( ) ) ; return mdui ; } sp extensions stream ( ) filter ( u i info class : : is instance ) for each ( obj - > { val ui info = ( u i info ) obj ; logger trace ( " found mdui info for [ { } ] " , entity id ) ; mdui set ui info ( ui info ) ; } ) ; return mdui ; }


hold configuration settings in a parent field mainly used for serialization

public serializable with holder ( ) { return new holder ( this ) ; }


returns a new diff map with the given key removed , does not modify the invoking instance if the key does not exist in the diff map , the same instance is returned

public immutable open map diff < k , t > with key removed ( k key ) { if ( this diffs contains key ( key ) = = false & & this upserts contains key ( key ) = = false ) { return this ; } map < k , diff < t > > new diffs = new hash map < > ( this diffs ) ; new diffs remove ( key ) ; map < k , t > new upserts = new hash map < > ( this upserts ) ; new upserts remove ( key ) ; return new immutable open map diff < > ( this key serializer , this value serializer , this deletes , new diffs , new upserts ) ; }


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


public boolean equals ( object other ) { if ( this = = other ) { return true ; } if ( other instanceof model snapshot = = false ) { return false ; } model snapshot that = ( model snapshot ) other ; return objects equals ( this job id , that job id ) & & objects equals ( this min version , that min version ) & & objects equals ( this timestamp , that timestamp ) & & objects equals ( this description , that description ) & & objects equals ( this snapshot id , that snapshot id ) & & this snapshot doc count = = that snapshot doc count & & objects equals ( this model size stats , that model size stats ) & & objects equals ( this quantiles , that quantiles ) & & objects equals ( this latest record time stamp , that latest record time stamp ) & & objects equals ( this latest result time stamp , that latest result time stamp ) & & this retain = = that retain ; }


converts the specified java cipher suite to its corresponding open s s l cipher suite name

static string to open ssl ( string java cipher suite , boolean boring s s l ) { string converted = j 2o get ( java cipher suite ) ; if ( converted ! = null ) { return converted ; } return cache from java ( java cipher suite , boring s s l ) ; }


verify a returned status array matches a single named file

private void verify status array matches file ( path f , file status [ ] status ) { assert equals ( 1 , status length ) ; file status file status = status [ 0 ] ; assert is named file ( f , file status ) ; }


returns true if this section is writable

public boolean is writable ( ) { return header get load adapter ( ) is section writable ( this ) ; }