entry.h

Go to the documentation of this file.

/******************************************************************************
 *
 * $Id: entry.h,v 1.36 2001/03/19 19:27:40 root Exp $
 *
 * Copyright (C) 1997-2008 by Dimitri van Heesch.
 *
 * 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.
 *
 */

#ifndef ENTRY_H
#define ENTRY_H

#include "qtbc.h"
#include <qlist.h>

#include <qgstring.h>

struct SectionInfo;
class QFile;
class EntryNav;
class FileDef;
class FileStorage;
class StorageIntf;

enum Protection { Public, Protected, Private, Package } ;
enum Specifier { Normal, Virtual, Pure } ;
enum MethodTypes { Method, Signal, Slot, DCOP, Property, Event };

struct ListItemInfo
{
  QCString type;
  int itemId;
};

struct BaseInfo 
{
  BaseInfo(const char *n,Protection p,Specifier v) : 
    name(n),prot(p),virt(v) {}
  QCString   name; 
  Protection prot; 
  Specifier  virt; 
};

struct Argument
{
  Argument() {}
  Argument(const Argument &a) 
  { 
    attrib=a.attrib.copy();
    type=a.type.copy(); 
    name=a.name.copy(); 
    defval=a.defval.copy(); 
    docs=a.docs.copy();
    array=a.array.copy();
  }
  Argument &operator=(const Argument &a)
  {
    if (this!=&a)
    {
      attrib=a.attrib.copy();
      type=a.type.copy(); 
      name=a.name.copy(); 
      defval=a.defval.copy(); 
      docs=a.docs.copy();
      array=a.array.copy();
    }
    return *this;
  }
  bool hasDocumentation() const 
  { 
    return !name.isEmpty() && !docs.isEmpty(); 
  }
  
  QCString attrib;   
  QCString type;     
  QCString canType;  
  QCString name;     
  QCString array;    
  QCString defval;   
  QCString docs;     
};

class ArgumentList : public QList<Argument> 
{
  public:
    ArgumentList() : QList<Argument>(), 
                     constSpecifier(FALSE),
                     volatileSpecifier(FALSE),
                     pureSpecifier(FALSE)
                     { setAutoDelete(TRUE); }
   ~ArgumentList() {}
    bool hasDocumentation() const;
    bool constSpecifier;
    bool volatileSpecifier;
    bool pureSpecifier;
};

typedef QListIterator<Argument> ArgumentListIterator;

struct TagInfo 
{
  QCString tagName;
  QCString fileName;
  QCString anchor;
};

struct Grouping 
{
  enum GroupPri_t 
  {
    GROUPING_LOWEST,
    GROUPING_AUTO_WEAK = 
      GROUPING_LOWEST,     
    GROUPING_AUTO_ADD,     
    GROUPING_AUTO_DEF,     
    GROUPING_AUTO_HIGHEST = GROUPING_AUTO_DEF,
    GROUPING_INGROUP,      
    GROUPING_HIGHEST = GROUPING_INGROUP
  };

  static const char *getGroupPriName( GroupPri_t priority )
  {
    switch( priority )
    {
      case GROUPING_AUTO_WEAK:
        return "@weakgroup";
      case GROUPING_AUTO_ADD:
        return "@addtogroup";
      case GROUPING_AUTO_DEF:
        return "@defgroup";
      case GROUPING_INGROUP:
        return "@ingroup";
    }       
    return "???";
  }

  Grouping( const char *gn, GroupPri_t p ) : groupname(gn), pri(p) {}
  Grouping( const Grouping &g ) : groupname(g.groupname), pri(g.pri) {}
  QCString groupname;   
  GroupPri_t pri;       

};

class Entry
{
  public:

    enum Sections { 
      CLASS_SEC        = 0x00000001, 
      //STRUCT_SEC       = 0x00000002,
      //UNION_SEC        = 0x00000004, 
      //EXCEPTION_SEC    = 0x00000008,
      NAMESPACE_SEC    = 0x00000010,
      //INTERFACE_SEC    = 0x00000020,
      //PROTOCOL_SEC     = 0x00000040,
      //CATEGORY_SEC     = 0x00000080,
      COMPOUND_MASK    = CLASS_SEC //| STRUCT_SEC | UNION_SEC | 
                         //INTERFACE_SEC | EXCEPTION_SEC | 
                         //PROTOCOL_SEC | CATEGORY_SEC
                         ,
      SCOPE_MASK       = COMPOUND_MASK | NAMESPACE_SEC,
      
      CLASSDOC_SEC     = 0x00000800, 
      STRUCTDOC_SEC    = 0x00001000,
      UNIONDOC_SEC     = 0x00002000,
      EXCEPTIONDOC_SEC = 0x00004000,
      NAMESPACEDOC_SEC = 0x00008000,
      INTERFACEDOC_SEC = 0x00010000,
      PROTOCOLDOC_SEC  = 0x00020000,
      CATEGORYDOC_SEC  = 0x00040000,
      COMPOUNDDOC_MASK = CLASSDOC_SEC | STRUCTDOC_SEC | UNIONDOC_SEC | 
                         INTERFACEDOC_SEC | EXCEPTIONDOC_SEC | PROTOCOLDOC_SEC |
                         CATEGORYDOC_SEC,

      SOURCE_SEC       = 0x00400000,
      HEADER_SEC       = 0x00800000,
      FILE_MASK        = SOURCE_SEC | HEADER_SEC,

      ENUMDOC_SEC      = 0x01000000,
      ENUM_SEC         = 0x02000000,
      EMPTY_SEC        = 0x03000000, 
      PAGEDOC_SEC      = 0x04000000, 
      VARIABLE_SEC     = 0x05000000,
      FUNCTION_SEC     = 0x06000000,
      TYPEDEF_SEC      = 0x07000000,
      MEMBERDOC_SEC    = 0x08000000, 
      OVERLOADDOC_SEC  = 0x09000000,
      EXAMPLE_SEC      = 0x0a000000, 
      VARIABLEDOC_SEC  = 0x0b000000,
      FILEDOC_SEC      = 0x0c000000,
      DEFINEDOC_SEC    = 0x0d000000,
      INCLUDE_SEC      = 0x0e000000,
      DEFINE_SEC       = 0x0f000000,
      GROUPDOC_SEC     = 0x10000000,
      USINGDIR_SEC     = 0x11000000,
      MAINPAGEDOC_SEC  = 0x12000000,
      MEMBERGRP_SEC    = 0x13000000,
      USINGDECL_SEC    = 0x14000000,
      PACKAGE_SEC      = 0x15000000,
      PACKAGEDOC_SEC   = 0x16000000,
      OBJCIMPL_SEC     = 0x17000000,
      DIRDOC_SEC       = 0x18000000
    };
    enum MemberSpecifier
    {
      Inline    = 0x000001,
      Explicit  = 0x000002,
      Mutable   = 0x000004,
      Settable  = 0x000008,
      Gettable  = 0x000010,
      Readable  = 0x000020,
      Writable  = 0x000040,
      Final     = 0x000080,
      Abstract  = 0x000100,
      Addable   = 0x000200,
      Removable = 0x000400,
      Raisable  = 0x000800,
      Override  = 0x001000,
      New       = 0x002000,
      Sealed    = 0x004000,
      Initonly  = 0x008000,
      Optional  = 0x010000,
      Required  = 0x020000,
      NonAtomic = 0x040000,
      Copy      = 0x080000,
      Retain    = 0x100000,
      Assign    = 0x200000
    };
    enum ClassSpecifier
    {
      Template       = 0x0001,
      Generic        = 0x0002,
      Ref            = 0x0004,
      Value          = 0x0008,
      Interface      = 0x0010,
      Struct         = 0x0020,
      Union          = 0x0040,
      Exception      = 0x0080,
      Protocol       = 0x0100,
      Category       = 0x0200,
      SealedClass    = 0x0400,
      AbstractClass  = 0x0800
    };
    enum GroupDocType
    {
      GROUPDOC_NORMAL,        
      GROUPDOC_ADD,           
      GROUPDOC_WEAK           
    };                        


    Entry();
    Entry(const Entry &);
    ~Entry();
    int getSize();
    void addSpecialListItem(const char *listName,int index);
    void createNavigationIndex(EntryNav *rootNav,FileStorage *storage,FileDef *fd);

    // while parsing a file these function can be used to navigate/build the tree
    void setParent(Entry *parent) { m_parent = parent; }
    Entry *parent() const { return m_parent; }
    const QList<Entry> *children() const { return m_sublist; }

    void        addSubEntry (Entry* e) ;
    void reset();
    void marshall(StorageIntf *);
    void unmarshall(StorageIntf *);

  public:

    // identification
    int          section;     
    QCString     type;        
    QCString     name;        
    TagInfo     *tagInfo;     

    // content
    Protection protection;    
    MethodTypes mtype;        
    int  spec;                
    int  initLines;           
    bool stat;                
    bool explicitExternal;    
    bool proto;               
    bool subGrouping;         
    bool callGraph;           
    bool callerGraph;         
    Specifier    virt;        
    QCString     args;        
    QCString     bitfields;   
    ArgumentList *argList;    
    QList<ArgumentList> *tArgLists; 
    QGString     program;     
    QGString     initializer; 
    QCString     includeFile; 
    QCString     includeName; 
    QCString     doc;         
    int          docLine;     
    QCString     docFile;     
    QCString     brief;       
    int          briefLine;   
    QCString     briefFile;   
    QCString     inbodyDocs;  
    int          inbodyLine;  
    QCString     inbodyFile;  
    QCString     relates;     
    bool         relatesDup;  
    QCString     read;        
    QCString     write;       
    QCString     inside;      
    QCString     exception;   
    ArgumentList *typeConstr; 
    int          bodyLine;    
    int          endBodyLine; 
    int          mGrpId;      
    QList<BaseInfo> *extends; 
    QList<Grouping> *groups;  
    QList<SectionInfo> *anchors; 
    QCString    fileName;     
    int         startLine;    
    QList<ListItemInfo> *sli; 
    bool        objc;         
    bool        hidden;       
    bool        artificial;   
    GroupDocType groupDocType;

    static int  num;          

    const char *groupDocCmd() const
    {
      switch( groupDocType ) 
      {
        case GROUPDOC_NORMAL: return "\\defgroup";
        case GROUPDOC_ADD: return "\\addgroup";
        case GROUPDOC_WEAK: return "\\weakgroup";
        default: return "unknown group command";
      }
    }
    Grouping::GroupPri_t groupingPri() const
    {
      if( section != GROUPDOC_SEC ) 
      {
        return Grouping::GROUPING_LOWEST;
      }
      switch( groupDocType ) 
      {
        case GROUPDOC_NORMAL: return Grouping::GROUPING_AUTO_DEF;
        case GROUPDOC_ADD:    return Grouping::GROUPING_AUTO_ADD;
        case GROUPDOC_WEAK:   return Grouping::GROUPING_AUTO_WEAK;
        default: return Grouping::GROUPING_LOWEST;
      }
    }

  private:  
    void createSubtreeIndex(EntryNav *nav,FileStorage *storage,FileDef *fd);
    Entry         *m_parent;    
    QList<Entry>  *m_sublist;   
    Entry &operator=(const Entry &); 
};

class EntryNav
{
  public:
    EntryNav(EntryNav *parent,Entry *e);
   ~EntryNav();
    void addChild(EntryNav *);
    bool loadEntry(FileStorage *storage);
    bool saveEntry(Entry *e,FileStorage *storage);
    void setEntry(Entry *e);
    void releaseEntry();
    void changeSection(int section) { m_section = section; }
    void setFileDef(FileDef *fd) { m_fileDef = fd; }

    Entry *entry() const { return m_info; }
    int section() const { return m_section; }
    const QCString &type() const { return m_type; }
    const QCString &name() const { return m_name; }
    TagInfo *tagInfo() const { return m_tagInfo; }
    const QList<EntryNav> *children() const { return m_subList; }
    EntryNav *parent() const { return m_parent; }
    FileDef *fileDef() const { return m_fileDef; }

  private:

    // navigation 
    EntryNav        *m_parent;    
    QList<EntryNav> *m_subList;   

    // identification
    int          m_section;     
    QCString     m_type;        
    QCString     m_name;        
    TagInfo     *m_tagInfo;      
    FileDef     *m_fileDef;

    Entry       *m_info;
    int64        m_offset;
    bool         m_noLoad;
};


typedef QList<Entry> EntryList;
typedef QListIterator<Entry> EntryListIterator;

typedef QList<EntryNav> EntryNavList;
typedef QListIterator<EntryNav> EntryNavListIterator;

#endif

---

• ソフトウェア開発
• ホームページ制作
• Tcl版
• STLport版
• Dradnats C++ Library
• 要約文庫