AnyValue.hpp

/* AnyValue.hpp */
/* $Id: AnyValue.hpp,v 1.12 2005/01/21 11:45:17 vlad Exp $ */
#ifndef __AnyValue_hpp
#define __AnyValue_hpp

#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>

#include <mix/units.h>
#include <mix/DmnDef.h>
#include <mix/Types.h>
#include <mix/Serial.hpp>
#include <mix/TextRepres.hpp>


class AnyValue : public SerialThis, public TextRepres
{
public:

  AnyValue (AtomType at = INT_4, unsigned count = 1,
        CategoryId catid = UC_NONE);

  AnyValue (double val, CategoryId catid = UC_NONE);
  AnyValue (int val, CategoryId catid = UC_NONE);
#ifdef CompilerIs64bitReady
  AnyValue (long long val, CategoryId catid = UC_NONE);
#endif /* CompilerIs64bitReady */

  AnyValue (const DomainDef& dmn, void* rec_ptr = NULL);

  AnyValue (const AnyValue& av);

  AnyValue& operator= (const AnyValue& av);


  virtual ~AnyValue ();

  void      new_def (AtomType at, unsigned count = 1,
             CategoryId catid = UC_NONE);

  void      new_def (const AnyValue& av);


  /***********************************************************************
   * Information about the value
   ***********************************************************************/

  AtomType  get_type () const;

  unsigned  get_dim () const;

  CategoryId    get_categ () const;


  /***********************************************************************
   * Setting the AnyValue at the arbitrary pointer of memory
   ***********************************************************************/

  void      attach (void* val_ptr);

  void      detach ();


  /***********************************************************************
   * Managing changes.  Moving the pointer is not counted as a change
   ***********************************************************************/

  bool      is_changed () const;

  void      changes ();

  void      reset_changes ();


  /***********************************************************************
   * Operations over the value
   ***********************************************************************/

  /*
   * Get the value
   */

  /* Scalar values (dim=1) and an item from vector value (dim>1);
   * automatic convertion between int and float scalar numbers and
   * ASCII<->EBCDIC mappings is performed */
  char      get_char (unsigned i = 0) const;
  Char2     get_unicode (unsigned i = 0) const;
  double    get_float (unsigned i = 0) const;
  int       get_int (unsigned i = 0) const;
#ifdef CompilerIs64bitReady
  long long get_int8 (unsigned i = 0) const;
  long long get_key (unsigned i = 0) const{
    return get_int8(i);
  }
#endif /* CompilerIs64bitReady */

  /* Aliases for scalar values */
  operator char () const;
  operator float () const;
  operator double () const;
  operator short () const;
  operator int () const;
  operator long () const;
#ifdef CompilerIs64bitReady
  operator long long () const;
#endif /* CompilerIs64bitReady */

  /* Always scalar */
  BlobRef   get_blob_ref () const;

  /* Vector values (dim>=1) */
  void      get_int1 (char* val) const;
  void      get_int2 (short* val) const;
  void      get_int4 (int* val) const;
#ifdef CompilerIs64bitReady
  void      get_int8 (long long* val) const;
  void      get_key (long long* val) const{
    get_int8(val);
  }
#endif /* CompilerIs64bitReady */
  void      get_real4 (float* val) const;
  void      get_real8 (double* val) const;
  void      get_char (char* val) const;
  void      get_unicode (Char2* val) const;

  /* Allocate-and-get operations (release memory by free() */
  char*     get_alloc_int1 () const;
  short*    get_alloc_int2 () const;
  int*      get_alloc_int4 () const;
#ifdef CompilerIs64bitReady
  long long*    get_alloc_int8 () const;
  long long*    get_alloc_key () const{
    return get_alloc_int8();
  }
#endif /* CompilerIs64bitReady */
  float*    get_alloc_real4 () const;
  double*   get_alloc_real8 () const;
  char*     get_alloc_char () const;
  Char2*    get_alloc_unicode () const;

  /*
   * Set the value
   */

  /* Scalar values (dim=1) and an item from vector value (dim>1);
   * automatic convertion between int and float scalar numbers and
   * ASCII<->EBCDIC mappings is performed */
  void      set_char (char val, unsigned i = 0);
  void      set_unicode (Char2 val, unsigned i = 0);
  void      set_float (double val, unsigned i = 0);
  void      set_int (int val, unsigned i = 0);
#ifdef CompilerIs64bitReady
  void      set_int8 (long long val, unsigned i = 0);
  void      set_key (long long val, unsigned i = 0){
    set_int8(val, i);
  }
#endif /* CompilerIs64bitReady */

  /* Always scalar */
  void      set_blob_ref (BlobRef val);

  /* Vector values (dim>=1) */
  void      set_int1 (const char* val);
  void      set_int2 (const short* val);
  void      set_int4 (const int* val);
#ifdef CompilerIs64bitReady
  void      set_int8 (const long long* val);
  void      set_key (const long long* val){
    set_int8(val);
  }
#endif /* CompilerIs64bitReady */
  void      set_real4 (const float* val);
  void      set_real8 (const double* val);
  /* Automatic length determination by EOL */
  void      set_char (const char* val);
  void      set_unicode (const Char2* val);

  /***********************************************************************
   * Comparison operation
   ***********************************************************************/

  virtual bool  operator== (const AnyValue& av) const;

  bool      operator!= (const AnyValue& av) const;

  static Compar compare (const AnyValue& av1, const AnyValue& av2);


  /***********************************************************************
   * Stream input/output operations are performed depending the
   * attached status: in case of own memory (attached=NULL) definition
   * will be put and get (so, type may change on deserialize());
   * attached object stores definition too but can't restore it since
   * doesn't own the memory.
   ***********************************************************************/

  virtual void      serialize (OutputStream& ost) const;

  virtual void      deserialize (InputStream& ist);

  void          definition (bool f);


  /***********************************************************************
   * Textual representation
   ***********************************************************************/

  virtual char* check_string (const char* s, int* pDim = NULL) const;

  virtual char* from_string (const char* s);

  virtual char* to_string () const;


  /***********************************************************************
   * Empty value management.
   ***********************************************************************/

  bool      is_empty_value () const;

  void      empty_value ();


  /***********************************************************************
   * Printing the value.
   ***********************************************************************/

  void      print_self (FILE* stream = NULL,
                const char* szPre = NULL,
                const char* szPost = NULL) const;

private:

  AtomType  atype;  
  unsigned  dim;    
  CategoryId    categ;  
  union Value {
    Real4   r4; 
    Real8   r8;
    Int1    i1; 
    Int2    i2;
    Int4    i4;
#ifdef CompilerIs64bitReady
    Int8    i8;
#endif /* CompilerIs64bitReady */
    Char    c1; 
    Char2   c2; 
    BlobRef blob;   
    Real4   *ptr_r4;    
    Real8   *ptr_r8;
    Int1    *ptr_i1;    
    Int2    *ptr_i2;
    Int4    *ptr_i4;
    Int8    *ptr_i8;
    BlobRef *ptr_blob;  
    Char    *ptr_c1;    
    Char2   *ptr_c2;    
    void    *ptr;   
  }     v;  
  bool      changed;

  void      *attached;

  bool      def_in_stream;

};


/***********************************************************************
 * Inline implementation of some methods
 ***********************************************************************/

/* Detach true value storage */
inline void
AnyValue::detach ()
{
  attached = NULL;

  empty_value();
}


/* Get status of changes */
inline bool
AnyValue::is_changed () const
{
  return changed;
}

 
/* Set changes flag */
inline void
AnyValue::changes ()
{
  changed = TRUE;
}


/* Reset status of changes, leads to FALSE at next call to
   is_changed() */
inline void
AnyValue::reset_changes ()
{
  changed = FALSE;
}


/* Return type of the value */
inline AtomType
AnyValue::get_type () const
{
  return atype;
}


/* Return dimension of the value */
inline unsigned
AnyValue::get_dim () const
{
  return dim;
}


/* Return category of the value */
inline CategoryId
AnyValue::get_categ () const
{
  return categ;
}


/* Turn on (by default) or off putting/getting value definition
   to/from the stream */
inline void
AnyValue::definition (bool f)
{
  def_in_stream = !!f;
}


/* Change value definition */
inline void
AnyValue::new_def (const AnyValue& av)
{
  new_def(av.get_type(), av.get_dim(), av.get_categ());
}


inline
AnyValue::operator char () const
{
  return get_char();
}

inline
AnyValue::operator double () const
{
  return get_float();
}

inline
AnyValue::operator float () const
{
  return get_float();
}

inline
AnyValue::operator long () const
{
  return get_int();
}

inline
AnyValue::operator int () const
{
  return get_int();
}

inline
AnyValue::operator short () const
{
  return get_int();
}

#ifdef CompilerIs64bitReady
inline
AnyValue::operator long long () const
{
  return get_int8();
}
#endif /* CompilerIs64bitReady */


#endif /* AnyValue.hpp */