• Skip to content
  • Skip to link menu
KDE API Reference
  • KDE API Reference
  • kdevelop API Reference
  • KDE Home
  • Contact Us
 

kdevplatform/language/duchain

  • sources
  • kfour-appscomplete
  • kdevelop
  • kdevplatform
  • language
  • duchain
instantiationinformation.cpp
Go to the documentation of this file.
1 /* This file is part of KDevelop
2  Copyright 2007-2009 David Nolden <[email protected]>
3 
4  This library is free software; you can redistribute it and/or
5  modify it under the terms of the GNU Library General Public
6  License version 2 as published by the Free Software Foundation.
7 
8  This library is distributed in the hope that it will be useful,
9  but WITHOUT ANY WARRANTY; without even the implied warranty of
10  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
11  Library General Public License for more details.
12 
13  You should have received a copy of the GNU Library General Public License
14  along with this library; see the file COPYING.LIB. If not, write to
15  the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
16  Boston, MA 02110-1301, USA.
17  */
18 
19 #include "instantiationinformation.h"
20 #include "identifier.h"
21 #include "serialization/itemrepository.h"
22 #include "types/typeutils.h"
23 #include <typeinfo>
24 #include "types/typealiastype.h"
25 #include "types/typerepository.h"
26 
27 namespace KDevelop {
28 DEFINE_LIST_MEMBER_HASH(InstantiationInformation, templateParameters, IndexedType)
29 
30 QualifiedIdentifier InstantiationInformation::applyToIdentifier(const QualifiedIdentifier& id) const
31 {
32  QualifiedIdentifier ret;
33  if (id.count() > 1) {
34  ret = id;
35  ret.pop();
36  if (previousInstantiationInformation.index())
37  ret = previousInstantiationInformation.information().applyToIdentifier(ret);
38  }
39 
40  Identifier lastId(id.last());
41 
42  KDevVarLengthArray<IndexedTypeIdentifier> oldTemplateIdentifiers;
43  for (uint a = 0; a < lastId.templateIdentifiersCount(); ++a)
44  oldTemplateIdentifiers.append(lastId.templateIdentifier(a));
45 
46  lastId.clearTemplateIdentifiers();
47 
48  for (uint a = 0; a < templateParametersSize(); ++a) {
49  if (templateParameters()[a].abstractType()) {
50  lastId.appendTemplateIdentifier(IndexedTypeIdentifier(templateParameters()[a].abstractType()->toString(),
51  true));
52  } else {
53  lastId.appendTemplateIdentifier(
54  ( uint ) oldTemplateIdentifiers.size() > a ? oldTemplateIdentifiers[a] : IndexedTypeIdentifier());
55  }
56  }
57 
58  for (int a = templateParametersSize(); a < oldTemplateIdentifiers.size(); ++a)
59  lastId.appendTemplateIdentifier(oldTemplateIdentifiers[a]);
60 
61  ret.push(lastId);
62  return ret;
63 }
64 
65 void InstantiationInformation::addTemplateParameter(const KDevelop::AbstractType::Ptr& type)
66 {
67  templateParametersList().append(IndexedType(type));
68 }
69 
70 QString InstantiationInformation::toString(bool local) const
71 {
72  QString ret;
73  if (previousInstantiationInformation.index() && !local)
74  ret = previousInstantiationInformation.information().toString() + QLatin1String("::");
75  ret += QLatin1Char('<');
76  QStringList types;
77  types.reserve(templateParametersSize());
78  for (uint a = 0; a < templateParametersSize(); ++a) {
79  if (templateParameters()[a].abstractType())
80  types.append(templateParameters()[a].abstractType()->toString());
81  else
82  // TODO: what should be here instead?
83  types.append(QString());
84  }
85 
86  ret += QLatin1Char('<') + types.join(QLatin1String(", ")) + QLatin1Char('>');
87  return ret;
88 }
89 
90 InstantiationInformation::InstantiationInformation() : m_refCount(0)
91 {
92  initializeAppendedLists();
93 }
94 
95 InstantiationInformation::InstantiationInformation(const InstantiationInformation& rhs,
96  bool dynamic) : previousInstantiationInformation(
97  rhs.previousInstantiationInformation)
98  , m_refCount(0)
99 {
100  initializeAppendedLists(dynamic);
101  copyListsFrom(rhs);
102 }
103 
104 InstantiationInformation::~InstantiationInformation()
105 {
106  freeAppendedLists();
107 }
108 
109 InstantiationInformation& InstantiationInformation::operator=(const InstantiationInformation& rhs)
110 {
111  previousInstantiationInformation = rhs.previousInstantiationInformation;
112  copyListsFrom(rhs);
113  return *this;
114 }
115 
116 bool InstantiationInformation::operator==(const InstantiationInformation& rhs) const
117 {
118  if (!(previousInstantiationInformation == rhs.previousInstantiationInformation))
119  return false;
120  return listsEqual(rhs);
121 }
122 
123 uint InstantiationInformation::hash() const
124 {
125  KDevHash kdevhash;
126  FOREACH_FUNCTION(const IndexedType &param, templateParameters) {
127  kdevhash << param.hash();
128  }
129  return kdevhash << previousInstantiationInformation.index();
130 }
131 
132 AbstractRepositoryManager* returnTypeRepository()
133 {
134  return typeRepositoryManager();
135 }
136 
137 static KDevelop::RepositoryManager<KDevelop::ItemRepository<InstantiationInformation,
138  AppendedListItemRequest<InstantiationInformation>>>& instantiationInformationRepository()
139 {
140  static KDevelop::RepositoryManager<KDevelop::ItemRepository<InstantiationInformation,
141  AppendedListItemRequest<InstantiationInformation>>> instantiationInformationRepositoryObject(QStringLiteral(
142  "Instantiation Information Repository"), 1, &returnTypeRepository);
143  return instantiationInformationRepositoryObject;
144 }
145 
146 uint standardInstantiationInformationIndex()
147 {
148  static uint idx = instantiationInformationRepository()->index(InstantiationInformation());
149  return idx;
150 }
151 
152 void initInstantiationInformationRepository()
153 {
154  standardInstantiationInformationIndex();
155 }
156 
157 IndexedInstantiationInformation::IndexedInstantiationInformation() : m_index(0)
158 {
159 }
160 
161 IndexedInstantiationInformation::IndexedInstantiationInformation(uint index) : m_index(index)
162 {
163  if (m_index == standardInstantiationInformationIndex())
164  m_index = 0;
165 
166  if (m_index && shouldDoDUChainReferenceCounting(this)) {
167  QMutexLocker lock(instantiationInformationRepository()->mutex());
168  increase(instantiationInformationRepository()->dynamicItemFromIndexSimple(m_index)->m_refCount, m_index);
169  }
170 }
171 
172 IndexedInstantiationInformation::IndexedInstantiationInformation(const IndexedInstantiationInformation& rhs) : m_index(
173  rhs.m_index)
174 {
175  if (m_index && shouldDoDUChainReferenceCounting(this)) {
176  QMutexLocker lock(instantiationInformationRepository()->mutex());
177  increase(instantiationInformationRepository()->dynamicItemFromIndexSimple(m_index)->m_refCount, m_index);
178  }
179 }
180 
181 IndexedInstantiationInformation& IndexedInstantiationInformation::operator=(const IndexedInstantiationInformation& rhs)
182 {
183  if (m_index && shouldDoDUChainReferenceCounting(this)) {
184  QMutexLocker lock(instantiationInformationRepository()->mutex());
185  decrease(instantiationInformationRepository()->dynamicItemFromIndexSimple(m_index)->m_refCount, m_index);
186  }
187 
188  m_index = rhs.m_index;
189 
190  if (m_index && shouldDoDUChainReferenceCounting(this)) {
191  QMutexLocker lock(instantiationInformationRepository()->mutex());
192  increase(instantiationInformationRepository()->dynamicItemFromIndexSimple(m_index)->m_refCount, m_index);
193  }
194  return *this;
195 }
196 
197 IndexedInstantiationInformation::~IndexedInstantiationInformation()
198 {
199  if (m_index && shouldDoDUChainReferenceCounting(this)) {
200  QMutexLocker lock(instantiationInformationRepository()->mutex());
201  decrease(instantiationInformationRepository()->dynamicItemFromIndexSimple(m_index)->m_refCount, m_index);
202  }
203 }
204 
205 bool IndexedInstantiationInformation::isValid() const
206 {
207  return m_index;
208 }
209 
210 const InstantiationInformation& IndexedInstantiationInformation::information() const
211 {
212  return *instantiationInformationRepository()->itemFromIndex(
213  m_index ? m_index : standardInstantiationInformationIndex());
214 }
215 
216 IndexedInstantiationInformation InstantiationInformation::indexed() const
217 {
218  return IndexedInstantiationInformation(instantiationInformationRepository()->index(*this));
219 }
220 }
KDevelop::Identifier::clearTemplateIdentifiers
void clearTemplateIdentifiers()
Definition: identifier.cpp:567
QList::append
void append(const T &value)
KDevelop::InstantiationInformation::toString
QString toString(bool local=false) const
Definition: instantiationinformation.cpp:70
KDevelop::initInstantiationInformationRepository
void initInstantiationInformationRepository()
Definition: instantiationinformation.cpp:152
KDevelop::returnTypeRepository
AbstractRepositoryManager * returnTypeRepository()
Definition: instantiationinformation.cpp:132
KDevelop::Identifier::appendTemplateIdentifier
void appendTemplateIdentifier(const IndexedTypeIdentifier &identifier)
Definition: identifier.cpp:561
DEFINE_LIST_MEMBER_HASH
#define DEFINE_LIST_MEMBER_HASH(container, member, type)
Definition: appendedlist.h:218
KDevelop::Identifier::templateIdentifiersCount
uint templateIdentifiersCount() const
Definition: identifier.cpp:553
KDevelop::instantiationInformationRepository
static KDevelop::RepositoryManager< KDevelop::ItemRepository< InstantiationInformation, AppendedListItemRequest< InstantiationInformation > > > & instantiationInformationRepository()
Definition: instantiationinformation.cpp:138
KDevelop::standardInstantiationInformationIndex
uint standardInstantiationInformationIndex()
Definition: instantiationinformation.cpp:146
KDevelop::InstantiationInformation::~InstantiationInformation
~InstantiationInformation()
Definition: instantiationinformation.cpp:104
KDevelop::TypePtr< AbstractType >
KDevelop::InstantiationInformation::addTemplateParameter
void addTemplateParameter(const AbstractType::Ptr &type)
This must always be used to add new parameters.
Definition: instantiationinformation.cpp:65
typerepository.h
KDevelop::IndexedType::hash
uint hash() const
Access the type's hash value.
Definition: indexedtype.h:94
KDevelop::InstantiationInformation::hash
uint hash() const
Definition: instantiationinformation.cpp:123
QList::reserve
void reserve(int alloc)
typeutils.h
KDevelop::InstantiationInformation::operator=
InstantiationInformation & operator=(const InstantiationInformation &rhs)
Definition: instantiationinformation.cpp:109
KDevelop::InstantiationInformation::InstantiationInformation
InstantiationInformation()
Definition: instantiationinformation.cpp:90
KDevelop::AppendedListItemRequest
This is a class that allows you easily putting instances of your class into an ItemRepository as seen...
Definition: appendedlist.h:388
typealiastype.h
FOREACH_FUNCTION
#define FOREACH_FUNCTION(item, container)
Foreach macro that takes a container and a function-name, and will iterate through the vector returne...
Definition: appendedlist.h:213
QString
identifier.h
KDevVarLengthArray
KDevelop::InstantiationInformation::previousInstantiationInformation
IndexedInstantiationInformation previousInstantiationInformation
Instantiation-information for the surrounding context(see IndexedInstantiationInformation).
Definition: instantiationinformation.h:125
instantiationinformation.h
QStringList::join
QString join(const QString &separator) const
QLatin1String
KDevelop::Identifier
Represents a single unqualified identifier.
Definition: identifier.h:150
KDevelop::Identifier::templateIdentifier
IndexedTypeIdentifier templateIdentifier(int num) const
Definition: identifier.cpp:545
KDevelop::QualifiedIdentifier::push
void push(const IndexedIdentifier &id)
Append id to this qualified identifier.
Definition: identifier.cpp:995
KDevelop::InstantiationInformation
Definition: instantiationinformation.h:71
KDevelop::InstantiationInformation::operator==
bool operator==(const InstantiationInformation &rhs) const
Definition: instantiationinformation.cpp:116
KDevelop::QualifiedIdentifier
Represents a qualified identifier.
Definition: identifier.h:245
QLatin1Char
KDevelop::QualifiedIdentifier::pop
void pop()
Pops one identifier from back:
Definition: identifier.cpp:1025
KDevelop::IndexedType
Indexed type pointer.
Definition: indexedtype.h:36
KDevelop
Definition: abstractfunctiondeclaration.cpp:27
QMutexLocker
KDevelop::IndexedTypeIdentifier
Extends IndexedQualifiedIdentifier by:
Definition: identifier.h:381
KDevelop::typeRepositoryManager
AbstractRepositoryManager * typeRepositoryManager()
Definition: typerepository.cpp:112
QStringList
This file is part of the KDE documentation.
Documentation copyright © 1996-2021 The KDE developers.
Generated on Wed Mar 3 2021 00:37:28 by doxygen 1.8.16 written by Dimitri van Heesch, © 1997-2006

KDE's Doxygen guidelines are available online.

kdevplatform/language/duchain

Skip menu "kdevplatform/language/duchain"
  • Main Page
  • Namespace List
  • Namespace Members
  • Alphabetical List
  • Class List
  • Class Hierarchy
  • Class Members
  • File List
  • File Members
  • Related Pages

kdevelop API Reference

Skip menu "kdevelop API Reference"
  • kdevplatform
  •   debugger
  •   documentation
  •   interfaces
  •   language
  •     assistant
  •     backgroundparser
  •     checks
  •     classmodel
  •     codecompletion
  •     codegen
  •     duchain
  •     editor
  •     highlighting
  •     interfaces
  •     util
  •   outputview
  •   project
  •   serialization
  •   shell
  •   sublime
  •   tests
  •   util
  •   vcs

Search



Report problems with this website to our bug tracking system.
Contact the specific authors with questions and comments about the page contents.

KDE® and the K Desktop Environment® logo are registered trademarks of KDE e.V. | Legal