plonk_Unit.h

/*
 -------------------------------------------------------------------------------
 This file is part of the Plink, Plonk, Plank libraries
  by Martin Robinson
 
 http://code.google.com/p/pl-nk/
 
 Copyright University of the West of England, Bristol 2011-14
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without
 modification, are permitted provided that the following conditions are met:
 
 * Redistributions of source code must retain the above copyright
   notice, this list of conditions and the following disclaimer.
 * 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.
 * Neither the name of University of the West of England, Bristol nor 
   the names of its contributors may be used to endorse or promote products
   derived from this software without specific prior written permission.
 
 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 UNIVERSITY OF THE WEST OF ENGLAND, BRISTOL 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. 
 
 This software makes use of third party libraries. For more information see:
 doc/license.txt included in the distribution.
 -------------------------------------------------------------------------------
 */

#ifndef PLONK_UNIT_H
#define PLONK_UNIT_H

#include "plonk_GraphForwardDeclarations.h"
#include "utility/plonk_ProcessInfo.h"
#include "utility/plonk_BlockSize.h"
#include "utility/plonk_SampleRate.h"
#include "info/plonk_InfoHeaders.h"

template<class SampleType>
class UnitBase : public NumericalArray<ChannelBase<SampleType> >
{
protected:
    typedef ChannelBase<SampleType>                     ChannelType;
    typedef ObjectArray<ChannelType>                    ChannelArrayType;          
    typedef ChannelInternalBase<SampleType>             ChannelInternalType;
    typedef NumericalArray<ChannelType>                 UnitType;
    typedef NumericalArray2D<ChannelType,UnitBase>      UnitArray;
    typedef NumericalArray2D<SampleType>                BufferArrayType;
    typedef NullChannelInternal<SampleType>             NullInternal;
    typedef Variable<SampleType>                        VariableType;
    typedef AtomicValue<SampleType>                     AtomicType;
    typedef Variable<AtomicType&>                       AtomicVariableType;
    typedef AtomicVariableUnit<SampleType>              AtomicVariableUnitType;
    typedef typename ChannelBase<SampleType>::Receiver  Receiver;

    typedef typename BinaryOpFunctionsHelper<SampleType>::BinaryOpFunctionsType BinaryOpFunctionsType;
    typedef typename UnaryOpFunctionsHelper<SampleType>::UnaryOpFunctionsType UnaryOpFunctionsType;

    typedef typename TypeUtility<SampleType>::IndexType IndexType;

public:
    typedef ObjectArrayInternal<ChannelType>    Internal;    
    typedef UnitType                            Base;    
    typedef WeakPointerContainer<UnitBase>      Weak;
    typedef NumericalArray<SampleType>          Buffer;
    typedef InputDictionary                     Inputs;    
    
    class InitialUnit
    {
        public:
                InitialUnit() throw() 
        :   value (UnitBase::getNull()), 
            valid (false) 
        { 
        }
        
                InitialUnit (UnitBase const& initialValue) throw()
                :       value (initialValue), 
            valid (true) 
                { 
                }
        
                template<class OtherType>
                InitialUnit (OtherType const& initialValue) throw()
                :       value (initialValue), 
            valid (true) 
                { 
                }
                
                const UnitBase value;
                const bool valid;
        
        private:
                InitialUnit& operator= (InitialUnit const&); // to prevent assignment and MSVC complaining!
        };

    
    inline UnitBase() throw()
    :   Base (ChannelType())
    {
    }
        
    explicit UnitBase (Internal* internal) throw()
    :   Base (internal)
    {
    }
    
    UnitBase (Dynamic const& other) throw()
    :   Base (other.as<UnitBase>().getInternal())
    {
    }          

    static UnitBase fromWeak (Weak const& weak) throw()
    {
        return weak.fromWeak();
    }       
    
    static const UnitBase& getNull() throw()
        {
                static UnitBase null;
                return null;
        }                                   
    
    static const UnitBase emptyChannels (const int numChannels) throw()
    {
        return UnitBase::withSize (numChannels);
    }
    
    UnitBase (ChannelType const& channel) throw()
    :   UnitType (channel)
    {
        this->atUnchecked (0).initChannel (0);
    }
    
    template<class ValueType>
    inline UnitBase (ValueType const& valueInit) throw()
    :   UnitType (ChannelType (valueInit))
    {
        this->atUnchecked (0).initChannel (0);
    }
    
    template<class ValueType>
    inline UnitBase (NumericalArray<ValueType> const& values) throw()
    :   UnitType (UnitType::template collect<ChannelType> (values))
    {
        for (int i = 0; i < this->getNumChannels(); ++i)
            this->atUnchecked (i).initChannel (i);
    }    
    
    inline UnitBase (VariableType const& variable) throw()
    :   UnitType (ParamUnit<SampleType>::kr (variable))
    {
    }
    
    UnitBase (AtomicVariableType const& variable) throw()
    :   UnitType (AtomicVariableUnitType::kr (variable))
    {
    }
        
    UnitBase (NumericalArray<VariableType> const& variables) throw()
    :   UnitType (UnitType::withSize (variables.length()))
    {
        for (int i = 0; i < this->getNumChannels(); ++i) 
        {
            UnitBase variable = variables.atUnchecked (i);
            this->put (i, variable.atUnchecked (0));
        }
    }
    
    inline UnitBase (UnitBase const& copy) throw()
        :       UnitType (static_cast<UnitType const&> (copy))
        {
        }                
    
    
    template<template <typename> class OtherUnitType, class OtherSampleType>
    inline UnitBase (OtherUnitType<OtherSampleType> const& other)
    :   UnitType (TypeUnit<SampleType,OtherSampleType>::ar (other))
    {
    }
    
    UnitBase (UnitBase const& i00,
              UnitBase const& i01) throw()
    :   Base (i00, i01)
    {
    }
    
private:
    static int countValidChannels (InitialUnit const& i00,
                                   InitialUnit const& i01,
                                   InitialUnit const& i02,
                                   InitialUnit const& i03) throw()
    {
        int numChannels = 0;
        
        if (i00.valid) numChannels += i00.value.getNumChannels();
        if (i01.valid) numChannels += i01.value.getNumChannels();
        if (i02.valid) numChannels += i02.value.getNumChannels();        
        if (i03.valid) numChannels += i03.value.getNumChannels();

        return numChannels;
    }
    
public:
    UnitBase (InitialUnit const& i00,
              InitialUnit const& i01,
              InitialUnit const& i02,
              InitialUnit const& i03 = InitialUnit()) throw()
        :       Base (NumericalArraySpec (countValidChannels (i00, i01, i02, i03), false))
        {
        int i;
        ChannelType* array = this->getArray();
        
        if (i00.valid) { for (i = 0; i < i00.value.getNumChannels(); ++i) *array++ = i00.value.atUnchecked (i); }
        if (i01.valid) { for (i = 0; i < i01.value.getNumChannels(); ++i) *array++ = i01.value.atUnchecked (i); }
        if (i02.valid) { for (i = 0; i < i02.value.getNumChannels(); ++i) *array++ = i02.value.atUnchecked (i); }
        if (i03.valid) { for (i = 0; i < i03.value.getNumChannels(); ++i) *array++ = i03.value.atUnchecked (i); }
        }
    
private:
    static int countValidChannels (InitialUnit const& i00,
                                   InitialUnit const& i01,
                                   InitialUnit const& i02,
                                   InitialUnit const& i03,
                                   InitialUnit const& i04,
                                   InitialUnit const& i05,
                                   InitialUnit const& i06,
                                   InitialUnit const& i07) throw()
    {
        int numChannels = 0;
        
        if (i00.valid) numChannels += i00.value.getNumChannels();
        if (i01.valid) numChannels += i01.value.getNumChannels();
        if (i02.valid) numChannels += i02.value.getNumChannels();        
        if (i03.valid) numChannels += i03.value.getNumChannels();
        if (i04.valid) numChannels += i04.value.getNumChannels();
        if (i05.valid) numChannels += i05.value.getNumChannels();
        if (i06.valid) numChannels += i06.value.getNumChannels();
        if (i07.valid) numChannels += i07.value.getNumChannels();
        
        return numChannels;
    }
    
public:
    UnitBase (InitialUnit const& i00,
              InitialUnit const& i01,
              InitialUnit const& i02,
              InitialUnit const& i03,
              InitialUnit const& i04,
              InitialUnit const& i05 = InitialUnit(),
              InitialUnit const& i06 = InitialUnit(),
              InitialUnit const& i07 = InitialUnit()) throw()
        :       Base (NumericalArraySpec (countValidChannels (i00, i01, i02, i03,
                                                      i04, i05, i06, i07), false))
        {
        int i;
        ChannelType* array = this->getArray();
        
        if (i00.valid) { for (i = 0; i < i00.value.getNumChannels(); ++i) *array++ = i00.value.atUnchecked (i); }
        if (i01.valid) { for (i = 0; i < i01.value.getNumChannels(); ++i) *array++ = i01.value.atUnchecked (i); }
        if (i02.valid) { for (i = 0; i < i02.value.getNumChannels(); ++i) *array++ = i02.value.atUnchecked (i); }
        if (i03.valid) { for (i = 0; i < i03.value.getNumChannels(); ++i) *array++ = i03.value.atUnchecked (i); }
        if (i04.valid) { for (i = 0; i < i04.value.getNumChannels(); ++i) *array++ = i04.value.atUnchecked (i); }
        if (i05.valid) { for (i = 0; i < i05.value.getNumChannels(); ++i) *array++ = i05.value.atUnchecked (i); }
        if (i06.valid) { for (i = 0; i < i06.value.getNumChannels(); ++i) *array++ = i06.value.atUnchecked (i); }
        if (i07.valid) { for (i = 0; i < i07.value.getNumChannels(); ++i) *array++ = i07.value.atUnchecked (i); }
        }
    
private:
    static int countValidChannels (InitialUnit const& i00,
                                   InitialUnit const& i01,
                                   InitialUnit const& i02,
                                   InitialUnit const& i03,
                                   InitialUnit const& i04,
                                   InitialUnit const& i05,
                                   InitialUnit const& i06,
                                   InitialUnit const& i07,
                                   InitialUnit const& i08,
                                   InitialUnit const& i09,
                                   InitialUnit const& i10,
                                   InitialUnit const& i11,
                                   InitialUnit const& i12,
                                   InitialUnit const& i13,
                                   InitialUnit const& i14,
                                   InitialUnit const& i15) throw()
    {
        int numChannels = 0;
        
        if (i00.valid) numChannels += i00.value.getNumChannels();
        if (i01.valid) numChannels += i01.value.getNumChannels();
        if (i02.valid) numChannels += i02.value.getNumChannels();        
        if (i03.valid) numChannels += i03.value.getNumChannels();
        if (i04.valid) numChannels += i04.value.getNumChannels();
        if (i05.valid) numChannels += i05.value.getNumChannels();
        if (i06.valid) numChannels += i06.value.getNumChannels();
        if (i07.valid) numChannels += i07.value.getNumChannels();
        if (i08.valid) numChannels += i08.value.getNumChannels();
        if (i09.valid) numChannels += i09.value.getNumChannels();
        if (i10.valid) numChannels += i10.value.getNumChannels();
        if (i11.valid) numChannels += i11.value.getNumChannels();
        if (i12.valid) numChannels += i12.value.getNumChannels();
        if (i13.valid) numChannels += i13.value.getNumChannels();
        if (i14.valid) numChannels += i14.value.getNumChannels();
        if (i15.valid) numChannels += i15.value.getNumChannels();
        
        return numChannels;
    }
    
public:
    UnitBase (InitialUnit const &i00,
              InitialUnit const &i01,
              InitialUnit const &i02,
              InitialUnit const &i03,
              InitialUnit const &i04,
              InitialUnit const &i05,
              InitialUnit const &i06,
              InitialUnit const &i07,
              InitialUnit const &i08,
              InitialUnit const &i09 = InitialUnit(),
              InitialUnit const &i10 = InitialUnit(),
              InitialUnit const &i11 = InitialUnit(),
              InitialUnit const &i12 = InitialUnit(),
              InitialUnit const &i13 = InitialUnit(),
              InitialUnit const &i14 = InitialUnit(),
              InitialUnit const &i15 = InitialUnit()) throw()
        :       Base (NumericalArraySpec (countValidChannels (i00, i01, i02, i03,
                                                      i04, i05, i06, i07,
                                                      i08, i09, i10, i11,
                                                      i12, i13, i14, i15), false))
        {
        int i;
        ChannelType* array = this->getArray();
        
        if (i00.valid) { for (i = 0; i < i00.value.getNumChannels(); ++i) *array++ = i00.value.atUnchecked (i); }
        if (i01.valid) { for (i = 0; i < i01.value.getNumChannels(); ++i) *array++ = i01.value.atUnchecked (i); }
        if (i02.valid) { for (i = 0; i < i02.value.getNumChannels(); ++i) *array++ = i02.value.atUnchecked (i); }
        if (i03.valid) { for (i = 0; i < i03.value.getNumChannels(); ++i) *array++ = i03.value.atUnchecked (i); }
        if (i04.valid) { for (i = 0; i < i04.value.getNumChannels(); ++i) *array++ = i04.value.atUnchecked (i); }
        if (i05.valid) { for (i = 0; i < i05.value.getNumChannels(); ++i) *array++ = i05.value.atUnchecked (i); }
        if (i06.valid) { for (i = 0; i < i06.value.getNumChannels(); ++i) *array++ = i06.value.atUnchecked (i); }
        if (i07.valid) { for (i = 0; i < i07.value.getNumChannels(); ++i) *array++ = i07.value.atUnchecked (i); }
        if (i08.valid) { for (i = 0; i < i08.value.getNumChannels(); ++i) *array++ = i08.value.atUnchecked (i); }
        if (i09.valid) { for (i = 0; i < i09.value.getNumChannels(); ++i) *array++ = i09.value.atUnchecked (i); }
        if (i10.valid) { for (i = 0; i < i10.value.getNumChannels(); ++i) *array++ = i10.value.atUnchecked (i); }
        if (i11.valid) { for (i = 0; i < i11.value.getNumChannels(); ++i) *array++ = i11.value.atUnchecked (i); }
        if (i12.valid) { for (i = 0; i < i12.value.getNumChannels(); ++i) *array++ = i12.value.atUnchecked (i); }
        if (i13.valid) { for (i = 0; i < i13.value.getNumChannels(); ++i) *array++ = i13.value.atUnchecked (i); }
        if (i14.valid) { for (i = 0; i < i14.value.getNumChannels(); ++i) *array++ = i14.value.atUnchecked (i); }
        if (i15.valid) { for (i = 0; i < i15.value.getNumChannels(); ++i) *array++ = i15.value.atUnchecked (i); }
    }
    
private:
    static int countValidChannels (InitialUnit const& i00,
                                   InitialUnit const& i01,
                                   InitialUnit const& i02,
                                   InitialUnit const& i03,
                                   InitialUnit const& i04,
                                   InitialUnit const& i05,
                                   InitialUnit const& i06,
                                   InitialUnit const& i07,
                                   InitialUnit const& i08,
                                   InitialUnit const& i09,
                                   InitialUnit const& i10,
                                   InitialUnit const& i11,
                                   InitialUnit const& i12,
                                   InitialUnit const& i13,
                                   InitialUnit const& i14,
                                   InitialUnit const& i15,
                                   InitialUnit const& i16,
                                   InitialUnit const& i17,
                                   InitialUnit const& i18,
                                   InitialUnit const& i19,
                                   InitialUnit const& i20,
                                   InitialUnit const& i21,
                                   InitialUnit const& i22,
                                   InitialUnit const& i23,
                                   InitialUnit const& i24,
                                   InitialUnit const& i25,
                                   InitialUnit const& i26,
                                   InitialUnit const& i27,
                                   InitialUnit const& i28,
                                   InitialUnit const& i29,
                                   InitialUnit const& i30,
                                   InitialUnit const& i31) throw()
    {
        int numChannels = 0;
        
        if (i00.valid) numChannels += i00.value.getNumChannels();
        if (i01.valid) numChannels += i01.value.getNumChannels();
        if (i02.valid) numChannels += i02.value.getNumChannels();        
        if (i03.valid) numChannels += i03.value.getNumChannels();
        if (i04.valid) numChannels += i04.value.getNumChannels();
        if (i05.valid) numChannels += i05.value.getNumChannels();
        if (i06.valid) numChannels += i06.value.getNumChannels();
        if (i07.valid) numChannels += i07.value.getNumChannels();
        if (i08.valid) numChannels += i08.value.getNumChannels();
        if (i09.valid) numChannels += i09.value.getNumChannels();
        if (i10.valid) numChannels += i10.value.getNumChannels();
        if (i11.valid) numChannels += i11.value.getNumChannels();
        if (i12.valid) numChannels += i12.value.getNumChannels();
        if (i13.valid) numChannels += i13.value.getNumChannels();
        if (i14.valid) numChannels += i14.value.getNumChannels();
        if (i15.valid) numChannels += i15.value.getNumChannels();
        if (i16.valid) numChannels += i16.value.getNumChannels();
        if (i17.valid) numChannels += i17.value.getNumChannels();
        if (i18.valid) numChannels += i18.value.getNumChannels();
        if (i19.valid) numChannels += i19.value.getNumChannels();
        if (i20.valid) numChannels += i20.value.getNumChannels();
        if (i21.valid) numChannels += i21.value.getNumChannels();
        if (i22.valid) numChannels += i22.value.getNumChannels();
        if (i23.valid) numChannels += i23.value.getNumChannels();
        if (i24.valid) numChannels += i24.value.getNumChannels();
        if (i25.valid) numChannels += i25.value.getNumChannels();
        if (i26.valid) numChannels += i26.value.getNumChannels();
        if (i27.valid) numChannels += i27.value.getNumChannels();
        if (i28.valid) numChannels += i28.value.getNumChannels();
        if (i29.valid) numChannels += i29.value.getNumChannels();
        if (i30.valid) numChannels += i30.value.getNumChannels();
        if (i31.valid) numChannels += i31.value.getNumChannels();
        
        return numChannels;
    }
    
public:
    UnitBase (InitialUnit const &i00,
              InitialUnit const &i01,
              InitialUnit const &i02,
              InitialUnit const &i03,
              InitialUnit const &i04,
              InitialUnit const &i05,
              InitialUnit const &i06,
              InitialUnit const &i07,
              InitialUnit const &i08,
              InitialUnit const &i09,
              InitialUnit const &i10,
              InitialUnit const &i11,
              InitialUnit const &i12,
              InitialUnit const &i13,
              InitialUnit const &i14,
              InitialUnit const &i15,
              InitialUnit const &i16,
              InitialUnit const &i17 = InitialUnit(),
              InitialUnit const &i18 = InitialUnit(),
              InitialUnit const &i19 = InitialUnit(),
              InitialUnit const &i20 = InitialUnit(),
              InitialUnit const &i21 = InitialUnit(),
              InitialUnit const &i22 = InitialUnit(),
              InitialUnit const &i23 = InitialUnit(),
              InitialUnit const &i24 = InitialUnit(),
              InitialUnit const &i25 = InitialUnit(),
              InitialUnit const &i26 = InitialUnit(),
              InitialUnit const &i27 = InitialUnit(),
              InitialUnit const &i28 = InitialUnit(),
              InitialUnit const &i29 = InitialUnit(),
              InitialUnit const &i30 = InitialUnit(),
              InitialUnit const &i31 = InitialUnit()) throw()
        :       Base (NumericalArraySpec (countValidChannels (i00, i01, i02, i03,
                                                      i04, i05, i06, i07,
                                                      i08, i09, i10, i11,
                                                      i12, i13, i14, i15,
                                                      i16, i17, i18, i19,
                                                      i20, i21, i22, i23,
                                                      i24, i25, i26, i27, 
                                                      i28, i29, i30, i31), false))
        {
        int i;
        ChannelType* array = this->getArray();
        
        if (i00.valid) { for (i = 0; i < i00.value.getNumChannels(); ++i) *array++ = i00.value.atUnchecked (i); }
        if (i01.valid) { for (i = 0; i < i01.value.getNumChannels(); ++i) *array++ = i01.value.atUnchecked (i); }
        if (i02.valid) { for (i = 0; i < i02.value.getNumChannels(); ++i) *array++ = i02.value.atUnchecked (i); }
        if (i03.valid) { for (i = 0; i < i03.value.getNumChannels(); ++i) *array++ = i03.value.atUnchecked (i); }
        if (i04.valid) { for (i = 0; i < i04.value.getNumChannels(); ++i) *array++ = i04.value.atUnchecked (i); }
        if (i05.valid) { for (i = 0; i < i05.value.getNumChannels(); ++i) *array++ = i05.value.atUnchecked (i); }
        if (i06.valid) { for (i = 0; i < i06.value.getNumChannels(); ++i) *array++ = i06.value.atUnchecked (i); }
        if (i07.valid) { for (i = 0; i < i07.value.getNumChannels(); ++i) *array++ = i07.value.atUnchecked (i); }
        if (i08.valid) { for (i = 0; i < i08.value.getNumChannels(); ++i) *array++ = i08.value.atUnchecked (i); }
        if (i09.valid) { for (i = 0; i < i09.value.getNumChannels(); ++i) *array++ = i09.value.atUnchecked (i); }
        if (i10.valid) { for (i = 0; i < i10.value.getNumChannels(); ++i) *array++ = i10.value.atUnchecked (i); }
        if (i11.valid) { for (i = 0; i < i11.value.getNumChannels(); ++i) *array++ = i11.value.atUnchecked (i); }
        if (i12.valid) { for (i = 0; i < i12.value.getNumChannels(); ++i) *array++ = i12.value.atUnchecked (i); }
        if (i13.valid) { for (i = 0; i < i13.value.getNumChannels(); ++i) *array++ = i13.value.atUnchecked (i); }
        if (i14.valid) { for (i = 0; i < i14.value.getNumChannels(); ++i) *array++ = i14.value.atUnchecked (i); }
        if (i15.valid) { for (i = 0; i < i15.value.getNumChannels(); ++i) *array++ = i15.value.atUnchecked (i); }
        if (i16.valid) { for (i = 0; i < i16.value.getNumChannels(); ++i) *array++ = i16.value.atUnchecked (i); }
        if (i17.valid) { for (i = 0; i < i17.value.getNumChannels(); ++i) *array++ = i17.value.atUnchecked (i); }
        if (i18.valid) { for (i = 0; i < i18.value.getNumChannels(); ++i) *array++ = i18.value.atUnchecked (i); }
        if (i19.valid) { for (i = 0; i < i19.value.getNumChannels(); ++i) *array++ = i19.value.atUnchecked (i); }
        if (i20.valid) { for (i = 0; i < i20.value.getNumChannels(); ++i) *array++ = i20.value.atUnchecked (i); }
        if (i21.valid) { for (i = 0; i < i21.value.getNumChannels(); ++i) *array++ = i21.value.atUnchecked (i); }
        if (i22.valid) { for (i = 0; i < i22.value.getNumChannels(); ++i) *array++ = i22.value.atUnchecked (i); }
        if (i23.valid) { for (i = 0; i < i23.value.getNumChannels(); ++i) *array++ = i23.value.atUnchecked (i); }
        if (i24.valid) { for (i = 0; i < i24.value.getNumChannels(); ++i) *array++ = i24.value.atUnchecked (i); }
        if (i25.valid) { for (i = 0; i < i25.value.getNumChannels(); ++i) *array++ = i25.value.atUnchecked (i); }
        if (i26.valid) { for (i = 0; i < i26.value.getNumChannels(); ++i) *array++ = i26.value.atUnchecked (i); }
        if (i27.valid) { for (i = 0; i < i27.value.getNumChannels(); ++i) *array++ = i27.value.atUnchecked (i); }
        if (i28.valid) { for (i = 0; i < i28.value.getNumChannels(); ++i) *array++ = i28.value.atUnchecked (i); }
        if (i29.valid) { for (i = 0; i < i29.value.getNumChannels(); ++i) *array++ = i29.value.atUnchecked (i); }
        if (i30.valid) { for (i = 0; i < i30.value.getNumChannels(); ++i) *array++ = i30.value.atUnchecked (i); }
        if (i31.valid) { for (i = 0; i < i31.value.getNumChannels(); ++i) *array++ = i31.value.atUnchecked (i); }
    }
    
    UnitBase (ChannelArrayType const& copy) throw()
        :       UnitType (static_cast<UnitType const&> (copy))
        {
        }    
    
    UnitBase& operator= (UnitBase const& other) throw()
        {
                if (this != &other)
            this->setInternal (other.getInternal());
        
        return *this;
        }
    
    UnitBase& operator= (ChannelType const& other) throw()
        {
                return operator= (UnitBase (other));
        }
    
    UnitBase& operator= (UnitType const& other) throw()
        {
                return operator= (static_cast<UnitBase const&> (other));
        }
    
    UnitBase& operator= (ObjectArray<ChannelType> const& other) throw()
        {
                return operator= (static_cast<UnitBase const&> (other));
        }    
    
    inline operator const ChannelType& () const throw()
    {
        plonk_assert (this->getNumChannels() == 1);
        return this->atUnchecked (0);
    }
    
    inline operator ChannelType& () throw()
    {
        plonk_assert (this->getNumChannels() == 1);
        return this->atUnchecked (0);
    }
    
    template<class ChannelInternalClassType>
    static inline UnitBase createFromInputs (Inputs const& inputs, 
                                             typename ChannelInternalClassType::Data const& data,
                                             BlockSize const& preferredBlockSize,
                                             SampleRate const& preferredSampleRate) throw()
    {        
        Inputs mainInputs = inputs;
        mainInputs.resetExpiredUnits();

        const Dynamic add = mainInputs.remove (IOKey::Add);
        const Dynamic mul = mainInputs.remove (IOKey::Multiply);
                        
        const int numChannels = mainInputs.getMaxNumChannels();
        UnitBase result (UnitBase::withSize (numChannels));
        
        for (int i = 0; i < numChannels; ++i) 
        {
            ChannelInternalType* internal = new ChannelInternalClassType (mainInputs, 
                                                                          data, 
                                                                          preferredBlockSize, 
                                                                          preferredSampleRate);
            
            plonk_assert ((internal->isProxyOwner() == false) || (internal->getNumChannels() == 1));

            internal->initChannel (i);
                        
            result.put (i, ChannelType (internal));
        }
        
        return applyMulAdd (result, UnitBase (mul), UnitBase (add));
    }     
    
    template<class ProxyOwnerChannelInternalClassType>
    static inline UnitBase proxiesFromInputs (Inputs const& inputs, 
                                              typename ProxyOwnerChannelInternalClassType::Data const& data,
                                              BlockSize const& preferredBlockSize,
                                              SampleRate const& preferredSampleRate) throw()
    {        
        Inputs mainInputs = inputs;
        mainInputs.resetExpiredUnits();
        
        const Dynamic add = mainInputs.remove (IOKey::Add);
        const Dynamic mul = mainInputs.remove (IOKey::Multiply);
                
        ChannelArrayType channels;        
        new ProxyOwnerChannelInternalClassType (mainInputs, 
                                                data, 
                                                preferredBlockSize, 
                                                preferredSampleRate, 
                                                channels);
        const int numChannels = channels.length();
        for (int i = 0; i < numChannels; ++i)
            channels.atUnchecked (i).initChannel (i);
        
        UnitBase result (channels);        
        return applyMulAdd (result, UnitBase (mul), UnitBase (add));
    }        
    
    static inline UnitBase applyMulAdd (UnitBase const& mainUnit, 
                                        UnitBase const& mul,
                                        UnitBase const& add) throw()
    {
        UnitBase result = mainUnit;
        
        bool hasMul = true;
        bool hasAdd = true;
                                
        if (mul.isNull() || (mul.isConstant() && (mul.getValue (0) == SampleType (1))))
            hasMul = false;
        
        if (add.isNull() || (add.isConstant() && (add.getValue (0) == SampleType (0))))
            hasAdd = false;
        
        if (hasMul && hasAdd)
            result = MulAddUnit<SampleType>::ar (result, mul, add, BlockSize::noPreference(), SampleRate::noPreference());
        else if (hasMul)
            result *= mul;
        else if (hasAdd)
            result += add;
            
        return result;        
    }
    
    UnitBase ar (const Interp::TypeCode interpType,
                 BlockSize const& preferredBlockSize = BlockSize::getDefault(),
                 SampleRate const& preferredSampleRate = SampleRate::getDefault()) const throw()
    {
        typedef UnitBase<IndexType> RateUnitType;
        const RateUnitType& rateOne (Math<RateUnitType>::get1());

        switch (interpType)
        {
            case Interp::Linear:    return ResampleUnit<SampleType,Interp::Linear>::ar (*this, rateOne, preferredBlockSize, preferredSampleRate);
            case Interp::Lagrange3: return ResampleUnit<SampleType,Interp::Lagrange3>::ar (*this, rateOne, preferredBlockSize, preferredSampleRate);
            default:                return ResampleUnit<SampleType,Interp::Linear>::ar (*this, rateOne, preferredBlockSize, preferredSampleRate);
        }
    }
    
    inline UnitBase ar() const throw()
    {
        return ResampleUnit<SampleType,Interp::Linear>::ar (*this);
    }
    
    UnitBase kr (const Interp::TypeCode interpType) const throw()
    {        
        switch (interpType)
        {
            case Interp::Linear:    return ResampleUnit<SampleType,Interp::Linear>::kr (*this);
            case Interp::Lagrange3: return ResampleUnit<SampleType,Interp::Lagrange3>::kr (*this);
            default:                return ResampleUnit<SampleType,Interp::Linear>::kr (*this);
        }
    }
    
    inline UnitBase kr() const throw()
    {
        return ResampleUnit<SampleType,Interp::Linear>::kr (*this);
    }
    
//    inline UnitBase reblock (BlockSize const& newBlockSize) const throw()
//    {
//        typedef UnitBase<IndexType> RateUnitType;
//        const RateUnitType& rateOne (Math<RateUnitType>::get1());
//        return ResampleUnit<SampleType,Interp::Linear>::ar (*this, rateOne, newBlockSize);
//    }
//    inline UnitBase reblock() const throw()
//    {
//        return ar();
//    }


    inline UnitBase reblock (BlockSize const& newBlockSize) const throw()
    {
        return ReblockUnit<SampleType>::ar (*this, newBlockSize);
    }
    
    inline UnitBase reblock() const throw()
    {
        return ReblockUnit<SampleType>::ar (*this, BlockSize::getDefault());
    }
    
    inline UnitBase lag (UnitBase const& duration) const throw()
    {
        return LagUnit<SampleType>::ar (*this, duration);
    }

    inline UnitBase lag() const throw()
    {
        return LagUnit<SampleType>::ar (*this);
    }
    
    inline UnitBase dc (UnitBase const& control) const throw()
    {
        return DCUnit<SampleType>::ar (*this, control);
    }
    
    inline UnitBase dc() const throw()
    {
        return DCUnit<SampleType>::ar (*this);
    }

    inline UnitBase mix() const throw()
    {
        return MixerUnit<SampleType>::ar (*this, true);
    }
    
    inline UnitBase mixBarrier() const throw()
    {
        return MixerUnit<SampleType>::ar (*this, false);
    }
    
    UnitBase overlapMake (DoubleVariable const& overlap = Math<DoubleVariable>::get0_5(), const bool zeroPad = false) const throw()
    {
        return OverlapMakeUnit<SampleType>::ar (*this, overlap, zeroPad);
    }
    
    UnitBase overlapZeroPad (DoubleVariable const& overlap = Math<DoubleVariable>::get0_5()) const throw()
    {
        return OverlapMakeUnit<SampleType>::ar (*this, overlap, true);
    }
    
    UnitBase overlapMix (DoubleVariable const& overlap = Math<DoubleVariable>::get0_5()) const throw()
    {
        return OverlapMixUnit<SampleType>::ar (*this, overlap);
    }
    
    template<PLONK_BINARYOPFUNCTION(SampleType, op)>
    UnitBase binary (UnitBase const& rightOperand) const throw() 
    {        
        typedef BinaryOpChannelInternal<SampleType,op>      ChannelInternalClassType;
        typedef typename ChannelInternalClassType::Data     Data;
                
        Inputs inputs;
        inputs.put (IOKey::LeftOperand, *this);
        inputs.put (IOKey::RightOperand, rightOperand);
        
        Data data = { -1.0, -1.0 }; // dummy sample rate data
        
        return createFromInputs<ChannelInternalClassType> (inputs, 
                                                           data, 
                                                           BlockSize::noPreference(), 
                                                           SampleRate::noPreference());
    }

    template<PLONK_UNARYOPFUNCTION(SampleType, op)>
    UnitBase unary() const throw() 
    {        
        typedef UnaryOpChannelInternal<SampleType,op>       ChannelInternalClassType;
        typedef typename ChannelInternalClassType::Data     Data;
        
        Inputs inputs;
        inputs.put (IOKey::Generic, *this);
        
        Data data = { -1.0, -1.0 }; // dummy sample rate data
        
        return createFromInputs<ChannelInternalClassType> (inputs, 
                                                           data, 
                                                           BlockSize::noPreference(), 
                                                           SampleRate::noPreference());
    }
     
    PLONK_BINARYOPS(UnitBase);
    PLONK_UNARYOPS(UnitBase);
    
    inline UnitBase linlin (UnitBase const& inLow, UnitBase const& inHigh,
                            UnitBase const& outLow, UnitBase const& outHigh) const throw()
    {
        return plonk::linlin (*this, inLow, inHigh, outLow, outHigh);
    }
    
    inline UnitBase linlin (UnitBase const& outLow, UnitBase const& outHigh) const throw()
    {
        const SampleType peak (TypeUtility<SampleType>::getTypePeak());
        const SampleType peak2peak (peak * Math<SampleType>::get2());
        return plonk::linlin2 (*this, 
                               UnitBase (-peak), UnitBase (peak2peak), 
                               outLow, (outHigh - outLow));
    }
    
    inline UnitBase linexp (UnitBase const& inLow, UnitBase const& inHigh,
                            UnitBase const& outLow, UnitBase const& outHigh) const throw()
    {
        return plonk::linexp (*this, inLow, inHigh, outLow, outHigh);
    }
    
    inline UnitBase linexp (UnitBase const& outLow, UnitBase const& outHigh) const throw()
    {
        const SampleType peak (TypeUtility<SampleType>::getTypePeak());
        const SampleType peak2peak (peak * Math<SampleType>::get2());
        const SampleType reciprocalInRange (plonk::reciprocal (peak2peak));
        return plonk::linexp2 (*this, 
                               UnitBase (reciprocalInRange), UnitBase (-peak * reciprocalInRange), 
                               outLow, (outHigh / outLow));
    }
    
    inline UnitBase linsin (UnitBase const& inLow, UnitBase const& inHigh, 
                     UnitBase const& outLow, UnitBase const& outHigh) const throw()
    {
        return plonk::linsin (*this, inLow, inHigh, outLow, outHigh);
    }
    
    inline UnitBase linsin (UnitBase const& outLow, UnitBase const& outHigh) const throw()
    {
        const SampleType peak (TypeUtility<SampleType>::getTypePeak());
        return plonk::linsin2 (*this, UnitBase (-peak), UnitBase (peak), outLow, outHigh);
    }
    
    inline UnitBase linwelch (UnitBase const& inLow, UnitBase const& inHigh, 
                       UnitBase const& outLow, UnitBase const& outHigh) const throw()
    {
        return plonk::linwelch (*this, inLow, inHigh, outLow, outHigh);
    }
    
    inline UnitBase linwelch (UnitBase const& outLow, UnitBase const& outHigh) const throw()
    {
        const SampleType peak (TypeUtility<SampleType>::getTypePeak());
        return plonk::linwelch (*this, UnitBase (-peak), UnitBase (peak), outLow, outHigh);
    }
    
    inline UnitBase explin (UnitBase const& inLow, UnitBase const& inHigh, 
                     UnitBase const& outLow, UnitBase const& outHigh) const throw()
    {
        return plonk::explin (*this, inLow, inHigh, outLow, outHigh);
    }
        
//    /** Create a array of units by concatenation. */
//    const UnitArray operator<< (UnitType const& other) const throw()   { return UnitArray (*this, other); }
//    
//    /** Create a array of units by concatenation. */
//      const UnitArray operator<< (UnitBase const& other) const throw()   { return UnitArray (*this, other); }
    
    UnitBase operator, (UnitType const& other) const throw();
    UnitBase operator, (UnitBase const& other) const throw();
    
    UnitBase& setLabel (Text const& unitId) throw()
    {
        const int numChannels = this->getNumChannels();
        ChannelType* channels = this->getArray();
        
        for (int i = 0; i < numChannels; ++i) 
            channels[i].setLabel (unitId);        
            
        return *this;
    }

    inline int getNumChannels() const throw() { return this->length(); }
    
    inline UnitBase getChannel (const int index) throw() { return this->wrapAt (index).getChannel (index); }
    
    inline UnitBase getChannel (const int index) const throw() { return this->copy().wrapAt (index).getChannel (index); }

    inline ChannelType getChannelObject (const int index) throw() { return this->wrapAt (index).getChannel (index); }
    
    inline ChannelType getChannelObject (const int index) const throw() { return this->copy().wrapAt (index).getChannel (index); }
    
    UnitBase operator[] (const int index) throw() { return this->getChannel (index); }
    
    UnitBase operator[] (const int index) const throw() { return this->getChannel (index); }
    
    UnitBase& put (const int index, UnitBase const& channel) throw()
    {
        plonk_assert (channel.getNumChannels() == 1); // channel MUST be only a single channel
        plonk_assert (index >= 0);
        plonk_assert (index < this->getNumChannels());
        
        this->getArray() [index] = channel.atUnchecked (0);
        return *this;
    }
    
    UnitBase flatten() const throw()
    {
        const int numChannels = this->getNumChannels();
        UnitBase result = UnitBase::emptyChannels(numChannels);
        
        for (int i = 0; i < numChannels; ++i)
            result.put (i, this->getChannel (i));
        
        return result;
    }
    
    UnitArray group (const int groupSize) const throw()
    {
                return this->flatten().Base::group (groupSize);
    }
    
    BlockSize getMinBlockSize() const throw();
    
    BlockSize getMaxBlockSize() const throw();
        
    inline BlockSize getBlockSize (const int index) const throw()            { return this->wrapAt (index).getBlockSize(); }

    void setBlockSize (BlockSize const& newBlockSize) throw()
    {
        const int numChannels = this->getNumChannels();
        ChannelType* channels = this->getArray();
        
        for (int i = 0; i < numChannels; ++i) 
            channels[i].setBlockSize (newBlockSize);        
    }
    
    BlockSizes getBlockSizes() const throw()
    {
        BlockSizes result (BlockSizes::withSize (this->getNumChannels()));
        
        for (int i = 0; i < this->getNumChannels(); ++i)
            result.put (i, this->getBlockSize (i));
        
        return result;
    }
    
    SampleRate getMinSampleRate() const throw();
    
    SampleRate getMaxSampleRate() const throw();
        
    inline SampleRate getSampleRate (const int index) const throw()          { return this->wrapAt (index).getSampleRate(); }
    
    void setSampleRate (SampleRate const& newSampleRate) throw()
    {
        const int numChannels = this->getNumChannels();
        ChannelType* channels = this->getArray();
        
        for (int i = 0; i < numChannels; ++i) 
            channels[i].setSampleRate (newSampleRate);        
    }   
    
    SampleRates getSampleRates() const throw()
    {
        SampleRates result (SampleRates::withSize (this->getNumChannels()));
        
        for (int i = 0; i < this->getNumChannels(); ++i)
            result.put (i, this->getSampleRate (i));
        
        return result;
    }
    
    inline double getSampleDurationInTicks (const int index) const throw()         { return this->wrapAt (index)->getSampleDurationInTicks(); }
    inline double getBlockDurationInTicks (const int index) const throw()          { return this->wrapAt (index)->getBlockDurationInTicks(); }
    
    inline const DoubleVariable& getOverlap (const int index) const throw()        { return this->wrapAt (index).getOverlap(); }
    inline DoubleVariable& getOverlap (const int index) throw()                    { return this->wrapAt (index).getOverlap(); }
    
    inline bool channelsHaveSameOverlap() const throw()
    {
        const int numChannels = this->getNumChannels();
        plonk_assert (numChannels > 0);

        const ChannelType* channels = this->getArray();
        DoubleVariable overlap = channels[0].getOverlap();
        
        for (int i = 1; i < numChannels; ++i)
            if (channels[i].getOverlap() != overlap)
                return false;
        
        return true;
    }
    
    inline bool channelsHaveSameBlockSize() const throw()
    {
        const int numChannels = this->getNumChannels();
        plonk_assert (numChannels > 0);
        
        const ChannelType* channels = this->getArray();
        BlockSize blockSize = channels[0].getBlockSize();
        
        for (int i = 1; i < numChannels; ++i)
            if (channels[i].getBlockSize() != blockSize)
                return false;
        
        return true;
    }
    
    inline bool channelsHaveSameSampleRate() const throw()
    {
        const int numChannels = this->getNumChannels();
        plonk_assert (numChannels > 0);
        
        const ChannelType* channels = this->getArray();
        SampleRate sampleRate = channels[0].getSampleRate();
        
        for (int i = 1; i < numChannels; ++i)
            if (channels[i].getSampleRate() != sampleRate)
                return false;
        
        return true;
    }
    
    inline const Buffer& getOutputBuffer (const int index) const throw() 
    { 
        return this->wrapAt (index).getOutputBuffer();
    }
    
//    /** Get the output buffer of a specific channel.  
//     Indices out of range will be wrapped to the available channels. */
//    inline Buffer& getOutputBuffer (const int index) throw() 
//    { 
//        return this->wrapAt (index).getOutputBuffer();
//    }
    
    inline const SampleType* getOutputSamples (const int index) const throw()
    { 
        return this->wrapAt (index)->getOutputSamples(); 
    }
    
    inline SampleType* getOutputSamples (const int index) throw()
    { 
        return this->wrapAt (index)->getOutputSamples(); 
    }
    
    inline void setOutputBuffer (const int index, Buffer const& externalBuffer) throw()
    {
        this->atUnchecked (index).setOutputBuffer (externalBuffer);
    }
    
    void setOutputBuffer (BufferArrayType const& externalBuffer) throw()
    {
        const int numBufferChannels = externalBuffer.length();
        const Buffer* bufferChannels = externalBuffer.getArray();
        
        for (int i = 0; i < numBufferChannels; ++i) 
            setOutputBuffer (i, bufferChannels[i]);
    }    
    
    inline const SampleType& getValue (const int index) const throw()
    {
        return this->wrapAt (index).getValue();
    }
    
    inline const Buffer getValues() const throw()
    {
        const int numChannels = this->getNumChannels();
        Buffer result = Buffer::withSize (numChannels);
        SampleType* const resultArray = result.getArray();
        
        for (int i = 0; i < numChannels; ++i)
            resultArray[i] = this->atUnchecked (i).getValue();
        
        return result;
    }
    
    inline const TimeStamp getNextTimeStamp(const int index) const throw()
    {
        return this->wrapAt (index).getNextTimeStamp();
    }
    
    inline UnitBase setNull() throw()
    {
        this->operator= (UnitBase::getNull());
        return *this;
    }
    
    inline bool isNull (const int index) const throw()
    {
        return this->wrapAt (index).isNull();
    }
    
    inline bool isNotNull (const int index) const throw()
    {
        return ! this->isNull (index);
    }
    
    inline bool isConstant (const int index) const throw()
    {
        return this->wrapAt (index).isConstant();
    }
    
    inline bool isEachChannelConstant() const throw()
    {        
        for (int i = 0; i < this->getNumChannels(); ++i)
            if (!this->atUnchecked (i).isConstant())
                return false;
        
        return true;
    }
    
    inline bool isNotConstant (const int index) const throw()
    {
        return ! this->isConstant (index);
    }    
    
    inline bool isNull() const throw()
    {
        if (this->getNumChannels() != 1)
            return false;
        else if (this->at(0).isNull())
            return true;
        else
            return false;
    }
    
    inline bool isNotNull() const throw()
    {
        return ! this->isNull();
    }
    
    inline bool isConstant() const throw()
    {
        if (this->getNumChannels() != 1)
            return false;
        else if (this->at (0).isConstant())
            return true;
        else
            return false;
    }
    
    inline bool isNotConstant() const throw()
    {
        return ! this->isConstant();
    }    
    
    inline void setToNull() throw()
    {
        this->setSize (1, true);
        this->put (0, ChannelType::getNull());
    }
    
    inline TextArray getNames() throw()
    {
        TextArray names;
        for (int i = 0; i < this->getNumChannels(); ++i)
            names.add (this->at (i).getName());
        return names;
    }
    
    inline bool needsToProcess (ProcessInfo const& info, const int channel) const throw()
    {        
        return this->wrapAt (channel).needsToProcess (info, channel);
    }
    
    inline bool shouldBeDeletedNow (ProcessInfo const& info) const throw()
    {
        bool flag = true;
        
        const int numChannels = this->getNumChannels();
        const ChannelType* channels = this->getArray();
        
        for (int i = 0; i < numChannels; ++i)
        {
            if (!channels[i].shouldBeDeletedNow (info.getTimeStamp()))
            {
                flag = false;
                break;
            }
        }
        
        return flag;
    }
    
    void resetIfExpired() throw()
    {
        const int numChannels = this->getNumChannels();
        ChannelType* channels = this->getArray();
        
        for (int i = 0; i < numChannels; ++i)
            channels[i].resetIfExpired();
    }
    
//    /** Process a specific channel in this unit.
//     The host should prepare a ProcessInfo which is passed to this function
//     for each required block of data. This is generally used by ChannelInternal
//     subclasses when obtaining input data. 
//     @return The buffer from the requested channel. */
//    inline const Buffer& process (ProcessInfo& info, const int channel) throw()
//    {
//        ChannelType& theChannel (this->wrapAt (channel));
//        
//        if (theChannel.shouldBeDeletedNow (info.getTimeStamp()))
//        {
//            Buffer& buffer = theChannel.getOutputBuffer();
//            buffer.zero();
//            return buffer;
//        }
//        else
//        {
//            theChannel.process (info, channel);
//            return this->getOutputBuffer (channel);
//        }
//        
//    }
    
    inline const Buffer& process (ProcessInfo& info, const int channel) throw()
    {
        this->wrapAt (channel).process (info, channel);
        return this->getOutputBuffer (channel);
    }

    
//    /** Process all channels in this unit.
//     The host should prepare a ProcessInfo which is passed to this function
//     for each required block of data. */    
//    void process (ProcessInfo& info) throw()
//    {        
//        const int numChannels = this->getNumChannels();
//        ChannelType* channels = this->getArray();
//                        
//        if (numChannels > 0)
//        {
//            int i;
//            bool didDelete = false;
//            
//            for (i = 0; i < numChannels; ++i) 
//            {
//                if (channels[i].shouldBeDeletedNow (info.getTimeStamp()))
//                {
//                    didDelete = true;
//                    break;
//                }
//            }
//                        
//            if (didDelete == false)
//            {
//                for (i = 0; i < numChannels; ++i)
//                    channels[i].process (info, i);
//            }
//            else
//            {
//                this->setToNull();
//                this->atUnchecked (0).process (info, 0); // probably unnecessary?
//            }
//        }
//    }

//    /** Process all channels in this unit.
//     The host should prepare a ProcessInfo which is passed to this function
//     for each required block of data. */
//    void process (ProcessInfo& info) throw()
//    {
//        const int numChannels = this->getNumChannels();
//        ChannelType* channels = this->getArray();
//        
//        for (int i = 0; i < numChannels; ++i)
//        {
//            if (channels[i].shouldBeDeletedNow (info.getTimeStamp()))
//                channels[i].getOutputBuffer().zero();
//            else
//                channels[i].process (info, i);
//        }
//    }
    
    void process (ProcessInfo& info) throw()
    {
        const int numChannels = this->getNumChannels();
        ChannelType* channels = this->getArray();
        
        for (int i = 0; i < numChannels; ++i)
            channels[i].process (info, i);
    }

    
    int getTypeCode() const throw()
    {
        return TypeUtility<UnitBase>::getTypeCode();
    }
    
    int getSampleTypeCode() const throw()
    {
        return TypeUtility<SampleType>::getTypeCode();
    }          
    
    typename TypeUtility<SampleType>::PeakType getTypePeak() const throw()
    {
        return TypeUtility<SampleType>::getTypePeak();
    }
    
    typename TypeUtility<SampleType>::IndexType getTypeScale() const throw()
    {
        return TypeUtility<SampleType>::getTypeScale();
    }
    
    void addReceiverToChannels (Receiver* const receiver)
    {
        const int numChannels = this->getNumChannels();
        ChannelType* channels = this->getArray();

        for (int i = 0; i < numChannels; ++i)
            channels[i].getInternal()->addReceiver (receiver);
    }
    
    void removeReceiverFromChannels (Receiver* const receiver)
    {
        const int numChannels = this->getNumChannels();
        ChannelType* channels = this->getArray();
        
        for (int i = 0; i < numChannels; ++i)
            channels[i].getInternal()->removeReceiver (receiver);
    }

    
    PLONK_OBJECTARROWOPERATOR(UnitBase);
    
private:
    UnitBase (BlockSize const& blockSize) throw()
    :   UnitType (ChannelType())
    {
        (void)blockSize;
        // you must have got your arguments mixed up, perhaps you tried to 
        // set a unit block size but missed out mul or add arguments? 
        plonk_assertfalse; 
    }
    
    UnitBase (SampleRate const& sampleRate) throw()
    :   UnitType (ChannelType())
    {
        (void)sampleRate;
        // you must have got your arguments mixed up, perhaps you tried to 
        // set a unit sample rate but missed out mul or add arguments? 
        plonk_assertfalse;
    }        
};

PLONK_BINARYOPGLOBALS_TEMPLATE(UnitBase,SampleType); // declares global functions with the same name as the binary operators
PLONK_UNARYOPGLOBALS_TEMPLATE(UnitBase,SampleType);  // declares global functions with the same name as the unary operators

//template<class SampleType>
//inline UnitBase<SampleType> explin (UnitBase<SampleType> const& input, 
//                                    UnitBase<SampleType> const& inLow, UnitBase<SampleType> const& inHigh, 
//                                    UnitBase<SampleType> const& outLow, UnitBase<SampleType> const& outHigh) throw()
//{
//    const UnitBase<SampleType> clipped (clip (input, inLow, inHigh));
//    return log (clipped / inLow) / log (inHigh / inLow) * (outHigh - outLow) + outLow;
//}

template<class SampleType>
UnitBase<SampleType> ar (UnitBase<SampleType> const& unit,
                         BlockSize const& preferredBlockSize = BlockSize::getDefault(),
                         SampleRate const& preferredSampleRate = SampleRate::getDefault()) throw()
{
    return unit.ar (preferredBlockSize, preferredSampleRate);
}    

template<class SampleType>
inline UnitBase<SampleType> kr (UnitBase<SampleType> const& unit) throw()
{
    return unit.kr();
}

template<class SampleType>
inline UnitBase<SampleType> mix (UnitBase<SampleType> const& unit) throw()
{
    return unit.mix();
}


//------------------------------------------------------------------------------

template<class SampleType>
UnitBase<SampleType> UnitBase<SampleType>::operator, (UnitType const& other) const throw()
{ 
    return operator, (UnitBase (other));
}

template<class SampleType>
UnitBase<SampleType> UnitBase<SampleType>::operator, (UnitBase const& other) const throw()
{ 
    const int numChannels = getNumChannels() + other.getNumChannels();
    UnitBase result (UnitBase::withSize (numChannels));
    
    int resultIndex = 0;
    int sourceIndex;
    
    for (sourceIndex = 0; sourceIndex < getNumChannels(); ++sourceIndex) 
        result.put (resultIndex++, this->at (sourceIndex));
    
    for (sourceIndex = 0; sourceIndex < other.getNumChannels(); ++sourceIndex) 
        result.put (resultIndex++, other.at (sourceIndex));
    
    return result;        
}

template<class SampleType>
BlockSize UnitBase<SampleType>::getMinBlockSize() const throw()
{
    const int numChannels = this->getNumChannels();
    BlockSize blockSize = this->atUnchecked (0).getBlockSize();
    
    for (int i = 1; i < numChannels; ++i) 
    {
        const BlockSize& channelBlockSize = this->atUnchecked (i).getBlockSize();
        blockSize = blockSize.selectMin (channelBlockSize);        
    }
    
    return blockSize;
}

template<class SampleType>
BlockSize UnitBase<SampleType>::getMaxBlockSize() const throw()
{
    const int numChannels = this->getNumChannels();
    BlockSize blockSize = this->atUnchecked (0).getBlockSize();
    
    for (int i = 1; i < numChannels; ++i) 
    {
        const BlockSize& channelBlockSize = this->atUnchecked (i).getBlockSize();
        blockSize = blockSize.selectMax (channelBlockSize);        
    }
    
    return blockSize;
}

template<class SampleType>
SampleRate UnitBase<SampleType>::getMinSampleRate() const throw()
{
    const int numChannels = this->getNumChannels();
    SampleRate sampleRate = this->atUnchecked (0).getSampleRate();
    
    for (int i = 1; i < numChannels; ++i) 
    {
        const SampleRate& channelSampleRate = this->atUnchecked (i).getSampleRate();
        sampleRate = sampleRate.selectMin (channelSampleRate);        
    }
    
    return sampleRate;    
}

template<class SampleType>
SampleRate UnitBase<SampleType>::getMaxSampleRate() const throw()
{
    const int numChannels = this->getNumChannels();
    SampleRate sampleRate = this->atUnchecked (0).getSampleRate();
    
    for (int i = 1; i < numChannels; ++i) 
    {
        const SampleRate& channelSampleRate = this->atUnchecked (i).getSampleRate();
        sampleRate = sampleRate.selectMax (channelSampleRate);        
    }
    
    return sampleRate;        
}


#endif // PLONK_UNIT_H