/home/raskolnikov/dev/psynth/trunk/src/psynth/sound/concept.hpp

Go to the documentation of this file.

/*
 *  Copyright (C) 2010 Juan Pedro Bolivar Puente
 *
 *  This file is part of Psychosynth.
 *   
 *  Psychosynth is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  Psychosynth is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 */

/*
 *  Copyright 2005-2007 Adobe Systems Incorporated
 * 
 *  Use, modification and distribution are subject to the Boost
 *  Software License, Version 1.0. (See accompanying file
 *  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt).
 */

#ifndef PSYNTH_SOUND_CONCEPT_H
#define PSYNTH_SOUND_CONCEPT_H

#include <psynth/base/concept.hpp>
#include <psynth/sound/forwards.hpp>

#include <type_traits>
#include <boost/type_traits.hpp>
#include <functional>
#include <boost/utility/enable_if.hpp>
#include <boost/iterator/iterator_concepts.hpp>
#include <boost/mpl/and.hpp>
#include <boost/mpl/size.hpp>

namespace psynth
{
namespace sound
{

/*
 *
 *       Extra iterator concepts.
 *
 */

namespace detail
{

template <class TT>
    /* Preconditions: TT Models
       boost_concepts::ForwardTraversalConcept */
struct ForwardIteratorIsMutableConcept
{
    void constraints() {
        *i++ = *i;    // require postincrement and assignment
    }
    TT i;
};

template <class TT>
/* Preconditions: TT Models boost::BidirectionalIteratorConcept */
struct BidirectionalIteratorIsMutableConcept
{
    void constraints() {
        base::psynth_function_requires< ForwardIteratorIsMutableConcept<TT> >();
        *i-- = *i;                  // require postdecrement and assignment
    }
    TT i;
};

template <class TT>
/* Preconditions: TT Models
   boost_concepts::RandomAccessTraversalConcept */
struct RandomAccessIteratorIsMutableConcept
{
    void constraints() {
        base::psynth_function_requires< BidirectionalIteratorIsMutableConcept<TT> >();
        typename std::iterator_traits<TT>::difference_type n=0;
        ignore_unused_variable_warning(n);
        i[n] = *i;
        // require element access and assignment
    }
    TT i;
};

} /* namespace detail */


/*
 *
 *  Channel Space concepts.
 *
 */

template <typename Cs>
struct ChannelSpaceConcept
{
    void constraints() {
        // An MPL Random Access Sequence, whose elements are channel tags
    }
};

template <typename ChannelSpace1, typename ChannelSpace2>
// Models ChannelSpaceConcept
struct channel_spaces_are_compatible :
    public boost::is_same<ChannelSpace1, ChannelSpace2> {};

template <typename Cs1, typename Cs2>
struct ChannelSpacesCompatibleConcept
{
    void constraints() {
        BOOST_STATIC_ASSERT((channel_spaces_are_compatible<Cs1,Cs2>::value));
    }
};


/*
 *
 *  Sample concepts
 *
 */

template <typename CM>
struct SampleMappingConcept
{
    void constraints() {
        // An MPL Random Access Sequence, whose elements model
        // MPLIntegralConstant representing a permutation
    }
};


template <typename T>
struct SampleConcept
{
    void constraints() {
        base::psynth_function_requires< boost::EqualityComparableConcept<T> >(); 
        
        typedef typename sample_traits<T>::value_type v;
        typedef typename sample_traits<T>::reference r;
        typedef typename sample_traits<T>::pointer p;
        typedef typename sample_traits<T>::const_reference cr;
        typedef typename sample_traits<T>::const_pointer cp;

        sample_traits<T>::min_value ();
        sample_traits<T>::max_value ();
        sample_traits<T>::zero_value (); // Added for sound. It is
                                         // important to know which is
                                         // the stable central value.
    }

     T c;
};

namespace detail
{

// Preconditions: T models SampleConcept
template <typename T>
struct SampleIsMutableConcept
{
    void constraints() {
        c=c;
        using std::swap;
        swap(c,c);
    }
    T c;
};

} /* namespace detail*/

template <typename T>
struct MutableSampleConcept
{
    void constraints() {
        base::psynth_function_requires<SampleConcept<T> >();
        base::psynth_function_requires<detail::SampleIsMutableConcept<T> >();
    }
};

template <typename T>
struct SampleValueConcept
{
    void constraints() {
        base::psynth_function_requires<SampleConcept<T> >();
        base::psynth_function_requires<base::Regular<T> >();
    }
};

template <typename T1, typename T2>  // Models Psynth Frame
struct samples_are_compatible 
    : public boost::is_same<typename sample_traits<T1>::value_type,
                            typename sample_traits<T2>::value_type> {};

template <typename T1, typename T2>
struct SamplesCompatibleConcept
{
    void constraints() {
        BOOST_STATIC_ASSERT((samples_are_compatible<T1,T2>::value));
    }
};

template <typename SrcSample, typename DstSample>
struct SampleConvertibleConcept
{
    void constraints() {
        base::psynth_function_requires<SampleConcept<SrcSample> >();
        base::psynth_function_requires<MutableSampleConcept<DstSample> >();
        dst = sample_convert<DstSample, SrcSample>(src);
        ignore_unused_variable_warning(dst);
    }
    SrcSample src;
    DstSample dst;
};


template <typename ChannelBase>
struct ChannelBaseConcept
{
    void constraints() {
        base::psynth_function_requires< base::CopyConstructible<ChannelBase> >();
        base::psynth_function_requires< base::EqualityComparable<ChannelBase> >();

        typedef typename ChannelBase::layout::channel_space channel_space;
        base::psynth_function_requires<ChannelSpaceConcept<channel_space> >();

        typedef typename ChannelBase::layout_t::sample_mapping sample_mapping;
        // TODO: sample_mapping_t must be an MPL RandomAccessSequence

        static const std::size_t num_elements = size<ChannelBase>::value;

        typedef typename kth_element_type<ChannelBase,num_elements-1>::type TN; 
        typedef typename kth_element_const_reference_type<
            ChannelBase, num_elements-1>::type CR; 

#if !defined(_MSC_VER) || _MSC_VER > 1310
        CR cr = at_c<num_elements-1>(cb);
        ignore_unused_variable_warning(cr);
#endif

        // functions that work for every frame (no need to require them)
        semantic_at_c<0>(cb);
        semantic_at_c<num_elements-1>(cb);
        // also static_max(cb), static_min(cb), static_fill(cb,value),
        // and all variations of static_for_each(), static_generate(),
        // static_transform()
    }

    ChannelBase cb;
};

template <typename ChannelBase>
struct MutableChannelBaseConcept
{
    void constraints() {
        base::psynth_function_requires< ChannelBaseConcept<ChannelBase> >();
        base::psynth_function_requires< base::Assignable<ChannelBase> >();
        base::psynth_function_requires< base::Swappable<ChannelBase> >();

        typedef typename kth_element_reference_type<ChannelBase, 0>::type CR; 

#if !defined(_MSC_VER) || _MSC_VER > 1310
        CR r=at_c<0>(cb);
        at_c<0>(cb)=r;
#endif
    }

    ChannelBase cb;
};

template <typename ChannelBase>
struct ChannelBaseValueConcept
{
    void constraints() {
        base::psynth_function_requires< MutableChannelBaseConcept<ChannelBase> >();
        base::psynth_function_requires< base::Regular<ChannelBase> >();
    }
};

template <typename ChannelBase>
struct HomogeneousChannelBaseConcept
{
    void constraints() {
        base::psynth_function_requires< ChannelBaseConcept<ChannelBase> >();

        static const std::size_t num_elements = size<ChannelBase>::value;

        typedef typename kth_element_type<ChannelBase,0>::type T0; 
        typedef typename kth_element_type<ChannelBase,num_elements-1>::type TN; 

        BOOST_STATIC_ASSERT((boost::is_same<T0,TN>::value));
        // better than nothing
        typedef typename kth_element_const_reference_type<
            ChannelBase,0>::type CRef0; 
        CRef0 e0=dynamic_at_c(cb,0);
    }
    ChannelBase cb;
};

template <typename ChannelBase>
struct MutableHomogeneousChannelBaseConcept
{
    void constraints() {
        base::psynth_function_requires< ChannelBaseConcept<ChannelBase> >();
        base::psynth_function_requires< HomogeneousChannelBaseConcept<ChannelBase> >();
        typedef typename kth_element_reference_type<ChannelBase, 0>::type R0;
        R0 x = dynamic_at_c (cb, 0);
        dynamic_at_c(cb,0) = dynamic_at_c (cb, 0);
    }
    ChannelBase cb;
};

template <typename ChannelBase>
struct HomogeneousChannelBaseValueConcept
{
    void constraints() {
        base::psynth_function_requires<
            MutableHomogeneousChannelBaseConcept<ChannelBase> >();
        base::psynth_function_requires< base::Regular<ChannelBase> >();
    }
};


template <typename ChannelBase1, typename ChannelBase2>
struct ChannelBasesCompatibleConcept
{
    void constraints() {
        BOOST_STATIC_ASSERT(
            (boost::is_same<typename ChannelBase1::layout_type::channel_space, 
             typename ChannelBase2::layout_type::channel_space>::value));
//        typedef typename kth_semantic_element_type<ChannelBase1,0>::type e1;
//        typedef typename kth_semantic_element_type<ChannelBase2,0>::type e2;
//        "e1 is convertible to e2"
    }
};


/*
 *
 *      Frame Concepts
 *
 */

template <typename P>
struct FrameBasedConcept
{
    void constraints() {
        typedef typename channel_space_type<P>::type channel_space;
        base::psynth_function_requires<ChannelSpaceConcept<channel_space> >();

        typedef typename sample_mapping_type<P>::type sample_mapping;
        base::psynth_function_requires<SampleMappingConcept<sample_mapping> >();

        static const bool planar = is_planar<P>::type::value;
        boost::ignore_unused_variable_warning(planar);


        // This is not part of the concept, but should still work
        static const std::size_t nc = num_samples<P>::value;
        boost::ignore_unused_variable_warning(nc);
    }
};

template <typename P>
struct HomogeneousFrameBasedConcept
{
    void constraints()
    {
        base::psynth_function_requires<FrameBasedConcept<P> >();

        typedef typename sample_type<P>::type sample;
        base::psynth_function_requires<SampleConcept<sample> >();        
    }
};


template <typename F>
struct FrameConcept
{
    void constraints() {
        base::psynth_function_requires<ChannelBaseConcept<F> >();
        base::psynth_function_requires<FrameBasedConcept<F> >();

        BOOST_STATIC_ASSERT((is_frame<F>::value));
        static const bool is_mutable = F::is_mutable;
        boost::ignore_unused_variable_warning(is_mutable);

        typedef typename F::value_type      value_type;
//      base::psynth_function_requires<FrameValueConcept<value_type> >();

        typedef typename F::reference       reference;
        base::psynth_function_requires<
            FrameConcept<typename remove_const_and_reference<reference>::type> >();

        typedef typename F::const_reference const_reference;
        base::psynth_function_requires<
            FrameConcept<
                typename remove_const_and_reference<const_reference>::type> >();
    }
};


template <typename F>
struct MutableFrameConcept
{
    void constraints() {
        base::psynth_function_requires<FrameConcept<F> >();
        BOOST_STATIC_ASSERT(F::is_mutable);
    }
};

template <typename F>
struct HomogeneousFrameConcept
{
    void constraints() {
        base::psynth_function_requires<FrameConcept<F> >();
        base::psynth_function_requires<HomogeneousChannelBaseConcept<F> >();
        base::psynth_function_requires<HomogeneousFrameBasedConcept<F> >();
        p[0];
    }
    F p;
};

template <typename F>
struct MutableHomogeneousFrameConcept
{
    void constraints() {
        base::psynth_function_requires<HomogeneousFrameConcept<F> >();
        base::psynth_function_requires<MutableHomogeneousChannelBaseConcept<F> >();
        p[0] = p[0];
    }
    F p;
};

template <typename F>
struct FrameValueConcept
{
    void constraints() {
        base::psynth_function_requires<FrameConcept<F> >();
        base::psynth_function_requires<base::Regular<F> >();
    }
};

template <typename F>
struct HomogeneousFrameValueConcept
{
    void constraints() {
        base::psynth_function_requires<HomogeneousFrameConcept<F> >();
        base::psynth_function_requires<base::Regular<F> >();
        BOOST_STATIC_ASSERT((boost::is_same<F, typename F::value_type>::value));
    }
};

namespace detail
{
    template <typename F1, typename F2, int K>
    struct samples_are_pairwise_compatible : public 
        boost::mpl::and_<
        samples_are_pairwise_compatible<F1,F2,K-1>,
        samples_are_compatible<
            typename kth_semantic_element_reference_type<F1,K>::type,
            typename kth_semantic_element_reference_type<F2,K>::type> >
    {};
                                                 
    template <typename F1, typename F2>
    struct samples_are_pairwise_compatible<F1, F2, -1> :
        public boost::mpl::true_ {};
} /* namespace detail */

template <typename F1, typename F2>  // Models Psynth Frame
struct frames_are_compatible 
    : public boost::mpl::and_<typename channel_spaces_are_compatible<
                                  typename channel_space_type<F1>::type, 
                                  typename channel_space_type<F2>::type>::type, 
                              detail::samples_are_pairwise_compatible<
                                  F1, F2, num_samples<F1>::value-1> > {};

template <typename F1, typename F2>
// precondition: P1 and P2 model FrameConcept
struct FramesCompatibleConcept
{
    void constraints() {
        BOOST_STATIC_ASSERT((frames_are_compatible<F1,F2>::value));
    }
};

template <typename SrcP, typename DstP>
struct FrameConvertibleConcept
{
    void constraints() {
        base::psynth_function_requires<FrameConcept<SrcP> >();
        base::psynth_function_requires<MutableFrameConcept<DstP> >();
        channel_convert(src,dst);
    }
    SrcP src;
    DstP dst;
};


/*
 *
 *      Dereference Adaptors Concepts
 *
 */

template <typename D>
struct FrameDereferenceAdaptorConcept
{
    void constraints() {
        base::psynth_function_requires< boost::UnaryFunctionConcept<D, 
            typename remove_const_and_reference<typename D::result_type>::type, 
            typename D::argument_type> >();
        base::psynth_function_requires< boost::DefaultConstructibleConcept<D> >();
        base::psynth_function_requires< boost::CopyConstructibleConcept<D> >();
        base::psynth_function_requires< boost::AssignableConcept<D> >();

        base::psynth_function_requires<FrameConcept<
            typename remove_const_and_reference<
                typename D::result_type>::type> >();

        typedef typename D::const_t const_t;
        base::psynth_function_requires<FrameDereferenceAdaptorConcept<const_t> >();
        typedef typename D::value_type value_type;
        base::psynth_function_requires<FrameValueConcept<value_type> >();
        typedef typename D::reference reference;
        // == FrameConcept (if you remove const and reference)
        typedef typename D::const_reference const_reference;
        // == FrameConcept (if you remove const and reference)

        const bool is_mutable = D::is_mutable;
        boost::ignore_unused_variable_warning (is_mutable);
    }
    D d;
};

template <typename F>
struct FrameDereferenceAdaptorArchetype : public std::unary_function<F, F>
{
    typedef FrameDereferenceAdaptorArchetype const_t;
    typedef typename boost::remove_reference<F>::type value_type;
    typedef typename boost::add_reference<F>::type reference;
    typedef reference const_reference;
    static const bool is_mutable=false;
    F operator()(F x) const { throw; }
};


/*
 *
 *     Frame iterator concepts.
 *
 */

template <typename T>
struct HasDynamicStepTypeConcept
{   
    void constraints () {
        typedef typename dynamic_step_type<T>::type type;
    }
};

template <typename Iterator>
struct FrameIteratorConcept
{   
    void constraints()
    {
        base::psynth_function_requires<
            boost_concepts::RandomAccessTraversalConcept<Iterator> >();
        base::psynth_function_requires<FrameBasedConcept<Iterator> >();
        
        typedef typename std::iterator_traits<Iterator>::value_type value_type;
        base::psynth_function_requires<FrameValueConcept<value_type> >();
 
        typedef typename const_iterator_type<Iterator>::type const_t;
        static const bool is_mut = iterator_is_mutable<Iterator>::type::value;
        boost::ignore_unused_variable_warning (is_mut);

        const_t const_it(it);
        boost::ignore_unused_variable_warning(const_it);
        // immutable iterator must be constructible from (possibly
        // mutable) iterator

        check_base (typename is_iterator_adaptor<Iterator>::type ());
    }
    
    void check_base(boost::mpl::false_) {}

    void check_base(boost::mpl::true_)
    {
        typedef typename iterator_adaptor_get_base<Iterator>::type base_t;
        base::psynth_function_requires<FrameIteratorConcept<base_t> >();
    }

    Iterator it;
};

namespace detail
{
    template <typename Iterator>
    // Preconditions: Iterator Models FrameIteratorConcept
    struct FrameIteratorIsMutableConcept
    {
        void constraints()
        {
            base::psynth_function_requires<
                detail::RandomAccessIteratorIsMutableConcept<Iterator> >();
            typedef typename boost::remove_reference<
                typename std::iterator_traits<Iterator>::reference>::type ref;
            typedef typename element_type<ref>::type sample_t;
            base::psynth_function_requires<detail::SampleIsMutableConcept<sample_t> >();
        }
    };
}

template <typename Iterator>
struct MutableFrameIteratorConcept
{
    void constraints()
    {
        base::psynth_function_requires<FrameIteratorConcept<Iterator> >();
        base::psynth_function_requires<
            detail::FrameIteratorIsMutableConcept<Iterator> >();
    }
};

namespace detail
{

/*
  Iterators that can be used as the base of memory_based_step_iterator
  require some additional functions
*/
template <typename Iterator>
// Preconditions: Iterator Models boost_concepts::RandomAccessTraversalConcept
struct RandomAccessIteratorIsMemoryBasedConcept
{
    void constraints()
    {
        std::ptrdiff_t bs=memunit_step(it);
        boost::ignore_unused_variable_warning (bs);
        it=memunit_advanced(it,3);
        std::ptrdiff_t bd=memunit_distance(it,it);
        boost::ignore_unused_variable_warning(bd);
        memunit_advance(it,3);
        // for performace you may also provide a customized
        // implementation of memunit_advanced_ref
    }
    Iterator it;
};

} /* namespace detail */

template <typename Iterator>
struct MemoryBasedIteratorConcept
{
    void constraints ()
    {
        base::psynth_function_requires<
            boost_concepts::RandomAccessTraversalConcept<Iterator> >();
        base::psynth_function_requires<
            detail::RandomAccessIteratorIsMemoryBasedConcept<Iterator> >();
    }
};

template <typename Iterator>
struct StepIteratorConcept
{
    void constraints()
    {
        base::psynth_function_requires<
            boost_concepts::ForwardTraversalConcept<Iterator> >();
        it.set_step(0);
    }
    Iterator it;
};


template <typename Iterator>
struct MutableStepIteratorConcept
{
    void constraints()
    {
        base::psynth_function_requires<StepIteratorConcept<Iterator> >();
        base::psynth_function_requires<
            detail::ForwardIteratorIsMutableConcept<Iterator> >();
    }
};

template <typename Iterator>
struct IteratorAdaptorConcept
{
    void constraints()
    {
        base::psynth_function_requires<
            boost_concepts::ForwardTraversalConcept<Iterator> >();

        typedef typename iterator_adaptor_get_base<Iterator>::type base_t;
        base::psynth_function_requires<
            boost_concepts::ForwardTraversalConcept<base_t> >();

        BOOST_STATIC_ASSERT(is_iterator_adaptor<Iterator>::value);
        typedef typename iterator_adaptor_rebind<Iterator, void*>::type rebind_t;

        base_t base=it.base();  boost::ignore_unused_variable_warning(base);
    }
    Iterator it;
};

template <typename Iterator>
struct MutableIteratorAdaptorConcept
{
    void constraints()
    {
        base::psynth_function_requires<IteratorAdaptorConcept<Iterator> >();
        base::psynth_function_requires<
            detail::ForwardIteratorIsMutableConcept<Iterator> >();
    }
};


/*
 *
 *             BUFFER RANGE CONCEPTS
 *
 */

template <typename Range>
struct RandomAccessBufferRangeConcept
{
    void constraints ()
    {
        base::psynth_function_requires< base::Regular<Range> >();

        typedef typename Range::value_type       value_type;
        typedef typename Range::reference        reference;
        // result of dereferencing
        typedef typename Range::difference_type  difference_type;
        // result of operator-(1d_iterator,1d_iterator)

        typedef typename Range::iterator         iterator;
        typedef typename Range::reverse_iterator reverse_iterator;
        typedef typename Range::size_type        size_type;
            
        base::psynth_function_requires<
            boost_concepts::RandomAccessTraversalConcept<iterator> >();
        base::psynth_function_requires<
            boost_concepts::RandomAccessTraversalConcept<reverse_iterator> >();

        iterator it;
        reverse_iterator rit;
        difference_type d;
        size_type sz;
        detail::initialize_it (d); boost::ignore_unused_variable_warning(d);

        Range (sz, it); // range must be constructible from a locator and a point

        // TODO: Should we minimize this interface to match Boost.Range?
        sz = range.size ();  boost::ignore_unused_variable_warning(sz);
        it = range.frames ();
        
        it  = range.begin ();
        it  = range.end ();
        rit = range.rbegin ();
        rit = range.rend ();

        reference r1=range[d]; boost::ignore_unused_variable_warning(r1);
        // 1D access 
        
        typedef FrameDereferenceAdaptorArchetype<typename Range::value_type>
            deref_t;
        typedef typename Range::template add_deref<deref_t>::type dtype;
    }
    Range range;
};

template <typename Range>
struct BufferRangeConcept {
    void constraints() {
        base::psynth_function_requires<RandomAccessBufferRangeConcept<Range> >();

        std::size_t num_chan = range.num_samples ();
        boost::ignore_unused_variable_warning (num_chan);

    }
    Range range;
};


namespace detail {

template <typename Range>
// Preconditions: Range Models RandomAccessNDBufferRangeConcept
struct RandomAccessBufferRangeIsMutableConcept
{
    void constraints() {
        base::psynth_function_requires<
            detail::RandomAccessIteratorIsMutableConcept<
                typename Range::iterator> >();
        base::psynth_function_requires<
            detail::RandomAccessIteratorIsMutableConcept<
                typename Range::reverse_iterator> >();
        
        typename Range::difference_type diff;
        initialize_it(diff); boost::ignore_unused_variable_warning(diff);
        typename Range::value_type v; initialize_it(v);
        
        range[diff]=v;
    }
    Range range;
};

template <typename Range>    // preconditions: Range Models BufferRangeConcept
struct FrameBufferRangeIsMutableConcept
{
    void constraints() {        
        base::psynth_function_requires<
            detail::RandomAccessBufferRangeIsMutableConcept<Range> >();
    }
};

} /* namespace detail */

template <typename Range>
struct MutableRandomAccessBufferRangeConcept
{
    void constraints() {
        base::psynth_function_requires<RandomAccessBufferRangeConcept<Range> >();
        base::psynth_function_requires<
            detail::RandomAccessBufferRangeIsMutableConcept<Range> >();
    }
};

template <typename Range>
struct MutableBufferRangeConcept
{
    void constraints() {
        base::psynth_function_requires<BufferRangeConcept<Range> >();
        base::psynth_function_requires<
            detail::FrameBufferRangeIsMutableConcept<Range> >();
    }
};

template <typename V1, typename V2>  // Model BufferRangeConcept
struct ranges_are_compatible :
    public frames_are_compatible<typename V1::value_type,
                                 typename V2::value_type> {};


template <typename V1, typename V2>
struct RangesCompatibleConcept
{
    void constraints () {
        BOOST_STATIC_ASSERT((ranges_are_compatible<V1,V2>::value));
    }
};


/*
 *
 *            BUFFER CONCEPTS
 *
 */

template <typename Buf>
struct RandomAccessBufferConcept
{
    void constraints() {
        base::psynth_function_requires<base::Regular<Buf> >();

        typedef typename Buf::range       range_t;
        base::psynth_function_requires<
            MutableRandomAccessBufferRangeConcept<range_t> >();

        typedef typename Buf::const_range const_range_t;
        typedef typename Buf::value_type   frame_t;

        const_range_t cv = const_range(buf);
        boost::ignore_unused_variable_warning(cv);
        range_t       v  = range(buf);
        boost::ignore_unused_variable_warning(v);

        frame_t fill_value;
        typename Buf::size_type pt = buf.size ();
        Buf im1 (pt);
        Buf im2 (pt,1);
        Buf im3 (pt, fill_value, 1);
        buf.recreate(pt);
        buf.recreate(pt,1);
        buf.recreate(pt,fill_value,1);
    }
    Buf buf;
};


template <typename Buf>
struct BufferConcept
{
    void constraints() {
        base::psynth_function_requires<RandomAccessBufferConcept<Buf> >();
        base::psynth_function_requires<MutableBufferRangeConcept<
            typename Buf::range> >();
        
        BOOST_STATIC_ASSERT(num_samples<Buf>::value ==
                            boost::mpl::size<
                                typename channel_space_type<Buf>::type>::value);
    }
    Buf buf;
};

} /* namespace sound */
} /* namespace psynth */

#endif /* PSYNTH_SOUND_CONCEPT */