XBRLInstance and XBRLmapper: Difference between pages

From XBRLWiki
(Difference between pages)
Jump to navigationJump to search
 
 
Line 1: Line 1:
[[http://www.reportingstandard.com/apidoc/com/ihr/xbrl/om/instance/XBRLInstance.html XBRLInstance javadoc page]]
[[File:XBRLMapperMain.png|thumb|right|XBRL Mapper tool main window]]
===Description===
An XBRLInstance object represents the content of an XBRL Report. This is:


* all XBRL facts , and
==Product page==
* all XBRL contexts, and
* all XBRL units, and
* all Footnote Linkbases, and
* all references to XBRLTaxonomies, XBRLLinkbases, XBRLRoleRef and XBRLArcroleRef required for obtaining the DTS.


===How to create an instance of an XBRLInstance object===
[[http://www.reportingstandard.com/XBRL_Mapper.xhtml XBRL Mapper product page]]


There are several ways depending on what you are doing:
[[File:XBRLMapperIcon.png|none|left|XBRL Mapper tool icon]]


* If the user have just created a new empty [[DTSContainer]] object and the purpose is to read the content of an XBRL report (and the whole referenced DTS) then the simplest way is to use one of the load methods in the [[DTSContainer]] object passing the document URI of the XBRL report. The returned object is an XBRLDocument that can be casted to an XBRLInstance.
==Description==


* If the user has already loaded a DTS (from a taxonomy file) and the purpose is to create a new XBRLInstance (in order to populate it with facts) then the user can use any of the available [http://www.reportingstandard.com/apidoc/com/ihr/xbrl/om/instance/XBRLInstance.html#constructor_summary constructors]. The most commonly used constructor is [http://www.reportingstandard.com/apidoc/com/ihr/xbrl/om/instance/XBRLInstance.html#XBRLInstance(com.ihr.xbrl.om.DTSContainer) XBRLInstance(com.ihr.xbrl.om.DTSContainer)] that accepts the current DTSContainer as a parameter and allows the user to start adding facts programatically.
XBRLmapper is a sophisticated tool that transfers data from information systems to XBRL reports and from XBRL reports to other systems. It supports then two different purposes:


Creation of a XBRLInstance object from a local file name:
# Automatic generation of XBRL reports from different data sources
<syntaxhighlight lang="java">
# Automatic extraction of data from XBRL reports and data loading into different repositories
/**
* Sample, a new instance document is read form the file received as a parameter
* After the instance object is obtained, the user can start working with it
*/
public class SampleReadInstance {


public static void main(String[] args) throws Exception {
Both products share a similar architecture. Both are based on a common definition of ''data events'' connected with the XBRL side and specific ''drivers'' that attend the data events. Both sides (''definition of events'', and ''drivers'') can be configured using XML files. This architecture has multiple advantages:
DTSContainer dts = DTSContainer.newEmptyContainer();
XBRLInstance instance = (XBRLInstance)dts.load(new File(args[0]).toURI());
// ... rest of the application code goes here
}
}
</syntaxhighlight>


Creation of a new instance document for a DTS after the DTS has been loaded:
# Isolates the complexity of the XBRL technology in one part (the definition of the data events). If there are changes in the taxonomy, the user may need to change just the definition of the data events
<syntaxhighlight lang="java">
# Isolates the complexity of the internal data repositories. Each one of the data repositories can be accessed by an instantiation of a driver
/**
# Each driver has his own configuration file
* Sample, a new instance document is created after the DTS has been loaded
# Drivers are defined for the repository data format
*/
# The generation of an XBRL report may involve several drivers looking at data in different repositores simultaneously
public class SampleCreateInstanceForDTS {
# The same event could be potentially attended by more than one driver if this is required
# Multiple drivers of the same repository type can be used concurrently


public static void main(String[] args) throws Exception {
The XBRL mapper is a software component that can be launched from a GUI or can be integrated in a workflow. The integration requires development of code (in Java or .NET)
DTSContainer dts = DTSContainer.newEmptyContainer();
dts.load(new File("sampleTaxonomy.xsd").toURI());
XBRLInstance instance = new XBRLInstance(dts);
// ... rest of the application code goes here
}
}
</syntaxhighlight>


===Working with facts in an XBRLInstance===
==Generating XBRL (Mapper)==


This section describes two abstract operations that the user can execute on XBRLInstance objects regardless the way they have been created.
Generating XBRL reports is one of the operations for which the mapper was conceived. In this documentation Mapping is the process of obtaining data from data repositories in order to create an XBRL report.


The XBRLInstance object is able to automatically change in order to keep consistency during operations. For example, the action of adding a new XBRLFact item to the XBRLInstance may automatically add a new context or may reuse an existing context instead. The same happens with the unit and with the reference to the required taxonomy schema. Removing facts from the XBRLInstance is also an operation that keeps the instance document content consistent while silently removes content that is no longer used (like unused units or contexts etc).
The XBRL Mapper product designed by Reporting Standard S.L. can be used in the most complex scenarios. The XBRL Mapper is robuts, powerful and flexible.


====Read access====
* Robust because it is based on a native XBRL API that supports 100% Conformance level with XBRL Validation
* Powerful because it is based on an architecture that allows the users to plug-in drivers prepared to read different data sources and prepare combinations of data sources attending "mapping events".
* Flexible because it allows users to easily migrate to new taxonomies by just changing the instance document template but maintaining the same "mapping event" names and driver configurations. Or to adapt the system to obtain data from different data sources while using the same target taxonomy.


Read access of facts in an XBRLInstance is an abstract operation implemented in several methods. The content of an XBRLInstance can be accessed in two modes: '''sequential mode''' and '''indexed mode'''. Both modes serves different purposes while working with data in an XBRLInstance. Both are described in the [[XBRLFactsList]] interface.
The configuration of the mapping engine requires then two steps:


In this example, the content of the XBRLInstance document is sequentially accessed in document order:
# Preparing an instance document template. This is the definition of "mapping events"
<syntaxhighlight lang="java">
# Preparing the configuration file for the driver(s) attending "mapping events"
Iterator<XBRLFact> iterF = instance.iterator();
while (iterF.hasNext()) {
XBRLFact fact = iterF.next();
// ... do some work with the fact
}
</syntaxhighlight>


====Write access====
===The instance document template===


Creating a fact is a very simple task. The user just need to call the apropriate constructor depending on the type of fact to be created. The final fact types that the user can directly create are:
The instance document template is the configuration file where the "mapping events" are defined. As the name suggest, the instance document template resembles an XBRL report but it is parameterized in order to turn each one of the facts in a report into a "mapping event". It is important to notice that while the instance document template may have just one fact for a concept definition in the taxonomy, the response from drivers about requesting data for one mapping event may be multiple facts and, if this is the case, the final output file will have multiple facts as a result of multiple data items for the same mapping event.


* [[XBRLFactNonNumeric]]
The creation of an initial instance document template is a straingt forward process that can be initiated from two different sources, the file can be adapted to cover more complex mapping scenarios later.
* [[XBRLFactNumeric]]
* [[XBRLFactTuple]]


The API takes care automatically of the consistency inside the XBRLInstance when the user do operations with facts; for example, the action of creating a new fact automatically performs the operation of adding the new fact to the fact container (instance or tuple), take care of the fact context and unit (if it is necessary), add the taxonomy reference to the DTS if it is not in the current DTS, etc. The programmer does not need to worry about how to keep consistency in the content of the XBRLInstance object. Note that consistency does not imply XBRL Validation.
The [[XBRL Template File]] page on this wiki explains the format of the template files and how the user can create their own files for more complex mapping scenarios.


All objects representing facts above are non abstract objects in the fact object hierarchy. Objects up in the hierarchy contains shared functionalty in order to make the non abstract object meaningful. See the javadoc documentation of each one of the objects in order to learn more about the hierarchy.
====From a DTS (A set of Taxonomies and Linkbases)====


The following example contains several lines of code in order to create the auxiliary objects first. Then a new XBRLFactNonNumeric fact is created. In the last line of the code, a value is assigned to the new created fact.
In this case, the instance document template will be generated according to all concept definitions that exists in the DTS (all taxonomy schemas providing item and tuple definitions for the DTS). If the purpose of the instance document template is just the concepts in a specific presentation hierarchy it would be more interesting prepating a sample instance document and convert the sample report into an instance document template (See the next section).
<syntaxhighlight lang="java">
  // create a context for the instant "Begning of year 2008"
  XBRLEntity ent = new XBRLEntity(dts,"http://www.xbrl.org/scheme","Sample Company",null);
  XBRLPeriod p = new XBRLPeriod(dts,"2008-01-01");
  XBRLContext ctx = new XBRLContext(dts,ent,p,null);
  // Obtain the concept definition of concept "A" from the DTS
  XBRLItem itemA = (XBRLItem)dts.getConcept(new QName(ns,"A"));
  // create the Non Numeric (Text) fact item
  XBRLFactNonNumeric fA = new XBRLFactNonNumeric(instance,ctx,itemA);


  // fA is nil until a value is assigned
So, the creation of an instance document template from a complete DTS may generate a template with lots of events. The user should use this option if he is absolutely sure this is the way to go.
  fA.setValue(new StringValue("sample text value"));
</syntaxhighlight>


In this example, a new XBRLNumericFact is added to the XBRLInstance. The creation of the auxiliary objects has been omitted.
Steps to produce the initial template file:
<syntaxhighlight lang="java">
# Open Loader Editor tool
  // create the Non Numeric (Text) fact item
# In the "Mapper" menu, select the "New Template from DTS" option
  XBRLFactNonNumeric fA = new XBRLFactNonNumeric(instance,ctx,itemA);
# In the [[Compose DTS]] dialog, select the required files
# Make sure there is a template file name in the [[Simple Instance Document Template Dialog|dialog to generate a simple instance document template]]. The file name extension should be (*.xbrlt).
# Make sure there is one initial data source in the [[Simple Instance Document Template Dialog|dialog to generate a simple instance document template]] (more data sources can be added later).
# A template will be generated and loaded into the XBRLMapper main window.


  // fA is nil until a value is assigned
====From a sample XBRL report====
  fA.setValue(new StringValue("test"));
</syntaxhighlight>


===Managing the elements that compose the DTS===
In this case, the instance document template will be generated according to the facts that already exists in an XBRL Report. The XBRLMapper tool will take the instance document and will prepare an [[XBRL Template File]] for all facts that exists in the instance.


In normal circumnstances the user should never care about dealing with elements that compose the DTS of the XBRLInstance document. The required elements will be added automatically when you create the XBRLInstance object using a dts as a parameter and at the time you add facts to the instance document. This is particularly true for all required XBRL taxonomies used by concepts in the XBRLInstance, all required XBRL taxonomies where role types used in footnote extended link containers are defined and all required XBRL taxonomies where arcrole types used in relationships in the footnote extended link containers are defined. But, there is one (very rare) use case left that is when the user wants to add a custom existing linkbase to the DTS of the report that is not part of the DTS discovered by the taxonomy schemas already referenced. In this case, it is still possible adding those linkbases using any of the following two methods:
This process generates a template with just the facts that exists in the instance document provided as a parameter. Hint: if the user wants to create an instance document according to the content of one single presentation linkbase, the user can use the XBRLizer tool in order to generate a sample instance document for the presentation tree and then use that file as input for the process of creating the instance document template.


[http://www.reportingstandard.com/apidoc/com/ihr/xbrl/om/instance/XBRLInstance.html#addXBRLDocument(com.ihr.xbrl.om.XBRLDocument,%20com.ihr.xbrl.om.taxonomy.XBRLRoleAndArcroleTypes) addXBRLDocument(com.ihr.xbrl.om.XBRLDocument, com.ihr.xbrl.om.taxonomy.XBRLRoleAndArcroleTypes)]
Steps to produce the initial template file:
# Open Loader Editor tool
# In the "Mapper" menu, select the "New Template from Instance" option
# Find the XBRL Report that must be a local file
# Make sure there is a template file name in the [[Simple Instance Document Template Dialog|dialog to generate a simple instance document template]]. The file name extension should be (*.xbrlt).
# Make sure there is one initial data source in the [[Simple Instance Document Template Dialog|dialog to generate a simple instance document template]] (more data sources can be added later).
# A template will be generated and loaded into the XBRLMapper main window.


or
===Editing instance document templates===


[http://www.reportingstandard.com/apidoc/com/ihr/xbrl/om/instance/XBRLInstance.html#addXBRLDocumentIfNotInDTS(com.ihr.xbrl.om.XBRLDocument,%20com.ihr.xbrl.om.taxonomy.XBRLRoleAndArcroleTypes) addXBRLDocumentIfNotInDTS(com.ihr.xbrl.om.XBRLDocument, com.ihr.xbrl.om.taxonomy.XBRLRoleAndArcroleTypes)]
The [[XBRL Template File]] page on this wiki explains the format of the template files and how the user can create their own files for more complex mapping scenarios. For complex mapping scenarios the mapping file needs to be edited in an XML Editor.


===Working with contexts===
===Drivers===


===Working with units===
The vast majority of use cases for mapping can be implemented using one of the generic drivers already developed by Reporting Standard S.L. For special use cases it is always possible to develop specific drivers in Java or .NET programming languages


===Working with footnotes===
List of available generic drivers:
* [[Excel data source driver]]
* [[CSV data source driver]]
* [[Relational database data source driver]]
* [[XBRL data source driver]]
* [[Web form data source driver]]


The user can create footnote containers in an XBRLInstance object. Footnote containers will hold all required elements in order to link the footnote text (in plain text or xhtml format) to a particular fact in the instance (the fact can be numeric, non numeric or a tuple).
===Running the template===


Creating a footnote requires some initial work on the XBRLInstance:
The [[Mapper engine|Mapper engine wiki page]] contains an explanation about the two modes of operation:
* as a software component, or
* called from the XBRLmapper GUI


====Create the footnotes container====
At this stage we assume the user has already finished the creation of an [[XBRL Template File]] as explained in the previous chapters. In general, the process requires following steps:


A footnotes container is an XLink extended link container for XBRL footnotes. In order to create the container the user must first get the desired role type from the DTS and then call the FootnoteLinkbase constructor with the required parameters.
# Creating a simple instance document template
# Create some raw data in Excel and map it
# Use the XBRLMapper GUI in order to produce an XBRL report


Here is an example about how to get the standard role URI from the [[DTSContainer]] object and then create an extended link for footnotes
The process may look hard if it is the first time you do it but remember you are preparing templates and the idea is to reuse the same templates multiple times in the future once the templates and the mapping configuration files are there, the process of producing a new report is much simpler than the first time you go through it.
<syntaxhighlight lang="java">
  XBRLRoleType role = dts.getStaticRoleTypeByURI(XBRLExtendedLink.standard_role_URI);


  // Now create a container for footnotes (Footnote Extended Link)
We continue now with the missing chapters but we are going to link with the relevant chapters also in the specific pages for the drivers.
  FootnoteLinkbase fl = new FootnoteLinkbase(instance, role);
</syntaxhighlight>


====Create the footnote resource====
====Create some raw data in Excel and map====


Reporting Standard API does not contain a specific resource type for footnotes. Footnote resources can be created using the base [[XBRLResource]] object from the API.
If you want to see how other drivers works find the explanation in the specific driver page.


The following example demonstrates how to do it. Note that the creation of the resource requires other parameters that we have just explained how to create in this document. According to the parameters indicated in the example, the resource will be added to the parent footnote extended link container at the moment it is created. See the [[XBRLResource]] page for more information about the parameters.
First thing you need is the excel XBRL mapping plug-in. This plug-in is able to read the content of an [[XBRL Template File]] and show the user all events suitable to be used from Excel. For installation instruction of the plug-in please contact Reporting Standard.


<syntaxhighlight lang="java">
Press the Load... button and open the [[XBRL Template File]]. Then, open the excel spreadsheet you want to map to XBRL. The mapping can be implemented in two ways:
  // Create a Footnote resource and add it to the fl container
* Using excel names for cells (and forcing the creation of names if names do not exists)
  XBRLResource footnoteRes = new XBRLResource(fl,FootnoteLinkbase.lbResource,true);
* Using excel cell address of the type Sheet1!C3


  // As footnotes can have simpleType content and complexType content (xhtml) the default is
Once you have both things open, just select on the right the event to map and drag & drop the name to the cell with the data. The mapping will be stored in the Excel driver configuration file. If you have forced the creation of cell names, at the end of the work you'll have to save both, the excel file and the driver configuration files. If the user has not modified excel because mapping has been created only to cell addresses then the user should just save the configuration file for the mapper.
  // complexType content. So we now force the resource to have simple type content.
  footnoteRes.setSimpleType();


  // Footnote resource requires some values to be set
The advantage of not storing information in the excel spreadsheet is that the same mapping configuration file can be used with new excel spreadsheets without having to do anything else with the excel file. The excel could be generated by an external tool automatically.
  footnoteRes.setValue(new StringValue("Footnote content"));
  footnoteRes.setLang("en");
</syntaxhighlight>


====Create the relationship linking the fact with the footnote====
The advantage of mapping to cell names rather than cell addresses is that after mapping is finished the user can still add rows and columns to the excel spreadsheet. The mapping will continue working as usual.


Finally, a relationship will join the fact in the report with the footnote resource. Creating a relationship requires providing some parameters we have already defined in this page. See the XBRL 2.1 specification for more information about the standard arcroles defined there.
====Use the XBRLMapper GUI in order to produce an XBRL report====


<syntaxhighlight lang="java">
This process is explained in the [[Mapper engine|mapper engine wiki page]].
  // Create a relationship linking the fact with the footnote.
  XBRLArcroleType fact_footnote = dts.getStaticArcroleTypeByURI(FootnoteLinkbase.fact_footnote_arcrole_URI);
  new XBRLRelationship(fl,FootnoteLinkbase.standard_arc,fA,footnoteRes,fact_footnote,null,true);
</syntaxhighlight>


====Cheking if a fact contains footnotes====
==Moving XBRL data (Loader)==


The user can check if a fact in an instance contains footnotes by traversing the existing relationships of which the fact is the source and the arcrole type of the relationship is the standard arcrole for linking facts with footnotes '''<nowiki>http://www.xbrl.org/2003/arcrole/fact-footnote</nowiki>'''
===The definition of the loading events===


The following piece of source code demonstrates how to do it:
===Drivers===


<source lang="java" lines="LINES">
==Navigate==
  // First obtains the standard arcrole type from the DTS Container
[[Main Page]]
  XBRLArcroleType art = dts.getArcroleType(FootnoteLinkbase.fact_footnote_arcrole_URI);
 
  Iterator<XBRLFact> iterF = instance.iterator();
  while (iterF.hasNext()) {
    XBRLFact fact = iterF.next();
 
    Iterator<XBRLRelationship> iterR = fact.getFromRelationships(art);
    while (iterR.hasNext()) {
      XBRLRelationship r = iterR.next();
      XMLFragment f = r.getTo();
      System.out.println("Fact \""+fact.getElementDefinition().getQName()+"\" has note \""+f.getStringValue()+"\"");
    }
  }
</source>
 
====Reading footnotes in an XBRLInstance====
 
===Navigation===
[[Main Page]] | [[XBRL API related discussions]]

Revision as of 10:56, 8 October 2009

File:XBRLMapperMain.png
XBRL Mapper tool main window

Product page

[XBRL Mapper product page]

XBRL Mapper tool icon

Description

XBRLmapper is a sophisticated tool that transfers data from information systems to XBRL reports and from XBRL reports to other systems. It supports then two different purposes:

  1. Automatic generation of XBRL reports from different data sources
  2. Automatic extraction of data from XBRL reports and data loading into different repositories

Both products share a similar architecture. Both are based on a common definition of data events connected with the XBRL side and specific drivers that attend the data events. Both sides (definition of events, and drivers) can be configured using XML files. This architecture has multiple advantages:

  1. Isolates the complexity of the XBRL technology in one part (the definition of the data events). If there are changes in the taxonomy, the user may need to change just the definition of the data events
  2. Isolates the complexity of the internal data repositories. Each one of the data repositories can be accessed by an instantiation of a driver
  3. Each driver has his own configuration file
  4. Drivers are defined for the repository data format
  5. The generation of an XBRL report may involve several drivers looking at data in different repositores simultaneously
  6. The same event could be potentially attended by more than one driver if this is required
  7. Multiple drivers of the same repository type can be used concurrently

The XBRL mapper is a software component that can be launched from a GUI or can be integrated in a workflow. The integration requires development of code (in Java or .NET)

Generating XBRL (Mapper)

Generating XBRL reports is one of the operations for which the mapper was conceived. In this documentation Mapping is the process of obtaining data from data repositories in order to create an XBRL report.

The XBRL Mapper product designed by Reporting Standard S.L. can be used in the most complex scenarios. The XBRL Mapper is robuts, powerful and flexible.

  • Robust because it is based on a native XBRL API that supports 100% Conformance level with XBRL Validation
  • Powerful because it is based on an architecture that allows the users to plug-in drivers prepared to read different data sources and prepare combinations of data sources attending "mapping events".
  • Flexible because it allows users to easily migrate to new taxonomies by just changing the instance document template but maintaining the same "mapping event" names and driver configurations. Or to adapt the system to obtain data from different data sources while using the same target taxonomy.

The configuration of the mapping engine requires then two steps:

  1. Preparing an instance document template. This is the definition of "mapping events"
  2. Preparing the configuration file for the driver(s) attending "mapping events"

The instance document template

The instance document template is the configuration file where the "mapping events" are defined. As the name suggest, the instance document template resembles an XBRL report but it is parameterized in order to turn each one of the facts in a report into a "mapping event". It is important to notice that while the instance document template may have just one fact for a concept definition in the taxonomy, the response from drivers about requesting data for one mapping event may be multiple facts and, if this is the case, the final output file will have multiple facts as a result of multiple data items for the same mapping event.

The creation of an initial instance document template is a straingt forward process that can be initiated from two different sources, the file can be adapted to cover more complex mapping scenarios later.

The XBRL Template File page on this wiki explains the format of the template files and how the user can create their own files for more complex mapping scenarios.

From a DTS (A set of Taxonomies and Linkbases)

In this case, the instance document template will be generated according to all concept definitions that exists in the DTS (all taxonomy schemas providing item and tuple definitions for the DTS). If the purpose of the instance document template is just the concepts in a specific presentation hierarchy it would be more interesting prepating a sample instance document and convert the sample report into an instance document template (See the next section).

So, the creation of an instance document template from a complete DTS may generate a template with lots of events. The user should use this option if he is absolutely sure this is the way to go.

Steps to produce the initial template file:

  1. Open Loader Editor tool
  2. In the "Mapper" menu, select the "New Template from DTS" option
  3. In the Compose DTS dialog, select the required files
  4. Make sure there is a template file name in the dialog to generate a simple instance document template. The file name extension should be (*.xbrlt).
  5. Make sure there is one initial data source in the dialog to generate a simple instance document template (more data sources can be added later).
  6. A template will be generated and loaded into the XBRLMapper main window.

From a sample XBRL report

In this case, the instance document template will be generated according to the facts that already exists in an XBRL Report. The XBRLMapper tool will take the instance document and will prepare an XBRL Template File for all facts that exists in the instance.

This process generates a template with just the facts that exists in the instance document provided as a parameter. Hint: if the user wants to create an instance document according to the content of one single presentation linkbase, the user can use the XBRLizer tool in order to generate a sample instance document for the presentation tree and then use that file as input for the process of creating the instance document template.

Steps to produce the initial template file:

  1. Open Loader Editor tool
  2. In the "Mapper" menu, select the "New Template from Instance" option
  3. Find the XBRL Report that must be a local file
  4. Make sure there is a template file name in the dialog to generate a simple instance document template. The file name extension should be (*.xbrlt).
  5. Make sure there is one initial data source in the dialog to generate a simple instance document template (more data sources can be added later).
  6. A template will be generated and loaded into the XBRLMapper main window.

Editing instance document templates

The XBRL Template File page on this wiki explains the format of the template files and how the user can create their own files for more complex mapping scenarios. For complex mapping scenarios the mapping file needs to be edited in an XML Editor.

Drivers

The vast majority of use cases for mapping can be implemented using one of the generic drivers already developed by Reporting Standard S.L. For special use cases it is always possible to develop specific drivers in Java or .NET programming languages

List of available generic drivers:

Running the template

The Mapper engine wiki page contains an explanation about the two modes of operation:

  • as a software component, or
  • called from the XBRLmapper GUI

At this stage we assume the user has already finished the creation of an XBRL Template File as explained in the previous chapters. In general, the process requires following steps:

  1. Creating a simple instance document template
  2. Create some raw data in Excel and map it
  3. Use the XBRLMapper GUI in order to produce an XBRL report

The process may look hard if it is the first time you do it but remember you are preparing templates and the idea is to reuse the same templates multiple times in the future once the templates and the mapping configuration files are there, the process of producing a new report is much simpler than the first time you go through it.

We continue now with the missing chapters but we are going to link with the relevant chapters also in the specific pages for the drivers.

Create some raw data in Excel and map

If you want to see how other drivers works find the explanation in the specific driver page.

First thing you need is the excel XBRL mapping plug-in. This plug-in is able to read the content of an XBRL Template File and show the user all events suitable to be used from Excel. For installation instruction of the plug-in please contact Reporting Standard.

Press the Load... button and open the XBRL Template File. Then, open the excel spreadsheet you want to map to XBRL. The mapping can be implemented in two ways:

  • Using excel names for cells (and forcing the creation of names if names do not exists)
  • Using excel cell address of the type Sheet1!C3

Once you have both things open, just select on the right the event to map and drag & drop the name to the cell with the data. The mapping will be stored in the Excel driver configuration file. If you have forced the creation of cell names, at the end of the work you'll have to save both, the excel file and the driver configuration files. If the user has not modified excel because mapping has been created only to cell addresses then the user should just save the configuration file for the mapper.

The advantage of not storing information in the excel spreadsheet is that the same mapping configuration file can be used with new excel spreadsheets without having to do anything else with the excel file. The excel could be generated by an external tool automatically.

The advantage of mapping to cell names rather than cell addresses is that after mapping is finished the user can still add rows and columns to the excel spreadsheet. The mapping will continue working as usual.

Use the XBRLMapper GUI in order to produce an XBRL report

This process is explained in the mapper engine wiki page.

Moving XBRL data (Loader)

The definition of the loading events

Drivers

Navigate

Main Page

Retrieved from "https://reportingstandard.com/wiki/index.php?title=XBRLInstance&oldid=155"