file.h

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

// file: $isip/class/system/File/File.h
// version: $Id: File.h,v 1.54 2003/04/09 19:46:31 duncan Exp $
//

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

// isip include files
//
#ifndef ISIP_INTEGRAL
#include <Integral.h>
#endif

#ifndef ISIP_ERROR
#include <Error.h>
#endif

#ifndef ISIP_MEMORY_MANAGER
#include <MemoryManager.h>
#endif

// forward class definitions
//
class SysChar;
class SysString;

// File: a general purpose file pointer. this class abstracts file
//  manipulations, which are operating system specific, and provides
//  a general interface that all classes should use to access files.
//
//  an important feature of this class is that a polling strategy for
//  opening files is built into the class. when a file open fails, it is
//  possible that the file exists, but the network file system for the
//  computer is in error. this happens often in unix when dealing with
//  files using the network file system. an effective solution is simply
//  to wait a specified time, and try again. more often than not,
//  the next open will succeed. since all file I/O is centralized through
//  this class, this feature is automatically available to all isip classes.
//
class File {
  
  //---------------------------------------------------------------------------
  //
  // public constants
  //
  //---------------------------------------------------------------------------
public:
  
  // define the class name
  //
  static const SysString CLASS_NAME;
  
  //----------------------------------------
  //
  // other important constants
  //
  //----------------------------------------

  // define some maximum sizes
  //
  static const long MAX_FNAME_SIZE = PATH_MAX;
  static const long BUF_SIZE = 8192;
  static const long BAD_COUNT = -1;
    
  // standard file streams
  //
  enum STREAM { NO_STREAM = -1, OUT, IN, ERROR, DEF_STREAM = NO_STREAM };
  
  // seek positions
  //
  enum SEEK { POS = SEEK_SET, POS_PLUS_CUR = SEEK_CUR,
	      POS_PLUS_END = SEEK_END };
  
  // i/o modes
  //
  enum MODE { READ_ONLY = 0, READ_PLUS, WRITE_ONLY,
	      WRITE_PLUS, APPEND_ONLY, APPEND_PLUS, DEF_MODE = READ_ONLY };
  
  // i/o types
  //
  enum TYPE { TEXT = 0, BINARY, DEF_TYPE = TEXT };
  
  // byte-order modes
  //
  enum BMODE { NATIVE = 0, SWAP, BIG_ENDIAN, LITTLE_ENDIAN,
	       DEF_BMODE = NATIVE };
  
  // names for each of the enumerated file modes
  //
  static const char SYS_TEXT_READ_ONLY[];
  static const char SYS_TEXT_READ_PLUS[];
  static const char SYS_TEXT_WRITE_ONLY[];
  static const char SYS_TEXT_WRITE_PLUS[];
  static const char SYS_TEXT_APPEND_ONLY[];
  static const char SYS_TEXT_APPEND_PLUS[];
  
  static const char SYS_BINARY_READ_ONLY[];
  static const char SYS_BINARY_READ_PLUS[];
  static const char SYS_BINARY_WRITE_ONLY[];
  static const char SYS_BINARY_WRITE_PLUS[];
  static const char SYS_BINARY_APPEND_ONLY[];
  static const char SYS_BINARY_APPEND_PLUS[];
 
  // names for each of the enumerated file type
  //
  static const SysString TYPE_TEXT;
  static const SysString TYPE_BINARY;

  // indention and line wrapping
  //
  static const SysString INDENT_STR;
  static const SysString WRAP_TERM_STR;
  static const SysString WRAP_PRE_INDENT_STR;
  static const SysString WRAP_POST_INDENT_STR;

  // a string denoting a piped input/output
  //
  static const SysString STREAM_FILE;
  
  //----------------------------------------
  //
  // default values and arguments
  //  
  //----------------------------------------  
  
  // lock constants:
  //  def_lock_retry is the default number of times we try to lock a file
  //  before reporting fails, the def_lock_delay is the time in seconds before 
  //  each retry
  //
  static const long DEF_LOCK = false;
  static const long DEF_LOCK_RETRY = 5;
  static const long DEF_LOCK_DELAY = 2;

  // formatting constants
  //
  static const long DEF_INDENT = 0;
  static const long NO_WRAP = -1;
  static const long DEF_LINE_WRAP = NO_WRAP;

  // open related constants:
  //  def_open_retry is the default number of times we try to open a file
  //  before reporting fails, the def_open_delay is the time in seconds before 
  //  each retry
  //
  static const long DEF_OPEN_RETRY = 5;
  static const long DEF_OPEN_DELAY = 2;
  
  //----------------------------------------
  //
  // error codes
  //
  //----------------------------------------  

  static const long ERR = 1000;
  static const long ERR_NOTCLS = 1001;
  static const long ERR_NOTOPN = 1002;
  static const long ERR_REOPEN = 1003;
  static const long ERR_CLOSE = 1004;
  static const long ERR_FLUSH = 1005;
  static const long ERR_TRUNCT = 1006;
  static const long ERR_WRAP = 1007;
  static const long ERR_DECODE = 1008;
  
  //---------------------------------------------------------------------------
  //
  // protected data
  //
  //---------------------------------------------------------------------------
protected:
  
  // the stream type
  //
  STREAM stream_d;
  
  // the file pointer
  //
  FILE* fp_d;
  
  // open mode and type
  //
  MODE mode_d;
  TYPE type_d;
  
  // lock flag
  //
  boolean lock_d;
  
  // byte-order modes:
  //  it can be an absolute byte-order (LITTLE_ENDIAN or BIG_ENDIAN) or
  //  a relative order to the machine (NATIVE or SWAP)
  //
  BMODE byte_mode_d;

  // byte-swap flag:
  //  this is relative to the machine's byte-order
  //
  boolean byte_swap_d;
  
  // indention level
  //
  long indent_level_d;
  
  // line wrapping limit
  //
  long line_wrap_d;
  
  // current column position
  //
  long column_position_d;
  
  // file polling:
  //  open_retry_d is the number of times that the file will be polled for
  //  opening before an error is returned. open_delay_d is the delay in
  //  seconds between attempts to open the file.
  //
  long open_retry_d;
  long open_delay_d;

  // declare an array of SysString objects to keep track of temporary filenames
  //
  static SysString** temp_files_d;
  static long temp_size_d;
  static long temp_num_d;

  // declare a static debug level for all class instantiations
  //
  static Integral::DEBUG debug_level_d;

  // static memory manager
  //
  static MemoryManager mgr_d;

  //---------------------------------------------------------------------------
  //
  // required public methods
  //
  //---------------------------------------------------------------------------
public:

  // method: name
  //
  static const SysString& name() {
    return CLASS_NAME;
  }
  
  // other static methods
  //
  static boolean diagnose(Integral::DEBUG debug_level);
  
  // method: setDebug
  //
  static boolean setDebug(Integral::DEBUG level) {
    debug_level_d = level;
    return true;
  }

  // other debug methods
  //  
  boolean debug(const unichar* message) const;
  
  // destructor/constructor(s):
  //  the copy constructor is private
  //
  ~File();
  File(STREAM stream = DEF_STREAM);

  // assign methods:
  //  these methods are omitted because we do not ever want multiple file
  //  pointers on the same file. see the File::swap method
  //

  // operator= methods:
  //  these methods are omitted because we do not ever want multiple file
  //  pointers on the same file. 
  //

  // i/o methods:
  //  these methods are omitted because File can not write itself
  //  to an sof file
  //
  
  // equality methods:
  //  these methods are omitted because they are not useful for File objects
  //
  
  // memory management methods:
  //  the clear method is omitted so the user is forced to open and close
  //  files in a disciplined manner
  //
  
  // method: new
  //
  static void* operator new(size_t size) {
    return mgr_d.get();
  }

  // method: new[]
  //
  static void* operator new[](size_t size) {
    return mgr_d.getBlock(size);
  }

  // method: delete