source: XIOS/dev/dev_ym/XIOS_COUPLING/src/transformation/transformation_path.cpp @ 1984

#include "transformation_path.hpp"

namespace xios
{
  void CTransformationPaths::mergePaths(const CTransformationPaths& transformationPaths)
  {
    donePath_ = transformationPaths.donePath_ ;
    //? if (donePath_.empty()) donePath_.push_back(transformationPaths.path_) ; // entry point
    
    if (!donePath_.empty())
    {
      TPath& remotePath = donePath_.back() ;
      
      // same element type and element id
      if (std::get<0>(remotePath)==std::get<0>(path_) && std::get<1>(remotePath)==std::get<1>(path_))
      {
        auto it = get<2>(path_).begin() ;
        auto remoteIt = get<2>(remotePath).begin() ;
        for(  ; remoteIt !=get<2>(remotePath).end() ; remoteIt++ )
        {
          if (it==get<2>(path_).end() || *it != *remoteIt) break ;
          else it++ ;
        }

        if (remoteIt==get<2>(remotePath).end()) get<2>(remainPath_).insert( get<2>(remainPath_).begin(), it , std::get<2>(path_).end() ) ;
        else  remainPath_ = path_ ;

      }
      else remainPath_=path_ ;
    }
    else
    {
      remainPath_=path_ ;
    } 
  }
  
  void CTransformationPaths::mergePaths(void)
  {
    CTransformationPaths transformationPath ;
    mergePaths(transformationPath) ;
  }

  CTransformationPaths CTransformationPaths::getDonePath(void)
  {
    CTransformationPaths returnDonePath ;
    returnDonePath.donePath_ = donePath_ ;
    return  returnDonePath ;
  }

  EElement CTransformationPaths::getNextElementType(void)
  {
    if (get<1>(remainPath_)=="") return get<0>(donePath_.back());
    else return get<0>(remainPath_) ;
  }

  string CTransformationPaths::getNextElementId(void)
  {
    string sep="/" ;
    string doneId=getPathsId(donePath_) ;
    if (doneId=="") sep="" ;
    TPath next = remainPath_ ;
    get<2>(next).erase(++(get<2>(next).begin()),get<2>(next).end()) ;
    string remainId=getPathId(next) ;
    if (remainId=="") sep="" ;
    return doneId+sep+remainId ;
  }

  string CTransformationPaths::getNextElementSrcId(void)
  {
    return getPathsId(donePath_) ;
  }

  ETranformationType CTransformationPaths::getNextTransformationType(void)
  {
    return get<2>(remainPath_).front().first ;
  }

  string CTransformationPaths::getNextTransformationId(void)
  {
    return get<2>(remainPath_).front().second ;
  }

  void CTransformationPaths::removeNextTransform(void)
  {
    if (get<1>(remainPath_)!="")
    {
      TPath newPath;
      get<0>(newPath)=get<0>(remainPath_) ;
      get<1>(newPath)=get<1>(remainPath_) ;
      if (!get<2>(remainPath_).empty()) get<2>(newPath).push_back(get<2>(remainPath_).front()) ;
      donePath_.push_back(newPath);
      get<1>(newPath)="" ;
      if (!get<2>(newPath).empty()) get<2>(remainPath_).pop_front() ;
    }
    else
    {
      if (!get<2>(remainPath_).empty())
      {
        get<2>(donePath_.back()).push_back(get<2>(remainPath_).front()) ;
        get<2>(remainPath_).pop_front() ;
      }
    }
  }


  string CTransformationPaths::getPathId(const TPath& path)
  {
    string id,id1 ;
    if (get<1>(path)!="")
    {
      if (get<0>(path)==EElement::DOMAIN) id="CDomain" ;
      if (get<0>(path)==EElement::AXIS)   id="CAxis" ;
      if (get<0>(path)==EElement::SCALAR) id="CScalar" ;
      id=id+":"+get<1>(path) ;
      id1="/" ;
    }

    for(auto transform : get<2>(path))
    {
      
      id=id+id1 ;
      id=id+to_string(transform.first) ; // not very nice but enough for now. Should be replace by string tranformation name
      id=id+":"+transform.second ;
      id1="/" ;
    }
    return id ;
  }

  string CTransformationPaths::getPathsId(const list<TPath>& paths)
  {
    string id ;
    string sep("") ;
    for(auto path:paths) 
    {
      id=id+sep+getPathId(path) ;
      sep="//" ;
    }
    return id ;
  }
}