util.h

Go to the documentation of this file.

// BSD 3-Clause License; see https://github.com/scikit-hep/awkward-1.0/blob/main/LICENSE
 
#ifndef AWKWARD_UTIL_H_
#define AWKWARD_UTIL_H_
 
#include <string>
#include <vector>
#include <map>
#include <memory>
 
#include "awkward/common.h"
 
#ifndef _MSC_VER
  #include "dlfcn.h"
#endif
 
namespace awkward {
  namespace util {
    enum class dtype {
        NOT_PRIMITIVE,
        boolean,
        int8,
        int16,
        int32,
        int64,
        uint8,
        uint16,
        uint32,
        uint64,
        float16,
        float32,
        float64,
        float128,
        complex64,
        complex128,
        complex256,
        datetime64,
        timedelta64,
        size
    };
 
    dtype
    name_to_dtype(const std::string& name);
 
    const std::string
    dtype_to_name(dtype dt);
 
    dtype
    format_to_dtype(const std::string& format, int64_t itemsize);
 
    const std::string
    dtype_to_format(dtype dt, const std::string& format = "");
 
    int64_t
    dtype_to_itemsize(dtype dt);
 
    bool
    is_integer(dtype dt);
 
    bool
    is_signed(dtype dt);
 
    bool
    is_unsigned(dtype dt);
 
    bool
    is_real(dtype dt);
 
    bool
    is_complex(dtype dt);
 
    void
    handle_error(const struct Error &err,
                 const std::string &classname = std::string(""));
 
    std::string
      quote(const std::string& x);
 
    using RecordLookup    = std::vector<std::string>;
    using RecordLookupPtr = std::shared_ptr<RecordLookup>;
 
    RecordLookupPtr
      init_recordlookup(int64_t numfields);
 
    int64_t
      fieldindex(const RecordLookupPtr& recordlookup,
                 const std::string& key,
                 int64_t numfields);
 
    const std::string
      key(const RecordLookupPtr& recordlookup,
          int64_t fieldindex,
          int64_t numfields);
 
    bool
      haskey(const RecordLookupPtr& recordlookup,
             const std::string& key,
             int64_t numfields);
 
    const std::vector<std::string>
      keys(const RecordLookupPtr& recordlookup, int64_t numfields);
 
    using Parameters = std::map<std::string, std::string>;
 
    bool
    json_equals(const std::string &myvalue, const std::string &value);
 
    bool
      parameter_equals(const Parameters& parameters,
                       const std::string& key,
                       const std::string& value);
 
    bool
      parameters_equal(const Parameters& self, const Parameters& other, bool check_all);
 
    void
      merge_parameters(Parameters& output, const Parameters& input);
 
    bool
      parameter_isstring(const Parameters& parameters, const std::string& key);
 
    bool
      parameter_isname(const Parameters& parameters, const std::string& key);
 
    const std::string
      parameter_asstring(const Parameters& parameters, const std::string& key);
 
    using TypeStrs = std::map<std::string, std::string>;
 
    std::string
      gettypestr(const Parameters& parameters,
                 const TypeStrs& typestrs);
 
    enum class ForthError {
        // execution can continue
        none,
 
        // execution cannot continue
        not_ready,
        is_done,
        user_halt,
        recursion_depth_exceeded,
        stack_underflow,
        stack_overflow,
        read_beyond,
        seek_beyond,
        skip_beyond,
        rewind_beyond,
        division_by_zero,
        varint_too_big,
        text_number_missing,
        quoted_string_missing,
        enumeration_missing,
 
        size
    };
 
    template <typename T>
    class LIBAWKWARD_EXPORT_SYMBOL array_deleter {
    public:
      void
      operator()(T const* ptr) {
        uint8_t const* in = reinterpret_cast<uint8_t const*>(ptr);
        delete [] in;
      }
    };
 
  }
}
 
#endif // AWKWARD_UTIL_H_