// file: $isip/class/stat/StatisticalModel/StatisticalModelUndefined.h
// version: $Id: StatisticalModelUndefined.h 8756 2002-10-18 21:47:07Z alphonso $
//

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

#ifndef ISIP_STATISTICAL_MODEL_BASE
#include <StatisticalModelBase.h>
#endif

// StatisticalModelUndefined: default model type that insures the user sets
// the type in StatisticalModel to a valid type before computing. all methods
// error
//
class StatisticalModelUndefined : public StatisticalModelBase {

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

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

  //----------------------------------------
  //
  // 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 bool8 diagnose(const unichar* msg) {
    return Error::handle(name(), L"diagnose", Error::VIRTUAL_PTR,
			 __FILE__, __LINE__);
  }
  
  // method: debug
  //
   bool8 debug(const unichar* msg) const {
    return Error::handle(name(), L"debug", Error::VIRTUAL_PTR,
			 __FILE__, __LINE__);
  }

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

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

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

  // method: assign
  //
  bool8 assign(const StatisticalModelUndefined& arg) {
    return Error::handle(name(), L"assign", Error::VIRTUAL_PTR,
			 __FILE__, __LINE__);
  }
  
  // method: eq
  //
  bool8 eq(const StatisticalModelUndefined& arg) const {
    return Error::handle(CLASS_NAME, L"eq", Error::VIRTUAL_PTR,
			 __FILE__, __LINE__);
  }

  // method: sofSize
  //
  int32 sofSize() const {
    return Error::handle(name(), L"sofSize", Error::VIRTUAL_PTR,
			 __FILE__, __LINE__);
  }

  // method: sofAccumulatorSize
  //
  int32 sofAccumulatorSize() const {
    return Error::handle(name(), L"sofAccumulatorSize", Error::VIRTUAL_PTR,
			 __FILE__, __LINE__);
  }

  // method: sofOccupanciesSize
  //
  int32 sofOccupanciesSize() const {
    return Error::handle(name(), L"sofOccupanciesSize", Error::VIRTUAL_PTR,
			 __FILE__, __LINE__);
  }  

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

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

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

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

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

  // method: writeAccumulator
  //
  bool8 writeAccumulator(Sof& sof, int32 tag, const String& name) const {
    return Error::handle(CLASS_NAME, L"writeAccumulator", Error::VIRTUAL_PTR,
			 __FILE__, __LINE__);
  }
  
  // method: readAccumulatorData
  //
  bool8 readAccumulatorData(Sof& sof, const String& pname,
		   int32 size, bool8 param, bool8 nested) {
    return Error::handle(CLASS_NAME, L"readData", Error::VIRTUAL_PTR,
			 __FILE__, __LINE__);
  }

  // method: writeAccumulatorData
  //
  bool8 writeAccumulatorData(Sof& sof, const String& pname) const {
    return Error::handle(CLASS_NAME, L"writeData", Error::VIRTUAL_PTR,
			 __FILE__, __LINE__);
  }
    
  // method: readOccupancies
  //
  bool8 readOccupancies(Sof& sof, int32 tag, const String& name) {
    return Error::handle(CLASS_NAME, L"readAccumulator", Error::VIRTUAL_PTR,
			 __FILE__, __LINE__);
  }

  // method: writeOccupancies
  //
  bool8 writeOccupancies(Sof& sof, int32 tag, const String& name) const {
    return Error::handle(CLASS_NAME, L"writeAccumulator", Error::VIRTUAL_PTR,
			 __FILE__, __LINE__);
  }
  
  // method: readOccupanciesData
  //
  bool8 readOccupanciesData(Sof& sof, const String& pname,
			      int32 size, bool8 param, bool8 nested) {
    return Error::handle(CLASS_NAME, L"readData", Error::VIRTUAL_PTR,
			 __FILE__, __LINE__);
  }

  // method: writeOccupanciesData
  //
  bool8 writeOccupanciesData(Sof& sof, const String& pname) const {
    return Error::handle(CLASS_NAME, L"writeData", Error::VIRTUAL_PTR,
			 __FILE__, __LINE__);
  }
  
  // method: operator new
  //
  static void* operator new(size_t size) {
    Error::handle(CLASS_NAME, L"new", Error::VIRTUAL_PTR,
		  __FILE__, __LINE__);
    return (void*)NULL;
  }

  // method: operator new[]
  //
  static void* operator new[](size_t size) {
    Error::handle(CLASS_NAME, L"new[]", Error::VIRTUAL_PTR,
		  __FILE__, __LINE__);
    return (void*)NULL;
  }

  // method: operator delete
  //
  static void operator delete(void* ptr) {
    Error::handle(CLASS_NAME, L"delete", Error::VIRTUAL_PTR,
		  __FILE__, __LINE__);
  }

  // method: operator delete[]
  //
  static void operator delete[](void* ptr) {
    Error::handle(CLASS_NAME, L"delete[]", Error::VIRTUAL_PTR,
		  __FILE__, __LINE__);
  }

  // method: setGrowSize
  //
  static bool8 setGrowSize(int32 size) {
    return Error::handle(CLASS_NAME, L"setGrowSize", Error::VIRTUAL_PTR,
		  __FILE__, __LINE__);
  }

  // method: clear
  //   return true instead of an error as this method is
  //   required by higher-level classes
  //
  bool8 clear(Integral::CMODE cmode = Integral::DEF_CMODE) {
    return true;
  }

  //---------------------------------------------------------------------------
  //
  // class-specific public methods
  //
  //---------------------------------------------------------------------------

  // method: eq
  //
  bool8 eq(const StatisticalModelBase& arg) const {
    return Error::handle(CLASS_NAME, L"eq", Error::VIRTUAL_PTR,
			 __FILE__, __LINE__);
  }

  // method: assign
  //
  bool8 assign(const StatisticalModelBase& arg) {
    return Error::handle(CLASS_NAME, L"assign", Error::VIRTUAL_PTR,
			 __FILE__, __LINE__);
  }

  // method: setMode
  //
  bool8 setMode(MODE mode) {
    mode_d = mode;
    return true;
  }
  
  // method: className
  //
  const String& className() const {
    return CLASS_NAME;
  }

  // method: init
  //
  bool8 init() {
    return false;
  }

  // method: getMean
  //
  bool8 getMean(VectorFloat& mean) {
    return Error::handle(CLASS_NAME, L"getMean", Error::VIRTUAL_PTR,
			 __FILE__, __LINE__);
  }

  // method: getCovariance
  //
  bool8 getCovariance(MatrixFloat& cov) {
    return Error::handle(CLASS_NAME, L"getCovariance", Error::VIRTUAL_PTR,
			 __FILE__, __LINE__);
  }

  // method: getLikelihood
  //
  float32 getLikelihood(const VectorFloat& input) {
    return Error::handle(CLASS_NAME, L"getLikelihood", Error::VIRTUAL_PTR,
			 __FILE__, __LINE__);
  }

  // method: getLogLikelihood
  //
  float32 getLogLikelihood(const VectorFloat& input) {
    return Error::handle(CLASS_NAME, L"getLogLikelihood", Error::VIRTUAL_PTR,
			 __FILE__, __LINE__);
  }

  // method: resetAccumulators
  //
  bool8 resetAccumulators() {
    return Error::handle(name(), L"resetAccumulators", Error::ARG, __FILE__, __LINE__);
  }
  
  // method: getOccupancy
  //
  float64 getOccupancy() {
    return Error::handle(name(), L"getOccupancy", Error::ARG, __FILE__, __LINE__);
  }

  // method: setOccupancy
  //
  bool8 setOccupancy(float64 arg) {
    Error::handle(name(), L"getOccupancy", Error::ARG, __FILE__, __LINE__);
    return false;
  }  

  // method: getAccessCount
  //
  int32 getAccessCount() {
    return Error::handle(name(), L"getAccessCount", Error::ARG, __FILE__, __LINE__);
  }

  // method: setAccessCount
  //
  bool8 setAccessCount(int32 arg) {
    return Error::handle(name(), L"setAccessCount", Error::ARG, __FILE__, __LINE__);
  }

  // method: initialize
  //
  bool8 initialize(VectorFloat& param) {
    return Error::handle(name(), L"initialize", Error::ARG, __FILE__, __LINE__);
  }
  
  // method: accumulate
  //
  bool8 accumulate(VectorFloat& data) {
    return Error::handle(name(), L"initialize", Error::ARG, __FILE__, __LINE__);
  }

  // method: accumulate
  //
  bool8 accumulate(VectorDouble& param,
		     VectorFloat& data, bool8 precomp) {
    return Error::handle(CLASS_NAME, L"accumulate", Error::VIRTUAL_PTR,
			 __FILE__, __LINE__);
  }

  // method: update
  //  
  bool8 update(VectorFloat& varfloor, int32 min_count) {
    return Error::handle(CLASS_NAME, L"update", Error::VIRTUAL_PTR,
			 __FILE__, __LINE__);
  }

  //---------------------------------------------------------------------------
  //
  // private methods
  //
  //---------------------------------------------------------------------------
private:

};

// end of include file
// 
#endif