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>



namespace AMOS {

const char      E_ADD          = 'A';
const char      E_DELETE       = 'D';
const char      E_REPLACE      = 'R';
const NCode_t   F_NULL         = Encode ("nul");
const NCode_t   F_AHANG        = Encode ("ahg");
const NCode_t   F_ACTION       = Encode ("act");
const NCode_t   F_ADJACENCY    = Encode ("adj");
const NCode_t   F_BASEPOSITION = Encode ("bcp");
const NCode_t   F_BHANG        = Encode ("bhg");
const NCode_t   F_BID          = Encode ("bid");
const NCode_t   F_CLEAR        = Encode ("clr");
const NCode_t   F_COMMENT      = Encode ("com");
const NCode_t   F_COUNT        = Encode ("cnt");
const NCode_t   F_EID          = Encode ("eid");
const NCode_t   F_EDGE         = Encode ("edg");
const NCode_t   F_FLAG         = Encode ("flg");
const NCode_t   F_FRAGMENT     = Encode ("frg");
const NCode_t   F_GAPS         = Encode ("gap");
const NCode_t   F_IID          = Encode ("iid");
const NCode_t   F_LIBRARY      = Encode ("lib");
const NCode_t   F_LINK         = Encode ("lnk");
const NCode_t   F_MAP          = Encode ("map");
const NCode_t   F_MEAN         = Encode ("mea");
const NCode_t   F_MEMBER       = Encode ("mbr");
const NCode_t   F_NODES        = Encode ("nds");
const NCode_t   F_OBJECT       = Encode ("obj");
const NCode_t   F_OFFSET       = Encode ("off");
const NCode_t   F_POSITION     = Encode ("pos");
const NCode_t   F_QUALITY      = Encode ("qlt");
const NCode_t   F_QUALITYCLEAR = Encode ("qcr");
const NCode_t   F_READS        = Encode ("rds");
const NCode_t   F_SCORE        = Encode ("scr");
const NCode_t   F_SEQUENCE     = Encode ("seq");
const NCode_t   F_SD           = Encode ("std");
const NCode_t   F_SIZE         = Encode ("sze");
const NCode_t   F_SOURCE       = Encode ("src");
const NCode_t   F_STATUS       = Encode ("sts");
const NCode_t   F_TYPE         = Encode ("typ");
const NCode_t   F_VECTORCLEAR  = Encode ("vcr");
const NCode_t   M_NULL         = Encode ("NUL");
const NCode_t   M_UNIVERSAL    = Encode ("UNV");
const NCode_t   M_CONTIG       = Encode ("CTG");
const NCode_t   M_CONTIGEDGE   = Encode ("CTE");
const NCode_t   M_CONTIGLINK   = Encode ("CTL");
const NCode_t   M_DISTRIBUTION = Encode ("DST");
const NCode_t   M_EDGE         = Encode ("EDG");
const NCode_t   M_FEATURE      = Encode ("FEA");
const NCode_t   M_FRAGMENT     = Encode ("FRG");
const NCode_t   M_GROUP        = Encode ("GRP");
const NCode_t   M_KMER         = Encode ("KMR");
const NCode_t   M_LAYOUT       = Encode ("LAY");
const NCode_t   M_LIBRARY      = Encode ("LIB");
const NCode_t   M_LINK         = Encode ("LNK");
const NCode_t   M_IDMAP        = Encode ("MAP");
const NCode_t   M_INDEX        = Encode ("IDX");
const NCode_t   M_OVERLAP      = Encode ("OVL");
const NCode_t   M_READ         = Encode ("RED");
const NCode_t   M_SCAFFOLD     = Encode ("SCF");
const NCode_t   M_SCAFFOLDEDGE = Encode ("SCE");
const NCode_t   M_SCAFFOLDLINK = Encode ("SCL");
const NCode_t   M_SEQUENCE     = Encode ("SEQ");
const NCode_t   M_TILE         = Encode ("TLE");


//================================================ 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

---