---

binarysave.h

Go to the documentation of this file.

#ifndef __BINARYSAVE_H_
#define __BINARYSAVE_H_

#include <cstdio>
#include <vector>

#include "tristate.h"
#include "ind_types.h"
#include "kernel.h"


/******************************************************************************/
/* StateSaver class                                                           */
/******************************************************************************/


class StateSaver {
public:
  virtual ~StateSaver() { }

  virtual int  read(       FILE *infile  )=0;

  virtual int  write(      FILE *outfile )=0;

  virtual void display_as_text( FILE *infile  )=0;
};



/******************************************************************************/
/* Defines                                                                    */
/******************************************************************************/

#define NEURONS_PER_BUFFER 1
#define parts_per_row ((lm.N)/NEURONS_PER_BUFFER)

#define LF_TOKEN_GRAIN_SIZE        4

#define LFBufferDataType_to_use      i32
#define LFBufferDataType_swap_endian i32_swap_endian




/******************************************************************************/
/* LISSOMBinaryStateSaver class                                               */
/******************************************************************************/

class LISSOMBinaryStateSaver : public StateSaver {
public:
  virtual ~LISSOMBinaryStateSaver() { }
  
  LISSOMBinaryStateSaver(BasicLissomMap& m) : 
    tokensWritten(0), tokensRead(0), status(0), errorsEncountered (0),
    bigendian(endianness()), lm(m) {  }
  
  static void init_hook( void ) {  binarysave_init_hook();  }

  virtual int  read(       FILE *infile  ) {  return binaryWeightsFileRead(  infile  );  }
  virtual int  write(      FILE *outfile ) {  return binaryWeightsFileWrite( outfile );  }
  virtual void display_as_text( FILE *infile  ) {    printTokens(            infile  );  }

  typedef LFBufferDataType_to_use LFBufferDataType;

private:
  typedef BasicLissomMap::a_weight a_weight;
  typedef BasicLissomMap::l_weight l_weight;
  
  /*  Typedefs */
  
  struct LFTokenType {
    i32 right;
    i32 left;
  };

  struct LFBuffer {
    LFBuffer(const int initial_size=0) : data(initial_size) { }
    int start;
    int end;
    inline int  length() const { return (end-start + 1); }
    inline void ensure_space_available(const unsigned additional_length) {
      const unsigned required_length = length()+additional_length;
      if (required_length >= data.size())
        data.resize(required_length);
    }
    std::vector<LFBufferDataType> data;
  };

  /*   Parameters */
  static Tristate save_afferent_weights_only;
  static Tristate save_all_lateral_weights;
  static Tristate load_afferent_weights_only;

  /*   Variables */
  int tokensWritten; 
  int tokensRead; 
  LFBuffer  binaryBuffer; 
  int       status;
  int       errorsEncountered; 
  
  int bigendian;


  /*   Prototypes for public functions */
  static void binarysave_init_hook( void );
  
  int  binaryWeightsFileWrite( FILE *file );
  int  binaryWeightsFileRead( FILE *file );
  void printTokens( FILE *file );
    
  /*   Prototypes for private functions */
  LFTokenType makeToken(int name, int length, int infoa, int infob );
  int  tokenName(   LFTokenType token );
  int  tokenLength( LFTokenType token );
  int  tokenInfoa(  LFTokenType token );
  int  tokenInfob(  LFTokenType token );
  void printToken( LFTokenType token, int offset );
  const char *tokenNameString(LFTokenType token);
         
  int writeToken(FILE *file, LFTokenType token );
  LFTokenType peekToken(FILE *file );
  LFTokenType readToken(FILE *file );
  LFTokenType readTokenExpecting(int tokenNameExpected, FILE *file);
  int writeItem(FILE *file, void *itemptr);
  LFBufferDataType readItem(FILE* file);
  int writeFloat(FILE *file, f32 aFloat );
  f32 readFloat(FILE *file);
  int writeInteger(FILE *file, int anInteger );
  int readInteger(FILE *file);
  void printTokensInBuffer( LFBuffer *buffer );
  
  int binaryWeightsFileReadInArbitraryOrder(FILE *file, LFBuffer *buffer);
  int binaryWeightsFileReadInFixedOrder(FILE *file, LFBuffer *buffer);
  
  int binaryWeightsBufferFill( LFBuffer *buffer, int current_map_row, 
                                int current_local_row, int part_of_row );
  
  int binaryWeightsBufferProcess( LFBuffer *buffer, int verify);
  int binaryWeightsBufferWriteLatWeights( LFBuffer *buffer, int token_name,
                                          int i, int j, int radius, int array_width,
                                          l_weight *weights);
  int binaryWeightsBufferReadLatWeights(  LFBuffer *buffer, LFTokenType token,
                                          int i, int j, int radius, int array_width,
                                          l_weight *weights, int verify, const char *description);
  
  void LFBufferGet(    LFBuffer *buffer, int pe );
  void LFBufferPut(    LFBuffer *buffer, int pe );
  void LFBufferClear(  LFBuffer *buffer );
  int  LFBufferLength( LFBuffer *buffer );
  int  LFBufferWrite(  LFBuffer *buffer, FILE *file );
  int  LFBufferRead(   LFBuffer *buffer, FILE *file, int length);
  int  LFBufferWriteToken(LFBuffer *buffer, LFTokenType token );
  LFTokenType LFBufferReadToken(LFBuffer *buffer );
  int  LFBufferWriteItem(LFBuffer *buffer, void *itemptr);
  LFBufferDataType LFBufferReadItem(LFBuffer *buffer);
  int  LFBufferWriteFloat(LFBuffer *buffer, f32 aFloat );
  f32  LFBufferReadFloat(LFBuffer *buffer);
  int  LFBufferWriteInteger(LFBuffer *buffer, int anInteger );
  int  LFBufferReadInteger( LFBuffer *buffer);
  int  compareParameter(int weight_file_parameter, int param_file_parameter, const char *description);
  int  compareOrSetInt(int *destination, int value, int verify, const char *description);

#define compareOrSet_proto(type) \
type compareOrSet_ ## type(type *destination, type value, int verify, const char *description)
  
  compareOrSet_proto(f64);
  compareOrSet_proto(a_weight);
  compareOrSet_proto(l_weight);

  BasicLissomMap& lm;
};



#endif

---