/home/gian/Progetti/falcon/core/include/falcon/format.h

Go to the documentation of this file.

/*
   FALCON - The Falcon Programming Language.
   FILE: format.h

   Format base class.
   -------------------------------------------------------------------
   Author: Giancarlo Niccolai
   Begin: sab giu 16 2007

   -------------------------------------------------------------------
   (C) Copyright 2004: the FALCON developers (see list in AUTHORS file)

   See LICENSE file for licensing details.
*/

#ifndef flc_format_H
#define flc_format_H

#include <falcon/setup.h>
#include <falcon/types.h>
#include <falcon/string.h>
#include <falcon/falcondata.h>

/* To be added to docs in the next version.
convType
Type of conversion; determines what type of variable is expected when formatting, depending on the format string. for example, when a decimal number is indicated in the format string, it is implied that the input variable to be formatted is meant to be a numeric value.
decimalChr
Unicode character used to separate decimal parts of numbers. Defaults to '.'.
decimals
Number of decimals that should be represented. Zero means to represent only integer numbers.
fixedSize
If true, the 'size' field is mandatory, and representation of this variable is truncated to a maximum of 'size' characters.
grouping
Count of grouping characters in numeric representation. For example, a number like "1,000,000" has a grouping of 3, while Japanese stanrd representation is 4-grouping (like "10,0000"). Zero means no grouping.
groupingChr
Character using for grouping. Defaults to comma (',').
misAct
Action to perform when a variable of unexpected type is formatted. Can be:
*/

namespace Falcon {

class VMachine;
class Item;


class Format: public FalconData
{

public:

   typedef enum {
      e_minusFront,
      e_plusMinusFront,
      e_minusBack,
      e_plusMinusBack,
      e_minusEnd,
      e_plusMinusEnd,
      e_parenthesis,
      e_parpad
   } t_negFormat;

   typedef enum {
      e_decimal,
      e_binary,
      e_binaryB,
      e_octal,
      e_octalZero,
      e_hexLower,
      e_hexUpper,
      e_cHexLower,
      e_cHexUpper,
      e_scientific
   } t_numFormat;

   typedef enum {
      e_tNum,
      e_tStr,
      e_tError
   }
   t_convType;

   typedef enum {
      e_actNoAction,
      e_actNil,
      e_actZero,
      e_actRaise,
      e_actConvertNil,
      e_actConvertZero,
      e_actConvertRaise
   }
   t_convMismatch;

   typedef enum {
      e_nilEmpty,
      e_nilNil,
      e_nilN,
      e_nilnil,
      e_nilNA,
      e_nilNone,
      e_nilNULL,
      e_nilNull,
      e_nilPad
   }
   t_nilFormat;


private:
   t_convType m_convType;
   t_convMismatch m_misAct;
   uint16 m_size;

   uint32 m_paddingChr;
   uint32 m_thousandSep;
   uint32 m_decimalSep;

   uint8 m_grouping;
   bool m_fixedSize;
   t_nilFormat m_nilFormat;

   bool m_rightAlign;
   uint8 m_decimals;
   t_negFormat m_negFormat;
   t_numFormat m_numFormat;

   String m_originalFormat;
   uint32 m_posOfObjectFmt;

   void formatInt( int64 number, String &target, bool bUseGroup );
   void applyNeg( String &target, int64 number );
   void applyPad( String &target, uint32 extraSize=0 );

   int negPadSize( int64 number );

   bool negBeforePad();

   bool processMismatch( VMachine *vm, const Item &source, String &target );

   bool tryConvertAndFormat( VMachine *vm, const Item &source, String &target );

   void formatScientific( numeric num, String &sBuffer );

public:

   Format() {
      reset();
   }

   Format( const String &fmt )
   {
      reset();
      parse( fmt );
   }


   bool parse( const String &fmt );

   bool isValid() const { return m_convType != e_tError; }


   bool format( const Item &source, String &target ) {
      return format( 0, source, target );
   }

   bool format( VMachine *vm, const Item &source, String &target );

   void reset();

   //==============================================================
   // Accessors
   //

   const String &originalFormat() const { return m_originalFormat; }

   t_convType convType() const { return m_convType; }

   t_convMismatch mismatchAction() const { return m_misAct; }
   void mismatchAction( t_convMismatch t ) { m_misAct = t; }

   uint16 fieldSize() const { return m_size; }
   void fieldSize( uint16 size ) { m_size = size; }

   uint32 paddingChr() const { return m_paddingChr; }
   void paddingChr( uint32 chr ) { m_paddingChr = chr; }

   bool rightAlign() const { return m_rightAlign; }
   void rightAlign( bool b ) { m_rightAlign = b; }

   uint8 decimals() const { return m_decimals; }
   void decimals( uint8 d ) { m_decimals = d; }

   uint8 grouping() const { return m_grouping; }
   void grouping( uint8 g ) { m_grouping = g; }

   t_negFormat negFormat() const { return m_negFormat; }
   void negFormat( t_negFormat f ) { m_negFormat = f; }

   t_nilFormat nilFormat() const { return m_nilFormat; }
   void nilFormat( t_nilFormat f ) { m_nilFormat = f; }

   t_numFormat numFormat() const { return m_numFormat; }
   void numFormat( t_numFormat t ) { m_numFormat = t; }

   bool fixedSize() const { return m_fixedSize; }
   void fixedSize( bool f ) { m_fixedSize = f; }

   //=================================================

   virtual FalconData *clone() const;
   virtual void gcMark( uint32 mark ) {}
};

}

#endif

/* end of format.h */

---