UIntOrEmpty.h

/*
 * Copyright (c) 2017-2024, NVIDIA CORPORATION.  All rights reserved.
 * 
 * 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 _UINTOREMPTY_H_
#define _UINTOREMPTY_H_
 
#include <systemc>
#include <nvhls_int.h>
#include <nvhls_types.h>
#include <nvhls_assert.h>
#include <nvhls_message.h>
 
// Provides an NVUINT field that can also be of width = 0
// May eventually integrate this more into Connections marshaller
 
namespace nvhls {
 
struct EmptyField : public nvhls_message {
  template <typename T>
  EmptyField operator=(T const &) {
#ifndef __SYNTHESIS__
    NVHLS_ASSERT_MSG(true,"EmptyField should never be assigned or accessed");   // If an assignment actually occurs during runtime
                                                                                // you've done something wrong
#endif
    return EmptyField();
  }
  uint64 to_uint64() { return 0; }
  const sc_bit operator[](std::size_t idx) const { return static_cast<sc_bit>(0); }
  bool and_reduce() { return 0; }
  bool or_reduce() { return 0; }
};
struct EmptyField : public nvhls_message {…};
 
/* Operator << for EmptyField. */
inline std::ostream &operator<<(ostream &os, const EmptyField &empty) {
  return os << "EMPTYFIELD";
}
 
/* Operator & for Marshaller and EmptyField. */
template <unsigned int Size>
Marshaller<Size> &operator&(Marshaller<Size> &m, EmptyField &rhs) {
  return m;  // just do nothing
}
 
/* Operator != for EmptyField and int. */
inline bool operator!=(const EmptyField lhs, const int rhs) {
  return true; // EmptyField never equals anything
}
 
template <bool, int W>
class UIntOrEmptywCheck;
 
template <int W>
class UIntOrEmptywCheck<true, W> {
 public:
  typedef NVUINTW(W) T;
};
class UIntOrEmptywCheck<true, W> {…};
 
template <int W>
class UIntOrEmptywCheck<false, W> {
 public:
  typedef EmptyField T;
};
class UIntOrEmptywCheck<false, W> {…};
 
template <int W>
class UIntOrEmpty {
 public:
  typedef typename UIntOrEmptywCheck<(W > 0), W>::T T;
};
class UIntOrEmpty {…};
 
};
 
 
#endif