Signal.h

#pragma once

#if defined(Signal_RECURSES)
#error Recursive header files inclusion detected in Signal.h
#else // defined(Signal_RECURSES)

#define Signal_RECURSES

#if !defined Signal_h

#define Signal_h

// Inclusions
#include <iostream>
#include "DGtal/base/Common.h"
#include "DGtal/base/CowPtr.h"

namespace DGtal
{

  template <typename TValue>
  struct SignalData {
    typedef TValue Value;

    Value* data;
    unsigned int size;
    int zero;
    bool periodic;

    SignalData();
    
    void init( unsigned int s, int z = 0, bool p = false, 
               const Value & def = Value( 0 ) );

    void init( const Value* t, unsigned int size, int z = 0, bool p = false, 
               const Value & def = Value( 0 )  );
    
    SignalData( unsigned int s, int z = 0, bool p = false, 
                const Value & def = Value( 0 ) );
    
    SignalData( const Value* t, unsigned int size, int z = 0, bool p = false, 
                const Value & def = Value( 0 )  );
    
    ~SignalData();
    
    SignalData( const SignalData & other );
    
    SignalData& operator=( const SignalData & other );
    
    const Value& defaut() const;
  };


  // template class Signal
  template <typename TValue>
  class Signal
  {
    
  public:
    typedef TValue Value;
    static Signal<TValue> G2();

    static Signal<TValue> H2();
    
    static Signal<TValue> Delta();
    
    static Signal<TValue> G2n( unsigned int n );

    static Signal<TValue> H2n( unsigned int n );
    
    static Signal<TValue> D2n( unsigned int n );

    // ----------------------- Standard services ----------------------------
  public:
      
    ~Signal();

    Signal();
      
    
    Signal( unsigned int size, int z, bool periodic, 
            const TValue & def = TValue( 0 )  );
    
    Signal( const TValue* t, unsigned int size, int z, bool periodic, 
            const TValue & def = TValue( 0 )  );
    
    Signal( const Signal<TValue> & other );
    
    Signal<TValue> & operator=( const Signal<TValue> & other );


    void init( unsigned int s, int z = 0, bool p = false, 
               const TValue & def = TValue( 0 ) );

    void init( const TValue* t, unsigned int size, int z = 0, bool p = false, 
               const TValue & def = TValue( 0 )  );
 

    unsigned int size() const;

    // ----------------------- Signal services ----------------------------
  public:
    
    TValue & operator[]( int i );
    
    const TValue & operator[]( int i ) const;
    
    void setAll( const TValue & val = TValue( 0 ) );
    
    
    void multiply( const TValue & val );

    Signal<TValue> operator*( const Signal<TValue>& G );

    // ----------------------- Interface --------------------------------------
  public:

    void selfDisplay ( std::ostream & out ) const;
    
    bool isValid() const;

     
    // ------------------------- Datas --------------------------------------
  private:
      
    CowPtr< SignalData<TValue> > m_data;
      
    // ------------------------- Hidden services ----------------------------
  protected:
    

  }; // end of class Signal


  template <typename TValue>
  std::ostream&
  operator<< ( std::ostream & out, const Signal<TValue> & object );

} // namespace DGtal


// Includes inline functions.
#include "DGtal/math/Signal.ih"

//                                                                           //

#endif // !defined Signal_h

#undef Signal_RECURSES
#endif // else defined(Signal_RECURSES)