• Skip to content
• Skip to link menu

KDE 4.4 API Reference

• KDE API Reference
• KDevelop Platform Libraries

• Sitemap
• Contact Us

 

language/duchain

appendedlist_static.h

/*
   Copyright 2008 David Nolden <david.nolden.kdevelop@art-master.de>

   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public
   License version 2 as published by the Free Software Foundation.

   This library 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
   Library General Public License for more details.

   You should have received a copy of the GNU Library General Public License
   along with this library; see the file COPYING.LIB.  If not, write to
   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
   Boston, MA 02110-1301, USA.
*/

#ifndef APPENDEDLIST_H
#define APPENDEDLIST_H

#include <util/kdevvarlengtharray.h>
#include "referencecounting.h"

namespace KDevelop {

// Foreach macro that takes a container and a function-name, and will iterate through the vector returned by that function, using the length returned by the function-name with "Size" appended.
//This might be a little slow
#define FOREACH_FUNCTION(item, container) for(uint a = 0, mustDo = 1; a < container ## Size(); ++a) if((mustDo == 0 || mustDo == 1) && (mustDo = 2)) for(item(container()[a]); mustDo; mustDo = 0)

#define START_APPENDED_LISTS(selftype) typedef selftype SelfType;

#define APPENDED_LIST_COMMON(type, name) \
      KDevelop::AppendedList<dynamic, type> name ## List; \
      unsigned int name ## Size() const { return name ## List.size(); } \
      template<class T> bool name ## Equals(const T& rhs) const { unsigned int size = name ## Size(); if(size != rhs.name ## Size()) return false; for(uint a = 0; a < size; ++a) {if(!(name()[a] == rhs.name()[a])) return false;} return true; }


#define APPENDED_LIST_FIRST(type, name)        APPENDED_LIST_COMMON(type, name) \
                                               const type* name() const { return name ## List.data( ((char*)this) + sizeof(SelfType) ); } \
                                               unsigned int name ## OffsetBehind() const { return name ## List.dynamicDataSize(); } \
                                               template<class T> bool name ## ListChainEquals( const T& rhs ) const { return name ## Equals(rhs); } \
                                               template<class T> void name ## CopyAllFrom( const T& rhs ) { name ## List.copy(const_cast<type*>(name()), rhs.name(), rhs.name ## Size()); }
                                                                                              
#define APPENDED_LIST(type, name, predecessor) APPENDED_LIST_COMMON(type, name) \
                                               const type* name() const { return name ## List.data( ((char*)this) + sizeof(SelfType) + predecessor ## OffsetBehind() ); } \
                                               unsigned int name ## OffsetBehind() const { return name ## List.dynamicDataSize() + predecessor ## OffsetBehind(); } \
                                               template<class T> bool name ## ListChainEquals( const T& rhs ) const { return name ## Equals(rhs) && predecessor ## ListChainEquals(rhs); } \
                                               template<class T> void name ## CopyAllFrom( const T& rhs ) { name ## List.copy(const_cast<type*>(name()), rhs.name(), rhs.name ## Size()); predecessor ## CopyAllFrom(); }

#define END_APPENDED_LISTS(predecessor) /* Returns the size of the object containing the appended lists, including them */ \
                                      unsigned int completeSize() const { return sizeof(SelfType) + predecessor ## OffsetBehind(); } \
                                      unsigned int lastOffsetBehind() const { return predecessor ## OffsetBehind(); } \
                                     /* Compares all appended lists and returns true if they are equal */                \
                                      template<class T> bool listsEqual(const T& rhs) const { return predecessor ## ListChainEquals(rhs); } \
                                      template<class T> void copyListsFrom(const T& rhs) { return predecessor ## CopyAllFrom(rhs); }

  template<bool dynamic, class T> 
class AppendedList : public KDevVarLengthArray<T, 10> {
  public: 
    unsigned int dynamicDataSize() const {
      return this->size() * sizeof(T);
    }
    const T* data(char* /*position*/) const {
      return KDevVarLengthArray<T, 10>::data();
    }
    void copy(T* /*target*/, const T* data, uint size) {
      Q_ASSERT(!shouldDoDUChainReferenceCountingInternal(KDevVarLengthArray<T, 10>::data()));
      bool empty = KDevVarLengthArray<T, 10>::isEmpty();
      Q_ASSERT(empty);
      for(uint a = 0; a < size; ++a)
        append(data[a]);
    }
    
    void free(T*) {
      Q_ASSERT(!shouldDoDUChainReferenceCountingInternal(KDevVarLengthArray<T, 10>::data()));
    }
};

template<class T> 
class AppendedList<false, T> {
  public:
    AppendedList() : listSize(0) {
    }
    unsigned int listSize;
    unsigned int size() const {
      return listSize;
    }
    
    void free(T* position) {
      if(listSize)
        Q_ASSERT(shouldDoDUChainReferenceCountingInternal(position)); //Since it's constant, it must be in the repository
      for(unsigned int a = 0; a < listSize; ++a)
        (position+a)->~T();
    }

    //currentOffset should point to the position where the data of this item should be saved
    const T* data(char* position) const {
      return (T*)position;
    }
    //Count of bytes that were appeendd
    unsigned int dynamicDataSize() const {
      return listSize * sizeof(T);
    }
    void copy(T* target, const T* data, uint size) {
      if(size)
        Q_ASSERT(shouldDoDUChainReferenceCountingInternal(target)); //Since it's constant, it must be in the repository
      for(uint a = 0; a < size; ++a)
        new (target+a) T(data[a]); //Properly call all the copy constructors
      listSize = size;
    }
};
}

#endif

language/duchain

Skip menu "language/duchain"

• Main Page
• Namespace List
• Class Hierarchy
• Alphabetical List
• Class List
• File List
• Namespace Members
• Class Members
• Related Pages

KDevelop Platform Libraries

Skip menu "KDevelop Platform Libraries"

• interfaces
• language
•   codegen
•   duchain
•   editor
• outputview
• project
• shell
• sublime
• util
• vcs

Generated for KDevelop Platform Libraries by doxygen 1.5.9-20090814
This website is maintained by Adriaan de Groot and Allen Winter.
KDE^® and the K Desktop Environment^® logo are registered trademarks of KDE e.V. | Legal