Page History

using System;
using System.Collections.Generic;
using log4net;
using NUnit.Framework;
using Oatc.OpenMI.Sdk.Backbone.IntegrationTests.Components;
using OpenMI.Standard;

namespace Oatc.OpenMI.Sdk.Backbone.IntegrationTests
{
    public[TestFixture]
  class UnitConverter :public OutputItem,class IOutputItemDecoratorOutputDecoratorTest
    {
        private new static readonly ILog log = LogManager.GetLogger(typeof (UnitConverter));
 ILinkableComponent sourceComponent;
        private ILinkableComponent targetComponent1;
        private IOutputItemILinkableComponent decoratedOutputItemtargetComponent2;

        private readonly IList<IArgument> arguments;
[SetUp]
        public void UnitConverterSetUp()
        {
            argumentssourceComponent = new List<IArgument>AnalyticalFunctionComponent();

            arguments.Add(new Argument("SourceUnit",targetComponent1 = new Unit("m").ToStringAnalyticalFunctionComponent(), true, "Source unit for conversion (set automatically when DecoratedOutputItem is set"));
    ;

            // connect items using decorator
        arguments.Add(new Argument("TargetUnit", new Unit("ft").ToString(), true, "Target unit for conversion") IOutputItemDecorator unitConverter = new UnitConverter();
        }

    unitConverter.DecoratedOutputItem = sourceComponent.OutputItems[0];
  public IList<IArgument> Arguments
        {unitConverter.AddConsumer(targetComponent1.InputItems[0]);

            gettargetComponent2 {= returnnew argumentsAnalyticalFunctionComponent(); }
        }

        public IOutputItem DecoratedOutputItem
        {// Example1: re-use existing unit converter in 2 different input exchange items

            get { return decoratedOutputItem; }[Test]
        [Ignore("Test is unfinished, added setfor { decoratedOutputItem = value; }OATC discusssion")]
        }

        public void UpdateReuseUnitConverterInTwoComponents()
        {
            log.InfoFormat("Converting units ..."ConnectExchangeItemsUsingExistingUnitConverter(sourceComponent, sourceComponent.OutputItems[0], targetComponent2.InputItems[0]);
        }

     foreach   (IInputItempublic targetItemvoid in Consumers)
    ConnectExchangeItemsUsingExistingUnitConverter(ILinkableComponent sourceComponent, IOutputItem sourceItem, IInputItem targetItem)
        {
            foreach (var outputItem in targetItem.Values = decoratedOutputItem.Values;
sourceComponent.OutputItems)
            {
    // TODO: add conversion here
        if (!(outputItem is  }IOutputItemDecorator))
        }
    }

    [TestFixture]{
    public class OutputDecoratorTest
    {
        private ILinkableComponent sourceComponentcontinue;
        private ILinkableComponent targetComponent1;
        private ILinkableComponent targetComponent2;}

        [SetUp]
        publicvar decorator void= SetUp(IOutputItemDecorator)outputItem;

        {
        if (decorator.DecoratedOutputItem != sourceItem)  sourceComponent = new AnalyticalFunctionComponent();

// TODO: add more check if needed
             targetComponent1 = new AnalyticalFunctionComponent();

{
                // connect items using decoratorcontinue;
            IOutputItemDecorator unitConverter = new UnitConverter();
 }

              unitConverter.DecoratedOutputItem = sourceComponent.OutputItems[0]decorator.AddConsumer(targetItem);
             unitConverter.AddConsumer(targetComponent1.InputItems[0]);

   return;
         targetComponent2 = new AnalyticalFunctionComponent();}
        }

        // Example1Example2: re-userender existinglinkable unitcomponent converterincluding in 2 different input exchange items
it's decorators
        [Test]
        [Ignore("Test is unfinished, added for OATC discusssion")]
        public void ReuseUnitConverterInTwoComponentsRenderComponent()
        {
            ConnectExchangeItemsUsingExistingUnitConverterRenderComponent(sourceComponent, sourceComponent.OutputItems[0], targetComponent2.InputItems[0]);
        }

        public void ConnectExchangeItemsUsingExistingUnitConverterRenderComponent(ILinkableComponent sourceComponent, IOutputItem sourceItem, IInputItem targetItemcomponent)
        {
            foreach (var outputItem in sourceComponent.OutputItems)
            {
                if (!(outputItem is IOutputItemDecorator))
                {
                    continueDrawOtputItemDecorator((IOutputItemDecorator)outputItem);
                }

                else
     var   decorator = (IOutputItemDecorator)outputItem;

      {
          if (decorator.DecoratedOutputItem != sourceItem) // TODO: add more check if neededDrawOutputExchangeItem(outputItem);
                {}
            }
        continue;}


        private void DrawOutputExchangeItem(IOutputItem item)
      }

  {
            throw new decorator.AddConsumerNotImplementedException(targetItem);
        }

         return;private void DrawOtputItemDecorator(IOutputItemDecorator decorator)
        {
    }
        throw new }

NotImplementedException();
        }

   // Example2: render linkable component including it's decorators
   }
}