Message_AMOS.hh

Go to the documentation of this file.

#ifndef __Message_AMOS_HH
#define __Message_AMOS_HH 1

#include "utility_AMOS.hh"
#include <string>
#include <vector>
#include <iostream>

// Use a macro because OS X doesn't like/allow static members initialized
// with actual code.
#define AMOS_ENCODE(a,b,c) ((((c << CHAR_BIT) | b) << CHAR_BIT) | a)

namespace AMOS {

const char      E_ADD          = 'A';
const char      E_DELETE       = 'D';
const char      E_REPLACE      = 'R';
const NCode_t   F_NULL         = AMOS_ENCODE ('n','u','l');
const NCode_t   F_AHANG        = AMOS_ENCODE ('a','h','g');
const NCode_t   F_ACTION       = AMOS_ENCODE ('a','c','t');
const NCode_t   F_ADJACENCY    = AMOS_ENCODE ('a','d','j');
const NCode_t   F_BASEPOSITION = AMOS_ENCODE ('b','c','p');
const NCode_t   F_BHANG        = AMOS_ENCODE ('b','h','g');
const NCode_t   F_BID          = AMOS_ENCODE ('b','i','d');
const NCode_t   F_CLEAR        = AMOS_ENCODE ('c','l','r');
const NCode_t   F_COMMENT      = AMOS_ENCODE ('c','o','m');
const NCode_t   F_COUNT        = AMOS_ENCODE ('c','n','t');
const NCode_t   F_EID          = AMOS_ENCODE ('e','i','d');
const NCode_t   F_EDGE         = AMOS_ENCODE ('e','d','g');
const NCode_t   F_FLAG         = AMOS_ENCODE ('f','l','g');
const NCode_t   F_FRAGMENT     = AMOS_ENCODE ('f','r','g');
const NCode_t   F_GAPS         = AMOS_ENCODE ('g','a','p');
const NCode_t   F_IID          = AMOS_ENCODE ('i','i','d');
const NCode_t   F_LIBRARY      = AMOS_ENCODE ('l','i','b');
const NCode_t   F_LINK         = AMOS_ENCODE ('l','n','k');
const NCode_t   F_MAP          = AMOS_ENCODE ('m','a','p');
const NCode_t   F_MEAN         = AMOS_ENCODE ('m','e','a');
const NCode_t   F_MEMBER       = AMOS_ENCODE ('m','b','r');
const NCode_t   F_NODES        = AMOS_ENCODE ('n','d','s');
const NCode_t   F_OBJECT       = AMOS_ENCODE ('o','b','j');
const NCode_t   F_OFFSET       = AMOS_ENCODE ('o','f','f');
const NCode_t   F_POSITION     = AMOS_ENCODE ('p','o','s');
const NCode_t   F_QUALITY      = AMOS_ENCODE ('q','l','t');
const NCode_t   F_QUALITYCLEAR = AMOS_ENCODE ('q','c','r');
const NCode_t   F_READS        = AMOS_ENCODE ('r','d','s');
const NCode_t   F_SCORE        = AMOS_ENCODE ('s','c','r');
const NCode_t   F_SEQUENCE     = AMOS_ENCODE ('s','e','q');
const NCode_t   F_SD           = AMOS_ENCODE ('s','t','d');
const NCode_t   F_SIZE         = AMOS_ENCODE ('s','z','e');
const NCode_t   F_SOURCE       = AMOS_ENCODE ('s','r','c');
const NCode_t   F_STATUS       = AMOS_ENCODE ('s','t','s');
const NCode_t   F_TYPE         = AMOS_ENCODE ('t','y','p');
const NCode_t   F_VECTORCLEAR  = AMOS_ENCODE ('v','c','r');
const NCode_t   M_NULL         = AMOS_ENCODE ('N','U','L');
const NCode_t   M_UNIVERSAL    = AMOS_ENCODE ('U','N','V');
const NCode_t   M_CONTIG       = AMOS_ENCODE ('C','T','G');
const NCode_t   M_CONTIGEDGE   = AMOS_ENCODE ('C','T','E');
const NCode_t   M_CONTIGLINK   = AMOS_ENCODE ('C','T','L');
const NCode_t   M_DISTRIBUTION = AMOS_ENCODE ('D','S','T');
const NCode_t   M_EDGE         = AMOS_ENCODE ('E','D','G');
const NCode_t   M_FEATURE      = AMOS_ENCODE ('F','E','A');
const NCode_t   M_FRAGMENT     = AMOS_ENCODE ('F','R','G');
const NCode_t   M_GROUP        = AMOS_ENCODE ('G','R','P');
const NCode_t   M_KMER         = AMOS_ENCODE ('K','M','R');
const NCode_t   M_LAYOUT       = AMOS_ENCODE ('L','A','Y');
const NCode_t   M_LIBRARY      = AMOS_ENCODE ('L','I','B');
const NCode_t   M_LINK         = AMOS_ENCODE ('L','N','K');
const NCode_t   M_IDMAP        = AMOS_ENCODE ('M','A','P');
const NCode_t   M_INDEX        = AMOS_ENCODE ('I','D','X');
const NCode_t   M_OVERLAP      = AMOS_ENCODE ('O','V','L');
const NCode_t   M_READ         = AMOS_ENCODE ('R','E','D');
const NCode_t   M_SCAFFOLD     = AMOS_ENCODE ('S','C','F');
const NCode_t   M_SCAFFOLDEDGE = AMOS_ENCODE ('S','C','E');
const NCode_t   M_SCAFFOLDLINK = AMOS_ENCODE ('S','C','L');
const NCode_t   M_SEQUENCE     = AMOS_ENCODE ('S','E','Q');
const NCode_t   M_TILE         = AMOS_ENCODE ('T','L','E');


//================================================ Message_t ===================
//==============================================================================
class Message_t
{

private:

  NCode_t mcode_m;                            
  std::vector<Message_t> subs_m;              
  HASHMAP::hash_map<NCode_t,std::string> fields_m;     


public:

  typedef HASHMAP::hash_map<NCode_t,std::string>::const_iterator const_iterator;


  //--------------------------------------------------- Message_t --------------
  Message_t ( )
  {
    mcode_m = M_NULL;
  }


  //--------------------------------------------------- ~Message_t -------------
  ~Message_t ( )
  {

  }


  //--------------------------------------------------- begin ------------------
  const_iterator begin ( ) const
  {
    return fields_m . begin( );
  }


  //--------------------------------------------------- end --------------------
  const_iterator end ( ) const
  {
    return fields_m . end( );
  }


  //--------------------------------------------------- clear ------------------
  void clear ( )
  {
    mcode_m = M_NULL;
    fields_m . clear( );
    subs_m . clear( );
  }


  //--------------------------------------------------- countFields ------------
  Size_t countFields ( ) const
  {
    return fields_m . size( );
  }


  //--------------------------------------------------- countSubMessages -------
  Size_t countSubMessages ( ) const
  {
    return subs_m . size( );
  }


  //--------------------------------------------------- empty ------------------
  bool empty ( ) const
  {
    return (fields_m . empty( ) && subs_m . empty( ));
  }


  //--------------------------------------------------- exists -----------------
  bool exists (NCode_t fcode) const
  {
    return fields_m . find (fcode) == fields_m . end( ) ? false : true;
  }


  //--------------------------------------------------- exists -----------------
  bool exists (const std::string & fname) const
  {
    return exists (Encode (fname));
  }


  //--------------------------------------------------- getField ---------------
  const std::string & getField (NCode_t fcode) const
  {
    HASHMAP::hash_map<NCode_t,std::string>::const_iterator
      mi = fields_m . find (fcode);
    if ( mi == fields_m . end( ) )
      AMOS_THROW_ARGUMENT
        ("Cannot retrieve absent field '" + Decode (fcode) + "'");
    return mi -> second;
  }


  //--------------------------------------------------- getField ---------------
  const std::string & getField (const std::string & fname) const
  {
    return getField (Encode (fname));
  }


  //--------------------------------------------------- getSubMessages ---------
  const std::vector<Message_t> & getSubMessages ( ) const
  {
    return subs_m;
  }


  //--------------------------------------------------- getSubMessages ---------
  std::vector<Message_t> & getSubMessages ( )
  {
    return subs_m;
  }


  //--------------------------------------------------- getMessageCode ---------
  NCode_t getMessageCode ( ) const
  {
    return mcode_m;
  }


  //--------------------------------------------------- operator[] -------------
  const std::string & operator[] (NCode_t fcode) const
  {
    return getField (fcode);
  }

  const std::string & operator[] (const std::string & fname) const
  {
    return getField (fname);
  }
  

  //--------------------------------------------------- read -------------------
  bool read (std::istream & in);


  //--------------------------------------------------- removeField ------------
  void removeField (NCode_t fcode)
  {
    fields_m . erase (fcode);
  }


  //--------------------------------------------------- removeField ------------
  void removeField (const std::string & fname)
  {
    removeField (Encode (fname));
  }


  //--------------------------------------------------- setSubMessages ---------
  void setSubMessages (const std::vector<Message_t> & subs)
  {
    subs_m = subs;
  }


  //--------------------------------------------------- setField ---------------
  void setField (NCode_t fcode, const std::string & data);


  //--------------------------------------------------- setField ---------------
  void setField (const std::string & fname, const std::string & data)
  {
    setField (Encode (fname), data);
  }


  //--------------------------------------------------- setMessageCode ---------
  void setMessageCode (NCode_t mcode)
  {
    mcode_m = mcode;
  }


  //--------------------------------------------------- setMessageCode ---------
  void setMessageCode (const std::string & mname)
  {
    setMessageCode (Encode (mname));
  }


  //--------------------------------------------------- skip -------------------
  static NCode_t skip (std::istream & in); // const


  //--------------------------------------------------- write ------------------
  void write (std::ostream & out) const;

};





//================================================ IMessagable_t ===============
//==============================================================================
class IMessagable_t
{

public:

  //--------------------------------------------------- IMessagable_t ----------
  IMessagable_t ( )
  {

  }


  //--------------------------------------------------- ~IMessagable_t ---------
  virtual ~IMessagable_t ( )
  {

  }


  //--------------------------------------------------- getNCode ---------------
  virtual NCode_t getNCode ( ) const = 0;


  //--------------------------------------------------- readMessage ------------
  virtual void readMessage (const Message_t & msg) = 0;


  //--------------------------------------------------- writeMessage -----------
  virtual void writeMessage (Message_t & msg) const = 0;

};

} // namespace AMOS

#endif // #ifndef __Message_AMOS_HH

---