vector.hpp

Go to the documentation of this file.

/*
 *   Copyright 2021 Huawei Technologies Co., Ltd.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#ifndef _H_GRB_VECTOR_BASE
#define _H_GRB_VECTOR_BASE

#include <cstdlib>  //size_t
#include <iterator> //std::iterator
#include <stdexcept>
#include <utility> //pair

#include <graphblas/backends.hpp>
#include <graphblas/descriptors.hpp>
#include <graphblas/ops.hpp>
#include <graphblas/rc.hpp>


namespace grb {

    template< typename D, enum Backend implementation, typename C >
    class Vector {

        public :

            typedef D value_type;

            typedef D& lambda_reference;

            class const_iterator :
                public std::iterator<
                    std::forward_iterator_tag,
                    std::pair< const size_t, const D >,
                    size_t
                >
            {

                public :

                    bool operator==( const const_iterator &other ) const {
                        (void) other;
                        return false;
                    }

                    bool operator!=( const const_iterator &other ) const {
                        (void) other;
                        return true;
                    }

                    std::pair< const size_t, const D > operator*() const {
                        return std::pair< const size_t, const D >();
                    }

                    const_iterator & operator++() {
                        return *this;
                    }

            };

            Vector( const size_t n, const size_t nz ) {
                (void) n;
                (void) nz;
            }

            Vector( const size_t n ) {
                (void) n;
            }

            Vector( const std::initializer_list< D > &vals ) {
                (void) vals;
            }

            Vector( Vector< D, implementation, C > &&x ) noexcept {
                (void) x;
            }

            Vector< D, implementation, C >& operator=(
                Vector< D, implementation, C > &&x
            ) noexcept {
                (void) x;
                return *this;
            }

            ~Vector() {}


            const_iterator cbegin() const {
                const_iterator ret;
                return ret;
            }

            const_iterator begin() const {
                const_iterator ret;
                return ret;
            }



            const_iterator cend() const {
                const_iterator ret;
                return ret;
            }

            const_iterator end() const {
                const_iterator ret;
                return ret;
            }

            template<
                Descriptor descr = descriptors::no_operation,
                class Accum = typename operators::right_assign< D, D, D >,
                typename fwd_iterator = const D * __restrict__
            >
            RC build(
                const Accum &accum,
                const fwd_iterator start, const fwd_iterator end,
                fwd_iterator npos
            ) {
                (void) accum;
                (void) start;
                (void) end;
                (void) npos;
                return PANIC;
            }

            template<
                Descriptor descr = descriptors::no_operation,
                class Accum = operators::right_assign< D, D, D >,
                typename ind_iterator = const size_t * __restrict__,
                typename nnz_iterator = const D * __restrict__,
                class Dup = operators::right_assign< D, D, D >
            >
            RC build(
                const Accum &accum,
                const ind_iterator ind_start, const ind_iterator ind_end,
                const nnz_iterator nnz_start, const nnz_iterator nnz_end,
                const Dup &dup = Dup()
            ) {
                (void) accum;
                (void) ind_start;
                (void) ind_end;
                (void) nnz_start;
                (void) nnz_end;
                (void) dup;
                return PANIC;
            }

            template<
                Descriptor descr = descriptors::no_operation,
                typename mask_type,
                class Accum,
                typename ind_iterator = const size_t * __restrict__,
                typename nnz_iterator = const D * __restrict__,
                class Dup = operators::right_assign< D, typename nnz_iterator::value_type, D >
            >
            RC build(
                const Vector< mask_type, implementation, C > &mask,
                const Accum &accum,
                const ind_iterator ind_start,
                const ind_iterator ind_end,
                const nnz_iterator nnz_start,
                const nnz_iterator nnz_end,
                const Dup &dup = Dup()
            ) {
                (void) mask;
                (void) accum;
                (void) ind_start;
                (void) ind_end;
                (void) nnz_start;
                (void) nnz_end;
                (void) dup;
                return PANIC;
            }

            template< typename T >
            RC size( T &size ) const {
                (void) size;
                return PANIC;
            }

            template< typename T >
            RC nnz( T &nnz ) const {
                (void) nnz;
                return PANIC;
            }

            template< class Monoid >
            lambda_reference operator()(
                const size_t i, const Monoid &monoid = Monoid()
            ) {
                (void) i;
                (void) monoid;
                return PANIC;
            }

            lambda_reference operator[]( const size_t i ) {
                (void) i;
 #ifndef _GRB_NO_EXCEPTIONS
                throw std::runtime_error(
                    "Requesting lambda reference of unimplemented Vector backend."
                );
 #endif
            }
    };

} // end namespace ``grb''

#endif // _H_GRB_VECTOR_BASE