component/val.hh

Go to the documentation of this file.

 
 
#ifndef WASMTIME_COMPONENT_VAL_HH
#define WASMTIME_COMPONENT_VAL_HH
 
#include <wasmtime/conf.h>
 
#ifdef WASMTIME_FEATURE_COMPONENT_MODEL
 
#include <assert.h>
#include <memory>
#include <optional>
#include <string_view>
#include <utility>
#include <vector>
#include <wasmtime/component/val.h>
#include <wasmtime/store.hh>
 
namespace wasmtime {
namespace component {
 
class Val;
class Record;
 
namespace detail {
 
inline const Val *val_from_capi(const wasmtime_component_val_t *capi) {
  return reinterpret_cast<const Val *>(capi);
}
 
} // namespace detail
 
#define VAL_REPR(name, raw_type)                                               \
private:                                                                       \
  using Raw = raw_type;                                                        \
  Raw raw;                                                                     \
                                                                               \
public:                                                                        \
                                                                          \
  explicit name(Raw &&capi) { name::transfer(std::move(capi), raw); }          \
                                                                               \
                                                                          \
  static const name *from_capi(const Raw *capi) {                              \
    return reinterpret_cast<const name *>(capi);                               \
  }                                                                            \
                                                                               \
                                                                          \
  static name *from_capi(Raw *capi) { return reinterpret_cast<name *>(capi); } \
                                                                               \
                                                                          \
  static const Raw *to_capi(const name *capi) {                                \
    return reinterpret_cast<const Raw *>(capi);                                \
  }                                                                            \
                                                                               \
                                                                          \
  static Raw *to_capi(name *capi) { return reinterpret_cast<Raw *>(capi); }    \
                                                                               \
                                                                          \
  name(const name &other) { copy(other.raw); }                                 \
                                                                               \
                                                                          \
  name &operator=(const name &other) {                                         \
    destroy();                                                                 \
    copy(other.raw);                                                           \
    return *this;                                                              \
  }                                                                            \
                                                                               \
                                                                          \
  name(name &&other) { name::transfer(std::move(other.raw), raw); }            \
                                                                               \
                                                                          \
  name &operator=(name &&other) {                                              \
    destroy();                                                                 \
    name::transfer(std::move(other.raw), raw);                                 \
    return *this;                                                              \
  }                                                                            \
                                                                               \
  ~name() { destroy(); }                                                       \
                                                                               \
                                                                          \
  const Raw *capi() const { return &raw; }                                     \
                                                                               \
private:
 
class RecordField {
  friend class Record;
 
  wasmtime_component_valrecord_entry_t entry;
 
  // This value can't be constructed or destructed, it's only used in iteration
  // of `Record`.
  RecordField() = delete;
  ~RecordField() = delete;
 
  static const RecordField *
  from_capi(const wasmtime_component_valrecord_entry_t *capi) {
    return reinterpret_cast<const RecordField *>(capi);
  }
 
public:
  std::string_view name() const {
    return std::string_view{entry.name.data, entry.name.size};
  }
 
  const Val &value() const { return *detail::val_from_capi(&entry.val); }
};
 
class Record {
  friend class Val;
 
  VAL_REPR(Record, wasmtime_component_valrecord_t);
 
  static void transfer(Raw &&from, Raw &to) {
    to = from;
    from.size = 0;
    from.data = nullptr;
  }
 
  void copy(const Raw &other) {
    wasmtime_component_valrecord_copy(&raw, &other);
  }
 
  void destroy() { wasmtime_component_valrecord_delete(&raw); }
 
public:
  Record(std::vector<std::pair<std::string_view, Val>> entries);
 
  size_t size() const { return raw.size; }
 
  const RecordField *begin() const { return RecordField::from_capi(raw.data); }
 
  const RecordField *end() const {
    return RecordField::from_capi(raw.data + raw.size);
  }
};
 
class List {
  friend class Val;
 
  VAL_REPR(List, wasmtime_component_vallist_t);
 
  static void transfer(Raw &&from, Raw &to) {
    to = from;
    from.size = 0;
    from.data = nullptr;
  }
 
  void copy(const Raw &other) { wasmtime_component_vallist_copy(&raw, &other); }
 
  void destroy() { wasmtime_component_vallist_delete(&raw); }
 
public:
  List(std::vector<Val> entries);
 
  size_t size() const { return raw.size; }
 
  const Val *begin() const { return reinterpret_cast<const Val *>(raw.data); }
 
  const Val *end() const {
    return reinterpret_cast<const Val *>(raw.data + raw.size);
  }
};
 
class Tuple {
  friend class Val;
 
  VAL_REPR(Tuple, wasmtime_component_valtuple_t);
 
  static void transfer(Raw &&from, Raw &to) {
    to = from;
    from.size = 0;
    from.data = nullptr;
  }
 
  void copy(const Raw &other) {
    wasmtime_component_valtuple_copy(&raw, &other);
  }
 
  void destroy() { wasmtime_component_valtuple_delete(&raw); }
 
public:
  Tuple(std::vector<Val> entries);
 
  size_t size() const { return raw.size; }
 
  const Val *begin() const { return reinterpret_cast<const Val *>(raw.data); }
 
  const Val *end() const {
    return reinterpret_cast<const Val *>(raw.data + raw.size);
  }
};
 
class Variant {
  friend class Val;
 
  VAL_REPR(Variant, wasmtime_component_valvariant_t);
 
  static void transfer(wasmtime_component_valvariant_t &&from,
                       wasmtime_component_valvariant_t &to) {
    to = from;
    from.discriminant.size = 0;
    from.discriminant.data = nullptr;
    from.val = nullptr;
  }
 
  void copy(const wasmtime_component_valvariant_t &other) {
    wasm_name_copy(&raw.discriminant, &other.discriminant);
    if (other.val) {
      wasmtime_component_val_t clone;
      wasmtime_component_val_clone(other.val, &clone);
      raw.val = wasmtime_component_val_new(&clone);
    } else {
      raw.val = nullptr;
    }
  }
 
  void destroy() {
    wasm_name_delete(&raw.discriminant);
    wasmtime_component_val_free(raw.val);
  }
 
public:
  Variant(std::string_view discriminant, std::optional<Val> x);
 
  std::string_view discriminant() const {
    return std::string_view(raw.discriminant.data, raw.discriminant.size);
  }
 
  const Val *value() const { return detail::val_from_capi(raw.val); }
};
 
class WitOption {
  friend class Val;
 
  VAL_REPR(WitOption, wasmtime_component_val_t *);
 
  static void transfer(Raw &&from, Raw &to) {
    to = from;
    from = nullptr;
  }
 
  void copy(const Raw &other) {
    if (other) {
      wasmtime_component_val_t clone;
      wasmtime_component_val_clone(other, &clone);
      raw = wasmtime_component_val_new(&clone);
    } else {
      raw = nullptr;
    }
  }
 
  void destroy() { wasmtime_component_val_free(raw); }
 
public:
  explicit WitOption(std::optional<Val> val);
 
  const Val *value() const { return detail::val_from_capi(raw); }
};
 
class WitResult {
  friend class Val;
 
  VAL_REPR(WitResult, wasmtime_component_valresult_t);
 
  static void transfer(Raw &&from, Raw &to) {
    to = from;
    from.val = nullptr;
  }
 
  void copy(const Raw &other) {
    raw.is_ok = other.is_ok;
    if (other.val) {
      wasmtime_component_val_t clone;
      wasmtime_component_val_clone(other.val, &clone);
      raw.val = wasmtime_component_val_new(&clone);
    } else {
      raw.val = nullptr;
    }
  }
 
  void destroy() {
    if (raw.val)
      wasmtime_component_val_free(raw.val);
  }
 
public:
  static WitResult ok(std::optional<Val> val);
 
  static WitResult err(std::optional<Val> val);
 
  bool is_ok() const { return raw.is_ok; }
 
  const Val *payload() const { return detail::val_from_capi(raw.val); }
};
 
class Flag {
  friend class Flags;
 
  VAL_REPR(Flag, wasm_name_t);
 
  static void transfer(Raw &&from, Raw &to) {
    to = from;
    from.size = 0;
    from.data = nullptr;
  }
 
  void copy(const Raw &other) { wasm_name_copy(&raw, &other); }
 
  void destroy() { wasm_name_delete(&raw); }
 
public:
  Flag(std::string_view name) { wasm_name_new(&raw, name.size(), name.data()); }
 
  std::string_view name() const { return std::string_view{raw.data, raw.size}; }
};
 
class Flags {
  friend class Val;
 
  VAL_REPR(Flags, wasmtime_component_valflags_t);
 
  static void transfer(Raw &&from, Raw &to) {
    to = from;
    from.size = 0;
    from.data = nullptr;
  }
 
  void copy(const Raw &other) {
    wasmtime_component_valflags_copy(&raw, &other);
  }
 
  void destroy() { wasmtime_component_valflags_delete(&raw); }
 
public:
  Flags(std::vector<Flag> flags) {
    wasmtime_component_valflags_new_uninit(&raw, flags.size());
    auto dst = raw.data;
    for (auto &&val : flags)
      Flag::transfer(std::move(val.raw), *dst++);
  }
 
  size_t size() const { return raw.size; }
 
  const Flag *begin() const { return reinterpret_cast<const Flag *>(raw.data); }
 
  const Flag *end() const {
    return reinterpret_cast<const Flag *>(raw.data + raw.size);
  }
};
 
class ResourceType {
  struct deleter {
    void operator()(wasmtime_component_resource_type_t *p) const {
      wasmtime_component_resource_type_delete(p);
    }
  };
 
  std::unique_ptr<wasmtime_component_resource_type_t, deleter> ptr;
 
public:
  explicit ResourceType(wasmtime_component_resource_type_t *raw) : ptr(raw) {}
 
  explicit ResourceType(uint32_t ty)
      : ptr(wasmtime_component_resource_type_new_host(ty)) {}
 
  ResourceType(const ResourceType &other)
      : ptr(wasmtime_component_resource_type_clone(other.ptr.get())) {}
  ResourceType &operator=(const ResourceType &other) {
    ptr.reset(wasmtime_component_resource_type_clone(other.ptr.get()));
    return *this;
  }
  ~ResourceType() = default;
  ResourceType(ResourceType &&other) = default;
  ResourceType &operator=(ResourceType &&other) = default;
 
  bool operator==(const ResourceType &b) const {
    return wasmtime_component_resource_type_equal(capi(), b.capi());
  }
 
  bool operator!=(const ResourceType &b) const {
    return !wasmtime_component_resource_type_equal(capi(), b.capi());
  }
 
  const wasmtime_component_resource_type_t *capi() const { return ptr.get(); }
 
  wasmtime_component_resource_type_t *capi() { return ptr.get(); }
};
 
class ResourceHost;
 
class ResourceAny {
  struct deleter {
    void operator()(wasmtime_component_resource_any_t *p) const {
      wasmtime_component_resource_any_delete(p);
    }
  };
 
  std::unique_ptr<wasmtime_component_resource_any_t, deleter> ptr;
 
public:
  explicit ResourceAny(wasmtime_component_resource_any_t *raw) : ptr(raw) {}
 
  ResourceAny(const ResourceAny &other)
      : ptr(wasmtime_component_resource_any_clone(other.ptr.get())) {}
  ResourceAny &operator=(const ResourceAny &other) {
    ptr.reset(wasmtime_component_resource_any_clone(other.ptr.get()));
    return *this;
  }
  ~ResourceAny() = default;
  ResourceAny(ResourceAny &&other) = default;
  ResourceAny &operator=(ResourceAny &&other) = default;
 
  const wasmtime_component_resource_any_t *capi() const { return ptr.get(); }
 
  wasmtime_component_resource_any_t *capi() { return ptr.get(); }
 
  wasmtime_component_resource_any_t *capi_release() { return ptr.release(); }
 
  bool owned() const { return wasmtime_component_resource_any_owned(capi()); }
 
  ResourceType type() const {
    wasmtime_component_resource_type_t *ty =
        wasmtime_component_resource_any_type(capi());
    return ResourceType(ty);
  }
 
  Result<std::monostate> drop(Store::Context cx) const {
    wasmtime_error_t *err =
        wasmtime_component_resource_any_drop(cx.capi(), capi());
    if (err)
      return Error(err);
    return std::monostate();
  }
 
  Result<ResourceHost> to_host(Store::Context cx) const;
 
  static const ResourceAny *
  from_capi(wasmtime_component_resource_any_t *const *capi) {
    return reinterpret_cast<const ResourceAny *>(capi);
  }
};
 
class ResourceHost {
  struct deleter {
    void operator()(wasmtime_component_resource_host_t *p) const {
      wasmtime_component_resource_host_delete(p);
    }
  };
 
  std::unique_ptr<wasmtime_component_resource_host_t, deleter> ptr;
 
public:
  explicit ResourceHost(wasmtime_component_resource_host_t *raw) : ptr(raw) {}
 
  ResourceHost(const ResourceHost &other)
      : ptr(wasmtime_component_resource_host_clone(other.ptr.get())) {}
  ResourceHost &operator=(const ResourceHost &other) {
    ptr.reset(wasmtime_component_resource_host_clone(other.ptr.get()));
    return *this;
  }
  ~ResourceHost() = default;
  ResourceHost(ResourceHost &&other) = default;
  ResourceHost &operator=(ResourceHost &&other) = default;
 
  const wasmtime_component_resource_host_t *capi() const { return ptr.get(); }
 
  wasmtime_component_resource_host_t *capi() { return ptr.get(); }
 
  ResourceHost(bool owned, uint32_t rep, uint32_t ty)
      : ptr(wasmtime_component_resource_host_new(owned, rep, ty)) {}
 
  bool owned() const { return wasmtime_component_resource_host_owned(capi()); }
 
  uint32_t rep() const { return wasmtime_component_resource_host_rep(capi()); }
 
  uint32_t type() const {
    return wasmtime_component_resource_host_type(capi());
  }
 
  Result<ResourceAny> to_any(Store::Context cx) const {
    wasmtime_component_resource_any_t *out;
    wasmtime_error_t *err =
        wasmtime_component_resource_host_to_any(cx.capi(), capi(), &out);
    if (err)
      return Error(err);
    return ResourceAny(out);
  }
};
 
inline Result<ResourceHost> ResourceAny::to_host(Store::Context cx) const {
  wasmtime_component_resource_host_t *out;
  wasmtime_error_t *err =
      wasmtime_component_resource_any_to_host(cx.capi(), capi(), &out);
  if (err)
    return Error(err);
  return ResourceHost(out);
}
 
class Val {
  friend class Variant;
  friend class WitOption;
  friend class WitResult;
 
  VAL_REPR(Val, wasmtime_component_val_t);
 
  static void transfer(Raw &&from, Raw &to) {
    to = from;
    from.kind = WASMTIME_COMPONENT_BOOL;
    from.of.boolean = false;
  }
 
  void copy(const Raw &other) { wasmtime_component_val_clone(&other, &raw); }
 
  void destroy() { wasmtime_component_val_delete(&raw); }
 
public:
  Val(bool v) {
    raw.kind = WASMTIME_COMPONENT_BOOL;
    raw.of.boolean = v;
  }
 
  Val(uint8_t v) {
    raw.kind = WASMTIME_COMPONENT_U8;
    raw.of.u8 = v;
  }
 
  Val(int8_t v) {
    raw.kind = WASMTIME_COMPONENT_S8;
    raw.of.s8 = v;
  }
 
  Val(uint16_t v) {
    raw.kind = WASMTIME_COMPONENT_U16;
    raw.of.u16 = v;
  }
 
  Val(int16_t v) {
    raw.kind = WASMTIME_COMPONENT_S16;
    raw.of.s16 = v;
  }
 
  Val(uint32_t v) {
    raw.kind = WASMTIME_COMPONENT_U32;
    raw.of.u32 = v;
  }
 
  Val(int32_t v) {
    raw.kind = WASMTIME_COMPONENT_S32;
    raw.of.s32 = v;
  }
 
  Val(uint64_t v) {
    raw.kind = WASMTIME_COMPONENT_U64;
    raw.of.u64 = v;
  }
 
  Val(int64_t v) {
    raw.kind = WASMTIME_COMPONENT_S64;
    raw.of.s64 = v;
  }
 
  Val(float v) {
    raw.kind = WASMTIME_COMPONENT_F32;
    raw.of.f32 = v;
  }
 
  Val(double v) {
    raw.kind = WASMTIME_COMPONENT_F64;
    raw.of.f64 = v;
  }
 
  static Val char_(uint32_t v) {
    wasmtime_component_val_t raw = {
        .kind = WASMTIME_COMPONENT_CHAR,
        .of = {.character = v},
    };
    return Val(std::move(raw));
  }
 
  static Val string(std::string_view v) {
    wasmtime_component_val_t raw;
    raw.kind = WASMTIME_COMPONENT_STRING;
    wasm_byte_vec_new(&raw.of.string, v.size(), v.data());
    return Val(std::move(raw));
  }
 
  Val(List v) {
    raw.kind = WASMTIME_COMPONENT_LIST;
    List::transfer(std::move(v.raw), raw.of.list);
  }
 
  Val(Record r) {
    raw.kind = WASMTIME_COMPONENT_RECORD;
    Record::transfer(std::move(r.raw), raw.of.record);
  }
 
  Val(Tuple v) {
    raw.kind = WASMTIME_COMPONENT_TUPLE;
    Tuple::transfer(std::move(v.raw), raw.of.tuple);
  }
 
  Val(Variant v) {
    raw.kind = WASMTIME_COMPONENT_VARIANT;
    Variant::transfer(std::move(v.raw), raw.of.variant);
  }
 
  Val(WitOption v) {
    raw.kind = WASMTIME_COMPONENT_OPTION;
    WitOption::transfer(std::move(v.raw), raw.of.option);
  }
 
  Val(WitResult r) {
    raw.kind = WASMTIME_COMPONENT_RESULT;
    WitResult::transfer(std::move(r.raw), raw.of.result);
  }
 
  static Val enum_(std::string_view discriminant) {
    wasmtime_component_val_t raw;
    raw.kind = WASMTIME_COMPONENT_ENUM;
    wasm_byte_vec_new(&raw.of.enumeration, discriminant.size(),
                      discriminant.data());
    return Val(std::move(raw));
  }
 
  Val(Flags f) {
    raw.kind = WASMTIME_COMPONENT_FLAGS;
    Flags::transfer(std::move(f.raw), raw.of.flags);
  }
 
  Val(ResourceAny r) {
    raw.kind = WASMTIME_COMPONENT_RESOURCE;
    raw.of.resource = r.capi_release();
  }
 
  bool is_bool() const { return raw.kind == WASMTIME_COMPONENT_BOOL; }
 
  bool get_bool() const {
    assert(is_bool());
    return raw.of.boolean;
  }
 
  bool is_u8() const { return raw.kind == WASMTIME_COMPONENT_U8; }
 
  uint8_t get_u8() const {
    assert(is_u8());
    return raw.of.u8;
  }
 
  bool is_s8() const { return raw.kind == WASMTIME_COMPONENT_S8; }
 
  int8_t get_s8() const {
    assert(is_s8());
    return raw.of.s8;
  }
 
  bool is_u16() const { return raw.kind == WASMTIME_COMPONENT_U16; }
 
  uint16_t get_u16() const {
    assert(is_u16());
    return raw.of.u16;
  }
 
  bool is_s16() const { return raw.kind == WASMTIME_COMPONENT_S16; }
 
  int16_t get_s16() const {
    assert(is_s16());
    return raw.of.s16;
  }
 
  bool is_u32() const { return raw.kind == WASMTIME_COMPONENT_U32; }
 
  uint32_t get_u32() const {
    assert(is_u32());
    return raw.of.u32;
  }
 
  bool is_s32() const { return raw.kind == WASMTIME_COMPONENT_S32; }
 
  int32_t get_s32() const {
    assert(is_s32());
    return raw.of.s32;
  }
 
  bool is_u64() const { return raw.kind == WASMTIME_COMPONENT_U64; }
 
  uint64_t get_u64() const {
    assert(is_u64());
    return raw.of.u64;
  }
 
  bool is_s64() const { return raw.kind == WASMTIME_COMPONENT_S64; }
 
  int64_t get_s64() const {
    assert(is_s64());
    return raw.of.s64;
  }
 
  bool is_f32() const { return raw.kind == WASMTIME_COMPONENT_F32; }
 
  float get_f32() const {
    assert(is_f32());
    return raw.of.f32;
  }
 
  bool is_f64() const { return raw.kind == WASMTIME_COMPONENT_F64; }
 
  double get_f64() const {
    assert(is_f64());
    return raw.of.f64;
  }
 
  bool is_string() const { return raw.kind == WASMTIME_COMPONENT_STRING; }
 
  std::string_view get_string() const {
    assert(is_string());
    return std::string_view(raw.of.string.data, raw.of.string.size);
  }
 
  bool is_list() const { return raw.kind == WASMTIME_COMPONENT_LIST; }
 
  const List &get_list() const {
    assert(is_list());
    return *List::from_capi(&raw.of.list);
  }
 
  bool is_record() const { return raw.kind == WASMTIME_COMPONENT_RECORD; }
 
  const Record &get_record() const {
    assert(is_record());
    return *Record::from_capi(&raw.of.record);
  }
 
  bool is_tuple() const { return raw.kind == WASMTIME_COMPONENT_TUPLE; }
 
  const Tuple &get_tuple() const {
    assert(is_tuple());
    return *Tuple::from_capi(&raw.of.tuple);
  }
 
  bool is_variant() const { return raw.kind == WASMTIME_COMPONENT_VARIANT; }
 
  const Variant &get_variant() const {
    assert(is_variant());
    return *Variant::from_capi(&raw.of.variant);
  }
 
  bool is_option() const { return raw.kind == WASMTIME_COMPONENT_OPTION; }
 
  const WitOption &get_option() const {
    assert(is_option());
    return *WitOption::from_capi(&raw.of.option);
  }
 
  bool is_enum() const { return raw.kind == WASMTIME_COMPONENT_ENUM; }
 
  std::string_view get_enum() const {
    assert(is_enum());
    return std::string_view(raw.of.enumeration.data, raw.of.enumeration.size);
  }
 
  bool is_result() const { return raw.kind == WASMTIME_COMPONENT_RESULT; }
 
  const WitResult &get_result() const {
    assert(is_result());
    return *WitResult::from_capi(&raw.of.result);
  }
 
  bool is_flags() const { return raw.kind == WASMTIME_COMPONENT_FLAGS; }
 
  const Flags &get_flags() const {
    assert(is_flags());
    return *Flags::from_capi(&raw.of.flags);
  }
 
  bool is_resource() const { return raw.kind == WASMTIME_COMPONENT_RESOURCE; }
 
  const ResourceAny &get_resource() const {
    assert(is_resource());
    return *ResourceAny::from_capi(&raw.of.resource);
  }
};
 
#undef VAL_REPR
 
inline Record::Record(std::vector<std::pair<std::string_view, Val>> entries) {
  wasmtime_component_valrecord_new_uninit(&raw, entries.size());
  auto dst = raw.data;
  for (auto &&[name, val] : entries) {
    wasm_byte_vec_new(&dst->name, name.size(), name.data());
    new (&dst->val) Val(std::move(val));
    dst++;
  }
}
 
inline List::List(std::vector<Val> values) {
  wasmtime_component_vallist_new_uninit(&raw, values.size());
  auto dst = raw.data;
  for (auto &&val : values)
    new (dst++) Val(std::move(val));
}
 
inline Tuple::Tuple(std::vector<Val> values) {
  wasmtime_component_valtuple_new_uninit(&raw, values.size());
  auto dst = raw.data;
  for (auto &&val : values)
    new (dst++) Val(std::move(val));
}
 
inline Variant::Variant(std::string_view discriminant, std::optional<Val> x) {
  wasm_name_new(&raw.discriminant, discriminant.size(), discriminant.data());
  if (x) {
    raw.val = wasmtime_component_val_new(&x->raw);
  } else {
    raw.val = nullptr;
  }
}
 
inline WitOption::WitOption(std::optional<Val> v) {
  if (v) {
    raw = wasmtime_component_val_new(&v->raw);
  } else {
    raw = nullptr;
  }
}
 
inline WitResult WitResult::ok(std::optional<Val> v) {
  wasmtime_component_valresult_t raw;
  raw.is_ok = true;
  if (v) {
    raw.val = wasmtime_component_val_new(&v->raw);
  } else {
    raw.val = nullptr;
  }
  return WitResult(std::move(raw));
}
 
inline WitResult WitResult::err(std::optional<Val> v) {
  wasmtime_component_valresult_t raw;
  raw.is_ok = false;
  if (v) {
    raw.val = wasmtime_component_val_new(&v->raw);
  } else {
    raw.val = nullptr;
  }
  return WitResult(std::move(raw));
}
 
} // namespace component
} // namespace wasmtime
 
#endif // WASMTIME_FEATURE_COMPONENT_MODEL
 
#endif // WASMTIME_COMPONENT_VAL_H