Type.cpp

#include "Type.h"
 
#include "TypeDatabase.h"
 
Cogs::Reflection::Type & Cogs::Reflection::Type::setMethods(Method * functions, size_t count)
{
  assert(enumerators.empty() && "Enumeration cannot contain methods.");
  assert(this->methods.empty() && "set only.");
  this->methods.reserve(this->methods.size() + count);
 
  for (size_t i = 0; i < count; ++i) {
    this->methods.emplace_back(std::move(functions[i]));
  }
 
  return *this;
}
 
Cogs::Reflection::Type& Cogs::Reflection::Type::setEnumerators(const EnumeratorDef* enumerators, size_t count)
{
  assert(fields.empty() && "Enumeration cannot contain fields.");
  assert(methods.empty() && "Enumeration cannot contain methods.");
  assert(this->enumerators.empty() && "set only.");
 
  this->enumerators.reserve(this->enumerators.size() + count);
  for (size_t i = 0; i < count; ++i) {
    this->enumerators.emplace_back(enumerators[i].getName(), enumerators[i].getValue());
  }
 
  return *this;
}
 
const Cogs::Reflection::Type * Cogs::Reflection::Type::getBase() const
{
  if (base == NoType) return nullptr;
 
  return &TypeDatabase::getType(base);
}
 
bool Cogs::Reflection::Type::canCastTo(const TypeId& destinationId) const
{
  if (this->getTypeId() == destinationId) {
    return true;
  }
 
  const Type* typeBase = getBase();
  while (typeBase && (typeBase->getTypeId() != destinationId)) {
    typeBase = typeBase->getBase();
  }
 
  return (typeBase != nullptr);
}
 
const Cogs::Reflection::Field * Cogs::Reflection::Type::getField(const Name & name) const
{
  for (const Field & item : fields) {
    if (item.getName() == name) {
      return &item;
    }
  }
 
  const Cogs::Reflection::Type* baseType = getBase();
  return baseType ? baseType->getField(name) : nullptr;
}
 
Cogs::Reflection::FieldId Cogs::Reflection::Type::getFieldId(const Field * field) const
{
  if (field < fields.data() || field >(fields.data() + fields.size())) {
    const Cogs::Reflection::Type* baseType = getBase();
    if (baseType) {
      FieldId baseFieldId = baseType->getFieldId(field);
 
      return baseFieldId != NoField ? baseFieldId + static_cast<FieldId>(fields.size()) : NoField;
    } else {
      return NoField;
    }
  }
 
  return static_cast<FieldId>(field - fields.data());
}
 
Cogs::Reflection::FieldId Cogs::Reflection::Type::getFieldId(TypeId componentTypeId, const Name& name)
{
  assert(componentTypeId != NoType);
  const Type& componentType = TypeDatabase::getType(componentTypeId);
 
  const Field* field = componentType.getField(name);
  if (field) {
    FieldId fieldId = componentType.getFieldId(field);
    return fieldId;
  }
  else {
    return Cogs::Reflection::NoField;
  }
}
 
size_t Cogs::Reflection::Type::getNumHierarchyFields() const
{
  const Cogs::Reflection::Type* baseType = getBase();
  if (baseType) {
    return baseType->getNumHierarchyFields() + getNumFields();
  }
  else {
    return getNumFields();
  }
}
 
 
const Cogs::Reflection::Field * Cogs::Reflection::Type::getField(const FieldId id) const
{
  const FieldId myFieldCount = static_cast<FieldId>(fields.size());
  if (id == NoField) {
    return nullptr;
  }
  else if (id >= myFieldCount) {
    const Cogs::Reflection::Type* baseType = getBase();
    return baseType ? baseType->getField(id - myFieldCount) : nullptr;
  }
 
  return &fields[id];
}
 
Cogs::Reflection::FieldId Cogs::Reflection::Type::getFieldId(size_t offset) const
{
  for (size_t i = 0; i < fields.size(); ++i) {
    if (fields[i].getOffset() == offset) {
      return static_cast<FieldId>(i);
    }
  }
 
  return NoField;
}
 
const Cogs::Reflection::Method * Cogs::Reflection::Type::getMethod(const Name & name) const
{
  for (const Method& item : methods) {
    if (item.getName() == name) {
      return &item;
    }
  }
 
  const Cogs::Reflection::Type* baseType = getBase();
  return baseType ? baseType->getMethod(name) : nullptr;
}
 
const Cogs::Reflection::Enumerator * Cogs::Reflection::Type::getEnumerator(const Name & name) const
{
  for (const Enumerator& item : enumerators) {
    if (item.getName() == name) {
      return &item;
    }
  }
 
  const Cogs::Reflection::Type* baseType = getBase();
  return baseType ? baseType->getEnumerator(name) : nullptr;
}
 
Cogs::Reflection::Type& Cogs::Reflection::Type::setFields(Field* fields, size_t count)
{
  assert(enumerators.empty() && "Enumeration cannot contain fields.");
  assert(this->fields.empty() && "set only.");
 
  this->fields.reserve(count);
  for (size_t i = 0; i < count; ++i) {
    this->fields.emplace_back(std::move(fields[i]));
  }
 
  return *this;
}