algorithmundefined.h

这是一个从音频信号里提取特征参量的程序

// file: $isip/class/algo/AlgorithmUndefined/AlgorithmUndefined.h
// version: $Id: AlgorithmUndefined.h,v 1.17 2002/06/25 01:42:41 picone Exp $
//

// make sure definitions are only made once
//
#ifndef ISIP_ALGORITHM_UNDEFINED
#define ISIP_ALGORITHM_UNDEFINED

// isip include files
//
#ifndef ISIP_ALGORITHM_BASE
#include <AlgorithmBase.h>
#endif


// AlgorithmUndefined: a class used to represent an empty choice
//  for an algorithm.
//
class AlgorithmUndefined : public AlgorithmBase {

  //---------------------------------------------------------------------------
  //
  // public constants
  //
  //---------------------------------------------------------------------------
public:

  // define the class name
  //
  static const String CLASS_NAME;

  //----------------------------------------
  //
  // other important constants
  //
  //----------------------------------------

  //----------------------------------------
  //
  // default values and arguments
  //
  //----------------------------------------  

  // define the default value(s) of the class data
  //
  
  //----------------------------------------
  //
  // error codes
  //
  //----------------------------------------  

  //---------------------------------------------------------------------------
  //
  // protected data
  //
  //---------------------------------------------------------------------------
protected:

  //---------------------------------------------------------------------------
  //
  // required public methods
  //
  //---------------------------------------------------------------------------
public:
  
  // method: name
  //
  static const String& name() {
    return CLASS_NAME;
  }

  // method: diagnose
  //
  static boolean diagnose(const unichar* msg) {
    return Error::handle(name(), L"diagnose",
			 Error::VIRTUAL_PTR, __FILE__, __LINE__);
  }
  
  // method: debug
  //  setDebug method is inherited from the base class
  //
  boolean debug(const unichar* msg) const;

  // method: destructor
  //
  ~AlgorithmUndefined() {}

  // method: default constructor
  //
  AlgorithmUndefined() {}

  // method: copy constructor
  //
  AlgorithmUndefined(const AlgorithmUndefined& arg) {
    assign(arg);
  }

  // method: assign
  //
  boolean assign(const AlgorithmUndefined& arg) {
    return Error::handle(name(), L"assign",
			 Error::VIRTUAL_PTR, __FILE__, __LINE__);
  }
  
  // method: sofSize
  //
  long sofSize() const {
    return Error::handle(name(), L"sofSize",
			 Error::VIRTUAL_PTR, __FILE__, __LINE__);
  }
  
  // method: read
  //
  boolean read(Sof& sof, long tag, const String& name) {
    return Error::handle(CLASS_NAME, L"read",
			 Error::VIRTUAL_PTR, __FILE__, __LINE__);
  }

  // method: write
  //
  boolean write(Sof& sof, long tag, const String& name) const {
    return Error::handle(CLASS_NAME, L"write",
			 Error::VIRTUAL_PTR, __FILE__, __LINE__);
  }

  // method: readData
  //
  boolean readData(Sof& sof, const String& pname,
		   long size, boolean param, boolean nested) {
    return Error::handle(CLASS_NAME, L"readData",
			 Error::VIRTUAL_PTR, __FILE__, __LINE__);
  }

  // method: writeData
  //
  boolean writeData(Sof& sof, const String& pname) const {
    return Error::handle(CLASS_NAME, L"writeData",
			 Error::VIRTUAL_PTR, __FILE__, __LINE__);
  }
  
  // method: eq
  //
  boolean eq(const AlgorithmUndefined& arg) const {
    return Error::handle(CLASS_NAME, L"eq",
			 Error::VIRTUAL_PTR, __FILE__, __LINE__);
  }

  // method: clear
  //
  boolean clear() {
    return Error::handle(CLASS_NAME, L"clear",
			 Error::VIRTUAL_PTR, __FILE__, __LINE__);
  }

  //---------------------------------------------------------------------------
  //
  // class-specific public methods:
  //  set methods
  //
  //---------------------------------------------------------------------------

  //  the set methods are inherited from the base class
  //

  //---------------------------------------------------------------------------
  //
  // class-specific public methods:
  //  get methods
  //
  //---------------------------------------------------------------------------  
  //  the get methods are inherited from the base class
  //
  
  //---------------------------------------------------------------------------
  //
  // class-specific public methods:  
  //  interface contract methods
  //
  //---------------------------------------------------------------------------
  
  // method: assign
  //
  boolean assign(const AlgorithmBase& arg) {
    return Error::handle(name(), L"assign",
			 Error::VIRTUAL_PTR, __FILE__, __LINE__);
  }

  // method: eq
  //
  boolean eq(const AlgorithmBase& arg) const {
    return Error::handle(name(), L"eq",
			 Error::VIRTUAL_PTR, __FILE__, __LINE__);
  }

  // method: className
  //
  const String& className() const {
    Error::handle(CLASS_NAME, L"className",
		  Error::VIRTUAL_PTR, __FILE__, __LINE__);
    return name();
  }
    
  // method: init
  //
  boolean init() {
    return true;
  }

  // method: apply
  //
  boolean apply(Vector<AlgorithmData>& output,
		const Vector< CircularBuffer<AlgorithmData> >& input) {
    return Error::handle(CLASS_NAME, L"apply",
			 Error::VIRTUAL_PTR, __FILE__, __LINE__);
  }
  
  // method: getLeadingPad
  //
  long getLeadingPad() const {
    return Error::handle(CLASS_NAME, L"getLeadingPad",
			 Error::VIRTUAL_PTR, __FILE__, __LINE__);
  }
  
  // method: getTrailingPad
  //
  long getTrailingPad() const {
    return Error::handle(CLASS_NAME, L"getTrailingPad",
			 Error::VIRTUAL_PTR, __FILE__, __LINE__);
  }
  
  // method: setParser
  //
  boolean setParser(SofParser* parser) {
    return Error::handle(CLASS_NAME, L"setParser",
			 Error::VIRTUAL_PTR, __FILE__, __LINE__);
  }
  
  //---------------------------------------------------------------------------
  //
  // private methods
  //
  //---------------------------------------------------------------------------
private:

};

// end of include file
// 
#endif