/* 
    * Copyright (c) 2007, Fraunhofer-Gesellschaft
    * All rights reserved.
    * 
    * Redistribution and use in source and binary forms, with or without
    * modification, are permitted provided that the following conditions are
    * met:
    * 
    * (1) Redistributions of source code must retain the above copyright
   *     notice, this list of conditions and the disclaimer at the end.
   *     Redistributions in binary form must reproduce the above copyright
   *     notice, this list of conditions and the following disclaimer in
   *     the documentation and/or other materials provided with the
   *     distribution.
   * 
   * (2) Neither the name of Fraunhofer nor the names of its
   *     contributors may be used to endorse or promote products derived
   *     from this software without specific prior written permission.
   * 
   * DISCLAIMER
   * 
   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
   * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
   * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
   * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
   * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
   * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
   * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
   * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
   * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
   * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
   * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
   *  
   */
  package org.ogf.graap.wsag.server.monitoring;
  
  import java.text.MessageFormat;
  import java.text.ParseException;
  import java.util.Arrays;
  import java.util.Date;
  import java.util.Iterator;
  import java.util.List;
  import java.util.Map;
  import java.util.Observable;
  import java.util.Observer;
  import java.util.Vector;
  
  import org.apache.log4j.Logger;
  import org.apache.xmlbeans.XmlBoolean;
  import org.apache.xmlbeans.XmlInt;
  import org.apache.xmlbeans.XmlObject;
  import org.apache.xmlbeans.XmlString;
  import org.ogf.graap.wsag.api.Agreement;
  import org.ogf.graap.wsag.api.logging.LogMessage;
  import org.ogf.graap.wsag.server.accounting.IAccountingSystem;
  import org.ogf.graap.wsag.server.accounting.SimpleAccountingSystemLogger;
  import org.ogf.graap.wsag.server.api.IAgreementContext;
  import org.ogf.graap.wsag.server.api.impl.AgreementContext;
  import org.ogf.graap.wsag.server.persistence.impl.PersistentAgreementContainer;
  import org.ogf.schemas.graap.wsAgreement.AgreementContextType;
  import org.ogf.schemas.graap.wsAgreement.AgreementPropertiesType;
  import org.ogf.schemas.graap.wsAgreement.AgreementStateType;
  import org.ogf.schemas.graap.wsAgreement.GuaranteeTermStateType;
  import org.ogf.schemas.graap.wsAgreement.ServiceTermStateType;
  import org.ogf.schemas.graap.wsAgreement.TermTreeType;
  import org.ogf.schemas.graap.wsAgreement.TerminateInputType;
  import org.quartz.CronExpression;
  import org.quartz.CronTrigger;
  import org.quartz.JobDetail;
  import org.quartz.Scheduler;
  import org.quartz.SchedulerException;
  import org.quartz.SchedulerFactory;
  import org.quartz.Trigger;
  import org.quartz.impl.StdSchedulerFactory;
  
  /**
   * MonitorableAgreement
   * 
   * Supports monitoring of service terms, agreement state and automatic evaluation of guarantee terms.
   * 
   * @author Oliver Waeldrich
   * 
   */
  public class MonitorableAgreement extends Observable
      implements Agreement, Observer
  {
  
      private static final Logger LOG = Logger.getLogger( MonitorableAgreement.class );
  
      //
      // definition of constants set in the execution properties
      //
  
      /**
       * Key to resolve if monitoring was started for a particular agreement implementation from the agreement
       * execution context. It refers a {@link XmlBoolean}. If the boolean value is true monitoring was started
       * using the {@link MonitorableAgreement}, if false or not present monitoring was not used.
       * 
       * Used for loading persisted agreements.
      * 
      * @see #getAgreementInstance()
      * @see Agreement#getExecutionContext()
      */
     public static final String MONITORING_ACTIVE = "org.wsag4j.monitoring.isActive";
 
     /**
      * Key to resolve the monitoring interval for a particular agreement implementation from the agreement
      * execution context. It refers a {@link XmlString} value.
      * 
      * Used for loading persisted agreements.
      * 
      * @see #getAgreementInstance()
      * @see Agreement#getExecutionContext()
      */
     public static final String MONITORING_CRON = "org.wsag4j.monitoring.cron";
 
     /**
      * Key to resolve the class names of the monitoring handler for a particular agreement implementation from
      * the agreement execution context. It refers a {@link XmlString}. The monitoring handler class names are
      * stored in the agreement execution context with the following strategy:
      * 
      * <code>MONITORING_HANDLER + "." + handler[i].getClass().getName()</code>
      * 
      * Used for loading persisted agreements.
      * 
      * @see #getAgreementInstance()
      * @see Agreement#getExecutionContext()
      */
     public static final String MONITORING_HANDLER = "org.wsag4j.monitoring.handler";
 
     /**
      * Key to resolve the number of the monitoring handler for a particular agreement implementation from the
      * agreement execution context. It refers a {@link XmlInt}.
      * 
      * Used for loading persisted agreements.
      * 
      * @see #getAgreementInstance()
      * @see Agreement#getExecutionContext()
      */
     public static final String MONITORING_HANDLER_COUNT = "org.wsag4j.monitoring.handler.count";
 
     //
     // private variable definitions
     //
     private Agreement agreementInstance;
 
     private IAgreementContext executionContext = new AgreementContext( this );
 
     private final List<IServiceTermMonitoringHandler> monitoringHandler =
         new Vector<IServiceTermMonitoringHandler>();
 
     private Scheduler scheduler;
 
     private String jobName;
 
     private static final String JOB_GROUP = "WSAG4J";
 
     private IAccountingSystem accountingSystem = new SimpleAccountingSystemLogger();
 
     private boolean monitoring = false;
 
     /**
      * @return the monitoring
      */
     public boolean isMonitoring()
     {
         return monitoring;
     }
 
     //
     // default schedule for monitoring that fires each minute
     //
     private static final String DEFAULT_SCHEDULE = "0 0/1 * * * ?";
 
     private String cronExpression = DEFAULT_SCHEDULE;
 
     /**
      * Creates a new instance of a monitorable agreement. The agreement object, for which this
      * MonitorableAgreement is created, implements the methods to store the terms and the state of the
      * agreement, and to terminate the agreement.
      * 
      * @param agreement
      *            the agreement object, which should be monitored.
      */
     public MonitorableAgreement( Agreement agreement )
     {
         this.agreementInstance = agreement;
 
         //
         // register this instance as observer to state change events of the agreement instance
         //
         agreement.addObserver( this );
 
         //
         // update the execution context
         //
         executionContext.getExecutionProperties().putAll( agreement.getExecutionContext() );
         executionContext.getTransientExecutionProperties().putAll( agreement.getTransientExecutionContext() );
 
         initializeScheduler();
     }
 
     /**
      * Recreates an instance of a monitorable agreement. The agreement object, for which this
      * MonitorableAgreement is created, implements the methods to store the terms and the state of the
      * agreement, and to terminate the agreement.
      * 
      * @param persistentAgreementContainer
      *            the persisted agreement object, which should be monitored.
      */
     public MonitorableAgreement( PersistentAgreementContainer persistentAgreementContainer )
     {
         // agreement.addObserver(this);
         throw new UnsupportedOperationException( "Not supported yet." );
     }
 
     private void initializeScheduler()
     {
         //
         // Initialize the quartz scheduler
         //
         synchronized ( SchedulerFactory.class )
         {
 
             SchedulerFactory factory = new StdSchedulerFactory();
 
             try
             {
                 scheduler = factory.getScheduler();
 
                 if ( !scheduler.isStarted() )
                 {
                     scheduler.start();
                 }
             }
             catch ( SchedulerException e )
             {
                 throw new IllegalStateException( "Failed to instantiate Quartz scheduler.", e );
             }
 
         }
 
     }
 
     private IMonitoringContext initializeMonitoringContext()
     {
 
         IMonitoringContext monitoringContext = new MonitoringContext();
 
         //
         // add the execution context properties to the monitoring context
         //
         monitoringContext.setProperties( executionContext.getExecutionProperties() );
 
         //
         // add the transient execution context properties to the monitoring context
         //
         monitoringContext.setTransientProperties( executionContext.getTransientExecutionProperties() );
 
         // deprecated
         // //
         // // add the agreement execution context
         // //
         // monitoringContext.getProperties().putAll(executionContext.getExecutionProperties());
 
         //
         // add monitoring handler to monitoring context
         //
         monitoringContext.setMonitoringHandler( new IServiceTermMonitoringHandler[0] );
 
         for ( int i = 0; i < monitoringHandler.size(); i++ )
         {
             monitoringContext.addMonitoringHandler( monitoringHandler.get( i ) );
         }
 
         monitoringContext.setAccountingSystem( accountingSystem );
 
         //
         // put the agreement context into the transient properties
         //
         monitoringContext.getTransientProperties().put(
             IMonitoringContext.WSAG4J_AGREEMENT_EXECUTION_CONTEXT, getExecutionContext() );
 
         return monitoringContext;
     }
 
     private synchronized void scheduleMonitoringJobs( IMonitoringContext monitoringContext ) throws Exception
     {
 
         //
         // TODO: set properties isMonitoring in the execution context
         // this allows us to restart monitoring if an agreement
         // was reloaded
         //
 
         jobName = initializeJobName();
 
         Trigger agreementMonitoringTrigger = createCronTrigger( jobName );
 
         //
         // create job details
         //
         JobDetail agreementMonitoringDetail = new JobDetail( jobName, JOB_GROUP, AgreementMonitorJob.class );
 
         agreementMonitoringDetail.getJobDataMap().put( AgreementMonitorJob.WSAG4J_AGREEMENT_INSTANCE,
             agreementInstance );
         agreementMonitoringDetail.getJobDataMap().put( AgreementMonitorJob.WSAG4J_MONITORING_CONTEXT,
             monitoringContext );
 
         scheduler.scheduleJob( agreementMonitoringDetail, agreementMonitoringTrigger );
 
         //
         // TODO: schedule job for terminating the monitoring process
         // if AgreementState is completed
         //
     }
 
     private String initializeJobName() throws SchedulerException
     {
         List<String> names = Arrays.asList( scheduler.getJobNames( JOB_GROUP ) );
 
         String name =
             MessageFormat.format( "WSAG4J_MONITORING_JOB_{0}", new Object[] { new Date().getTime() } );
 
         while ( names.contains( name ) )
         {
             name = MessageFormat.format( "WSAG4J_MONITORING_JOB_{0}", new Object[] { new Date().getTime() } );
             try
             {
                 wait( 10 );
             }
             catch ( InterruptedException e )
             {
                 // do nothing, just continue
             }
         }
 
         return name;
     }
 
     /**
      * Stores the number and class names of the monitoring handler in the execution properties.
      */
     private void saveHandlerToExecutionContext()
     {
         int handlerCount = 0;
         Iterator<IServiceTermMonitoringHandler> handler = monitoringHandler.iterator();
 
         while ( handler.hasNext() )
         {
 
             String handlerClass = handler.next().getClass().getName();
 
             String key = MONITORING_HANDLER + "." + handlerCount;
             XmlString value = XmlString.Factory.newValue( handlerClass );
 
             getMonitoringContext().getExecutionProperties().put( key, value );
 
             handlerCount++;
         }
 
         XmlInt value = XmlInt.Factory.newValue( Integer.valueOf( handlerCount ) );
         getMonitoringContext().getExecutionProperties().put( MONITORING_HANDLER_COUNT, value );
     }
 
     /**
      * Initializes the monitoring handler based on the handler count and names stored in the execution
      * context.
      */
     private void initializeHandlerFromExecutionContext()
     {
         int handlerCount = 0;
         monitoringHandler.clear();
 
         XmlInt count =
             (XmlInt) getMonitoringContext().getExecutionProperties().get( MONITORING_HANDLER_COUNT );
         if ( count != null )
         {
             handlerCount = count.getIntValue();
         }
 
         while ( handlerCount > 0 )
         {
             handlerCount--;
 
             String key = MONITORING_HANDLER + "." + handlerCount;
             XmlString value = (XmlString) getMonitoringContext().getExecutionProperties().get( key );
 
             LOG.debug( "initialize agreement monitoring handler" );
 
             //
             // load the agreement monitoring handler
             //
             try
             {
                 String className = value.getStringValue();
                 LOG.debug( LogMessage.getMessage( "instantiate monitoring handler ''{0}''", className ) );
 
                 Class<IServiceTermMonitoringHandler> clazz;
                 try
                 {
                     //
                     // check if the class to instantiate implements our handler interface
                     //
                     @SuppressWarnings( "unchecked" )
                     Class<IServiceTermMonitoringHandler> convert =
                         (Class<IServiceTermMonitoringHandler>) this.getClass().getClassLoader()
                                                                    .loadClass( className );
 
                     clazz = convert;
                 }
                 catch ( ClassCastException e )
                 {
                     final String msgNotRequiredInterface =
                         "monitoring handler must implement the 'IServiceTermMonitoringHandler' interface.";
                     throw new Exception( msgNotRequiredInterface, e );
                 }
 
                 //
                 // instantiate and add the monitoring handler
                 //
                 addMonitoringHandler( clazz.newInstance() );
 
                 LOG.debug( LogMessage.getMessage( "successfully instantiated monitoring handler ''{0}''",
                     className ) );
             }
             catch ( Exception e )
             {
                 String msgText = "re-initializing monitorable agreement failed: {0}";
                 LogMessage message = LogMessage.getMessage( msgText, e.getMessage() );
                 LOG.error( message, e );
             }
         }
 
     }
 
     /**
      * @return the executionContext
      * @deprecated
      */
     @Deprecated
     public IAgreementContext getMonitoringContext()
     {
         return executionContext;
     }
 
     /**
      * @param executionContext
      *            the executionContext to set
      */
     public void setExecutionContext( IAgreementContext executionContext )
     {
         this.executionContext = executionContext;
     }
 
     /**
      * 
      * @param handler
      *            monitoring handler
      */
     public void addMonitoringHandler( IServiceTermMonitoringHandler handler )
     {
         monitoringHandler.add( handler );
     }
 
     /**
      * Returns the list of registered monitoring handler.
      * 
      * @return the monitoringHandler
      */
     public IServiceTermMonitoringHandler[] getMonitoringHandler()
     {
         return monitoringHandler.toArray( new IServiceTermMonitoringHandler[monitoringHandler.size()] );
     }
 
     /**
      * @return the cronExpression
      */
     public String getCronExpression()
     {
         return cronExpression;
     }
 
     /**
      * @param cronExpression
      *            the cronExpression to set
      */
     public void setCronExpression( String cronExpression )
     {
         this.cronExpression = cronExpression;
     }
 
     private Trigger createCronTrigger( String name ) throws Exception
     {
         //
         // create the cron trigger for job monitoring
         //
         CronTrigger trigger = new CronTrigger();
 
         try
         {
             if ( CronExpression.isValidExpression( cronExpression ) )
             {
                 trigger.setCronExpression( cronExpression );
             }
             else
             {
                 LOG.error( LogMessage.getMessage(
                     "Invalid cron expression ({0}). Using default monitoring schedule ({1}).",
                     cronExpression, DEFAULT_SCHEDULE ) );
                 trigger.setCronExpression( DEFAULT_SCHEDULE );
             }
         }
         catch ( ParseException e )
         {
             String msgText = "Invalid default schedule <{0}>. Monitoring not scheduled.";
             String message = LogMessage.format( msgText, DEFAULT_SCHEDULE );
             throw new Exception( message, e );
         }
 
         trigger.setGroup( JOB_GROUP );
         trigger.setName( name );
 
         return trigger;
     }
 
     /**
      * Starts the agreement monitoring process.
      * 
      * @throws Exception
      *             failed to start monitoring
      */
     public void startMonitoring() throws Exception
     {
         //
         // set flag that the monitoring process has started
         //
         XmlBoolean isMonitoring = XmlBoolean.Factory.newValue( true );
         XmlString cron = XmlString.Factory.newValue( cronExpression );
         getMonitoringContext().getExecutionProperties().put( MONITORING_ACTIVE, isMonitoring );
         getMonitoringContext().getExecutionProperties().put( MONITORING_CRON, cron );
 
         //
         // save the monitoring handler in the execution context
         //
         saveHandlerToExecutionContext();
 
         //
         // initialize the monitoring context
         //
         IMonitoringContext monitoringContext = initializeMonitoringContext();
 
         //
         // schedule the monitoring jobs
         //
         try
         {
             scheduleMonitoringJobs( monitoringContext );
         }
         catch ( Exception e )
         {
             final String msgText = "Error scheduling monitoring jobs. Reason: {0}";
             String message = LogMessage.format( msgText, e.getMessage() );
             LOG.error( message, e );
 
             throw new Exception( message, e );
         }
 
         this.monitoring = true;
     }
 
     /**
      * Stops the agreement monitoring.
      * 
      * @throws Exception
      *             error while stopping the agreement monitor scheduler
      */
     public void stopMonitoring() throws Exception
     {
         try
         {
             XmlBoolean isMonitoring = XmlBoolean.Factory.newValue( false );
             getMonitoringContext().getExecutionProperties().put( MONITORING_ACTIVE, isMonitoring );
             getAgreementInstance().getExecutionContext().put( MONITORING_ACTIVE, isMonitoring );
 
             //
             // TODO: unset properties isMonitoring in the execution context
             // when an agreement is reloaded, the monitoring is started
             // if isMonitoring property is set in the execution properties
             //
 
             scheduler.unscheduleJob( jobName, JOB_GROUP );
         }
         catch ( SchedulerException e )
         {
             String message = "Error stoping the agreement monitoring. Reason: " + e.getMessage();
             LOG.error( message );
 
             throw new Exception( message, e );
         }
 
         this.monitoring = false;
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public void terminate( TerminateInputType reason )
     {
         try
         {
             stopMonitoring();
         }
         catch ( Exception ex )
         {
             LOG.error( "The agreement monitoring scheduler was not stoped" );
 
             if ( LOG.isDebugEnabled() )
             {
                 LOG.debug( ex );
             }
         }
 
         try
         {
             agreementInstance.terminate( reason );
         }
         catch ( Exception ex )
         {
             LOG.error( "The agreement could not be terminated." );
 
             if ( LOG.isDebugEnabled() )
             {
                 LOG.debug( ex );
             }
         }
 
     }
 
     /**
      * This method notifies a concrete agreement instance that the monitored agreement instance was reloaded.
      * This essentially implies that the {@link Agreement#notifyReload(java.util.Map)} method is invoked.
      * Implementations of the {@link Agreement} can override the
      * {@link Agreement#notifyReinitialized(java.util.Map)} in order to implement domain specific
      * re-initialization logic.
      * 
      * @throws Exception
      *             indicates an error during the agreement reload process
      */
     public void notifyReload() throws Exception
     {
         agreementInstance.notifyReload( executionContext.getExecutionProperties() );
 
         //
         // re-initialize monitoring handler and restart agreement monitoring
         //
         initializeHandlerFromExecutionContext();
 
         Map<String, XmlObject> executionProperties = getMonitoringContext().getExecutionProperties();
         XmlString cron = (XmlString) executionProperties.get( MonitorableAgreement.MONITORING_CRON );
 
         if ( cron != null )
         {
             cronExpression = cron.getStringValue();
         }
         else
         {
             cronExpression = DEFAULT_SCHEDULE;
         }
 
         boolean isActive = false;
         if ( executionProperties.containsKey( MONITORING_ACTIVE ) )
         {
             isActive =
                 ( (XmlBoolean) executionProperties.get( MonitorableAgreement.MONITORING_ACTIVE ) ).getBooleanValue();
         }
 
         if ( isActive )
         {
             startMonitoring();
         }
     }
 
     /**
      * @return the agreement id
      * @see org.ogf.graap.wsag.api.Agreement#getAgreementId()
      */
     @Override
     public String getAgreementId()
     {
         return agreementInstance.getAgreementId();
     }
 
     /**
      * @return the agreement context
      * @see org.ogf.graap.wsag.api.Agreement#getContext()
      */
     @Override
     public AgreementContextType getContext()
     {
         return agreementInstance.getContext();
     }
 
     /**
      * @return the guarantee term states
      * @see org.ogf.graap.wsag.api.Agreement#getGuaranteeTermStates()
      */
     @Override
     public GuaranteeTermStateType[] getGuaranteeTermStates()
     {
         return agreementInstance.getGuaranteeTermStates();
     }
 
     /**
      * @return the agreement name
      * @see org.ogf.graap.wsag.api.Agreement#getName()
      */
     @Override
     public String getName()
     {
         return agreementInstance.getName();
     }
 
     /**
      * @return the service term states
      * @see org.ogf.graap.wsag.api.Agreement#getServiceTermStates()
      */
     @Override
     public ServiceTermStateType[] getServiceTermStates()
     {
         return agreementInstance.getServiceTermStates();
     }
 
     /**
      * @return the agreement state
      * @see org.ogf.graap.wsag.api.Agreement#getState()
      */
     @Override
     public AgreementStateType getState()
     {
         return agreementInstance.getState();
     }
 
     /**
      * @return the terms of the agreement
      * @see org.ogf.graap.wsag.api.Agreement#getTerms()
      */
     @Override
     public TermTreeType getTerms()
     {
         return agreementInstance.getTerms();
     }
 
     /**
      * {@inheritDoc}
      */
     public Agreement getAgreementInstance()
     {
         return agreementInstance;
     }
 
     /**
      * @param accountingSystem
      *            the accountingSystem to set
      */
     public void setAccountingSystem( IAccountingSystem accountingSystem )
     {
         if ( accountingSystem != null )
         {
             this.accountingSystem = accountingSystem;
         }
     }
 
     /**
      * @return the accountingSystem
      */
     public IAccountingSystem getAccountingSystem()
     {
         return accountingSystem;
     }
 
     /**
      * If the monitored agreement receives a state change notification of the concrete agreement
      * implementation (@link {@link Agreement#notifyObservers()}) all observer registered to this monitorable
      * agreement will be notified of the state change ass well.
      * 
      * {@inheritDoc}
      * 
      * @see java.util.Observer#update(java.util.Observable, java.lang.Object)
      */
     @Override
     public void update( Observable o, Object arg )
     {
         setChanged();
         notifyObservers();
         // if ( o instanceof Wsag4jObservable )
         // {
         // Wsag4jObservable observable = (Wsag4jObservable) o;
         // if ( observable.getType() == agreementInstance )
         // {
         // setChanged();
         // notifyObservers();
         // }
         // }
     }
 
     /**
      * @see org.ogf.graap.wsag.api.Agreement#validate()
      */
     @Override
     public boolean validate()
     {
         return agreementInstance.validate();
     }
 
     /**
      * @see org.ogf.graap.wsag.api.Agreement#notifyReload(java.util.Map)
      */
     @Override
     public void notifyReload( Map<String, XmlObject> executionCtx )
     {
         agreementInstance.notifyReload( executionCtx );
     }
 
     /**
      * @see org.ogf.graap.wsag.api.Agreement#setAgreementId(java.lang.String)
      */
     @Override
     public void setAgreementId( String agreementId )
     {
         agreementInstance.setAgreementId( agreementId );
     }
 
     /**
      * @see org.ogf.graap.wsag.api.Agreement#setContext(org.ogf.schemas.graap.wsAgreement.AgreementContextType)
      */
     @Override
     public void setContext( AgreementContextType context )
     {
         agreementInstance.setContext( context );
     }
 
     /**
      * @see org.ogf.graap.wsag.api.Agreement#setName(java.lang.String)
      */
     @Override
     public void setName( String name )
     {
         agreementInstance.setName( name );
 
     }
 
     /**
      * @see org.ogf.graap.wsag.api.Agreement#setTerms(org.ogf.schemas.graap.wsAgreement.TermTreeType)
      */
     @Override
     public void setTerms( TermTreeType terms )
     {
         agreementInstance.setTerms( terms );
     }
 
     /**
      * @see org.ogf.graap.wsag.api.Agreement#setState(org.ogf.schemas.graap.wsAgreement.AgreementStateType)
      */
     @Override
     public void setState( AgreementStateType agreementState )
     {
         agreementInstance.setState( agreementState );
     }
 
     /**
      * @see org.ogf.graap.wsag.api.Agreement#setGuaranteeTermStates(org.ogf.schemas.graap.wsAgreement.GuaranteeTermStateType[])
      */
     @Override
     public void setGuaranteeTermStates( GuaranteeTermStateType[] guaranteeTermStateList )
     {
         agreementInstance.setGuaranteeTermStates( guaranteeTermStateList );
     }
 
     /**
      * @see org.ogf.graap.wsag.api.Agreement#setServiceTermStates(org.ogf.schemas.graap.wsAgreement.ServiceTermStateType[])
      */
     @Override
     public void setServiceTermStates( ServiceTermStateType[] serviceTermStateList )
     {
         agreementInstance.setServiceTermStates( serviceTermStateList );
     }
 
     /**
      * @see org.ogf.graap.wsag.api.Agreement#getXMLObject()
      */
     @Override
     public AgreementPropertiesType getXMLObject()
     {
         return agreementInstance.getXMLObject();
     }
 
     /**
      * @see org.ogf.graap.wsag.api.Agreement#setXmlObject(org.ogf.schemas.graap.wsAgreement.AgreementPropertiesType)
      */
     @Override
     public void setXmlObject( AgreementPropertiesType properties )
     {
         agreementInstance.setXmlObject( properties );
     }
 
     /**
      * @see org.ogf.graap.wsag.api.Agreement#getTransientExecutionContext()
      */
     @Override
     public Map<String, Object> getTransientExecutionContext()
     {
         return agreementInstance.getTransientExecutionContext();
     }
 
     /**
      * @see org.ogf.graap.wsag.api.Agreement#getImplementationClass()
      */
     @Override
     public Class getImplementationClass()
     {
         return agreementInstance.getImplementationClass();
     }
 
     /*
      * (non-Javadoc)
      * 
      * @see org.ogf.graap.wsag.api.Agreement#getExecutionContext()
      */
     @Override
     public Map<String, XmlObject> getExecutionContext()
     {
         return agreementInstance.getExecutionContext();
     }
 }