Accessor.hpp

Go to the documentation of this file.

#ifndef __Accessor_H_
#define __Accessor_H_
 
#include "Type.hpp"
#include "cytnx_error.hpp"
//#include "Tensor.hpp"
#include <vector>
#include <cstring>
#include <string>
#include <iostream>
#include <initializer_list>
namespace cytnx{
    class Accessor{
        private:
            cytnx_int64 _type; 
 
        public:
            cytnx_int64 _min{}, _max{}, _step{};
            cytnx_int64 loc{};
            std::vector<cytnx_int64> idx_list;
 
            
 
            // if type is singl, _min/_max/_step     are not used
            // if type is all  , _min/_max/_step/loc are not used
            // if type is range, loc              are not used.
            // if type is tilend, loc/_max are not used. 
 
            enum : cytnx_int64{
                none,
                Singl,
                All,
                Range,
                Tilend,
                Step,
                Tn,
                list
            };
 
            Accessor(): _type(Accessor::none){};
 
            // single constructor
            explicit Accessor(const cytnx_int64 &loc);
            //explicit Accessor(const Tensor &tn);// construct from Tensor, should be 1d with dtype integer.
 
 
 
            template<class T>
            explicit Accessor(const std::initializer_list<T> &list){
                std::vector<T> tmp = list;
                this->_type = this->list;
                this->idx_list = std::vector<cytnx_int64>(tmp.begin(),tmp.end());
                //std::cout << "VV" << this->idx_list.size() << std::endl;
            };// construct from vector/list, should be 1d with dtype integer.
 
            template<class T>
            explicit Accessor(const std::vector<T> &list){
                this->_type = this->list;
                this->idx_list = std::vector<cytnx_int64>(list.begin(),list.end());
            };// construct from vector/list, should be 1d with dtype integer.
 
 
            
 
 
            // all constr. ( use string to dispatch )            
            explicit Accessor(const std::string &str);
 
            
 
 
            // range constr. 
            Accessor(const cytnx_int64 &min, const cytnx_int64 &max, const cytnx_int64 &step);
 
 
            //copy constructor:
            Accessor(const Accessor& rhs);
            //copy assignment:
            Accessor& operator=(const Accessor& rhs);
 
            int type() const{
                return this->_type;
            }
 
 
 
 
            //handy generator function :
            static Accessor all(){
                return Accessor(std::string(":"));
            };
 
 
            static Accessor range(const cytnx_int64 &min, 
                                  const cytnx_int64 &max, 
                                  const cytnx_int64 &step=1){
                return Accessor(min,max,step);
            };
 
            static Accessor tilend(const cytnx_int64 &min, const cytnx_int64 &step=1){
                cytnx_error_msg(step==0,"[ERROR] cannot have _step=0 for tilend%s","\n");
                Accessor out; 
                out._type = Accessor::Tilend;
                out._min = min;
                out._step = step; 
                return out;
            };
 
            static Accessor step(const cytnx_int64 &step){
                cytnx_error_msg(step==0,"[ERROR] cannot have _step=0 for _step%s","\n");
                Accessor out; 
                out._type = Accessor::Step;
                //out._min = 0;
                out._step = step; 
                return out;
            };
 
            // get the real len from dim
            // if type is all, pos will be null, and len == dim
            // if type is range, pos will be the locator, and len == len(pos)
            // if type is singl, pos will be pos, and len == 0 
            void get_len_pos(const cytnx_uint64 &dim, cytnx_uint64 &len, std::vector<cytnx_uint64> &pos) const;
    };//class Accessor
 
    //layout:
    std::ostream& operator<<(std::ostream& os, const Accessor &in);
 
    // elements resolver
    template<class T>
    void _resolve_elems(std::vector<cytnx::Accessor> &cool, const T& a){
        cool.push_back(cytnx::Accessor(a));
    }
 
    template<class T, class ... Ts>
    void _resolve_elems(std::vector<cytnx::Accessor> &cool,const T&a, const Ts&... args){
        cool.push_back(cytnx::Accessor(a));
        _resolve_elems(cool,args...);
    } 
 
    template<class T,class ... Ts>
    std::vector<cytnx::Accessor> Indices_resolver(const T&a, const Ts&... args){
        //std::cout << a << std::endl;;
        std::vector<cytnx::Accessor> idxs;
        _resolve_elems(idxs,a,args...);
        //cout << idxs << endl;
        return idxs;
    }
 
}// namespace cytnx
 
#endif