/******************************************************************************

 *

 * 

 *

 *

 * Permission to use, copy, modify, and distribute this software and its

 * documentation under the terms of the GNU General Public License is hereby 

 * granted. No representations are made about the suitability of this software 

 * for any purpose. It is provided "as is" without express or implied warranty.

 * See the GNU General Public License for more details.

 *

 * Documents produced by Doxygen are derivative works derived from the

 * input used in their production; they are not affected by this license.

 *

 */

#include <stdio.h>

#include <qfile.h>

#include <qregexp.h>

#include "classdef.h"

#include "classlist.h"

#include "entry.h"

#include "doxygen.h"

#include "membername.h"

#include "message.h"

#include "config.h"

#include "util.h"

#include "diagram.h"

#include "language.h"

#include "htmlhelp.h"

#include "example.h"

#include "outputlist.h"

#include "dot.h"

#include "defargs.h"

#include "debug.h"

#include "docparser.h"

#include "searchindex.h"

#include "vhdldocgen.h"

#include "layout.h"

//-----------------------------------------------------------------------------

//static inline MemberList *createNewMemberList(MemberList::ListType lt)

//{

//  MemberList *result = new MemberList(lt);

//  return result;

//}

class ClassDefImpl

{

  public:

    ClassDefImpl();

   ~ClassDefImpl();

    void init(const char *defFileName, const char *name,

              const QCString &ctStr, const char *fName);

    /*! file name that forms the base for the output file containing the

     *  class documentation. For compatibility with Qt (e.g. links via tag 

     *  files) this name cannot be derived from the class name directly.

     */

    QCString fileName;                   

    /*! Include information about the header file should be included

     *  in the documentation. 0 by default, set by setIncludeFile().

     */

    IncludeInfo *incInfo;                

    /*! List of base class (or super-classes) from which this class derives

     *  directly. 

     */

    BaseClassList *inherits;

    /*! List of sub-classes that directly derive from this class 

     */

    BaseClassList *inheritedBy;

    /*! Namespace this class is part of 

     *  (this is the inner most namespace in case of nested namespaces)

     */

    NamespaceDef  *nspace;              

    /*! File this class is defined in */

    FileDef *fileDef;

    /*! List of all members (including inherited members) */

    MemberNameInfoSDict *allMemberNameInfoSDict;

    /*! Template arguments of this class */

    ArgumentList *tempArgs;

    /*! Type constraints for template parameters */

    ArgumentList *typeConstraints;

    /*! Files that were used for generating the class documentation. */

    QStrList files;

    /*! Examples that use this class */

    ExampleSDict *exampleSDict;

    /*! Holds the kind of "class" this is. */

    ClassDef::CompoundType compType;

    /*! The protection level in which this class was found. 

     *  Typically Public, but for nested classes this can also be Protected

     *  or Private.

     */ 

    Protection prot;

    /*! The inner classes contained in this class. Will be 0 if there are

     *  no inner classes.

     */

    ClassSDict *innerClasses;

    /* classes for the collaboration diagram */

    UsesClassDict *usesImplClassDict;

    UsesClassDict *usedByImplClassDict;

    UsesClassDict *usesIntfClassDict;

    /*! Template instances that exists of this class, the key in the

     *  dictionary is the template argument list.

     */ 

    QDict<ClassDef> *templateInstances;

    /*! Template instances that exists of this class, as defined by variables.

     *  We do NOT want to document these individually. The key in the

     *  dictionary is the template argument list.

     */ 

    QDict<ClassDef> *variableInstances;

    QDict<int> *templBaseClassNames;

    /*! The class this class is an instance of. */

    ClassDef *templateMaster;

    /*! local class name which could be a typedef'ed alias name. */

    QCString className;

    /*! If this class is a Objective-C category, then this points to the

     *  class which is extended.

     */

    ClassDef *categoryOf;

    QList<MemberList> memberLists;

    /* user defined member groups */

    MemberGroupSDict *memberGroupSDict;

    /*! Is this an abstact class? */

    bool isAbstract;

    /*! Is the class part of an unnamed namespace? */

    bool isStatic;

    /*! Is the class part implemented in Objective C? */

    bool isObjC;

    /*! TRUE if classes members are merged with those of the base classes. */

    bool membersMerged;

    /*! TRUE if the class is defined in a source file rather than a header file. */

    bool isLocal;

    bool isTemplArg;

    /*! Does this class group its user-grouped members

     *  as a sub-section of the normal (public/protected/..) 

     *  groups?

     */

    bool subGrouping; 

    bool usedOnly;

};

void ClassDefImpl::init(const char *defFileName, const char *name,

                        const QCString &ctStr, const char *fName)

{

  if (fName)

  {

    fileName=stripExtension(fName);

  }

  else

  {

    fileName=ctStr+name;

  }

  exampleSDict = 0;

  inherits    = 0;

  inheritedBy = 0;

  allMemberNameInfoSDict = 0;

  incInfo=0;

  tempArgs=0;

  typeConstraints=0;

  prot=Public;

  nspace=0;

  fileDef=0;

  usesImplClassDict=0;

  usedByImplClassDict=0;

  usesIntfClassDict=0;

  memberGroupSDict = 0;

  innerClasses = 0;

  subGrouping=Config_getBool("SUBGROUPING");

  templateInstances = 0;

  variableInstances = 0;

  templateMaster =0;

  templBaseClassNames = 0;

  isAbstract = FALSE;

  isStatic = FALSE;

  isTemplArg = FALSE;

  membersMerged = FALSE;

  categoryOf = 0;

  usedOnly = FALSE;

  //QCString ns;

  //extractNamespaceName(name,className,ns);

  //printf("m_name=%s m_className=%s ns=%s\n",m_name.data(),m_className.data(),ns.data());

  if (((QCString)defFileName).right(5)!=".java" && 

      guessSection(defFileName)==Entry::SOURCE_SEC)

  {

    isLocal=TRUE;

  }

  else

  {

    isLocal=FALSE;

  }

}

ClassDefImpl::ClassDefImpl()

{

}

ClassDefImpl::~ClassDefImpl()

{

  delete inherits;

  delete inheritedBy;

  delete allMemberNameInfoSDict;

  delete exampleSDict;

  delete usesImplClassDict;

  delete usedByImplClassDict;

  delete usesIntfClassDict;

  delete incInfo;

  delete memberGroupSDict;

  delete innerClasses;

  delete templateInstances;

  delete variableInstances;

  delete templBaseClassNames;

  delete tempArgs;

  delete typeConstraints;

}

// constructs a new class definition

ClassDef::ClassDef(

    const char *defFileName,int defLine,

    const char *nm,CompoundType ct,

    const char *lref,const char *fName,

    bool isSymbol) 

 : Definition(defFileName,defLine,removeRedundantWhiteSpace(nm),0,0,isSymbol) 

{

  visited=FALSE;

  setReference(lref);

  m_impl = new ClassDefImpl;

  m_impl->compType = ct;

  m_impl->isObjC   = FALSE;

  m_impl->init(defFileName,name(),compoundTypeString(),fName);

}

// destroy the class definition

ClassDef::~ClassDef()

{

  delete m_impl;

}

QCString ClassDef::getMemberListFileName() const

{

  return convertNameToFile(compoundTypeString()+name()+"-members");

}

QCString ClassDef::displayName() const

{

  static bool optimizeOutputForJava = Config_getBool("OPTIMIZE_OUTPUT_JAVA");

  static bool vhdlOpt = Config_getBool("OPTIMIZE_OUTPUT_VHDL");

  QCString n;

  if (vhdlOpt)

  {

    n = VhdlDocGen::getClassName(this);

  }

  else 

  {

    n=qualifiedNameWithTemplateParameters();

  }

  if (optimizeOutputForJava)

  {

    n=substitute(n,"::",".");

  }

  if (m_impl->compType==ClassDef::Protocol && n.right(2)=="-p")

  {

    n="<"+n.left(n.length()-2)+">";

  }

  return n;

}

// inserts a base class in the inheritance list

void ClassDef::insertBaseClass(ClassDef *cd,const char *n,Protection p,

                               Specifier s,const char *t)

{

  //printf("*** insert base class %s into %s\n",cd->name().data(),name().data());

  //inherits->inSort(new BaseClassDef(cd,p,s,t));

  if (m_impl->inherits==0)

  {

    m_impl->inherits = new BaseClassList;

    m_impl->inherits->setAutoDelete(TRUE);

  }

  if (Config_getBool("PREPROCESS_INCLUDES")) {

    // If we are preprocessing the #included files we might have seen

    // this class declaration, and inheritance more than once so we

    // only add a relationship where one did not exist before

    bool hasAlready = false;

	BaseClassListIterator bcli(*baseClasses());

	BaseClassDef *bcd;

	for (bcli.toFirst();(bcd=bcli.current());++bcli) {

	  if (bcd->usedName == n) {

		hasAlready = true;

		//printf("*** Seen it...\n");

		break;

	  }

	}

	if (!hasAlready) {

	  m_impl->inherits->append(new BaseClassDef(cd,n,p,s,t));

	}

  } else {

	m_impl->inherits->append(new BaseClassDef(cd,n,p,s,t));

  }

}

// inserts a sub class in the inherited list

void ClassDef::insertSubClass(ClassDef *cd,Protection p,

                                Specifier s,const char *t)

{

  //printf("*** insert sub class %s into %s\n",cd->name().data(),name().data());

  if (m_impl->inheritedBy==0)

  {

    m_impl->inheritedBy   = new BaseClassList;

    m_impl->inheritedBy->setAutoDelete(TRUE);

  }

  m_impl->inheritedBy->inSort(new BaseClassDef(cd,0,p,s,t));

}

void ClassDef::addMembersToMemberGroup()

{

  QListIterator<MemberList> mli(m_impl->memberLists);

  MemberList *ml;

  for (mli.toFirst();(ml=mli.current());++mli)

  {

    if ((ml->listType()&MemberList::detailedLists)==0)

    {

      ::addMembersToMemberGroup(ml,&m_impl->memberGroupSDict,this);

    }

  }

  // add members inside sections to their groups

  if (m_impl->memberGroupSDict)

  {

    MemberGroupSDict::Iterator mgli(*m_impl->memberGroupSDict);

    MemberGroup *mg;

    for (;(mg=mgli.current());++mgli)

    {

      if (mg->allMembersInSameSection() && m_impl->subGrouping) 

      {

        //printf("addToDeclarationSection(%s)\n",mg->header().data());

        mg->addToDeclarationSection();

      }

    }

  }

}

// adds new member definition to the class

void ClassDef::internalInsertMember(MemberDef *md,

                                    Protection prot,

                                    bool addToAllList

                                   )

{

  if (md->isHidden()) return;

  if (!isReference())

  {

    static bool extractPrivate = Config_getBool("EXTRACT_PRIVATE");

    /********************************************/

    /* insert member in the declaration section */

    /********************************************/

    if (md->isRelated() && (extractPrivate || prot!=Private))

    {

      addMemberToList(MemberList::related,md,true);

    }

    else if (md->isFriend())

    {

      addMemberToList(MemberList::friends,md,true);

    }

    else

    {

      switch (md->memberType())

      {

        case MemberDef::Signal: // Qt specific

          addMemberToList(MemberList::signals,md,true);

          break;

        case MemberDef::DCOP:   // KDE2 specific

          addMemberToList(MemberList::dcopMethods,md,true);

          break;

        case MemberDef::Property:

          addMemberToList(MemberList::properties,md,true);

          break;

        case MemberDef::Event:

          addMemberToList(MemberList::events,md,true);

          break;

        case MemberDef::Slot:   // Qt specific

          switch (prot)

          {

            case Protected: 

            case Package: // slots in packages are not possible!

              addMemberToList(MemberList::proSlots,md,true);

              break;

            case Public:    

              addMemberToList(MemberList::pubSlots,md,true);

              break;

            case Private:   

              addMemberToList(MemberList::priSlots,md,true);

              break;

          }

          break;

        default: // any of the other members

          if (md->isStatic())

          {

            if (md->isVariable())

            {

              switch (prot)

              {

                case Protected: 

                  addMemberToList(MemberList::proStaticAttribs,md,true);

                  break;

                case Package: 

                  addMemberToList(MemberList::pacStaticAttribs,md,true);

                  break;

                case Public:    

                  addMemberToList(MemberList::pubStaticAttribs,md,true);

                  break;

                case Private:   

                  addMemberToList(MemberList::priStaticAttribs,md,true);

                  break;

              }

            }

            else // function

            {

              switch (prot)

              {

                case Protected: 

                  addMemberToList(MemberList::proStaticMethods,md,true);

                  break;

                case Package: 

                  addMemberToList(MemberList::pacStaticMethods,md,true);

                  break;

                case Public:    

                  addMemberToList(MemberList::pubStaticMethods,md,true);

                  break;

                case Private:   

                  addMemberToList(MemberList::priStaticMethods,md,true);

                  break;

              }

            }

          }

          else // not static

          {

            if (md->isVariable())

            {

              switch (prot)

              {

                case Protected: 

                  addMemberToList(MemberList::proAttribs,md,true);

                  break;

                case Package:

                  addMemberToList(MemberList::pacAttribs,md,true);

                  break;

                case Public:    

                  addMemberToList(MemberList::pubAttribs,md,true);

                  break;

                case Private:   

                  addMemberToList(MemberList::priAttribs,md,true);

                  break;

              }

            }

            else if (md->isTypedef() || md->isEnumerate() || md->isEnumValue())

            {

              switch (prot)

              {

                case Protected: 

                  addMemberToList(MemberList::proTypes,md,true);

                  break;

                case Package: 

                  addMemberToList(MemberList::pacTypes,md,true);

                  break;

                case Public:    

                  addMemberToList(MemberList::pubTypes,md,true);

                  break;

                case Private:   

                  addMemberToList(MemberList::priTypes,md,true);

                  break;

              }

            }

            else // member function

            {

              switch (prot)

              {

                case Protected: 

                  addMemberToList(MemberList::proMethods,md,true);

                  break;

                case Package: 

                  addMemberToList(MemberList::pacMethods,md,true);

                  break;

                case Public:    

                  addMemberToList(MemberList::pubMethods,md,true);

                  break;

                case Private:   

                  addMemberToList(MemberList::priMethods,md,true);

                  break;

              }

            }

          }

          break;