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 UnitConvertervoid SetUp()
        {
            argumentssourceComponent = new List<IArgument>AnalyticalFunctionComponent();

            arguments.Add(new Argument("SourceUnit",targetComponent1 = new Unit("m").ToStringAnalyticalFunctionComponent(), true,;

            // connect items using decorator
            IOutputItemDecorator unitConverter = new UnitConverter();
       "Source unit for conversion (set automatically when  unitConverter.DecoratedOutputItem is set"))= sourceComponent.OutputItems[0];
            argumentsunitConverter.Add(new Argument("TargetUnit", new Unit("ft").ToString(), true, "Target unit for conversion"));AddConsumer(targetComponent1.InputItems[0]);

        }

    targetComponent2 = new AnalyticalFunctionComponent();
 public IList<IArgument> Arguments
     }

   {
     // Example1: re-use existing unit converter in get2 {different returninput arguments;exchange }items

        }[Test]

        [Ignore("Test publicis IOutputItemunfinished, DecoratedOutputItem
added for OATC discusssion")]
     {
   public void ReuseUnitConverterInTwoComponents()
       get { return decoratedOutputItem; }
            set { decoratedOutputItem = value; }ConnectExchangeItemsUsingExistingUnitConverter(sourceComponent, sourceComponent.OutputItems[0], targetComponent2.InputItems[0]);
        }

        public void UpdateConnectExchangeItemsUsingExistingUnitConverter()
ILinkableComponent sourceComponent, IOutputItem sourceItem,     {IInputItem targetItem)
            log.InfoFormat("Converting units ...");{
            foreach (IInputItemvar targetItemoutputItem in ConsumerssourceComponent.OutputItems)
            {
                targetItem.Values = decoratedOutputItem.Values;

if (!(outputItem is IOutputItemDecorator))
                // TODO: add conversion here{
            }
        }continue;
    }

    [TestFixture]
    public class OutputDecoratorTest
    {}

        private ILinkableComponent sourceComponent;
      var decorator private ILinkableComponent targetComponent1= (IOutputItemDecorator)outputItem;

        private ILinkableComponent targetComponent2;

      if  [SetUp]
        public void SetUp()(decorator.DecoratedOutputItem != sourceItem) // TODO: add more check if needed
        {
        {
    sourceComponent = new AnalyticalFunctionComponent();

            targetComponent1 = new AnalyticalFunctionComponent();
 continue;
            // connect items using decorator}

            IOutputItemDecorator unitConverter = new UnitConverterdecorator.AddConsumer(targetItem);
            unitConverter.DecoratedOutputItem = sourceComponent.OutputItems[0];
            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
   }
}