Initializing help system before first use

Reading and writing data using the 'bin:' format
Type: Programming
Rating: 3 (intermediate)
Description: This example shows how to generate and read data files using the 'bin:' data format from a C (bdrv.c) or a java (bdrv.java) program.
File(s): bdrv.c, bdrv.java

bdrv.c
/********************************************************/
/*  BinDrv library example                              */
/*  ======================                              */
/*                                                      */
/*  file bdrv.c                                         */
/*  ```````````                                         */
/* Example of use of BinDrv                             */
/*                                                      */
/*  (c) 2011 Fair Isaac Corporation                     */
/*      author: Y. Colombani, 2011                      */
/********************************************************/

#include <stdio.h>
#include <stdlib.h>
#include <limits.h>
#include "bindrv.h"

static void writeit(void);
static void readit(void);
static void *dummy_malloc(size_t s,void *ctx);

int main()
{
 writeit();
 readit();
 return 0;
}

/*****************************/
/* Create a BinDrv data file */
/*****************************/
static void writeit(void)
{
 FILE *f;
 s_bindrvctx bdrv;

 f=fopen("bindata","w");
 bdrv=bindrv_newwriter((size_t (*)(const void *,size_t,size_t,void*))fwrite,f);
 bindrv_putctrl(bdrv,BINDRV_CTRL_LABEL); bindrv_putstring(bdrv,"A");
 bindrv_putctrl(bdrv,BINDRV_CTRL_OPENLST);
 bindrv_putctrl(bdrv,BINDRV_CTRL_OPENNDX); bindrv_putint(bdrv,1);
 bindrv_putctrl(bdrv,BINDRV_CTRL_CLOSENDX);
 bindrv_putreal(bdrv,0.45);bindrv_putreal(bdrv,-31.02); bindrv_putint(bdrv,-28);
 bindrv_putctrl(bdrv,BINDRV_CTRL_CLOSELST);
 bindrv_putctrl(bdrv,BINDRV_CTRL_LABEL); bindrv_putstring(bdrv,"B");
 bindrv_putbool(bdrv,1);
 bindrv_putctrl(bdrv,BINDRV_CTRL_LABEL); bindrv_putstring(bdrv,"C");
 bindrv_putstring(bdrv,"sometext");
 bindrv_putctrl(bdrv,BINDRV_CTRL_LABEL); bindrv_putstring(bdrv,"D");
 bindrv_putlong(bdrv,(BINDRV_LONG)INT_MAX*11);
 bindrv_delete(bdrv);
 fclose(f);
}

/***************************************/
/* Read and display a BinDrv data file */
/***************************************/
static void readit(void)
{
 FILE *f;
 s_bindrvctx bdrv;
 union { int i; double r; char b; char *str; BINDRV_LONG l;} val;

 f=fopen("bindata","r");
 bdrv=bindrv_newreader((size_t (*)(void *,size_t,size_t,void*))fread,f);
 /* By default the library will allocate strings (returned by 'getstring') */
 /* using 'malloc'. The following routine allows to replace 'malloc' by some */
 /* user-defined memory allocation routine (that gets a context as an */
 /* extra parameter) */
 bindrv_setalloc(bdrv,dummy_malloc,NULL);

 while(bindrv_nexttoken(bdrv)>=0)
 {
  switch(bindrv_nexttoken(bdrv))
  {
   case BINDRV_TYP_INT:
	bindrv_getint(bdrv,&(val.i));
	printf(" %d",val.i);
	break;
   case BINDRV_TYP_REAL:
	bindrv_getreal(bdrv,&(val.r));
	printf(" %g",val.r);
	break;
   case BINDRV_TYP_STR:
	bindrv_getstring(bdrv,&(val.str));
	printf(" %s",val.str);
	break;
   case BINDRV_TYP_BOOL:
	bindrv_getbool(bdrv,&(val.b));
	printf(" %s",val.b?"true":"false");
	break;
   case BINDRV_TYP_CTRL:
	bindrv_getctrl(bdrv,&(val.i));
	switch(val.i)
	{
	 case BINDRV_CTRL_SKIP: printf(" *"); break;
	 case BINDRV_CTRL_LABEL:
		bindrv_getstring(bdrv,&(val.str));
		printf("\n%s:",val.str);
		break;
	 case BINDRV_CTRL_OPENLST: printf("["); break;
	 case BINDRV_CTRL_CLOSELST: printf("]"); break;
	 case BINDRV_CTRL_OPENNDX: printf("("); break;
	 case BINDRV_CTRL_CLOSENDX: printf(")"); break;
	 default:
	 	fprintf(stderr,"Unexpected control\n");
		exit(1);
	}
	break;
   case BINDRV_TYP_LONG:
	bindrv_getlong(bdrv,&(val.l));
	printf(" %lld",val.l);
	break;
   default:
	fprintf(stderr,"Unexpected token\n");
	exit(1);
  }
 }
 bindrv_delete(bdrv);
 fclose(f);
 printf("\n");
}

/* A dummy malloc function using a static region */
static void *dummy_malloc(size_t s,void *ctx)
{
 static char buf[1024];

 return (s>1024)?NULL:buf;
}
bdrv.java
/********************************************************/
/*  BinDrv library example                              */
/*  ======================                              */
/*                                                      */
/*  file bdrv.java                                      */
/*  ``````````````                                      */
/* Example of use of BinDrv                             */
/*                                                      */
/*  (c) 2011 Fair Isaac Corporation                     */
/*      author: Y. Colombani, 2011                      */
/********************************************************/

import java.io.*;
import java.nio.*;
import com.dashoptimization.*;

public class bdrv
{
 public static void main(String[] args) throws Exception
 {
  ByteBuffer buf=ByteBuffer.allocate(128);

  writeIt();
  readIt();

  writeIt(buf);
  buf.rewind();
  readIt(buf);
 }

 /*****************************/
 /* Create a BinDrv data file */
 /*****************************/
 static void writeIt() throws IOException
 {
  BinDrvWriter bdrv;
  FileOutputStream f;

  f=new FileOutputStream("bindata");
  bdrv=new BinDrvWriter(f);

  bdrv.putControl(bdrv.CTRL_LABEL).put("A");
  bdrv.putControl(bdrv.CTRL_OPENLST);
  bdrv.putControl(bdrv.CTRL_OPENNDX).put(1).putControl(bdrv.CTRL_CLOSENDX);
  bdrv.put(0.45).put(-31.02).put(-123);
  bdrv.putControl(bdrv.CTRL_CLOSELST);
  bdrv.putControl(bdrv.CTRL_LABEL).put("B").put(true);
  bdrv.putControl(bdrv.CTRL_LABEL).put("C").put("sometext");
  bdrv.putControl(bdrv.CTRL_LABEL).put("D").put(Long.MAX_VALUE/2);
  f.close();
 }

 /***************************************/
 /* Read and display a BinDrv data file */
 /***************************************/
 static void readIt() throws IOException
 {
  BinDrvReader bdrv;
  FileInputStream f;

  f=new FileInputStream("bindata");
  bdrv=new BinDrvReader(f);

  while(bdrv.nextToken()>=0)
  {
   switch(bdrv.nextToken())
   {
    case BinDrvReader.TYP_INT:
	System.out.print(" "+bdrv.getInt());
	break;
    case BinDrvReader.TYP_REAL:
	System.out.print(" "+bdrv.getReal());
	break;
    case BinDrvReader.TYP_STR:
	System.out.print(" "+bdrv.getString());
	break;
    case BinDrvReader.TYP_BOOL:
	System.out.print(" "+bdrv.getBoolean());
	break;
    case BinDrvReader.TYP_CTRL:
	switch(bdrv.getControl())
	{
	 case BinDrvReader.CTRL_SKIP: System.out.print(" *"); break;
	 case BinDrvReader.CTRL_LABEL: System.out.print("\n"+bdrv.getString()+":"); break;
	 case BinDrvReader.CTRL_OPENLST: System.out.print("["); break;
	 case BinDrvReader.CTRL_CLOSELST: System.out.print("]"); break;
	 case BinDrvReader.CTRL_OPENNDX: System.out.print("("); break;
	 case BinDrvReader.CTRL_CLOSENDX: System.out.print(")"); break;
         default:
	  System.out.println("Unexpected Control");
	  System.exit(0);
	}
	break;
    case BinDrvReader.TYP_LONG:
	System.out.print(" "+bdrv.getLong());
	break;
    default:
	System.out.println("Unexpected token: "+bdrv.nextToken());
	System.exit(0);
   }
  }
  f.close();
  System.out.println("");
 }

 /*******************************/
 /* Create a BinDrv data buffer */
 /*******************************/
 static void writeIt(ByteBuffer buf)
 {
  BinDrvWriter.putControl(buf,BinDrvWriter.CTRL_LABEL);
  BinDrvWriter.put(buf,"A");
  BinDrvWriter.putControl(buf,BinDrvWriter.CTRL_OPENLST);
  BinDrvWriter.putControl(buf,BinDrvWriter.CTRL_OPENNDX);
  BinDrvWriter.put(buf,1);
  BinDrvWriter.putControl(buf,BinDrvWriter.CTRL_CLOSENDX);
  BinDrvWriter.put(buf,0.45);
  BinDrvWriter.put(buf,-31.02);
  BinDrvWriter.put(buf,-123);
  BinDrvWriter.putControl(buf,BinDrvWriter.CTRL_CLOSELST);
  BinDrvWriter.putControl(buf,BinDrvWriter.CTRL_LABEL);
  BinDrvWriter.put(buf,"B");
  BinDrvWriter.put(buf,true);
  BinDrvWriter.putControl(buf,BinDrvWriter.CTRL_LABEL);
  BinDrvWriter.put(buf,"C");
  BinDrvWriter.put(buf,"sometext");
  BinDrvWriter.putControl(buf,BinDrvWriter.CTRL_LABEL);
  BinDrvWriter.put(buf,"D");
  BinDrvWriter.put(buf,Long.MAX_VALUE/2);
  buf.limit(buf.position());
 }

 /*****************************************/
 /* Read and display a BinDrv data buffer */
 /*****************************************/
 static void readIt(ByteBuffer buf) throws IOException
 {
  while(BinDrvReader.nextToken(buf)>=0)
  {
   switch(BinDrvReader.nextToken(buf))
   {
    case BinDrvReader.TYP_INT:
	System.out.print(" "+BinDrvReader.getInt(buf));
	break;
    case BinDrvReader.TYP_REAL:
	System.out.print(" "+BinDrvReader.getReal(buf));
	break;
    case BinDrvReader.TYP_STR:
	System.out.print(" "+BinDrvReader.getString(buf));
	break;
    case BinDrvReader.TYP_BOOL:
	System.out.print(" "+BinDrvReader.getBoolean(buf));
	break;
    case BinDrvReader.TYP_CTRL:
	switch(BinDrvReader.getControl(buf))
	{
	 case BinDrvReader.CTRL_SKIP: System.out.print(" *"); break;
	 case BinDrvReader.CTRL_LABEL: System.out.print("\n"+BinDrvReader.getString(buf)+":"); break;
	 case BinDrvReader.CTRL_OPENLST: System.out.print("["); break;
	 case BinDrvReader.CTRL_CLOSELST: System.out.print("]"); break;
	 case BinDrvReader.CTRL_OPENNDX: System.out.print("("); break;
	 case BinDrvReader.CTRL_CLOSENDX: System.out.print(")"); break;
         default:
	  System.out.println("Unexpected Control");
	  System.exit(0);
	}
	break;
    case BinDrvReader.TYP_LONG:
	System.out.print(" "+BinDrvReader.getLong(buf));
	break;
    default:
	System.out.println("Unexpected token: "+BinDrvReader.nextToken(buf));
	System.exit(0);
   }
  }
  System.out.println("");
 }
}
Parent Topic XPRD and bindrv libraries: usage examples

© 2001-2020 Fair Isaac Corporation. All rights reserved. This documentation is the property of Fair Isaac Corporation (“FICO”). Receipt or possession of this documentation does not convey rights to disclose, reproduce, make derivative works, use, or allow others to use it except solely for internal evaluation purposes to determine whether to purchase a license to the software described in this documentation, or as otherwise set forth in a written software license agreement between you and FICO (or a FICO affiliate). Use of this documentation and the software described in it must conform strictly to the foregoing permitted uses, and no other use is permitted.