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)