/*
  metaobject.cpp

  This file is part of GammaRay, the Qt application inspection and
  manipulation tool.

  Copyright (C) 2011-2015 Klarälvdalens Datakonsult AB, a KDAB Group company, info@kdab.com
  Author: Volker Krause <volker.krause@kdab.com>

  This program is free software; you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation, either version 2 of the License, or
  (at your option) any later version.

  This program is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

#include "metaobject.h"

using namespace GammaRay;

MetaObject::MetaObject()
{
}

MetaObject::~MetaObject()
{
  qDeleteAll(m_properties);
}

int MetaObject::propertyCount() const
{
  int count = 0;
  foreach (MetaObject *mo, m_baseClasses) {
    count += mo->propertyCount();
  }
  return count + m_properties.size();
}

MetaProperty *MetaObject::propertyAt(int index) const
{
  foreach (MetaObject *mo, m_baseClasses) {
    if (index >= mo->propertyCount()) {
      index -= mo->propertyCount();
    } else {
      return mo->propertyAt(index);
    }
  }
  Q_ASSERT(index >= 0 && index < m_properties.size());
  return m_properties.at(index);
}

void MetaObject::addBaseClass(MetaObject *baseClass)
{
  Q_ASSERT(baseClass);
  m_baseClasses.push_back(baseClass);
}

void MetaObject::addProperty(MetaProperty *property)
{
  Q_ASSERT(property);
  // TODO: sort
  property->setMetaObject(this);
  m_properties.push_back(property);
}

QString MetaObject::className() const
{
  return m_className;
}

void MetaObject::setClassName(const QString &className)
{
  m_className = className;
}

void *MetaObject::castForPropertyAt(void *object, int index) const
{
  for (int i = 0; i < m_baseClasses.size(); ++i) {
    const MetaObject *base = m_baseClasses.at(i);
    if (index >= base->propertyCount()) {
      index -= base->propertyCount();
    } else {
      return base->castForPropertyAt(castToBaseClass(object, i), index);
    }
  }
  return object; // our own property
}

MetaObject* MetaObject::superClass(int index) const
{
  if (m_baseClasses.size() <= index)
    return 0;
  return m_baseClasses[index];
}

bool MetaObject::inherits(const QString& className) const
{
  if (className == m_className)
    return true;
  foreach (MetaObject *metaObject, m_baseClasses) {
    if (metaObject->inherits(className))
      return true;
  }
  return false;
}
