notes: pointer's pointer **p

  looper_type& selecte_looper(sequencer_type& seqer);
  looper_type* selecte_looper(sequencer_type& seqer,const std::string& looper_name);
  void update_sequencer_fullness(sequencer_type& seqer,size_t& emptiest_lper_index);
  //output
  bool check_pkg_available(sequencer_type& seqer,const package_type& opt_pkg,looper_type **opt_lper);
  
   

//void Resequencer::selecte_looper(sequencer_type& seqer,looper_type** lper)
looper_type& Resequencer::selecte_looper(sequencer_type& seqer)
{//make sure sequencer is not full before call this func
  //find the emptiest looper 
  //and return by lper
  size_t lper_index = 0;
  if(seqer.looper_vec.size() > 1)
    update_sequencer_fullness(seqer,lper_index);

  //std::cout << "selecte_looper address: " << &(seqer.looper_vec[lper_index]) << std::endl;
  //std::cout << "selecte_looper" << &(lper) << std::endl;
  std::cout << "selecte_looper:" << seqer.looper_vec[lper_index].lper_name<< std::endl;
  return seqer.looper_vec[lper_index];
}

//looper_type& Resequencer::selecte_looper(sequencer_type& seqer,const std::string& looper_name)
looper_type* Resequencer::selecte_looper(sequencer_type& seqer,const std::string& looper_name)
{//make sure sequencer is not full before call this func
  //and return by lper
  size_t lper_index = 0;
  if(seqer.looper_vec.size() > 1)
  {
    for(auto& it : seqer.looper_vec)
    {
      if(it.lper_name == looper_name)
        break;
      lper_index++;
    }
  }
  //std::cout << "selecte_looper address: " << &(seqer.looper_vec[lper_index]) << std::endl;
  //return  seqer.looper_vec[lper_index];
  return  &(seqer.looper_vec[lper_index]);
}

void Resequencer::update_sequencer_fullness(sequencer_type& seqer,size_t& emptiest_lper_index)
{
  //find the emptiest looper index
  //and return by emptiest_lper_index
  emptiest_lper_index = 0;
  auto& emptiness_v = seqer.emptiness_vec;
  auto& looper_v = seqer.looper_vec;
  size_t emptiest = 0;
  size_t lper_count = emptiness_v.size();
  //just includes 1 looper
  if(1 == lper_count && 0 == emptiest)
    seqer.full = true;

  //includes >1 looper
  for(size_t i = 0;i < lper_count;i++)
  {//compare emptiness of all looper
    //buble sort to find the emptiest
    if(emptiest < emptiness_v[i])
    {
      emptiest_lper_index = i;
      emptiest = emptiness_v[i];
    }
  }
  if(0 == emptiest)
    seqer.full = true;

  seqer.full = false;
  std::cout << "emptiest: "<<emptiest
    << "emptiest_lper_index: " <<emptiest_lper_index
    <<" looper_name:" << looper_v[emptiest_lper_index].lper_name
    <<std::endl;
}

//output
bool Resequencer::check_pkg_available(sequencer_type& seqer,const package_type& opt_pkg,looper_type **opt_lper)
{//check pkg from pkg_pool_map_,and return a looper by opt_lper
  for(auto& it : pkg_pool_map_)
  {
    auto lper_name = it.first;
    auto pkg_info_vec = it.second;
    for(auto& piv_it : pkg_info_vec)
    {//TODO:map
      if(piv_it.pkg == opt_pkg)
      {//TODO:bug
        //looper_type& opt_lper= selecte_looper(seqer,lper_name);
        //opt_lper = &(selecte_looper(seqer,lper_name));
        *opt_lper = selecte_looper(seqer,lper_name);
        //std::cout << "check_pkg_available: value of *opt_lper: "<<(*opt_lper)<<std::endl;
        //std::cout << "check_pkg_available: addressof &opt_lper: "<<&(opt_lper)<<std::endl;
        //std::cout << "check_pkg_available: addressof &*opt_lper: "<<&(*opt_lper)<<std::endl;
        //std::cout << "check_pkg_available: addressof &**opt_lper: "<<&(**opt_lper)<<std::endl;
        return true;
      }
    }
  }
  return false;
}


//usage
main()
{
 //check if pkg_pool includes a target pkg
    looper_type* opt_lper_p = nullptr;
    looper_type** opt_lper_pt = &opt_lper_p;
    //std::cout << "resequence : before check addressof &*opt_lper_p: "<<&(*opt_lper_p)<<std::endl;

    if(true == check_pkg_available(seqer,opt_pkg,opt_lper_pt))
    {// get the output looper
      if( opt_lper_pt != nullptr )
        //if( *opt_lper_p == nullptr )
      {
        looper_type& opt_lper = *opt_lper_p;
        //std::cout << " resequence: after addressof &*opt_lper_pt: "<<&(*opt_lper_p)<<std::endl;
        //print_sequencer_unit(*opt_lper_p);
        print_sequencer_unit(opt_lper);

        //check if a package can be release immediately
        std::cout <<"opt_pkg=====:"<<opt_pkg<< std::endl;
        if(true == check_pkg_releasable(opt_lper,opt_pkg)) 
        {
          release_pkg_from_looper(opt_lper,opt_pkg);
          update_loopers_info_map(seqer,opt_lper.lper_name);
          give_pkg_done(output_seq, opt_pkg);
          succeed_pkg_count_++;
        }else{
          //statistic dispatch expense
          std::cout<< "pkg available,but not releasable\n";
        }
      }
    }
 }