// file: $isip/class/pr/LanguageModel/LanguageModelUndefined.h
//

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

#ifndef ISIP_LANGUAGE_MODEL_BASE
#include <LanguageModelBase.h>
#endif

// forward class definitions
//

// LanguageModelUndefined: default model type that ensures the user sets
// the format in LanguageModel to a valid type before computing.  all
// methods error
//
class LanguageModelUndefined : public LanguageModelBase {

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

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

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

  //----------------------------------------
  //
  // error codes
  //
  //----------------------------------------  

  static const long ERR = 100100;
  
  //---------------------------------------------------------------------------
  //
  // protected data
  //
  //---------------------------------------------------------------------------
protected:

  // debug level
  //
  // inherited from LanguageModelBase
  
  // empty RuleModel
  //
  RuleModel rm_d;

  //---------------------------------------------------------------------------
  //
  // 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__);
  }
  
  // debug methods
  //
  boolean debug(const unichar* msg_a) const {
    return Error::handle(name(), L"debug", Error::VIRTUAL_PTR,
			 __FILE__, __LINE__);
  }

  // method: setDebug
  //
  // inherited from LanguageModelBase

  // destructor/constructor(s)
  //
  ~LanguageModelUndefined() { }

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

  // assign methods
  //
  boolean assign(const LanguageModelUndefined& arg) {
    return Error::handle(name(), L"assign", Error::VIRTUAL_PTR,
			 __FILE__, __LINE__);
  }

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

  // i/o methods
  //
  // 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& cname = CLASS_NAME) {
    return Error::handle(name(), L"read", Error::VIRTUAL_PTR,
			 __FILE__, __LINE__);
  }

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

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

  boolean writeData(Sof& sof, const String& pname) const {
    return Error::handle(name(), L"writeData", Error::VIRTUAL_PTR,
			 __FILE__, __LINE__);
  }
  
  // other memory managements methods
  //
  boolean clear(Integral::CMODE cmode = Integral::DEF_CMODE) {
    return true;
  }
  
  //---------------------------------------------------------------------------
  //
  // class-specific public methods: these methods define the
  // interface contract.
  //
  //---------------------------------------------------------------------------

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

  boolean assign(const LanguageModelBase& arg) {
    return Error::handle(name(), L"assign", Error::VIRTUAL_PTR,
			 __FILE__, __LINE__);
  }
  
  // method: getRuleModel
  //
  RuleModel getRuleModel() {
    Error::handle(name(), L"getRuleModel", Error::VIRTUAL_PTR,
		  __FILE__, __LINE__);
    return rm_d;
  }

  // method: setRuleModel
  //
  boolean setRuleModel(const RuleModel& rm) {
    return Error::handle(name(), L"setRuleModel", Error::VIRTUAL_PTR,
			 __FILE__, __LINE__);
  }
  
  // method: className
  //
  const String& className() const {
    return CLASS_NAME;
  }
  
  //---------------------------------------------------------------------------
  //
  // private methods
  //
  //---------------------------------------------------------------------------
private:  
  
};

// end of include file
// 
#endif
