universals_AMOS.hh

Go to the documentation of this file.

#ifndef __universals_AMOS_HH
#define __universals_AMOS_HH 1

#include "ContigEdge_AMOS.hh"
#include "ContigLink_AMOS.hh"
#include "Contig_AMOS.hh"
#include "Edge_AMOS.hh"
#include "Feature_AMOS.hh"
#include "Fragment_AMOS.hh"
#include "Group_AMOS.hh"
#include "Index_AMOS.hh"
#include "Kmer_AMOS.hh"
#include "Layout_AMOS.hh"
#include "Library_AMOS.hh"
#include "Link_AMOS.hh"
#include "Overlap_AMOS.hh"
#include "Read_AMOS.hh"
#include "ScaffoldEdge_AMOS.hh"
#include "ScaffoldLink_AMOS.hh"
#include "Scaffold_AMOS.hh"
#include "Sequence_AMOS.hh"
#include "Universal_AMOS.hh"

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



namespace AMOS {

//================================================ UniversalSet_t ==============
//==============================================================================
class UniversalSet_t
{

private:

  std::vector<Universal_t *> objs_m;     
  HASHMAP::hash_map<NCode_t, Universal_t *> hash_m;   


public:

  class iterator
  {
  private:
    std::vector<Universal_t *>::iterator i_m;

  public:
    iterator ()
    { }
    iterator (std::vector<Universal_t *>::iterator i)
    { i_m = i; }
    Universal_t & operator*() const
    { return **i_m; }
    Universal_t * operator->() const
    { return *i_m; }
    iterator & operator++()
    { ++ i_m; return *this; }
    iterator operator++(int)
    { iterator tmp = *this; this->operator++(); return tmp; }
    bool operator== (iterator x)
    { return i_m == x . i_m; }
    bool operator!= (iterator x)
    { return i_m != x . i_m; }
  };

  class const_iterator
  {
  private:
    std::vector<Universal_t *>::const_iterator i_m;

  public:
    const_iterator ()
    { }
    const_iterator (std::vector<Universal_t *>::const_iterator i)
    { i_m = i; }
    const Universal_t & operator*() const
    { return **i_m; }
    const Universal_t * operator->() const
    { return *i_m; }
    const_iterator & operator++()
    { ++ i_m; return *this; }
    const_iterator operator++(int)
    { const_iterator tmp = *this; this->operator++(); return tmp; }
    bool operator== (const_iterator x)
    { return i_m == x . i_m; }
    bool operator!= (const_iterator x)
    { return i_m != x . i_m; }
  };

  
  //--------------------------------------------------- UniversalSet_t ---------
  UniversalSet_t ( );


  //--------------------------------------------------- ~UniversalSet_t --------
  ~UniversalSet_t ( );


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


  //--------------------------------------------------- clearAll ---------------
  void clearAll ( );


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


  //--------------------------------------------------- exists -----------------
  bool exists (NCode_t ncode)
  {
    return ( hash_m . find (ncode) != hash_m . end( ) );
  }


  //--------------------------------------------------- getSize ----------------
  Size_t getSize ( )
  {
    return objs_m . size( );
  }


  //--------------------------------------------------- operator[] -------------
  Universal_t & operator[] (NCode_t ncode)
  {
    HASHMAP::hash_map<NCode_t, Universal_t *>::iterator i;
    if ( (i = hash_m . find (ncode)) == hash_m . end( ) )
      AMOS_THROW_ARGUMENT
        ("Unknown UniversalSet_t object NCode " + Decode(ncode));
    return *(i -> second);
  }


  //--------------------------------------------------- operator[] -------------
  const Universal_t & operator[] (NCode_t ncode) const
  {
    HASHMAP::hash_map<NCode_t, Universal_t *>::const_iterator i;
    if ( (i = hash_m . find (ncode)) == hash_m . end( ) )
      AMOS_THROW_ARGUMENT
        ("Unknown UniversalSet_t object NCode " + Decode(ncode));
    return *(i -> second);
  }


  //--------------------------------------------------- operator[] -------------
  Universal_t & operator[] (const std::string & ncode)
  {
    return operator[] (Encode (ncode));
  }


  //--------------------------------------------------- operator[] -------------
  const Universal_t & operator[] (const std::string & ncode) const
  {
    return operator[] (Encode (ncode));
  }
};




//================================================ BankSet_t ===================
//==============================================================================
class BankSet_t
{

private:

  std::vector<Bank_t *> bnks_m;     
  HASHMAP::hash_map<NCode_t, Bank_t *> hash_m;   


public:

  class iterator
  {
  private:
    std::vector<Bank_t *>::iterator i_m;

  public:
    iterator ()
    { }
    iterator (std::vector<Bank_t *>::iterator i)
    { i_m = i; }
    Bank_t & operator*() const
    { return **i_m; }
    Bank_t * operator->() const
    { return *i_m; }
    iterator & operator++()
    { ++ i_m; return *this; }
    iterator operator++(int)
    { iterator tmp = *this; this->operator++(); return tmp; }
    bool operator== (iterator x)
    { return i_m == x . i_m; }
    bool operator!= (iterator x)
    { return i_m != x . i_m; }
  };

  class const_iterator
  {
  private:
    std::vector<Bank_t *>::const_iterator i_m;

  public:
    const_iterator ()
    { }
    const_iterator (std::vector<Bank_t *>::const_iterator i)
    { i_m = i; }
    const Bank_t & operator*() const
    { return **i_m; }
    const Bank_t * operator->() const
    { return *i_m; }
    const_iterator & operator++()
    { ++ i_m; return *this; }
    const_iterator operator++(int)
    { const_iterator tmp = *this; this->operator++(); return tmp; }
    bool operator== (const_iterator x)
    { return i_m == x . i_m; }
    bool operator!= (const_iterator x)
    { return i_m != x . i_m; }
  };

  
  //--------------------------------------------------- BankSet_t --------------
  BankSet_t ( );


  //--------------------------------------------------- ~BankSet_t -------------
  ~BankSet_t ( );


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


  //--------------------------------------------------- clearAll ---------------
  void clearAll ( );


  //--------------------------------------------------- closeAll ---------------
  void closeAll ( );


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


  //--------------------------------------------------- exists -----------------
  bool exists (NCode_t ncode)
  {
    return ( hash_m . find (ncode) != hash_m . end( ) );
  }


  //--------------------------------------------------- getSize ----------------
  Size_t getSize ( )
  {
    return bnks_m . size( );
  }


  //--------------------------------------------------- operator[] -------------
  Bank_t & operator[] (NCode_t ncode)
  {
    HASHMAP::hash_map<NCode_t, Bank_t *>::iterator i;
    if ( (i = hash_m . find (ncode)) == hash_m . end( ) )
      AMOS_THROW_ARGUMENT
        ("Unknown BankSet_t object NCode " + Decode(ncode));
    return *(i -> second);
  }


  //--------------------------------------------------- operator[] -------------
  const Bank_t & operator[] (NCode_t ncode) const
  {
    HASHMAP::hash_map<NCode_t, Bank_t *>::const_iterator i;
    if ( (i = hash_m . find (ncode)) == hash_m . end( ) )
      AMOS_THROW_ARGUMENT
        ("Unknown BankSet_t object NCode " + Decode(ncode));
    return *(i -> second);
  }


  //--------------------------------------------------- operator[] -------------
  Bank_t & operator[] (const std::string & ncode)
  {
    return operator[] (Encode (ncode));
  }


  //--------------------------------------------------- operator[] -------------
  const Bank_t & operator[] (const std::string & ncode) const
  {
    return operator[] (Encode (ncode));
  }
};




//================================================ BankStreamSet_t =============
//==============================================================================
class BankStreamSet_t
{

private:

  std::vector<BankStream_t *> bnks_m;     
  HASHMAP::hash_map<NCode_t, BankStream_t *> hash_m;   


public:

  class iterator
  {
  private:
    std::vector<BankStream_t *>::iterator i_m;

  public:
    iterator ()
    { }
    iterator (std::vector<BankStream_t *>::iterator i)
    { i_m = i; }
    BankStream_t & operator*() const
    { return **i_m; }
    BankStream_t * operator->() const
    { return *i_m; }
    iterator & operator++()
    { ++ i_m; return *this; }
    iterator operator++(int)
    { iterator tmp = *this; this->operator++(); return tmp; }
    bool operator== (iterator x)
    { return i_m == x . i_m; }
    bool operator!= (iterator x)
    { return i_m != x . i_m; }
  };

  class const_iterator
  {
  private:
    std::vector<BankStream_t *>::const_iterator i_m;

  public:
    const_iterator ()
    { }
    const_iterator (std::vector<BankStream_t *>::const_iterator i)
    { i_m = i; }
    const BankStream_t & operator*() const
    { return **i_m; }
    const BankStream_t * operator->() const
    { return *i_m; }
    const_iterator & operator++()
    { ++ i_m; return *this; }
    const_iterator operator++(int)
    { const_iterator tmp = *this; this->operator++(); return tmp; }
    bool operator== (const_iterator x)
    { return i_m == x . i_m; }
    bool operator!= (const_iterator x)
    { return i_m != x . i_m; }
  };

  
  //--------------------------------------------------- BankStreamSet_t --------
  BankStreamSet_t ( );


  //--------------------------------------------------- ~BankStreamSet_t -------
  ~BankStreamSet_t ( );


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


  //--------------------------------------------------- clearAll ---------------
  void clearAll ( );


  //--------------------------------------------------- closeAll ---------------
  void closeAll ( );


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


  //--------------------------------------------------- exists -----------------
  bool exists (NCode_t ncode)
  {
    return ( hash_m . find (ncode) != hash_m . end( ) );
  }


  //--------------------------------------------------- getSize ----------------
  Size_t getSize ( )
  {
    return bnks_m . size( );
  }


  //--------------------------------------------------- operator[] -------------
  BankStream_t & operator[] (NCode_t ncode)
  {
    HASHMAP::hash_map<NCode_t, BankStream_t *>::iterator i;
    if ( (i = hash_m . find (ncode)) == hash_m . end( ) )
      AMOS_THROW_ARGUMENT
        ("Unknown BankStreamSet_t object NCode " + Decode(ncode));
    return *(i -> second);
  }


  //--------------------------------------------------- operator[] -------------
  const BankStream_t & operator[] (NCode_t ncode) const
  {
    HASHMAP::hash_map<NCode_t, BankStream_t *>::const_iterator i;
    if ( (i = hash_m . find (ncode)) == hash_m . end( ) )
      AMOS_THROW_ARGUMENT
        ("Unknown BankStreamSet_t object NCode " + Decode(ncode));
    return *(i -> second);
  }


  //--------------------------------------------------- operator[] -------------
  BankStream_t & operator[] (const std::string & ncode)
  {
    return operator[] (Encode (ncode));
  }


  //--------------------------------------------------- operator[] -------------
  const BankStream_t & operator[] (const std::string & ncode) const
  {
    return operator[] (Encode (ncode));
  }
};

} // namespace AMOS

#endif // #ifndef __universals_AMOS_HH

---