Abstract:
Disclosed herein are technologies for a generic annotation seeker to generate an index of class annotation, mapping classes with annotations during build time. Files may be dynamically registered and scanned by a registration seeker for revised and updated annotation. This Abstract is submitted with the understanding that it will not be used to interpret or limit the scope or meaning of the claims.

Description:
TECHNICAL FIELD 
       [0001]    The present disclosure relates generally to providing and determining annotation of software component classes and other code-related categories. 
       BACKGROUND 
       [0002]    Software systems are made of numerous components or code. Components may be classified into various and numerous classes. Classes may define functionality of components. When development, integration, and/or maintenance of the software system takes place, it is important for users or developers to know the associated functionality of the classes. Typically, this is determined using notes or annotation that is associated with classes. With numerous classes, the task may be difficult to find and determine annotation of the classes. 
         [0003]    In object oriented languages, such as Java programming language, annotation may be provided by a tag; however there is no simple or easy way to determine classes and their annotation. A developer or user may have to check each and every class as to its annotation. Furthermore, for certain implementations, it is desirable to be able to seek certain classes that are particularly annotated. For example, current platforms, such as Java programming language based platforms may seek or scan for Java methods that are annotated with “@RuleFunction”; a meta data framework (MDF) may seek for Java methods annotated with “@MDFEntity”; platforms may seek Java classes that are annotated with “@Name”; platforms may seek Java servlets with annotation defined by particular specifications; and so on. 
         [0004]    Typical methods to seek classes include a “scanner” method. The scanner method is direct, but may slow startup. Another method is a “registration” method. The registration method may be faster, but a user may have to manually register the classes. 
       SUMMARY 
       [0005]    Disclosed herein are technologies for annotating categories using a pre-cached index that is automatically generated during build time of code. In accordance with one aspect, an index file may be generated as a build file is run, annotations may be mapped to categories and the index file with the mapped annotations may be further archived. 
         [0006]    With these and other advantages and features that will become hereinafter apparent, further information may be obtained by reference to the following detailed description and appended claims, and to the figures attached hereto. 
     
    
     
       BRIEF DESCRIPTION OF THE DRAWINGS 
         [0007]      FIG. 1  illustrates an exemplary network or system; 
           [0008]      FIG. 2  illustrates exemplary code script of an index for annotation; 
           [0009]      FIG. 3  illustrates exemplary software folders; 
           [0010]      FIG. 4  illustrates an exemplary process flow to generate and implement an annotating index; and 
           [0011]      FIG. 5  illustrates an exemplary computing system to implement technologies described herein. 
       
    
    
       [0012]    The Detailed Description references the accompanying figures. In the figures, the left-most digit(s) of a reference number identifies the figure in which the reference number first appears. The same numbers are used throughout the drawings to reference like features and components. 
       DETAILED DESCRIPTION 
       [0013]    In the description, annotation is automatically provided to classes which define particular software code or code components. It is to be understood that classes are used here as an example. Annotation may also be applied to other areas such as subclasses, interfaces, and so on. Java programming language and Java programming platform are used as an example herein; however, it is to be understood that other programming languages (e.g. object oriented), and computing/programming platforms are also applicable. In particular, methods are described to determine Java classes that are annotated or implement some type of interface. It may be assumed that the Java code is not changed, and that in certain instances some classes may be instrumented or constructed in run time. 
         [0014]      FIG. 1  shows an example system  100  as described in the present implementations herein. It is to be understood, that system  100  may include other devices, components, entities, and the like which are not shown in order to simplify the description. 
         [0015]    System  100  includes various components or code  102 . The components or code  102  may be part of a larger system or software program. In certain implementations components or code  102  are stored together or stored separately. It is to be understood that it does not matter where such components or code  102  are stored or located; however, the components or code  102  may have access to or implement the use of one another. A network or networks  104 , such as the Internet, connects to the components or code  102 . The network  104  is connected to various entities. 
         [0016]    In this example, multiple users  106  are connected to the network  104  through respective computing devices, such as servers  108 . Users  106  may be a group, or a single individual as shown in  FIG. 1 . A standalone server or computing device  110  may be implemented. In this example, server  110  hosts classes  112 . Classes  112  define or classify components or code  102 . 
         [0017]    The classes  112  may be annotated using the generic annotation seeker or GAS (not shown) described herein. In certain implementations the GAS is hosted in server  110 ; however, it is to be understood that the GAS may be part of or is included in several servers, devices, and the like, including the “cloud.” An archived file index or indices  114  may also be hosted in server  110 . For example, in Java language based platforms, Java Archive or JAR files may be used as described below and stored as archive file index (or indices)  114 . 
         [0018]      FIG. 2  shows exemplary index in the form of a code script or “xml” file  200 . For example, xml file  200  may be referred to as “gas.xml” referring to the generic annotation seeker or GAS. The xml file  200  is an index that maps classes with annotations. The xml file  200  may be generated when a Java file is generated, for example during the build process. The xml file  200  may include information or annotation for users/developers. 
         [0019]    In this example, the xml file  200  is considered as an annotation index for classes. A string in xml file  200  defines the annotation  202  which is “Service.” In other words, classes defined in the xml file  200  are annotated as “Service” classes as defined by annotation  202 . In the example, set  204  defines the classes. 
         [0020]    Since the classes are now defined or are annotated, during generation of a Java file, there is no need to manually define or register classes with annotation. Because the classes are annotated, it may be more efficient in finding classes that have particular annotation. In this example, classes annotated as “Service” classes. This can lead to faster startup times, since the searching or seeking is more efficient. 
         [0021]    In certain implementations, because the xml file  200  is archived, there may be no need to recompile the Java file in order to create the xml file  200 . By avoiding recompiling, build times may be reduced and in certain cases eliminated, reducing build costs. Recompilation may take place when the xml file  200  needs to be updated. Recompilation and generation of xml file  200  may take place when classes are added or changed, and/or annotations are added or changed. 
         [0022]    Therefore, the generic annotation seeker or GAS seeks classes by using a pre-cached class-annotation index or xml file  200  that is called gas.xml in the example. The gas.xml or xml file  200  includes pre-cached key value entry that defines annotation (i.e., annotation:class). 
         [0023]      FIG. 3  shows exemplary software folders  300  in the present implementations described herein. 
         [0024]    Annotations that are to be indexed by GAS may be predefined in the folder “gas.properties”  302 . The folder “gas.properties”  302  may reside in a “build-system/lib/gas” folder. The example folder “gas.properties”  302  may be added as indexed annotation. 
         [0025]    The file “gas.xml”  304  may be generated into a &lt;RESOURCE_FOLDER&gt; before the build system packages a Java Archive or JAR file. In one implementation, the file “gas.xml”  304  may be packaged with the Java Archive or JAR file, and particularly into a module JAR as illustrated in  FIG. 3 . 
         [0026]    In an implementation, a build system may call GAS.jar to generate the “gas.xml”  306  during “package-service” target. The GAS.jar may package a simple scanner that scans %classes% folder for finding classes by using “ResourceScanner”. The file “gas.xml”  306  contains the xml serialized by XStream from a MAP which maps annotation with a set of classes that are annotated with that annotation. 
         [0027]      FIG. 4  shows an exemplary process  400  for implementing, at least in part, the technology described herein. In particular, process  400  depicts a flow to generate and implement an annotating index. The process  400  may be performed by a computing device. An example architecture of such a computer device is described below with reference to  FIG. 5 . 
         [0028]    At  402 , running a build file is performed. In certain implementations, the build file is a Java file that is executed. 
         [0029]    At  404 , generating an xml file or an index is performed, as the build file is run. This may be automatically performed. 
         [0030]    At  406 , mapping annotations to classes is performed. 
         [0031]    At  408 , archiving the xml file or index is performed. The archiving may be performed using a Java Archive (JAR) file. 
         [0032]    At  410 , a look-up of the xml file or index is performed. The look up may be performed during startup of a system implementing the classes. 
         [0033]      FIG. 5  illustrates an exemplary system  500  that may implement, at least in part, the technologies described herein. The computer system  500  includes one or more processors, such as processor  504 . Processor  504  can be a special-purpose processor or a general-purpose processor. Processor  504  is connected to a communication infrastructure  502  (for example, a bus or a network). Depending upon the context, the computer system  500  may also be called a client device. 
         [0034]    Computer system  500  also includes a main memory  506 , preferably Random Access Memory (RAM), containing possibly inter alia computer software and/or data  508 . 
         [0035]    Computer system  500  may also include a secondary memory  510 . Secondary memory  510  may include, for example, a hard disk drive  512 , a removable storage drive  514 , a memory stick, etc. A removable storage drive  514  may comprise a floppy disk drive, a magnetic tape drive, an optical disk drive, a flash memory, or the like. A removable storage drive  514  reads from and/or writes to a removable storage unit  516  in a well-known manner. A removable storage unit  516  may comprise a floppy disk, a magnetic tape, an optical disk, etc. which is read by and written to by removable storage drive  514 . As will be appreciated by persons skilled in the relevant art(s) removable storage unit  516  includes a computer usable storage medium  518  having stored therein possibly inter alia computer software and/or data  520 . 
         [0036]    In alternative implementations, secondary memory  510  may include other similar means for allowing computer programs or other instructions to be loaded into computer system  500 . Such means may include, for example, a removable storage unit  524  and an interface  522 . Examples of such means may include a program cartridge and cartridge interface (such as that found in video game devices), a removable memory chip (such as an Erasable Programmable Read-Only Memory (EPROM), or Programmable Read-Only Memory (PROM)) and associated socket, and other removable storage units  524  and interfaces  522  which allow software and data to be transferred from the removable storage unit  524  to computer system  500 . 
         [0037]    Computer system  500  may also include an input interface  526  and a range of input devices  528  such as, possibly inter alia, a keyboard, a mouse, etc. 
         [0038]    Computer system  500  may also include an output interface  530  and a range of output devices  532  such as, possibly inter alia, a display, one or more speakers, etc. 
         [0039]    Computer system  500  may also include a communications interface  534 . Communications interface  534  allows software and/or data  538  to be transferred between computer system  500  and external devices. Communications interface  534  may include a modem, a network interface (such as an Ethernet card), a communications port, a Personal Computer Memory Card International Association (PCMCIA) slot and card, or the like. Software and/or data  538  transferred via communications interface  534  are in the form of signals  536  which may be electronic, electromagnetic, optical, or other signals capable of being received by communications interface  534 . These signals  536  are provided to communications interface  534  via a communications path  540 . Communications path  540  carries signals and may be implemented using a wire or cable, fiber optics, a phone line, a cellular phone link, a Radio Frequency (RF) link or other communication channels. 
         [0040]    As used in this document, the terms “computer-program medium,” “computer-usable medium,” and “computer-readable medium” generally refer to media such as removable storage unit  516 , removable storage unit  524 , and a hard disk installed in hard disk drive  512 . Computer program medium and computer usable medium can also refer to memories, such as main memory  506  and secondary memory  510 , which can be memory semiconductors (e.g., Dynamic Random Access Memory (DRAM) elements, etc.). These computer program products are means for providing software to computer system  500 . 
         [0041]    Computer programs (also called computer control logic) are stored in main memory  506  and/or secondary memory  510 . Such computer programs, when executed, enable computer system  500  to implement the present technology described herein. In particular, the computer programs, when executed, enable processor  504  to implement the processes of aspects of the above. Accordingly, such computer programs represent controllers of the computer system  500 . Where the technology described herein is implemented, at least in part, using software, the software may be stored in a computer program product and loaded into computer system  500  using removable storage drive  514 , interface  522 , hard disk drive  512  or communications interface  534 . 
         [0042]    The technology described herein may be implemented as computer program products comprising software stored on any computer useable medium. Such software, when executed in one or more data processing devices, causes data processing device(s) to operate as described herein. Embodiments of the technology described herein may employ any computer useable or readable medium, known now or in the future. Examples of computer useable mediums include, but are not limited to, primary storage devices (e.g., any type of random access memory), secondary storage devices (e.g., hard drives, floppy disks, Compact Disc Read-Only Memory (CD-ROM) disks, Zip disks, tapes, magnetic storage devices, optical storage devices, Microelectromechanical Systems (MEMS), and nanotechnological storage device, etc.). 
         [0043]    A computing system may take the form of any combination of one or more of inter alia a wired device, a wireless device, a mobile phone, a feature phone, a smartphone, a tablet computer (such as for example an iPad™), a mobile computer, a handheld computer, a desktop computer, a laptop computer, a server computer, an in-vehicle (e.g., audio, navigation, etc.) device, an in-appliance device, a Personal Digital Assistant (PDA), a game console, a Digital Video Recorder (DVR) or Personal Video Recorder (PVR), a cable system or other set-top-box, an entertainment system component such as a television set, etc. 
         [0044]    In the above description of exemplary implementations, for purposes of explanation, specific numbers, materials configurations, and other details are set forth in order to better explain the present invention, as claimed. However, it will be apparent to one skilled in the art that the claimed invention may be practiced using different details than the exemplary ones described herein. In other instances, well-known features are omitted or simplified to clarify the description of the exemplary implementations. 
         [0045]    The inventor intends the described exemplary implementations to be primarily examples. The inventor does not intend these exemplary implementations to limit the scope of the appended claims. Rather, the inventor has contemplated that the claimed invention might also be embodied and implemented in other ways, in conjunction with other present or future technologies. 
         [0046]    Moreover, the word “exemplary” is used herein to mean serving as an example, instance, or illustration. Any aspect or design described herein as exemplary is not necessarily to be construed as preferred or advantageous over other aspects or designs. Rather, use of the word “exemplary” is intended to present concepts and techniques in a concrete fashion. The term “technology,” for instance, may refer to one or more devices, apparatuses, systems, methods, articles of manufacture, and/or computer-readable instructions as indicated by the context described herein. 
         [0047]    As used in this application, the term “or” is intended to mean an inclusive “or” rather than an exclusive “or.” That is, unless specified otherwise or clear from context, “X employs A or B” is intended to mean any of the natural inclusive permutations. That is, if X employs A; X employs B; or X employs both A and B, then “X employs A or B” is satisfied under any of the foregoing instances. In addition, the articles “a” and “an” as used in this application and the appended claims should generally be construed to mean “one or more,” unless specified otherwise or clear from context to be directed to a singular form. 
         [0048]    Note that the order in which the processes are described is not intended to be construed as a limitation, and any number of the described process blocks can be combined in any order to implement the processes or an alternate process. Additionally, individual blocks may be deleted from the processes without departing from the spirit and scope of the subject matter described herein. 
         [0049]    One or more embodiments described herein may be implemented fully or partially in software and/or firmware. This software and/or firmware may take the form of instructions contained in or on a non-transitory computer-readable storage medium. Those instructions may then be read and executed by one or more processors to enable performance of the operations described herein. The instructions may be in any suitable form, such as but not limited to source code, compiled code, interpreted code, executable code, static code, dynamic code, and the like. Such a computer-readable medium may include any tangible non-transitory medium for storing information in a form readable by one or more computers, such as but not limited to read only memory (ROM); random access memory (RAM); magnetic disk storage media; optical storage media; a flash memory, etc.