// HeaderFile
#include <cstdint>
#include <memory>

struct Foo;
struct Blah;

class Object
{
};

struct RefClass : public Object
{
  RefClass(Object parent);
  RefClass(Object parent, int x, int y, int z);
  void foo();
  void bar();

  struct Foo_value
  {
    Foo get();
    void set(Foo);
  } foo_value;

  Foo&            value();
  const Foo&      value() const;
  uint8_t&        x();
  const uint8_t&  x() const;
  uint16_t&       y();
  const uint16_t& y() const;
  uint32_t&       z();
  const uint32_t& z() const;
  uint64_t&       a();
  const uint64_t& a() const;
  float&          f();
  const float&    f() const;
  double&         g();
  const double&   g() const;

private:
  struct Pimpl;
  std::shared_ptr<Pimpl> m_data;
};


// CppFile

struct MetaData
{
  const char* name;
};

void RegisterClass(const char* name, MetaData d)
{
}

struct Foo
{
  int x, y;
};


struct RefClass::Pimpl
{
  Foo      value;
  uint8_t  x;
  uint16_t y;
  uint32_t z;
  uint64_t a;
  float    f;
  double   g;
};
  
Foo&            RefClass::value()       { return m_data->value; }
const Foo&      RefClass::value() const { return m_data->value; }
uint8_t&        RefClass::x()           { return m_data->x; }  
const uint8_t&  RefClass::x() const     { return m_data->x; }
uint16_t&       RefClass::y()           { return m_data->y; }
const uint16_t& RefClass::y() const     { return m_data->y; }
uint32_t&       RefClass::z()           { return m_data->z; }
const uint32_t& RefClass::z() const     { return m_data->z; }
uint64_t&       RefClass::a()           { return m_data->a; }
const uint64_t& RefClass::a() const     { return m_data->a; }
float&          RefClass::f()           { return m_data->f; }
const float&    RefClass::f() const     { return m_data->f; }
double&         RefClass::g()           { return m_data->g; }
const double&   RefClass::g() const     { return m_data->g; }

MetaData refClassMetaData()
{
  // need all the function pointers and all the types and value etc
  MetaData d;
  return d;
}

struct RefClassRegisterType
{
  RefClassRegisterType()
  {
    RegisterClass("RefClass", refClassMetaData());
  }
}
g_refClass;

RefClass::RefClass(Object parent, int x, int y, int z)
  : m_data(std::make_shared<Pimpl>())
{
}

RefClass::RefClass(Object parent)
  : m_data(std::make_shared<Pimpl>())
{
}


int main(int argc, char* argv[])
{
}