Waveform.hpp

/*
 Waveform.hpp
 Waveform class provides functions frequently used in the RF simulations.
 Written by Paul Schellin at the Ohio State University, 2012-2013
 */

#ifndef WAVEFORM_HPP
#define WAVEFORM_HPP 1
#pragma once


// Standard libraries
#include <iostream>
#include <algorithm>
#include <functional>
#include <iterator>
#include <numeric>
//#include <fstream>
#include <string>
#include <cmath>
//#include <iomanip>
//#include <sstream>


// Boost header files

#include <boost/operators.hpp>

#include <boost/range.hpp>

#include <boost/assert.hpp>


#define WAVEFORM_USE_CBEGIN_CEND 1

namespace PS {
        

    class PlaceholderTransformClass {
      public:
        template <typename Iterator1, typename Iterator2>
        PlaceholderTransformClass (Iterator1 first1, Iterator1 last1, Iterator2 first2)
        {

        }

        template <typename RandomAccessRange1, typename RandomAccessRange2>
        PlaceholderTransformClass (RandomAccessRange1& range1, RandomAccessRange2& range2)
        {

        }

        ~PlaceholderTransformClass (void)
        {

        }


        void
        exec_transform (void)
        {

        }


        void
        exec_inverse_transform (void)
        {

        }
    };
    
    
    
    

    template< /*template<typename...> class*/ typename TimeContainer
            , /*template<typename...> class*/ typename FreqContainer = TimeContainer
            , typename TransformT = PlaceholderTransformClass
            >
            /*
            < typename T1
            , typename T2 = T1
            , template <typename ...ArgsX1> class Container1 = std::vector
            , template <typename ...ArgsX2> class Container2 = Container1
            //, typename ...Args1
            //, typename ...Args2
            >
            */

    class Waveform {
      public:

        typedef typename TimeContainer::value_type  TimeT;
        
        typedef typename FreqContainer::value_type  FreqT;
        
        typedef typename std::pair<TimeT,FreqT> value_type;
        
        typedef typename TimeContainer::allocator_type TimeAllocT;
        
        typedef typename FreqContainer::allocator_type  FreqAllocT;

        typedef typename TimeContainer::iterator    TimeIterator;
        
        typedef typename FreqContainer::iterator    FreqIterator;
        

        typedef typename TimeContainer::const_iterator  TimeConstIterator;
        
        typedef typename FreqContainer::const_iterator  FreqConstIterator;
        
        


        enum DomainSpecifier {TimeDomain, FreqDomain, EitherDomain};
        
      private:

        DomainSpecifier             validDomain_;

        TimeContainer   timeSeries_;

        FreqContainer   freqSpectrum_;

        TransformT      transform_;
 

        Waveform(void) = delete;
        /*
        Waveform(void)
            : validDomain_(EitherDomain)
        { }
        */
        
      public:
        
        Waveform(const std::size_t count)
            : validDomain_(EitherDomain)
            , timeSeries_(count)
            , freqSpectrum_(count)
            , transform_(timeSeries_, freqSpectrum_)
        { 
            if (timeSeries_.size()%2)
                throw std::length_error("Waveform: The array length was not a multiple of 2!");
        }


        explicit Waveform(const Waveform& toCopy)
            : validDomain_(toCopy.validDomain_)
            , timeSeries_(toCopy.timeSeries_)
            , freqSpectrum_(toCopy.freqSpectrum_)
            , transform_(timeSeries_, freqSpectrum_)
        {
            if (timeSeries_.size()%2)
                throw std::length_error("Waveform: The array length was not a multiple of 2!");
        }
        
        
        explicit Waveform(const TimeContainer& toCopy)
            : validDomain_(TimeDomain)
            , timeSeries_(toCopy)
            , freqSpectrum_(timeSeries_.size()/2 + 1)
            , transform_(timeSeries_, freqSpectrum_)
        {
            if (timeSeries_.size()%2)
                throw std::length_error("Waveform: The array length was not a multiple of 2!");
        }
        
        explicit Waveform(const FreqContainer& toCopy)
            : validDomain_(FreqDomain)
            , timeSeries_((toCopy.size() - 1) * 2)
            , freqSpectrum_(toCopy)
            , transform_(timeSeries_, freqSpectrum_)
        {
            if (timeSeries_.size()%2)
                throw std::length_error("Waveform: The array length was not a multiple of 2!");
        }
        
        ~Waveform (void) {}
        
        

        std::size_t
        GetSize (void) //const
        { return GetConstTimeSeries().size(); }
    

        std::size_t
        size (void) //const
        { return GetConstTimeSeries().size(); }
        


        const TimeContainer&
        GetConstTimeSeries (void)
        { ValidateDomain(EitherDomain); return timeSeries_; }
        


        const FreqContainer&
        GetConstFreqSpectrum (void)
        { ValidateDomain(EitherDomain); return freqSpectrum_; }
        


        TimeContainer&
        GetTimeSeries (void)
        { ValidateDomain(TimeDomain); return timeSeries_; }
        


        FreqContainer&
        GetFreqSpectrum (void)
        { ValidateDomain(FreqDomain); return freqSpectrum_; }
        
        


        //
        //
        //      Iterator Access Functions
        //
        //

        /*
            Because of the nature of the Waveform class, I'm most likely
            going to be removing the iterator functions from the library.

            The iterators will still be available from the containers
            themselves, of course, but because there is no obvious way
            to have just a "begin()" or "end()" function instead of
            "beginTime()" and "beginFreq()", and with there being no
            impact on performance either way, there is no good reason to
            keep the functions.

            Issues with not being able to mark "const" a function at the
            same time as checking the domain array validity (though there
            is a way to do it -- check in the function itself and throw an
            exception if the domain is not valid, but it's error prone and
            ugly) makes it difficult to consider this portion of the library
            intuitive or well-formed.

            The only reason iterators would be very useful is if they
            provided validation checks as well, but at the moment that
            portion of the library is not yet completed.
         
         
            [ Iterator access functions have been removed ]
         */

        //______________________________________________________________________

        int
        ValidateDomain (const DomainSpecifier toValidate)
        {
            if (toValidate == validDomain_ || validDomain_ == EitherDomain) {
                //  There aren't any transforms to be performed
            }
            else if (toValidate == TimeDomain) {
                transform_.exec_inverse_transform();
            }
            else if (toValidate == FreqDomain) {
                transform_.exec_transform();
            }
            else if (toValidate == EitherDomain) {
                if (validDomain_ == TimeDomain) {
                    transform_.exec_transform();
                } else // if (validDomain_ == FreqDomain)
                {
                    transform_.exec_inverse_transform();
                }
            }
            
            validDomain_ = toValidate;
            return 0;
        }
        



        friend void swap(Waveform& first, Waveform& second)
        {
            using std::swap;

            swap(first.validDomain_, second.validDomain_);

            swap(first.timeSeries_, second.timeSeries_);

            swap(first.freqSpectrum_, second.freqSpectrum_);

            swap(first.transform_, second.transform_);
        }



        //template <typename WaveformT>
        Waveform&
        //operator= (const Waveform& rhs)
        //operator= (WaveformT rhs)
        operator= (Waveform rhs)
        {
            swap(*this, rhs);

            return *this;
        }



        Waveform(Waveform&& rhs)
            : Waveform()
        {
            swap(*this, rhs);
        }
        
    };


    template <typename ...Args1, typename ...Args2>
    inline bool
    operator==(const Waveform<Args1...>& lhs, const Waveform<Args2...>& rhs)
    {
        //  Could probably just see what the valid domain is and compare only that.
        //  Perhaps in a later version.

        //  At the very least it makes sense to check the valid domain first, because
        //  the valid domain doesn't require a transform. 
        //  However, that would require either this function to be a friend function or
        //  for the validDomain_ variable to be made public.
        return lhs.GetTimeSeries() == rhs.GetTimeSeries() && lhs.GetFreqSpectrum() == rhs.GetFreqSpectrum();
    }

    template <typename ...Args1, typename ...Args2>
    inline bool
    operator!=(const Waveform<Args1...>& lhs, const Waveform<Args2...>& rhs)
    {
        return !(lhs == rhs);
    }


    
} // End of namespace PS

#endif