Patent Document

BACKGROUND 
   1. Technical Field 
   The present disclosures relates to a system and method for communicating data to a process. More specifically, the present disclosure relates to a system and method for controlling communication of data from a database to a process using directives. 
   2. Description of the Related Art 
   In software engineering, the Model-View-Controller paradigm (MVC) has gained favor as a beneficial way of structuring applications, as it isolates three aspects of an application such that one aspect may be changed without requiring alteration of the other aspects. 
   The Model aspect of MVC relates to the data which may be accessed and/or manipulated. The View aspect of MVC relates to the part of the software that processes that data and presents results of the processing to the user. The Controller aspect of MVC relates to the part of the software that acts as an interface between the Model and the View. 
   The View portion of a software application may include, for example, engines for processing the data, as well as a graphical user interface (GUI) providing audio/visual presentation. It is possible that, for example, a first user may wish to process and view data in an arrangement different from that of a second user. In order to satisfy both users, under the MVC paradigm, the View may be altered, but the controller and the data model may remain unchanged. A problem occurs when the second View can not process data presented in the same format as the original View. This problem may be solved by using a Controller that can present data in a manner which accommodates multiple Views. 
   Therefore, in order to effectively achieve this degree of modularity, it is desirable to have a system in which the Controller is capable of providing operational transparency between a plurality of Models and Views. 
   SUMMARY 
   The present disclosure relates to a method for communicating with a process, comprises, receiving a request including a target data identifier and a process identifier, retrieving target data including an target data type from a database based on the received target data identifier, selecting instructions based on the target data type and the process identifier, generating a data object and populating the data object with the retrieved target data according to the selected instructions, and transmitting the generated data object to a process corresponding to the received process identifier. The step of selecting instructions may include parsing the target data retrieved from the database, determining a target data class based on one of the target data and the target data identifier, identifying objects within the parsed target data, accessing meta-data which defines a structure of the target data class, and selecting instructions from an instruction set based on the identified objects, the process, and the meta-data. 

   
     BRIEF DESCRIPTION OF THE DRAWINGS 
     A more complete appreciation of the present disclosure and many of the attendant advantages thereof will be readily obtained as the same becomes better understood by reference to the following detailed description when considered in connection with the accompanying drawings, wherein: 
       FIG. 1  shows a block diagram of the system and method for controlling communication according to an aspect of the present disclosure. 
       FIG. 2  shows a flowchart of the system and method for controlling communication according to an aspect of the present disclosure. 
       FIG. 3  shows a flowchart for creating dynamic recipe according to an aspect of the present disclosure. 
   

   DETAILED DESCRIPTION 
   In describing a preferred embodiment of the present disclosure illustrated in the drawings, specific terminology is employed for sake of clarity. The present disclosure is not intended to be limited to the specific terminology so selected, and it is to be understood that each specific element includes all technical equivalents which operate in a similar manner. It will be apparent to one skilled in the art that the system and method of the present disclosure are not limited to controlling and processing financial data, and that any type of data may be substituted therefor. 
     FIG. 1  shows a block diagram of the system and method for controlling communication according to an aspect of the present disclosure. The system and method of the present disclosure may operate on nearly any type of computing system or platform, at a centralized location, or with portions distributed across a network. 
   As shown in  FIG. 1 , a Controller  106  may communicate with Database  100  and retrieve Data  102  and a Recipe  104 , which may be converted by the Controller  106  into DataDOM  108  and RecipeDOM  110  respectively. The Controller  106  may then create a Model Object  112  from the DataDOM  108  using the RecipeDOM  110 , and may pass the Model Object  112  to a Process  114  which may return a Result  116 . 
     FIG. 2  shows a flowchart of the system and method for controlling communication according to an aspect of the present disclosure. 
   In Step S 200 , the system receives a request for processing that may include, for example, information identifying the Data  102  to be processed and information identifying a Process  114  for processing the Data  102 . In one aspect of the system and method of the present disclosure, the Data  102  may identify the Process  114 . In one aspect of the system and method of the present disclosure, the Data  102  may include one or more financial instruments to be processed, as well as other financial information, such as trading holidays, market open and close times, and current and past prices. The Process  114  may be a process for pricing the financial instruments, for example, according to sensitivities known as “Greeks”. The request may include other information useful to perform processing, for example, relevant times and dates, results requested, and specific modes, such as, from a credit perspective. 
   In Step S 202 , the Controller  106  receives the request for processing and communicates with Database  100 , extracting Data  102  based on the request. Data  102  may be stored as records in Database  100  and may be arranged similarly for similar financial instruments, such as single and double knockout options. 
   In one aspect of the system and method of the present disclosure, the Controller  106  may extract Data  102  from the Database  100  using stored procedures, and there may be no embedded Structured Query Language (SQL). The data model specifics may be encapsulated within the Database  100 , and, as a result, the Controller  106  may not have knowledge of the specific internal organization of the Data  102  in the Database  100 . 
   The Data  102  may be sent to the Controller  106  from the Database  100  in a series of self-describing record sets, for example, in which the leading row of the record set may identify the nature of the data which follows. These self-descriptor records may include, for example, information identifying a path from a root node where the data belongs. 
   The translation of Data  102  from the format found in the Database  100  into the Model Object  112  suitable for use by the Process  114  may be controlled and defined by one or more directives included in the Recipe  104 . 
   In Step S 204 , the Controller  106  finds the appropriate Recipe  104  corresponding to the Data  102  selected for processing and the selected Process  114 . 
   A Recipe  104  is a set of one or more directives used to translate Data  102  into a Model Object  112  for use with a selected Process  114 . In one aspect of the system and method of the present disclosure, the structure and content of Recipe  104  may depend on both Data  102  and Process  114 . 
   The Recipe  104  may be implemented as Extensible Markup Language (XML) text files; however, it may not necessarily be “well-formed” XML, and other formats may be used including self-describing record sets. The Controller  106  may use standard XML parsers to traverse and tokenize the Recipe  104 , and a tree nature may reflect the structure used by the Recipe  104 . 
   The Controller  106  may use the Recipe  104  to control the transformation of the Data  102  retrieved from the Database  100  and held in the DataDOM  108  into a Model Object  112  that the Process  114  can use. In one aspect of the system and method of the present disclosure, the Recipe  104  may be stored in the Database  100 . 
   In one aspect of the system and method of the present disclosure, for each Process  114 , there may be a Recipe  104  for each Data  102  related to a financial instrument or financial instrument type. In another aspect of the system and method of the present disclosure, for each Process  114 , there may be a Recipe  104  containing or referencing one or more Sub-recipes corresponding to Data  102  related to financial instruments or financial instrument types. In yet another aspect of the system and method of the present disclosure, for a given Process  114 , Data  102  related to a financial instrument may have a different Recipe  104  or Sub-recipe based on whether the instrument is a standalone instrument or if it is the underlying of another type of instrument. 
   Because a Recipe  104  is closely correlated with the Data  102  and Process  114 , it follows that changes to Data  102  or to the Process  114  may require changes to a corresponding Recipe  104 . 
   In Step S 206 , the Controller  106  may place the Data  102  retrieved from the Database  100  into a DataDOM  108 , which is an instance of a Document Object Model (DOM) and may be represented, for example, in a tree-style data structure. The Controller  106  may do the same with the Recipe  104 , placing it into a RecipeDOM  110 . In another aspect of the system and method of the present disclosure, the Data  102  or Recipe  104  may be stored in the Database  100  in DataDOM  108  and RecipeDOM  110  formats, respectively. 
   The DOM format used for the DataDOM  108  and RecipeDOM  110  may be an open and public specification and may be searchable, for example, by an XML parser. DataDOM  108  may include fields of data identified by tags that may be used as reference points by RecipeDOM  110 . 
   In Step S 208 , the RecipeDOM  110  may be applied to a standard XML parser, which may traverse each line of the RecipeDOM  110 , tokenizing the line. The Controller  106  may then act as an interpreter, extracting from the RecipeDOM  110  the recipe directive, that is, the name of the XML tag, which may be text adjacent to the opening angle bracket. For example, the XML text “&lt;datadict value=‘Holiday’&gt;” includes the recipe directive “datadict”, which indicates construction of a Model Object  112 , for example, a models data dictionary object, of type ‘Holiday’. 
   In Step S 210 , the Controller  106  may execute a block of code specific for each recipe directive. This code may be written in any programming language, for example, C++, Java, C#, etc. A list of example directives and their actions is attached as Appendix A. 
   Directives found within the RecipeDOM  110  may define variables and data structures, for example, arrays, strings and Boolean, for the Model Object  112  and may assign to those variables a predetermined value or a value found in the DataDOM  108 . In one aspect of the system and method of the present disclosure, the directives may also include decision-making logic. 
   In another aspect of the system and method of the present disclosure, RecipeDOM  110  may also contain operations, for example, the “select” operation. For example, in the RecipeDOM  110 , the text “&lt;string key=‘name’ select=‘@filename’/&gt;”, the “string” directive causes creation of a string variable in the Model Object  112 , the “key” directive creates a string field named “name”, and “select” assigns to the string the value found in the “filename” field of the DataDOM  108 . The “select” operation specifies a path attribute, which may be absolute or relative to the current position in the DataDOM  108 , identifying the data to be read. 
   In this example, in the text “&lt;array child=‘holiday’ dt=‘DateTime’ key=‘Holidays’ man=‘y’/&gt;”, the “array” and “key” directives create in the Model Object  112  an array named “Holidays”, whose array contents are children having the tag “holiday” (“child=‘holiday’”), the “dt” directive identifies the datatype of array elements, which will be of type “DateTime”, and the “man” directive indicates that the array is mandatory or required to form a complete valid object. 
   Continuing the example, in the text “&lt;DateTime select=‘@holDate’ time=‘EOD’/&gt;”, “DateTime” refers to the DateTime array described above within the Model Object  112 , the “select=‘@holDate’” operation tells the interpreter to create a “DateTime” entry in the array “Holidays” and to set the value of that entry to the “holDate” value in the DataDOM  108 . The interpreter may parse the DataDOM  108  and create one entry in the array “Holidays” for each “holDate” value found in the DataDOM  108 . 
   In Step S 212 , the controller may pass the Model Object  112  to the selected Process  114  where Result  116  is calculated. 
   The Model Object  112  may be, for example, data dictionaries, i.e. a nested tree structure where elements may be atomic types (doubles and strings), arrays or other data dictionaries. 
   In Step S 214 , the Result  116  of the Process  114  is passed to the Controller  106 , which may perform post-processing manipulation, for example, free-formatting or scaling, before providing the Result  116  to the user. 
   Fixed and Dynamic Recipes 
   As described above, in Step S 204  the Controller  106  may locate the appropriate Recipe  104  corresponding to the selected Data  102  and Process  114 . A Fixed Recipe may be used when the structure and content of Data  102  is known and, therefore, may provide directives for appropriately handling the Data  102 . 
   When the Controller  106  encounters Data  102  and does not have a corresponding Recipe  104  with which to prepare a Model Object  112  for a selected Process  114 , a Dynamic Recipe or RecipeDOM may be created and may be saved or discarded after use. A Dynamic Recipe may provide a flexible and generalized form of the recipe concept and may be applied to Data  102  which does not have a “rigid” or predefined structure. In one aspect of the system and method of the present disclosure, an example of Data  102  which does not have a predefined structure is a “generic financial instrument”. Generic financial instruments may have data fields with undefined tags. 
   Generic financial instruments may be instances of a class, for example, OTC Vanilla, where the class definition, for example, market data, option date, etc., is formed of pre-existing components. In one aspect of the system and method of the present disclosure, the class definition for generic financial instruments may be created and modified and may be stored in the Database  100 , for example, as meta-data. 
   In another aspect of the system and method of the present disclosure, the class definition for fixed, non-generic instruments may be held in a models library data structures in code. 
     FIG. 3  shows a flowchart for creating a Dynamic Recipe according to one aspect of the present disclosure. 
   In Step S 300 , the Controller  106  may parse the Data  104  to extract the meta-data that describes a specific generic instrument instance. The Controller  106  may interrogate the Database  100  to get the instrument definition. In one aspect of the system and method of the present disclosure, the Controller  106  examines the set of objects used to create the DataDOM  108 , for example, examining the top-level children of the DataDOM  108  and may build a RecipeDOM  110  based on the set of objects. 
   Fixed Recipes may be created by interrogating a models library for the definition of the data structure of the fixed instrument class with which they will be used. To alter the definition of a fixed instrument class, the models library may be changed and re-interrogated to re-create the revised Fixed Recipe. An equivalent change to the dynamic class definition in the Database  100  may automatically be referenced on the next and subsequent recipe demand and creation. 
   Generic class definitions for generic instruments may be formed of fundamental data structure types, for example, strings, Boolean, arrays, etc., and the components defined that may be used to create the generic class may be a specialization of one or more of these fundamental data structure types. For example, a yield curve object and dividend lists are specializations of a pair of arrays, one array storing dates and the other storing corresponding values. 
   In Step S 302 , the Controller  106  may determine which data structure types and specializations are included in the generic class definition. The Controller  106  may sort through the generic class definition to identify the data structure types and specializations. 
   In Step S 304 , the Controller  106  may create a RecipeDOM  110  representation of a specific structure which may then be applied against the DataDOM  108  in a manner similar to a Fixed RecipeDOM. 
   In one aspect of the system and method of the present disclosure, the Controller  106  may create a RecipeDOM  110  including directives and operations based on the data structure types and specializations identified in Step S 302 , and which may be used to convert the DataDOM  108  into a ModelObject  112  for use with a selected Process  114 . 
   In another aspect of the system and method of the present disclosure, the Controller  106  may create and insert an appropriate data dictionary portion into the newly created Dynamic RecipeDOM based on the data structure types and specializations identified in Step S 302 . The Controller  106 , upon encountering the data dictionary may populate the data dictionary, for example in the case of a yield curve object or dividend list described above, with a pair of arrays from Data  102 . This operation may be the same for both Dynamic and Fixed Recipes. As described above, it is the presence of the finite set of objects, such as data structure types and specializations, used to describe the generic instrument which allows the formation of Dynamic Recipe. 
   Numerous additional modifications and variations of the present disclosure are possible in view of the above-teachings. It is therefore to be understood that within the scope of the appended claims, the present disclosure may be practiced other than as specifically described herein. 
   Appendix A 
   A. Recipe Directives 
   1. Append
     Usage: &lt;append value=“/DefaultEDRControl”/&gt;   

   Makes a copy of the node specified by the value and inserts it as a child of the current node. 
   2. Array 
   
     
       
             
             
           
         
             
                 
                 
             
           
           
             
                 
               Usage: &lt;array key=‘expiries’ context=‘volCurve’ 
             
             
                 
               child=‘volPoint’ dt=‘Expiry’ 
             
             
                 
               sort=‘matDays’ man=‘y’&gt; 
             
             
                 
                 
             
           
        
       
     
   
   Creates an array object with the name as given by the key value. The context specifies a relocation (in this case simply to a child node). The child attribute identified the tag name of the lines that contain the data from which the array is to be constructed. The dt specifies the array element data type. Sort indicates that the array is to be sorted by that attribute value. 
   
     
       
             
             
           
         
             
                 
                 
             
           
           
             
                 
               Recipe: 
             
             
                 
               &lt;array dt = “Double” key = “rates” sort = “matDays” 
             
             
                 
               child = “curvePoint”&gt; 
             
             
                 
                &lt;double select = “@rate” percent = “Y”/&gt; 
             
             
                 
               &lt;/array&gt; 
             
             
                 
                 
             
           
        
       
     
       
       Data: Rate curve with Mat points 
     
  
   First the interpreter calls EASNodeVector::addNamedChildren( ) to add to a vector all the child nodes of borrowingCurve in current DOM node that have the tag curvePoint (the child attribute). Then EASSortedNodeVector::mergeSort( ) is called to order the nodes in that vector by the value of the matDays attribute. 
   Note that in this case, matDays is an artifice to enable sorting of the maturity periods. Maturity periods are 1M, 3M, 6M, 1Y, 3Y etc and as simple strings will not sort into the right order. The matDays is added by the stored procedure to give an ascending number on which sorting can take place by proxy. 
   A models array object of type Double (dt attribute) and of the correct size is created. The name of the array is rates. It is then populated by traversing the (now sorted) vector of nodes, applying the child of the array declaration in the recipe
 
&lt;double select=“@rate” percent=“Y”/&gt;
 
as a recipe to the node from the vector such as
 
&lt;curvepoint rate=“{number}” matDays=“1” matPeriod=“ON”/&gt;
 
   This may create a double object for the rate value of each child of the borrowCurve and adds it by index into the array object. 
   3. Boolean 
   
     
       
             
           
         
             
                 
             
           
           
             
               Usage:   &lt;boolean key=‘fwdStarting’ select=‘effective/@isFwdStart’ 
             
             
               test=‘Y’/&gt; 
             
             
               &lt;boolean key=‘accrueIRonFullNotional’ 
             
             
               select=‘accrueIRonFullNotional/@boolean’/&gt; 
             
             
               &lt;boolean value=‘0’/&gt; 
             
             
                 
             
           
        
       
     
   
   Creates a Boolean object with a name specified by key. The false/true state can be specified by value being zero or unity, or by the zero/unity value at the select location. If zero/unity are not the logical data provided, the value or select value can be compared to test value. 
   EXAMPLE 
   
       
       Recipe: &lt;boolean key=“isCall” test=“C” select=“@claim”/&gt; 
     
  
   4. Cache
     Usage: &lt;cache key=‘model’ select=‘modelType/@doc’/&gt;   

   Creates a models object with name key working from the node specified by select. The resulting object is held in cache. 
   EXAMPLE 
   
       
       Recipe: &lt;cache key=“model” select=“modelType/@doc”/&gt; 
     
  
   This creates an models object to add to the models object cache by interpreting the top-level child node with the name MP-40004399 (dataDOM line  345 ) as selected by the modelType/@doc path See the sample model object section for further details 
   5. Case
     Usage: &lt;case equals=‘ON’&gt;   

   A labeled block of statements referenced within a switch statement. See switch. It should be noted that a case statement (as with all directives) can only return one object: therefore if a case situation required multiple objects, the switch statement has to be repeated for each object. 
   6. Clonemarketcache
     Usage: &lt;clonemarketcache value=‘MarketData’ key=‘market’ man=‘y’/&gt;   

   Performs a shallow copy, with the new name of value of the key attribute, of the models market cache object named value. The man flag being ‘Y’ indicates that this copy is a mandatory requirement 
   7. Easdict 
   
     
       
             
           
         
             
                 
             
           
           
             
               Usage: 
             
             
               &lt;easdict&gt; 
             
             
                &lt;string key=“pp” value=“rm”/&gt; 
             
             
                &lt;import key=“instrument” recipe=“recipe/AssetValueRecipe.xml” /&gt; 
             
             
                &lt;cache key=‘model’ select=‘IND/modelType/@doc’ /&gt; 
             
             
               &lt;/easdict&gt; 
             
             
                 
             
           
        
       
     
   
   This is a non-models collection of models objects, i.e. a private, Analytics data dictionary and is used to hold a private collection of models objects (in this case an instrument object and a model object). 
   8. Datadict 
   
     
       
             
             
           
         
             
                 
                 
             
           
           
             
                 
               Usage: &lt;datadict value=‘PayStream’ key=‘payStream’ man=‘y’&gt; 
             
             
                 
                &lt;datadict context=‘TR1F’ value=‘Tree1fLN’&gt; 
             
             
                 
                &lt;datadict value=‘Tree1fLN’&gt; 
             
             
                 
                &lt;datadict value=‘Fund’ cache_add=“y” 
             
             
                 
                   cache_add_key_prefix=“Fund-”&gt; 
             
             
                 
                 
             
           
        
       
     
   
   This is a models object collection container. It causes a models data dictionary object to be created with the name key or causes a cached object with name value to be found. The context parameter causes the current working location in the DOM to be moved to that specified. If the object is mandatory, man is ‘y’. Implemented by EASXtoEDRModel::interpretContainerChildren( ). 
   The special case of cache_add is used to specify that this market data should also be added to the models objects cache as well as to the models market data cache. The prefix is pre-pended to the treeid tag to make a distinctive name. 
   EXAMPLE 
   
     
       
             
             
           
         
             
                 
                 
             
           
           
             
                 
               Recipe: 
             
             
                 
               &lt;datadict value = “Holiday”&gt; 
             
             
                 
                  &lt;string key = “name” select = “@fileName”/&gt; 
             
             
                 
                &lt;boolean key = “useWeekends” value = “1”/&gt; 
             
             
                 
                &lt;array dt = “DateTime” key = “holidays” man = “y” 
             
             
                 
                   child = “holiday”&gt; 
             
             
                 
                 &lt;datetime time = “EOD” select = “@holDate”/&gt; 
             
             
                 
                &lt;/array&gt; 
             
             
                 
               &lt;/datadict&gt; 
             
             
                 
               Data: 
             
             
                 
               &lt;holidayList treeid = “holiday-USEXCH” 
             
             
                 
               fileName = “holiday-USEXCH”&gt; 
             
             
                 
                &lt;holiday treeid = “holiday-USEXCH” holDate = “19991125”/&gt; 
             
             
                 
                &lt;holiday treeid = “holiday-USEXCH” holDate = “20000117”/&gt; 
             
             
                 
                &lt;holiday treeid = “holiday-USEXCH” holDate = “20000221”/&gt; 
             
             
                 
                &lt;holiday treeid = “holiday-USEXCH” holDate = “20000421”/&gt; 
             
             
                 
                 . . . 
             
             
                 
                &lt;holiday treeid = “holiday-USEXCH” holDate = “20041225”/&gt; 
             
             
                 
               &lt;/holidayList&gt; 
             
             
                 
                 
             
           
        
       
     
   
   Creates a data dictionary object of type Holiday and contains three elements:- a name string “holiday-USEXCH”, a Boolean to indicate whether to use weekends (true) and an array of dates. 
   9. Datetime 
   
     
       
             
             
           
         
             
                 
                 
             
           
           
             
                 
               Usage: &lt;datetime select=‘@datetime’/&gt; 
             
             
                 
                &lt;datetime select=‘@initialRefixDate’ time=‘EOD’/&gt; 
             
             
                 
                &lt;datetime key=‘consoliDate’ select=‘consoliDate/@datetime’/&gt; 
             
             
                 
                &lt;datetime key=‘baseDate’ select=‘../@valueDate’ 
             
             
                 
                   timepath=‘../@valuationTime’/&gt; 
             
             
                 
                 
             
           
        
       
     
       
       
         
           Creates a models datetime object. The first two formats are used in schedules where the object is anonymous (just one of the schedules dates). The value at the select location specifies the date element. The time can be hard coded or reference the value at the timepath location. The key value specifies the name of a standalone object 
         
       
     
  
   EXAMPLES 
   
     
       
             
           
         
             
                 
             
           
           
             
               Recipe: 
             
             
                &lt;datetime select = “@date” timepath = “../exchangeEvent/@dayPart”/&gt; 
             
             
               Data: (data DOM line 148) 
             
             
                &lt;strike date = “19990726” strike = “#/&gt; 
             
             
                 
             
           
        
       
     
   
   The timepath resolves to data DOM line  150   
                                           &lt;exchangeEvent spn = “0266922” ampm = “P” timing = “CLOS”               dayPart = “EOD” reuters = “N”/&gt;                        
so the datetime object will represent EndOfDay, 26 th  Jul. 1999
 
   10. Double 
   
     
       
             
             
           
         
             
                 
                 
             
           
           
             
                 
               Usage: &lt;double select=‘@initialSpot’/&gt; 
             
             
                 
                &lt;double key=‘spotFX’ select=‘@spotFX’/ 
             
             
                 
                &lt;double percent=‘Y’ select=‘@spread’/&gt; 
             
             
                 
                 
             
           
        
       
     
   
   Creates a models object containing a double value found at the select location. Key specifies the name if a standalone object (i.e. not an entry in an array/schedule). The percent parameter can be used to identify those values held in the DOM as a percentage rather than actual value. 
   EXAMPLE 
                                           Recipe: &lt;double key = “stockPrice” select = “price/@price”/&gt;           Data:           &lt;equity treeid = “equity-466”&gt;            &lt;equityI treeid = “equityI-466”&gt;             ...            &lt;/equityI&gt;            &lt;dividends treeid = “equity-466”&gt;             ...            &lt;/dividends&gt;            &lt;borrowingCurve dcc = “Actual/365F”...&gt;             ...            &lt;/borrowingCurve&gt;            &lt;price price = “#” treeid = “equity-466”              exchange = “NYSE” valuationRule = “REF”/&gt;            &lt;STK treeid = “equity-466”...&gt;            ...            &lt;/STK&gt;           &lt;/equity&gt;                        
creates a double object with a name of “stockprice” and value #
 
   PERCENT EXAMPLE 
   
       
       Recipe: &lt;double select=“@rate” percent=“Y”/&gt; 
       Data: 
       &lt;curvePoint rate=“#” matDays=“1” matPeriod=“ON”/&gt;
 
creates a models double object with value=#—i.e. rate/100.
 
     
  
   11. Doublematrix 
   
     
       
             
           
         
             
                 
             
           
           
             
               Usage: &lt;doublematrix key=‘vol’ row=‘volCurve’ point=‘volPoint’ 
             
             
                item=‘@volatility’ rowSort=‘strike’ colSort=‘matDays’ man=‘y’/&gt; 
             
             
                 
             
           
        
       
     
   
   Creates a models matrix object holding a grid of double values. The name of the object is specified by key. The row value gives the tag name of the nodes children containing the data to go into the object. The actual double value is found within those children as attribute named by item. The sequence of the rows and columns are specified by sorting the values contained in the rowSort and colSort attributes. If the object is mandatory, this s specified by man. 
   EXAMPLE 
                                           Recipe:           &lt;doublematrix key = “vol” man = “y” row = “volCurve”            item = “@volatility” point = “volPoint” colSort = “matDays”              rowSort = “strike”/&gt;                        
data:
     Volatility Curve Points−Mat days   
   A models doubleMatrix object is created 
   A vector of row nodes is created by EASNodeVector::addNamedChildren( ) picking all the volCurve nodes (i.e. the row attribute value) of which, in this case is only one node. This row vector is sorted on the strike values of each of the nodes in the vector (i.e. rowSort attribute value). The row vector is then iterated in sequence and the iterated node is then handled as an array: all the volPoint (i.e. the point attribute value) nodes are added to a temporary column vector which is then sorted using the proxy matDays (colSort attribute value). 
   In turn each volPoint node is searched for the value of the item specified attribute (volatility), and that value set at the row/col location in the matrix object. 
   12. Exists 
   
     
       
             
           
         
             
                 
             
           
           
             
               Usage &lt;exists key=‘rateDCC’ test=‘floatingRate/@DCC’&gt; 
             
             
                &lt;exists select=‘.’ key=‘startDate’ test=‘effective/@date’&gt; 
             
             
                &lt;exists context=‘dividends’ key=‘synthDivs’ test=‘dividend/@exDate’ 
             
             
                 
             
           
        
       
     
   
   Effectively a logical if statement—the child of this element are only parsed if there is an attribute at the location test but does not fail if it is missing. This path may be re-based by the select or context values. The name of an object created from the child of this exist can be specified by key although it would be more logical to give the child attribute the key entry. 
   EXAMPLE 
                                           &lt;exists key = “startDate” test = “effective/@date” select=“.”&gt;            &lt;datetime select = “effective/@date” timepath =            “effective/@dayPart”/&gt;           &lt;/exists&gt;                        
on data node
 
                                           &lt;OTC-VAN claim = “C” style = “A...&gt;            &lt;premium date = “19991124” treeid = “EQD-40004399”/&gt;            ...            &lt;effective treeid = “EQD-40004399” isFwdStart = “N”/&gt;             ...           &lt;/OTC-VAN&gt;                        
the date attribute does not exist in the effective tag so the datetime line of the recipe will not be executed.
 
   13. If
     Usage: &lt;if key=‘callDate’ test=‘@callable’ equals=‘Y’&gt;   

   A similar test as exists but will fail if the test attribute is not present. The child elements of this tag are executed if the value in test matches the value in equals. Key is the name of any object created within the sub-block. 
   EXAMPLE 
   
     
       
             
             
           
         
             
                 
                 
             
           
           
             
                 
               Recipe: 
             
             
                 
                &lt;if test = “@optionType” equals = “CVB”&gt; 
             
             
                 
                 &lt;append value = “/DefaultEDRControl”/&gt; 
             
             
                 
               &lt;/if&gt; 
             
             
                 
                 
             
           
        
       
     
   
   Here the value of the optionClass attribute is not “CVB” so the append directive will not be executed. 
   14. Import 
   
     
       
             
           
         
             
                 
             
           
           
             
               Usage: &lt;import key=“instrument” recipe=“recipe/compRecipe.xml”/&gt; 
             
             
                   &lt;import context=‘samples’ 
             
             
                  recipe=‘recipe/SampleListRecipe.xml’/&gt; 
             
             
                 
             
           
        
       
     
   
   Causes the specified recipe to be parsed at this point. Effectively a function call. Optionally can transfer the current data node to context. Each import creates its own private interpreter in order to preserve the outer, calling, interpreter. DOMs created from recipes are held in a cache to avoid repeated recipe file reads &amp; transformation into DOMs. 
   15. Integer 
   
     
       
             
             
           
         
             
                 
                 
             
           
           
             
                 
               Usage: &lt;integer value=‘5000’/&gt; 
             
             
                 
                &lt;integer key=‘accrueDivType’ value=‘0’/&gt; 
             
             
                 
                  &lt;integer key=‘payStyle’ select=‘@payStyle’/&gt; 
             
             
                 
                &lt;integer key=“offset” variable=“@className” variable_select= 
             
             
                 
                 ‘../../controlOverride/$variable$/shift/@offset’/&gt; 
             
             
                 
                 
             
           
        
       
     
   
   Creates a models object holding an integer value specified either literally by value or by the content of the select attribute. The name of the standalone object can be given by key. The last form is a special parameterized selected statement. The expression $variable$ is replaced by the content of the variable attribute. 
   EXAMPLE 
   
     
       
             
             
           
         
             
                 
                 
             
           
           
             
                 
               Recipe: &lt;integer key = “period” select = “eqSettleRoll/@period”/&gt; 
             
             
                 
               Data: 
             
             
                 
                &lt;eqSettleRoll period = “3” /&gt; 
             
             
                 
                 
             
           
        
       
     
   
   Creates an integer object with name “period” and value  3 . 
   16. Marketcache 
   
     
       
             
             
           
         
             
                 
                 
             
           
           
             
                 
               Usage: &lt;marketcache select=‘@currency’/&gt; 
             
             
                 
                &lt;marketcache key=‘marketHols’ value=‘holiday-NONE’ 
             
             
                 
                &lt;marketcache key=‘discount’ select=‘ccyLink/@ref’/&gt; 
             
             
                 
                 
             
           
        
       
     
   
   Reuses or creates a models object that is held in/passed to the models market data cache (i.e. not held within the Analytics cache). The select attribute value is referenced so models internally extract that named object or an object is created with the name given by key parsing the node specified by select. The key is ignored. 
   The market cache is held within the library and other than being able to add objects, it may be inaccessible. This means that it may not be interrogated to discover if an object already exists. In order to avoid duplicate constructions, may keep separate list of the names of objects put into their cache 
   EXAMPLE 
   
     
       
             
           
         
             
                 
             
           
           
             
               Recipe:   &lt;marketcache key = “hols” select = “eqSettleHol/@ref”/&gt; 
             
             
               Data: 
             
             
               &lt;eqSettlement bdc = “None” delivery = “physical” exchange = “NYSE”&gt; 
             
             
                &lt;eqSettleHol ref = “holiday-USEXCH” treeid = “equityI-466”/&gt; 
             
             
                &lt;eqSettleRoll period = “3” treeid = “equityI-466” effDate = 
             
             
                “19940101”/&gt; 
             
             
                &lt;eqSettlementType treeid = “equityI-466” settleType = “T”/&gt; 
             
             
               &lt;/eqSettlement&gt; 
             
             
                 
             
           
        
       
     
       
       
         
           Creates (assuming not previously created &amp; cached) a models object by parsing the “holiday-USEXCH” top-level child node (data DOM line  244 ) 
         
       
     
  
   17. Maturityperiod
     Usage: &lt;maturityperiod select=‘@matPeriod’/&gt;   

   Gets the maturity bucket value (‘1M’, ‘3M’, ‘20Y’ etc) value specified by the attribute at select. 
   EXAMPLES 
   
     
       
             
             
           
         
             
                 
                 
             
           
           
             
                 
               Recipe: &lt;maturityperiod select = “@matPeriod”/&gt; 
             
             
                 
               Data:  &lt;curvePoint rate = “#” matDays = “X” 
             
             
                 
                  matPeriod = “1M”/&gt; 
             
             
                 
                 
             
           
        
       
     
   
   Creates a models object of type maturityPeriod with a value of “1M”. 
   18. Mattimeperiod 
   
     
       
             
           
         
             
                 
             
           
           
             
               Usage: &lt;mattimeperiod select=‘@matPeriod’ time=‘EOD’/&gt; 
             
             
                &lt;mattimeperiod key=‘expiry’ select=‘@matPeriod’ time=‘EOD’/&gt; 
             
             
                 
             
           
        
       
     
   
   Creates a models object holding a maturity date time. The object holds the bucket label of the select attribute with a time-of-day flag given by the time value. The name of the object can be specified by key. 
   EXAMPLE 
   
     
       
             
             
           
         
             
                 
                 
             
           
           
             
                 
               Recipe: &lt;mattimeperiod time = “EOD” select = “@matPeriod”/&gt; 
             
             
                 
               Data: &lt;volPoint matDays = “7” matPeriod = “1W” 
             
             
                 
                volatility = “#”/&gt; 
             
             
                 
                 
             
           
        
       
     
   
   Creates a models maturity time period object with values ‘1W’ and ‘EOD’ (from the time attribute value) 
   19. Mudates
     Usage: &lt;mudates key=‘expiries’ value=‘SPECIAL’/&gt;   

   Creates a models object identifying a set of MU dates with the name given by key and the set of dates identified by value text. 
   20. String 
   
     
       
             
             
           
         
             
                 
                 
             
           
           
             
                 
               Usage: &lt;string key =‘interp’ value=‘N’/&gt; 
             
             
                 
                &lt;string key=‘period’ select=‘@matPeriod’/&gt; 
             
             
                 
                 
             
           
        
       
     
   
   Creates a models object containing the string text given by value or the value of the select attribute. 
   EXAMPLES 
   
       
       &lt;string key=“pp” value=“rm”/&gt; 
     
  
   Creates a models string object containing “rm” 
   
     
       
             
             
           
         
             
                 
                 
             
           
           
             
                 
               Recipe: &lt;string key = “name” select = “@fileName”/&gt; 
             
             
                 
               Data:  &lt;holidayList treeid = “holiday-NONE” fileName = 
             
             
                 
               “holiday-NONE”/&gt; 
             
             
                 
                 
             
           
        
       
     
   
   The string object has the name ‘name’ and text “holiday-NONE” from the filename attribute. (Originally holiday lists were held in files hence the legacy of ‘filename’) 
   21. Switch 
   
     
       
             
             
           
         
             
                 
                 
             
           
           
             
                 
               Usage: &lt;switch test=‘@averagingType’&gt; 
             
             
                 
                 &lt;switch key=‘rateBadDayConv’ test=‘@bdc’&gt; 
             
             
                 
                 &lt;switch test=“&amp;lt;NAME&amp;gt;” hash=‘y’&gt; 
             
             
                 
                 
             
           
        
       
     
   
   Performs the function of, for example, a C++/Java switch statement where block of statements identified by a case label, denoted by the equals value, that matches the test value. The name of an object created within that case block can be named via key. Note: whilst there is support for a default case, this should only be used to flag an error. Also, the concept of ‘fallthrough’ may not exist so there are no ‘break’ statements. 
   The hash variant is a special situation, may be used only in the metaRecipe, to denote that the necessary node may already be in the meta recipe cache &amp; should be added on creation if not. Note the &amp;lt; and &amp;gt; are special XML directives to specify the &lt;and&gt; symbol within text fields. 
   EXAMPLE 
   
     
       
             
             
           
         
             
                 
                 
             
           
           
             
                 
               Recipe: 
             
             
                 
               &lt;switch key = “Asset” test = “equityI/illiquidEquity/@illiquid”&gt; 
             
             
                 
                &lt;case equals = “Y”&gt; 
             
             
                 
                 &lt;import recipe = “recipe/IlliquidStockRecipe.xml”/&gt; 
             
             
                 
                &lt;/case&gt; 
             
             
                 
                &lt;case equals = “N”&gt; 
             
             
                 
                 &lt;import recipe = “recipe/equityRecipe.xml”/&gt; 
             
             
                 
                &lt;/case&gt; 
             
             
                 
                &lt;default&gt; 
             
             
                 
                 &lt;writetolog text = “Unknown illiquidEquity 
             
             
                 
                 flag: ” select = “equityI/illiquidEquity/@illiquid”/&gt; 
             
             
                 
                &lt;/default&gt; 
             
             
                 
               &lt;/switch&gt; 
             
             
                 
                 
             
           
        
       
     
   
   Note: data happens to be duplicated, takes first one only. In this case the test value is ‘N’ so the equityRecipe will be imported, not the IlliquidStockRecipe. 
   22. Writetololg
     Usage: &lt;writetolog text=‘Unknown weightType:’ select=‘@(weightType’/&gt;   

   Causes an entry to be written into the log file, reporting the text information augmented with the value of the select attribute. 
   23. Xlatrecipe 
   Denotes a recipe. The interpreter calls EASXtoEDRModel::interpretChild( ) to traverse all the child nodes of the recipe and apply to the current data node

Technology Category: 4