Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package pt.webdetails.cda.settings;
  
  import java.util.HashMap;
  import java.util.List;
  import java.util.Map;
  
 
 import  org.apache.commons.logging.Log;
 import  org.apache.commons.logging.LogFactory;
 import  org.dom4j.Document;
 import  org.dom4j.DocumentFactory;
 import  org.dom4j.Element;
 import  org.pentaho.reporting.libraries.resourceloader.ResourceKey;
CdaSettings class

Created by IntelliJ IDEA. User: pedro Date: Feb 2, 2010 Time: 2:41:44 PM

 
 public class CdaSettings {
 
   private static final Log logger = LogFactory.getLog(CdaSettings.class);
   private String id;
   private ResourceKey contextKey;
   private Element root;
   private Document genDoc;
  
  
  
Creates a representation of an existing CDA file.

Parameters:
doc - XML document
id - File id
key - Context key - representation of the id in the solution rep.
Throws:
UnsupportedConnectionException
UnsupportedDataAccessException
 
   public CdaSettings(final Document doc,
           final String id,
           final ResourceKey keythrows UnsupportedConnectionExceptionUnsupportedDataAccessException {
 
     this. = key;
     this. = id;
     this. = doc.getRootElement();
 
      = new HashMap<StringConnection>();
      = new HashMap<StringDataAccess>();
 
     parseDocument();
 
   }

  
Creates a representation of a CDA via API

Parameters:
id
key
Throws:
UnsupportedConnectionException
UnsupportedDataAccessException
  public CdaSettings(final String id,
          final ResourceKey key) {
    this. = key;
    this. = id;
     = DocumentFactory.getInstance().createDocument("UTF-8");
    .addElement("CDADescriptor");
    this. = .getRootElement();
     = new HashMap<StringDataAccess>();
  }
  
  public CdaSettings(final String idfinal ResourceKey keyboolean garbage) {
    this. = key;
    this. = id;
     = new HashMap<StringDataAccess>();
  }
  public TableModel listQueries(DiscoveryOptions discoveryOptions) {
    return TableModelUtils.dataAccessMapToTableModel();
  }
    // 1 - Parse Connections
    // 2 - Parse DataAccesses
    .debug("Creating CdaSettings - parsing document");
    .debug("CdaSettings created successfully");
  }
  
  
  private DataAccess parseDataAccess(Element element) {
    final String typeName = element.attributeValue("type");
    DataAccessInstanceType type = DataAccessInstanceType.parseType(typeName);
    if(type != null){
      switch (type){
        case :
          return new DenormalizedMdxDataAccess(element);
        case :
          return new JoinCompoundDataAccess(element);
        case :
          return new DenormalizedOlap4JDataAccess(element);
        case :
          return new KettleDataAccess(element);
        case :
          return new MdxDataAccess(element);
        case :
          return new MqlDataAccess(element);
        case :
          return new Olap4JDataAccess(element);
        case :
          return new ReflectionDataAccess(element);
        case :
          return new ScriptableDataAccess(element);
        case :
          return new SqlDataAccess(element);
        case :
          return new UnionCompoundDataAccess(element);
        case :
          return new XPathDataAccess(element);
      }
    }
    return null;
  }
  private void parseDataAccesses() throws UnsupportedDataAccessException {
    // Parsing DataAccess.
    // 1 - Parse data access, and then parse the CompoundDataAccess
    
    @SuppressWarnings("unchecked")
    final List<Element> dataAccessesList = .selectNodes("/CDADescriptor/DataAccess | /CDADescriptor/CompoundDataAccess");
    for (final Element element : dataAccessesList) {
      final String type = element.attributeValue("type");
      // Initialize this ConnectionType
      DataAccess dataAccess = null;
      try {
        dataAccess = parseDataAccess(element);
        if (dataAccess != null) {
          dataAccess.setCdaSettings(this);
          addInternalDataAccess(dataAccess);
        }
      } catch (Exception e) {
        throw new UnsupportedDataAccessException("Error parsing DataAccess: " + Util.getExceptionDescription(e), e);
      }
      if(dataAccess == null){
        throw new UnsupportedDataAccessException(MessageFormat.format("Unknown DataAccess type {0}."type));
      }
    }
  }
  
  private Connection parseConnection(String type, Element elementthrows InvalidConnectionException {
    
    ConnectionInstanceType connType = ConnectionInstanceType.parseType(type); 
    
    if(connType != null){
      switch (connType){
        case :
          return new TransFromFileConnection(element);
        case :
          return new MetadataConnection(element);
        case :
          return new pt.webdetails.cda.connections.mondrian.JdbcConnection(element);
        case :
          return new pt.webdetails.cda.connections.mondrian.JndiConnection(element);
        case :
          return new pt.webdetails.cda.connections.olap4j.DefaultOlap4jConnection(element);
        case :
          return new ScriptingConnection(element);
        case :
          return new pt.webdetails.cda.connections.sql.JdbcConnection(element);
        case :
          return new pt.webdetails.cda.connections.sql.JndiConnection(element);
        case :
          return new XPathConnection(element);
      }
    }
    return null;
  }
  private void parseConnections() throws UnsupportedConnectionException {
    @SuppressWarnings("unchecked")
    final List<Element> connectionList = .selectNodes("/CDADescriptor/DataSources/Connection");
    for (final Element element : connectionList) {
      final String type = element.attributeValue("type");
      
      Connection connection = null;
      try {
        connection = parseConnection(typeelement);
        if(connection != null){
          connection.setCdaSettings(this);
          addInternalConnection(connection);
        }
      } catch (InvalidConnectionException e) {
        throw new UnsupportedConnectionException(MessageFormat.format("Error initializing connection: {0}", Util.getExceptionDescription(e)),e);
      }
      if(connection == null){
        throw new UnsupportedConnectionException(MessageFormat.format("Unrecognized connection type {0}."type));
      }
    }
  }
	  //if genDoc does not exist we can be sure that the CdaSetting
	  //was instantiatet from an existing file. we don't want to regenerate
	  //the xml in that case
	  
	  if(==null){
		  return this..asXML();	  
	  }
	  
	  DomTraversalHelper tHelper = new DomTraversalHelper();
	  
	  return XmlUtils.prettyPrint(tHelper.traverse(this).asXML());
  }
  
 

Parameters:
dataAccess
  public void addDataAccess(final DataAccess dataAccess)
  {
  	addInternalDataAccess(dataAccess);
  	dataAccess.setCdaSettings(this);
  }
  
  

Parameters:
connection
   public void addConnection(final Connection connection)
   {
  	 addInternalConnection(connection);
  	 connection.setCdaSettings(this);
   }
  private void addInternalConnection(final Connection connectionSettings
  {
    .put(connectionSettings.getId(), connectionSettings);
  }
  private void addInternalDataAccess(final DataAccess dataAccess
  {
    .put(dataAccess.getId(), dataAccess);
  }
  public Connection getConnection(final String idthrows UnknownConnectionException 
  {
    if (!.containsKey(id)) {
      throw new UnknownConnectionException("Unknown connection with id " + idnull);
    }
    
    Connection connection = .get(id);
    
    if(connection instanceof EvaluableConnection)
    {//return evaluated copy, keep original
      return ((EvaluableConnectionconnection).evaluate();
    }
    else return connection;
  }
  public DataAccess getDataAccess(final String idthrows UnknownDataAccessException 
  {
    if (!.containsKey(id)) {
      throw new UnknownDataAccessException("Unknown dataAccess with id " + idnull);
    }
    return .get(id);
  }
  public String getId() {
    return ;
  }
  public ResourceKey getContextKey() {
    return ;
  }
  
	  return this.;
  }
	  return this.;
  }
New to GrepCode? Check out our FAQ X