seqregion.h

#include "mutation.h"
 
#pragma once
#include <array>
#include <memory>  // for unique_ptr
 
namespace cmaple {
class SeqRegion : public Mutation {
 public:
  using LHType = std::array<cmaple::RealNumType, NUM_STATES>;
  using LHPtrType = std::unique_ptr<LHType>;
  enum SeqType {
    SEQ_DNA,     
    SEQ_PROTEIN, 
    SEQ_AUTO,    
    SEQ_UNKNOWN, 
  };
 
 private:
  void computeLhAmbiguity(const LHType& entries);
 
  void convertAmbiguiousState(cmaple::SeqRegion::SeqType seq_type,
                              int max_num_states);
 
  void convertAmbiguiousStateDNA(int max_num_states);
 
  void convertAmbiguiousStateAA(int max_num_states);
 
 public:
  cmaple::RealNumType plength_observation2node = -1;
 
  cmaple::RealNumType plength_observation2root = -1;
 
  LHPtrType likelihood;
 
  cmaple::RealNumType getLH(int pos) const {
      assert(type == TYPE_O);
      return (*likelihood)[static_cast<unsigned long>(pos)];
  }
 
  SeqRegion() = default;
 
  SeqRegion(cmaple::StateType n_type,
            cmaple::PositionType n_position,
            cmaple::RealNumType n_plength_observation = -1,
            cmaple::RealNumType n_plength_from_root = -1,
            LHPtrType n_likelihood = nullptr);
 
  SeqRegion(cmaple::StateType n_type,
            cmaple::PositionType n_position,
            cmaple::RealNumType n_plength_observation,
            cmaple::RealNumType n_plength_from_root,
            const LHType& n_likelihood);
 
  SeqRegion(cmaple::StateType n_type,
            cmaple::PositionType n_position,
            cmaple::SeqRegion::SeqType seq_type,
            int max_num_states);
 
  SeqRegion(Mutation* n_mutation,
            cmaple::SeqRegion::SeqType seq_type,
            int max_num_states);
 
  // SeqRegion(SeqRegion* region, StateType num_states, bool copy_likelihood =
  // true);
 
  SeqRegion(SeqRegion&& region) noexcept = default;
  SeqRegion& operator=(SeqRegion&& region) noexcept = default;
 
  static inline SeqRegion clone(const SeqRegion& from) {
    if (from.likelihood)
      return SeqRegion(from.type, from.position, from.plength_observation2node,
                       from.plength_observation2root, *from.likelihood);
    else
      return SeqRegion(from.type, from.position, from.plength_observation2node,
                       from.plength_observation2root);
  }
 
  ~SeqRegion() = default;
 
  bool operator==(const SeqRegion& seqregion_1) const;
 
  static SeqType parseSeqType(const std::string& n_seqtype_str);
};
}  // namespace cmaple