+ if (KMessageBox::warningContinueCancel(this, i18nc("@info", "Remove all the .gcda files in <filename>%1</filename> directory and, recursively, in its subdirectories?", m_targetDirectory->url().toLocalFile()),
+ //i18nc can't be used. It seems that at this moment (2009-09-04) only
+ //plain text can be used in the outputview
+ //errorList << i18nc("@info", "Failed to start <filename>%1</filename>. Make sure that the path to <command>geninfo</command> is specified correctly in <interface>Settings->Configure KDevelop...->Lcov Preferences->geninfo Executable</interface>.", m_lcov->program().first());
+ errorList << i18n("Failed to start '%1'. Make sure that the path to geninfo is specified correctly in Settings->Configure KDevelop...->Lcov Preferences->geninfo Executable.", m_lcov->program().first());
+ } else if (error == QProcess::Crashed) {
+ errorList << i18n("geninfo process crashed.");
+ } else if (error == QProcess::Timedout) {
+ errorList << i18n("geninfo process timed out.");
+ } else if (error == QProcess::WriteError) {
+ errorList << i18n("Failed to write to geninfo process.");
+ } else if (error == QProcess::ReadError) {
+ errorList << i18n("Failed to read from geninfo process.");
+ } else if (error == QProcess::UnknownError) {
+ errorList << i18n("Unknown geninfo process error.");
+# run valgrind's memory error checker on all tests.
+# filter uninteresting errors and known false positives
+# eg staticly initialized memory from libraries like libfontconfig
+#
+
+from os import system, remove
+from sys import exit, stdout
+from subprocess import Popen, PIPE
+from xml.dom.minidom import parse, parseString
+
+def garbage(line):
+ ''' filter for valgridn output'''
+ return not line.startswith('<unknown program name>') and \
+ not line.startswith('profiling:') and \
+ line.find('</valgrindoutput>') # problem is that valgrind erroneously puts multiple of these end-document entries if processes are spawned _inside_ the exe under investigation
+
+def isValgrind3_5OrHigher():
+ process = Popen("valgrind --version", stdout=PIPE, shell=True)
+ process.wait()
+ valgrindOutput = process.stdout.read().strip()
+
+ import re, string
+ version = re.search("[0-9]+(.[0-9]+)*", valgrindOutput).group(0)
+ version = string.split(version, ".")
+
+ if map(int, version) < [3, 5]:
+ return False
+ else:
+ return True
+
+def memcheck(test):
+ ''' run valgrind-memcheck on test in testdir. return xml output as string '''
+Set the directory to generate the report for and start the scan.
+
+Once finished, you can select the directories in the coverage report to see their statistics. A more detailed report can be seen for each directory, showing all the covered files in it. Each file can also be shown in the editor, annotated with line by line coverage information.</string>
+ <string comment="@info:tooltip">Use the build path from the selected project</string>
+ </property>
+ <property name="whatsThis">
+ <string comment="@info:whatsthis">When one of the opened projects is selected, the directory to scan for <filename>.gcda</filename> files will be set to the build path of that project.</string>
+ </property>
+ <property name="text">
+ <string comment="@label:listbox">Get from project:</string>
+In directory mode, the report summarizes the coverage with a list of all the directories that contain at least one covered file. It could include directories out of the specified path, depending on the files included in the source code.
+
+In file mode, all the files of the selected directory are shown. If several directories are selected, only the files of the last selected directory are shown. Double clicking on any of the items shows the associated file in the editor, annotated with the coverage information.
+
+You can change between directory and file mode using left and right keys.</string>
+ <string comment="@info:whatsthis"><para>Configuration for coverage report colors.</para>
+
+<para>In the directory view of the coverage report, each directory coverage percentage is represented using a color.</para>
+
+<para>The color associated to each percentage is taken from a color range, made up of several stop points. Stop points represent a color at a specific percentage.</para>
+
+<para>A color range has two different and independent modes: discrete and gradient. In discrete type, all percentage values between the previous stop point and the current one have the color of the current one. In gradient type, the values are interpolated between the previous stop point's color and the current stop point's color.</para></string>
+K_EXPORT_PLUGIN(AutomakeBuilderFactory(KAboutData("kdevautomakebuilder","kdevautomakebuilder", ki18n("Automake Builder"), "0.1", ki18n("Support for building Automake projects"), KAboutData::License_GPL)))
+ classTypeOpened( currentAbstractType() ); //This callback is needed, because the type of the class-declaration needs to be set early so the class can be referenced from within itself
+ classTypeOpened( TypeRepository::self()->registerType(currentAbstractType()) ); //This callback is needed, because the type of the class-declaration needs to be set early so the class can be referenced from within itself
+ * Compile an identifier for the specified AstNode \a id.
+ *
+ * \note this reference will only be valid until the next time the function
+ * is called, so you need to create a copy (store as non-reference).
+ * @param typeSpecifier a pointer that will eventually be filled with a type-specifier that can be found in the name(for example the return-type of a cast-operator)
+Comment=This plugin displays a graphical view of the definition-use chain produced by the C++ support
+Comment[bs]=Ovaj dodatak prikazuje grafički prikaz definicije lanca upotrebe, izrađenog od strane C++ podrške
+Comment[ca]=Aquest connector mostra una vista gràfica de la cadena de definició-ús produïda per la implementació del llenguatge C++
+Comment[ca@valencia]=Aquest connector mostra una vista gràfica de la cadena de definició-ús produïda per la implementació del llenguatge C++
+Comment[de]=Dieses Modul zeigt eine grafische Ansicht der Definition-Use-Chain, die durch die Unterstützung für C++ erzeugt wurde.
+Comment[en_GB]=This plugin displays a graphical view of the definition-use chain produced by the C++ support
+Comment[es]=Este complemento muestra una vista gráfica de la cadena definición-uso producida por la implementación de C++
+Comment[et]=See plugin näitab graafiliselt C++ toetusel loodud definitsiooni-kasutuse ahelat.
+Comment[fr]=Ce module externe affiche une vue graphique de la chaîne définition-utilisation produite par la prise en charge du C++
+Comment[gl]=Este complemento mostra unha vista gráfica da cadea de definicións e usos producida pola compatibilidade con C++.
+Comment[it]=Questa estensione mostra graficamente la definition-use chain (DUChain) prodotta dal supporto per il linguaggio C++.
+Comment[nl]=Deze plugin geeft een grafische weergave van door C++ ondersteuning geproduceerde definition-use Chain
+Comment[pl]=Wtyczka ta wyświetla widok graficzny łańcucha definicji-użycia wyprodukowany przez obsługę C++
+Comment[pt]=Este 'plugin' apresenta uma vista gráfica sobre a sequência de definições-usos que é produzida pelo componente da linguagem C++
+Comment[pt_BR]=Este plugin apresenta uma vista gráfica sobre a sequência de definições-usos que é produzida pelo suporte ao C++
+Comment[sv]=Insticksprogrammet visar en grafisk vy av definition-användningskedjan skapad av C++ stödet.
+Comment[uk]=За допомогою цього додатка можна переглянути у графічному вигляді ланцюжок «Визначення-Використання», створений частиною, що відповідає за мову програмування C++.
+Comment[x-test]=xxThis plugin displays a graphical view of the definition-use chain produced by the C++ supportxx
+Name=DUChain View
+Name[bs]=DUChain pregled
+Name[ca]=Visualització de cadena DU
+Name[ca@valencia]=Visualització de cadena DU
+Name[de]=DUChain-Ansicht
+Name[en_GB]=DUChain View
+Name[es]=Vista DUChain
+Name[et]=DU-ahela vaade
+Name[fr]=Affichage DUChain
+Name[ga]=Amharc DUChain
+Name[gl]=Vista de DUChain
+Name[it]=Vista DUChain
+Name[nl]=DUChain weergave
+Name[pl]=Widok DUChain
+Name[pt]=Área de Definições-Usos
+Name[pt_BR]=Área de Definições-Usos
+Name[sk]=Prehliadať DUChain
+Name[sv]=Visning av definition-användningskedja
+Name[uk]=Перегляд ВВ-ланцюжка
+Name[x-test]=xxDUChain Viewxx
+GenericName=DUChain View
+GenericName[bs]=DUChain pregled
+GenericName[ca]=Visualització de cadena DU
+GenericName[ca@valencia]=Visualització de cadena DU
+GenericName[de]=DUChain-Ansicht
+GenericName[en_GB]=DUChain View
+GenericName[es]=Vista DUChain
+GenericName[et]=DU-ahela vaade
+GenericName[fr]=Afficheur DUChain
+GenericName[ga]=Amharc DUChain
+GenericName[gl]=Vista de DUChain
+GenericName[it]=Vista DUChain
+GenericName[ja]=DUChain ビュー
+GenericName[nds]=Dbkeed-Ansicht
+GenericName[nl]=DUChain weergave
+GenericName[pl]=Widok DUChain
+GenericName[pt]=Área de Definições-Usos
+GenericName[pt_BR]=Área de Definições-Usos
+GenericName[sk]=Prehliadať DUChain
+GenericName[sv]=Visning av definition-användningskedja
+GenericName[tr]=DUChain Görünümü
+GenericName[uk]=Перегляд ВВ-ланцюжка
+GenericName[x-test]=xxDUChain Viewxx
+ServiceTypes=KDevelop/Plugin
+X-KDE-Library=kdevduchainview
+X-KDevelop-Version=7
+X-KDevelop-Category=Project
+X-KDE-PluginInfo-Name=kdevduchainview
+X-KDE-PluginInfo-Author=Hamish Rodda
+X-KDE-PluginInfo-License=GPL
+X-KDevelop-Mode=GUI
Property changes on: tags/unmaintained/4/kdevelop4-extra-plugins/duchainviewer/kdevduchainview.desktop
+K_EXPORT_PLUGIN(KDevDUChainViewFactory(KAboutData("kdevduchainview","kdevduchainviewer",ki18n("DUChain View"), "0.1", ki18n("A simple tool to view the raw DUChain"), KAboutData::License_GPL)))
+
+class DUChainViewFactory: public KDevelop::IToolViewFactory
+K_EXPORT_PLUGIN (KdevPlugFactory (KAboutData ("kdevpreprocessor","kdevpreprocessor", ki18n ("Preprocess the Current File"), "0.1", ki18n ("Preprocess the Current File"), KAboutData::License_GPL)))
+ connect (m_actionPreprocess, SIGNAL (triggered (bool)), this, SLOT (preprocess()));
+ m_actionPreprocess->setToolTip (i18n ("Preprocess the Current File"));
+ m_actionPreprocess->setWhatsThis (i18n ("<b>Preprocessor</b><p> View the preprocessor ouput, the content of included files will not be displayed</p>"));
+K_EXPORT_PLUGIN(QtDesignerPluginFactory(KAboutData("kdevqtdesigner","kdevqtdesigner", ki18n("Qt Designer"), "0.1", ki18n("A GUI form designer for the Qt toolkit"), KAboutData::License_GPL)))
+
+class QtDesignerDocumentFactory : public KDevelop::IDocumentFactory
+ int result = KMessageBox::warningContinueCancel( m_editDlg, i18n( "You are about to unapply a dynamic patch created by the command \"%1\". That can be very dangerous. If the same command will not produce the same text after the unapply, the patch cannot be reapplied and all data may be lost. \nRecommendation: Make the patch a file-patch before unapplying it.", l->command.c_str() ), i18n("Warning") );
+# macro_log_feature( COMMONCPP2_FOUND "Common C++2" "Support for Teamwork plugin integration" "http://ftp.gnu.org/pub/gnu/commoncpp/" FALSE "1.5.9" "The commoncpp2 libraries are needed for the Teamwork plugin" )
+# macro_log_feature( Boost_FOUND "Boost" "Support for Teamwork plugin integration" "http://www.boost.org/" FALSE "1.34.0" "The iostreams and serialization components of the boost C++ libraries are needed for the Teamwork plugin" )
+/**This is called once a message has been tried to be sent, with the appropriate result, and can be used by the message to give some feedback to the sender. The Session used to send the message is still locked.
+ */
+void RawMessage::result( bool /*success*/ ) {
+}
+
+/**Returns a reference to the data-store of this raw message. It does not include data serialized to inherited messages. */
+DataVector& RawMessage::body() {
+ return body_;
+}
+
+/**Returns a reference to the data-store of this raw message. It does not include data serialized to inherited messages. */
+ /**The unique id is the identity of a message-instance, not of the message-type */
+ UniqueMessageId uniqueId() const;
+
+ /**Since the uniqueId is not used for sorting this casts away constness so the id of a MessageType that is used as Key in a Map can be changed */
+ void setUniqueId( UniqueMessageId newId ) const;
+
+ /** if the message is a reply to another message, this should be the uniqueId of the other message.
+ this function is thread-safe.(because after creation, this value should not be changed anymore) */
+ UniqueMessageId isReplyTo() const;
+
+ /** to make one message a reply to another while sending(to the other side), this is enough. To mark the message for local use, setReplyMessage(...) should be set too.*/
+ void setReply( UniqueMessageId replyId );
+
+ /** this does not automatically set the reply-id, it just sets a message-pointer. */
+ ///If the reply is not handled directly by the message that the reply has gone to, the message this is a reply to is stored here.(The message with the id isReplyTo() ), may be invalid
+ const MessagePointer& replyToMessage() const;
+
+ void setId( const MessageType& id );
+
+ /**Removes all kept references to important objects like sessions(those might keep the sessions alive too long)
+ this should be called before a message is stored permanently */
+
+ void makePersistent();
+
+ ///Returns whether the message was constructed from a stream(if false, it was created locally)
+ bool isIncoming() const;
+
+ ///This can be used to set the isIncoming()-flag. The application or messages may use the flag as indication whether the message is incoming or outgoing.
+ void setIsIncoming( bool b );
+};
+
+/**Since messages can have different IDs in different Message-Sets, the id's cannot be hardcoded and must be given with each creation.
+That is simplified by using MessageTypeSet::create which directly fills the correct id
+To create and use an own message there's three things to do:
+1. Implement a message based on MessageInterface(or simpler based on RawMessage)
+2. Within the class-declaration, use the DECLARE_MESSAGE(name, parent, subindex)-macro to define the inheritance used in the message-tree
+3. Register the message to the used MessageTypeSet, to register it to globalMessageTypeSet() simply use the REGISTER_MESSAGE(Message)-macro(within an implementation-file).
+Now the message can be sent and received. */
+
+class NETWORK_EXPORT MessageInterface : public SafeShared /*, public virtual Serializable*/ {
+ ///this function must be thread-safe(so the message does not need to be locked when it is called)
+ virtual MessageInfo& info() = 0;
+
+ virtual const MessageInfo& info() const = 0;
+
+ /**This is called once a message has been tried to be send, with the appropriate result, and can be used by the message to give some feedback to the sender. The Session used to send the message is still locked.
+ */
+ virtual void result( bool success ) = 0;
+
+ virtual ~MessageInterface();
+
+ ///This function is thread-safe
+ virtual const char* name();
+
+ ///This function must be implemented for all messages, it is atomatically cared about by the DECLARE_MESSAGE(..) macros etc.
+ static const char* staticName();
+
+ ///This is just a convenience-function that redirects to info().type()
+ const MessageType& type() const;
+
+ ///This is just a convenience-function that redirects to info().uniqueId()
+ UniqueMessageId uniqueId() const;
+
+ ///This should return "true" when the message wants a reply. gotReply will then be called once a reply has been received. The default-implementation returns false.
+ virtual bool needReply() const;
+
+ struct NETWORK_EXPORT ReplyResult {
+ bool messageHandled; ///This should indicate that the message was used locally and should not be handled on by higher instances
+ bool awaitingMore; ///whether the message is awaiting more replies.(if this is true, the message will not be deleted and needReply will be called again as soon as another reply arrives)
+ cout << "possible commands configuration-manipulation-commands(everything within the [] is optional): \n";
+ cout << "--adduser username [password] | Add the user to the list of known users\n";
+ cout << "--serverpassword [password] | Change the server-wide password which is used for users without an own password. If empty, access is made public.\n";
+ cout << "--servername name | Change the name of the server\n";
+ cout << "--deluser username | delete a user from the list of known users\n";
+ cout << "--list | list all registered users\n";
+ cout << "--show | show current settings of the server\n";
+ cout << "--setrights username [banned][admin][trusted] | change the rights of the user(no argument for normal user-rights)\n";
+ cout << "--setport [port] | change the port the server is opened on(if the port is left away the default-port("<<STANDARDPORT<<") is used)\n";
+ cout << "--setbind [address] | change the address the server is bound to(if it is left away the default(0.0.0.0) is used)\n";
+ cout << "\nAll these commands manipulate the configuration-file created in the run-directory. \nThe settings will then apply for the next start of the server.\n";
+ cout << "only one of the commands can be called at one time.\n";
+/** This header gives an additional type of pointer with a higher level. It's functionality is similar to that of QPointer.
+ Holding a pointer of type WeakSafeShared, does not increase the reference-count of the pointed object. If the object is deleted,
+ the pointer is set to zero. This comes with additional cost. The pointed object must be based on WeakSafeShared, and for each creation of
+ that type one additional allocation of an internal SafeShared-object(especially a mutex) is done.
+
+ WeakSafeSharedPtr itself does not consume more memory than SafeSharedPtr, but locking-operations are more costly, because two locks are done instead of one.
+ */
+
+template <class Item, class Serialization>
+class NETWORK_EXPORT WeakSafeSharedPtr {
+ SafeSharedPtr<WeakReference> ref_;
+ public:
+ WeakSafeSharedPtr() {}
+
+ template <class Input>
+ WeakSafeSharedPtr( const Input& ptr ) {
+ set
+ ( ptr );
+ }
+
+ SafeSharedPtr<Item, Serialization> get
+ () const {
+ typename SafeSharedPtr<WeakReference>::Locked l = ref_;
+//The first 4 lines of the following macros are used to store the values for the implementation, so they must not be given to the implementation again
+ //Returns the message-type mapped to a message-name. A message-name in rtti (typeid(Message).name()) format is also accepted for messages derived from MessageInterface
+ const MessageType& idFromName( const std::string& name ) const;
+
+ std::string stats() const;
+
+ ///returns the class-name of the message(the most specialized one registered in this type-set)
+ /** registers a type as slave of another given type, for simlicity registerMessageTypes should be used instead, together with a whole list of types */
+ template <class Message, class ParentMessage>
+ MessageType registerMessageType( int preferredSubId = 0 ) {
+ if ( ids_.find( staticMessageName<Message>() ) != ids_.end() )
+ std::cout << "while registering \"" << staticMessageName<Message>() << "\" the id of \"" << staticMessageName<ParentMessage>() << "\" could not be allocated!" << endl;
+ if ( myId ) {
+ //std::cout << "registering message-type " << staticMessageName<Message>() << " with id " << myId.desc() << endl;
+ ids_[ staticMessageName<Message>() ] = myId;
+ ids_[ typeid(Message).name() ] = myId;
+ if ( types_.find( myId ) != types_.end() )
+ delete types_[ myId ];
+ types_[ myId ] = new MessageFactory<Message>();
+ } else {
+ std::cout << "could not allocate id for message-type " << staticMessageName<Message>() << endl;
+ return MessageInfo( idFromName( name ), currentUniqueMessageId_++ );
+ }
+ /*
+ //For now the following is disabled to test whether it can be conveniently replaced with something that isn't that bad for executable-size
+ ///Conveniently create a new message with the correct Message-Id and unique-Id filled. All parameters are passed to the constructor of the created message.
+ ///Conveniently create a new message with the correct Message-Id and unique-Id filled. All parameters are passed to the constructor of the created message.
+ ///Conveniently create a new message with the correct Message-Id and unique-Id filled. All parameters are passed to the constructor of the created message.
+ template <class MessageType, class ParamType1, class ParamType2>
+ ///Conveniently create a new message with the correct Message-Id and unique-Id filled. All parameters are passed to the constructor of the created message.
+ template <class MessageType, class ParamType1, class ParamType2, class ParamType3>
+ ///Conveniently create a new message with the correct Message-Id and unique-Id filled. All parameters are passed to the constructor of the created message.
+ template <class MessageType, class ParamType1, class ParamType2, class ParamType3, class ParamType4>
+ ///Conveniently create a new message with the correct Message-Id and unique-Id filled. All parameters are passed to the constructor of the created message.
+ template <class MessageType, class ParamType1, class ParamType2, class ParamType3, class ParamType4, class ParamType5>
+ ///Conveniently create a new message with the correct Message-Id and unique-Id filled. All parameters are passed to the constructor of the created message.
+ template <class MessageType, class ParamType1, class ParamType2, class ParamType3, class ParamType4, class ParamType5, class ParamType6>
+ cerr << "serious error in the message-type-system!";
+ return 0;
+ }
+};
+
+
+///This message-type-set contains all messages that were registered by a call to REGISTER_MESSAGE, and may be used instead of the local type-sets, for simplicity. That way messages can be serialized/deserialized without the core-parts being aware that they exist.
+class NETWORK_EXPORT BasicTCPSocket : public ost::TCPSocket {
+ protected:
+ bool onAccept( const ost::InetHostAddress &ia, ost::tpport_t port );
+
+ public:
+ BasicTCPSocket( ost::InetAddress &ia, int port );
+};
+
+/**This class runs the server as the run()-method is called in the same ost::Thread.
+This class never deletes itself, it can be deleted from outside once isRunning() returns false or the threads are joined, or it can be deleted through a SharedPtr/SafeSharedPtr.
+For each client that connects, it creates a session derived from BasicSession, which can also be
+created by a derived class.
+ */
+class NETWORK_EXPORT BasicServer : protected ost::Thread, public WeakSafeShared {
+ ///returns the reference to a synchronized list of messages that are waiting for being processed. Processed messages should be removed from that list.
+ SafeList<MessagePointer>& messages();
+
+ /**After this function was called, the ost::Thread is going to exit soon.
+ once isRunning() returns false, it can be deleted.*/
+ void stopRunning();
+
+ ///Returns whether the ost::Thread is running
+ using ost::Thread::isRunning;
+
+ ///Starts the ost::Thread, should be called after the ost::Thread was constructed
+ using ost::Thread::start;
+
+ using ost::Thread::join;
+
+ ///This can be used to allow/disallow incoming connections. Already connected clients are not kicked on deactivation.
+ void allowIncoming( bool allow );
+
+ protected:
+
+ ///this one is called from within another Thread, so it is more useful to override processMessage(...) in the teamwork-server than this one
+ ///strips away all information that should stay private, but leaves things like description etc.
+ virtual void stripForPublic();
+
+ ///this function strips all information that is not necessary to generally identify a user(this might strip away more than stripForTarget, and removes passwords and such). It should not be called on derived classes, because the User-class is enough for simple Identification.
+ void stripForIdentification();
+
+ ///the structure can be changed through this.
+ OnlineInformation& online();
+
+ ///To set the user offline, this should be called with a zero-pointer
+///this class represents one line of logger-output. On its destruction the line is given to the logger. When it is copied, the copy-source is invalidated.
+ ///If the server-name in the configuration is not empty, and there currently is no local identity std::set, the local identity is std::set to that name.
+ ///The following two functions can be used to make UserPointers consistent through a longer session where the server may be closed/opened multiple times:
+ void getUserSet( UserSet& users );
+
+ ///Insert the given user-std::set into the server's own.
+ void insertUserSet( const UserSet& users );
+
+
+ ///If the user is not registered yet, the user is either created, copied and returned, or zero is returned.
+ virtual UserPointer getUser( const UserPointer& user );
+
+ ///Creates and registers a user with that identity if it does not already exist. May return zero on conflict.
+ virtual UserPointer getUser( const UserIdentity& user );
+
+ MessageTypeSet& messageTypes();
+
+ ///These two should be overridden to use derived user-classes.
+ virtual UserPointer createUser( const User* user );
+
+
+ int receiveMessage( SystemMessage* msg );
+ int receiveMessage( ForwardMessage* msg );
+ int receiveMessage( IdentificationMessage* msg );
+ int receiveMessage( TextMessage* msg );
+ int receiveMessage( MessageInterface* msg );
+
+ ///Tries to find the user(together with appropriately filled online-information) among connected users, servers, and users available through another connected server
+ UserPointer findUser( const UserPointer& user );
+
+ UserPointer findUser( const UserIdentity& user );
+
+ ///Returns the user associated with the given session, may return invalid pointer.
+ /**Associate this client with a user-identity. May be invalid( is initialized as such ).
+ Without this identity correctly std::set, forwarded messages can not be dispatched. The identity will also be broadcasted to new clients that connect to the server, but not to already connected ones */
+ void setIdentity( const UserPointer& user );
+ ///Returns the user-identity currently associated with this client. May be invalid.
+///This header defines a serialization-class that can be used as template-parameter to SafeSharedPtr so it uses the message-serialization-system and the MessageTypeSet to serialize and deserialize messages(it stores and loads the messages as vectors). It automatically uses the global message-set stored in globalMessageTypeSet(). A hard lock is done while saving. Warning: May throw exceptions on errors
+
+#include "serialization.h"
+#include "messagetypeset.h"
+#include "helpers.h"
+#include <vector>
+
+#define USE_BUFFER_SERIALIZATION
+
+struct NETWORK_EXPORT MessageSerialization {
+ template <class Type, class Archive, class Target>
+ * Use this to register your class for receiving all messages based on a given one.
+ *
+ * When a callback is registered using this function, the target will be locked before the target-function is called.
+ *
+ * @param Message(template-param 1) The message-type your class should receive
+ * @param target a weak-pointer to the target the message should be delivered to(the weak pointer makes it safe to register and later delete the object without notification)
+ * @param function pointer to a member-function of the taget-class, that must have the signature "int function( const SafeSharedPtr<Message>& )"
+ *
+ * For an example see main.cpp, there's a version of StandaloneServer that uses this.
+ /** Call this to dispatch the message to the registered targets
+ * @return 0 if there is no fitting target, or the value returned by the target's dispatch-function
+ */
+ int operator() ( const MessagePointer& msg );
+
+ protected:
+ /** Call this to dispatch the message to the registered targets. It is the same as operator(), but looks cleaner when called from an inherited class.
+ * @return 0 if there is no fitting target, or the value returned by the target's dispatch-function
+ ///This can be overridden to do some work on a regular basis. Returns whether more time is needed.
+ virtual bool think() = 0;
+
+ ///This can be overridden to do some cleanup-work within the session-thread. By default it tries to lock the associated user, and call setSession(this) so the user has a chance to notice the difference.
+ virtual void final();
+ };
+}
+#endif
Property changes on: tags/unmaintained/4/kdevelop4-extra-plugins/teamwork/lib/network/sessioninterface.h
+ CustomMessage( const MessageConstructionInfo& info, MyDataType& data ) : RawMessage( info(this) ), myData( data ) {
+}
+
+ CustomMessage( InArchive& arch, const MessageInfo& info ) : RawMessage( arch, info ) {
+ serial( arch );
+}
+
+ virtual void serialize( OutArchive& arch ) {
+ Precursor::serialize( arch );
+ serial( arch );
+}
+};
+ */
+
+ class MessageConstructionInfo;
+ /**MessageConstructionInfo is a class used while constructing messages, that makes sure that the name of the most derived message will be passed on to RawMessage.
+ *Use it by simply passing the this-pointer of each constructed message while passing it to the parent-message. */
+
+ class NETWORK_EXPORT MessageConstructionInfo {
+ public:
+ //This is the constructor you are supposed to use when creating a message(use the automatic conversion from MessageTypeSet&)
+ RawMessage( const MessageConstructionInfo& messageTypes, const DataVector& data );
+
+ ///This should be used to indicate that this message is a reply to the other message(replyTarget)
+ void setReply( MessageInterface* replyTarget );
+
+ RawMessage( InArchive& from, const MessageInfo& info );
+
+ virtual void serialize( OutArchive& target );
+
+ virtual const MessageInfo& info() const;
+
+ virtual MessageInfo& info();
+
+ /**This is called once a message has been tried to be sent, with the appropriate result, and can be used by the message to give some feedback to the sender. The Session used to send the message is still locked.
+ */
+ virtual void result( bool success );
+
+ /**Returns a reference to the data-store of this raw message. It does not include data serialized to inherited messages. */
+ DataVector& body();
+
+ /**Returns a reference to the data-store of this raw message. It does not include data serialized to inherited messages. */
+ const DataVector& body() const;
+ };
+
+
+ class NETWORK_EXPORT TextMessage : public RawMessage {
+/// A teamwork-client generally is the same as a teamwork-server, except it not only supports incoming connections, but also outgoing ones and connections forwarded through a server, and may be associated with a user-identity.
+///Action must have a member-template called Action, that has a typedef called Result. Action will be applied to each item, and the result bound together.
+ ///This walks the tree until it cannot go on, then applies the given Action to the current node(additionally giving the type at the node as template-argument), and gives back the return-type(Action::ReturnType).
+ public:
+
+ inline void buildFullId( const std::string& pre ) {
+ ///Searches the tree. Returns 0 if the action could be applied to no node, 1 if the action was applied but not to the searched leaf, and 2 if it was applied to the exact searched target
+/**Stuff is the list of types that define the tree
+in form of multiple Chain<Type, Parent-Type, int preferredIndex>, and EntryTemplate is a class which embeds
+a template-class called "Entry" which will be inherited by every single node, with the current type of the node as template-parameter(See StandardEntryTemplate).
+Instead of using the explicit Chain<...>-notation, just a type can be used, and the chain will be extracted by using the type's Precursor"-Typedef, and it's preferredIndex constant/enum. Every item MUST have an explicit sub-id, the automatic generation of ID's was abandoned to make building partial trees easiert.
+Stuff is a set of "Chain"'s or Types, bound together with "Binder". It can be incomplete, only the important leafs have to be there, and the tree leading to them is extracted automatically.
+ */
+template < class Master, class Stuff, class EntryTemplate = StandardEntryTemplate >
+ out() << "got forward-message from unknown session";
+ return 0;
+ }
+
+ try {
+ if ( it != users_.end() ) {
+ ///@todo check if the given session (user) is authorized to send data to the given target(check for connection), and check whether the source-user-information in the message fits the real source
+ UserPointer::Locked l = *it;
+ if ( l ) {
+ if ( l->online() && l->online().session() ) {
+ out( Logger::Debug ) << "forwarding a message from " << msg->source().name() << " to " << msg->target().name();
+ l->online().session().unsafe() ->send( msg );
+ } else {
+ if ( msg->storeOnServer() ) {
+ out( Logger::Debug ) << "failed to forward a message from " << msg->source().name() << " to " << msg->target().name() << ", storing it on the server";
+ out( Logger::Debug ) << "failed to forward a message from " << msg->source().name() << " to " << msg->target().name() << " because the target is not online";
+ for( ServerConfiguration::UserSet::iterator it = configuration_.registeredUsers.begin(); it != configuration_.registeredUsers.end(); ++it ) {
+ UserPointer::Locked u = new User( *it );
+ UserPointer ru = findUser( u );
+ if( ru ) {
+ ///The user already exists, update it
+ UserPointer::Locked rlu = ru;
+ if( rlu ) {
+ (*rlu) = *it;
+ rlu->setSession( rlu->online().session() ); ///Session is used to track the state of the user, so give a hint using that interface that something about the user changed.
+/**The MessageType holds all information necessary to Identify a Message and build an Object from it.
+ The IdList is an inheritance-chain. Messages whose list begins with IDs of other Messages must be specializations of those, and the parent-types should be able to handle those too.
+*/
+
+void BasicServer::buildSocket() {
+ closeSocket();
+ failed_ = false;
+
+ try {
+ server_ = new BasicTCPSocket( addr, port_ );
+ out() << "server is listening on " << addr << ":" << port_;
+ err() << "the reconstruction of a message of type \"" << mp->name() << "\" is wrong, the serialized content does not match!" ;
+ compare( buffer, buffer2 );
+ } else {
+ err() << "the reconstruction of a message of type \"" << mp->name() << "\" is wrong!(mismatch in size: " << buffer.size() << " -> " << buffer2.size() << ")" ;
+ compare( buffer, buffer2 );
+ }
+ } else {
+ err() << "a message that is being sent could not be reconstructed for debugging: \"" << mp->name() << "\"";
+ }
+ } catch ( const CannotReserialize& )
+ {}
+ catch( const boost::archive::archive_exception& e ) {
+ err() << "archive-exception while reconstructing message: " << e.what();
+ }
+#ifndef DISABLEUNIVERSALCATCH
+
+ catch ( ... ) {
+ err() << "exception while serializing the reconstructed message";
+ throw;
+ }
+#endif
+#endif
+ processOutgoingMessage( buffer );
+ sendData_ = binaryInt( buffer.size() );
+ sendData_ += buffer;
+ //out() << "sending: " << toString( buffer );
+
+ DEBUGLOG( "serialized outgoing message of size " << sendData_.size() << " and type " << messages_.identify( mp ) );
+ //The following message indicates that the message's constructor does not correctly fill it's message-info. When this error happens, probably MessageConstructionInfo is not used correctly.
+ needUserUpdate_ = true; ///The connected client may have been a client that created a direct connection to us, and which may still be reachable through an indirect connection, so an update is needed
+}
+
+
+///this is called whenever a connection is successfully established to a server
+ needUserUpdate_ = true; ///The connected server may have been a client we created a direct connection to, and which is still reachable through an indirect connection, so an update is needed
+}
+
+
+bool Client::think() {
+ for ( ClientSessionMap::iterator it = clientSessions_.begin(); it != clientSessions_.end(); ) {
+ if ( !( *it ).second.session.unsafe() ->isRunning() ) {
+ out() << "closing outgoing session because it stopped running";
+ err() << "could not get/create indirect user " << ( *it ).name();
+ continue;
+ }
+ if ( l->online() )
+ continue; ///The user is already online, maybe through a direct connection
+
+ ForwardSessionPointer s = lsession->getForwardSession( l );
+
+ allReceivedUsers.insert( l );
+
+ if ( s ) {
+ ///There already is an open session to the user
+ } else {
+ ///Create a new session to the user
+ users.push_back( l );
+
+ l->setSession( new ForwardSession( identity(), l, msg->info().session().cast<MultiSession>(), logger(), messageTypes(), new HandlerProxy<BasicServer>( this ) ) );
+ registerSessionUser( l ); ///Register the user together with its session, so it's noticed once the session is down.
+ }
+ }
+
+ ///now invalidate all users that the session has a forward-session to but that were not listed by the server, because those probably are offline.
+
+ for ( list<UserPointer::Locked>::iterator it = sessionUsers.begin(); it != sessionUsers.end(); ++it ) {
+ UserPointer::Locked user = getUser( createUser( &msg->source() ) );
+ if ( !user ) {
+ err() << "could not get/lock the user for a forward-message";
+ return 1;
+ }
+
+ ForwardSession* f = new ForwardSession( identity(), user, msg->info().session().cast<MultiSession>(), logger(), messageTypes(), new HandlerProxy<BasicServer>( this ) );
+ f->setUser( f->target() );
+ cl->info().setSession( f );
+
+ if ( user->online() ) {
+ out( Logger::Warning ) << "got indirect message from directly connected user " << user->name() << ", keeping communication indirect";
+ } else {
+ user->setSession( f );
+ }
+
+ processMessage( cl.data() );
+ } else {
+ out() << "could not handle a forwarded message";
+///This macro simplifies the syntax of defining a static type-list. The first parameter is the name of the new type, the other parameters are the types.
+///strips away all information that should stay private, but leaves things like description etc.
+void User::stripForPublic() {
+ password_ = "";
+}
+
+///this function strips all information that is not necessary to generally identify a user(this might strip away more than stripForTarget, and includes passwords and such)
+///This file defines a multi-indexed set(called CrossMap) similar to boost's multi-index, but with simpler api, with support for index-lists, and less efficient.
+ void serialize( Archive & arch, uint version ) {
+ arch & id_;
+ }
+
+ operator uint() const {
+ return id_;
+ }
+};
+
+/**This is a kind of in-memory database that allows storing/sorting items by an arbitrary count of keys
+ * and key-types. The keys are extracted in
+ * the moment an item is inserted. If the keys change, update(..) should be called on the item.
+ *
+ *
+ * It is very similar to the boost multi-index, but the api is a bit easier.
+ *
+ * Advantage against boost's multi-index: One item can be reachable by many indices in the same category,
+ * by using CROSSMAP_DEFINE_CONTAINER(..) and giving such a key-container as to the key-list.
+ * Then the item will be searchable by each key in the list.
+ * (If the value-type is used as key, it will be filled with the key's value by default and no key-extractor needs to be defined for that case)
+ * (Example: multiple filenames may be associated to users, and it is possible to get a list of users for each filename)
+ *
+ * Disadvantage: Less efficient, bigger binary
+ *
+ * @param Value The value-type, should be a type with a default-constructor(is used as Dummy for Functions like operator[] if the key cannot be found)
+ * @param Keys a meta-list containing all keys(using BIND_LIST or Binder<...,...>
+ * @param KeyExtractor (optional) a class that helps extracting the keys from the values
+ * @param rebuildAfterLoad whether serialization should only store a list of values, without the additional maps and the cross-link-data etc.(then every key has to be re-extracted after the archive was loaded, and the structure may be different)
+ */
+
+template <class Value, class Keys, class KeyExtractor = StandardCrossMapKeyExtractor>
+ ///Creates a copy of all key-values which can be used to reference items. This might be used to store a consistent representation of the keys a value was stored under.
+ static KeyValues copyKeyValues( const Value & value ) {
+ return KeyValues( value );
+ }
+
+ ///When KeyValues are given from outside, they do not have to be recomputed by using the KeyExtractor.
+ Id insert( const KeyValues & keyValues, const Value & value ) {
+ uint id = currentId_++;
+ values_.insert( make_pair( id, value ) );
+ insertToData( keyValues, value, id );
+ return id;
+ }
+
+ Id insert( const Value & value ) {
+ KeyValues keys( value );
+ return insert( keys, value );
+ }
+
+ ///Returns the Id of the removed Value, or zero on fail
+ Id remove
+ ( Id id ) {
+ if ( id ) {
+ typename ValueMap::iterator it = values_.find( id );
+ if ( it == values_.end() )
+ return 0;
+
+ removeFromData( ( *it ).second.keyValues, id );
+ values_.erase( id );
+ return id;
+ } else {
+ return 0;
+ }
+ }
+
+ ///Removes the item the iterator currently points at
+ bool remove
+ ( const Iterator& it ) {
+ if ( !it )
+ return false;
+ return ( bool ) remove
+ ( it.id() );
+ }
+
+ ///Removes all items the iterator iterates over
+ uint removeAll( const Iterator& it ) {
+ if ( !it )
+ return false;
+ Iterator i = it;
+ i.restart();
+ uint ret = 0;
+ while ( i ) {
+ if ( remove
+ ( i.id() ) ) ret++;
+ }
+ return ret;
+ }
+
+ ///Returns the Id of the removed Value, or zero on fail
+ Id remove
+ ( const KeyValues & keyValues, const Value & value ) {
+ Id id = find( keyValues, value );
+ return remove
+ ( id );
+ }
+
+ ///Returns the Id of the removed Value, or zero on fail
+ Id remove
+ ( const Value & value ) {
+ KeyValues keys( value );
+ return remove
+ ( keys, value );
+ }
+
+ ///@return 0 if the item was not found, else the id of a matching value */
+ Id find( const KeyValues & values, const Value & value ) {
+A client-server-system is needed, which will be implemented as a static C++-library.
+
+The library will provide classes and functions to:
+- run a client in a seperate thread.
+- run a server in a seperate thread.
+
+The final link between the program using the library and the library will be established by virtual member-functions.
+
+The library will then be used by kdevelop to connect to a server, or to open an own server. The whole library will only depend on STL and common-c++.
+Additionally a standalone server-program will be developed that opens a server using the library, independent from kdevelop.
+
+Objects that have the same number will share one implementation
+
+What the server implemented in the library has to do:
+- keep a list of (user, password, additional authentication-date, additional user-information, user-log) tuples
+- [2] store, manage, and use some options like whether anonymous users are allowed using a storage-class that allows simple changing, storing and restoring of the settings(the storage is done by the program that implements the server)
+- [3] provide a unified message-class for messages to either the server, or to other clients(the clients can communicate through the server or directly, but always moderated by the server). It will allow the clients sending each other messages of types the server does not know and would not understand.
+- provide a set of administrative messages for communications with clients.
+- store messages that are flagged to be safely delivered until the target-client comes online and gives a reply that it got the message
+
+What the client implemented in the library has to do:
+- keep a log of all interesting communication communication
+- keep and manage list of connected users
+- care about most of the implementation-details, and offer the client-program a simple interface to just override interesting high-level functions
+- [2] store, manage, etc. settings
+- [3] provide additional derived message-classes to communicate with other clients through the server
+- implementation of the client will be finished together with the kdevelop-plugin
Property changes on: tags/unmaintained/4/kdevelop4-extra-plugins/teamwork/lib/network/plan
+ result = KIO::NetAccess::upload( temp->name(), KUrl( m_destination ), (QWidget*)parent() );
+ }
+
+ if ( !result )
+ {
+ emit error( i18n( "<qt>Could not upload the temporary file to the destination location <b>%1</b>. The temporary file is still available under: <b>%2</b>. You can manually copy it to the right place.</qt>", m_destination, temp->name() ) );
+ /** unregister a previously registered notifier */
+ void unregisterNotifier() const {
+ notify_ = 0;
+ }
+
+ BOOST_SERIALIZATION_SPLIT_MEMBER()
+ private:
+
+ ///Erase and insert could be public, the only problem is that the change-notification would become more complicated(currently notification is done in linear measure)
+
+ void insert( int line, int column, const String& text ) {
+#ifdef EXTREMDEBUG
+ cout << "insertion at " << line << ":" << column << " length " << text.length() << " of \"" << text << "\"" << endl;
+ checkConsistency();
+#endif
+ uint len = text.length();
+ if( len == 0 ) return;
+ int currentStart = 0;
+ bool nobreak = true;
+ String endAppend; ///Needs to be appended to the last line inserted
+ int l = line + 1;
+
+ for ( uint a = 0; a < len; a++ ) {
+ if ( text[ a ] == lineBreak ) {
+ if( nobreak ) {
+ ///It is the first line, put it into the insertion-line and break.
+ int insertLength = a - currentStart;
+ String& curLine( *text_[line] );
+ int removeLength = curLine.length() - column;
+ DYN_VERIFY_SMALLERSAME( 0, removeLength );
+ ///Copy the last part of the line it is inserted to, and append it to the last line inserted.
+ ///Remove 'length' characters in line 'line', starting at column 'column'. If the length is longer than the rest of the line, this will continue deleting in the next line.
+ void erase( int line, int column, int length ) {
+ * @param state The state which the text should have after the change. The default-parameter changes to the current state.
+ * If force is enabled, conflicts will be ignored instead of stopping.(The resulting text may be damaged)
+ */
+ bool changeState( const VectorTimestamp& state = VectorTimestamp(), bool force = false );
+
+ /**
+ * Removes everything above the current state.
+ * */
+ void cut();
+
+ /**rewinds to a position that is smaller/same than state in every index
+ * @param state the state of the document will be smaller than that state
+ * */
+ bool rewind( const VectorTimestamp& state );
+ ///The given state must be bigger/same than the current state in every stamp
+ bool advance( const VectorTimestamp& state );
+
+ void dump() const;
+
+ /** @return the first replacement with the given primary index, or zero */
+ ReplacementPointer first( uint index ) const;
+
+ /** @return the first replacement with the given primary index, that is currently not applied to the text(its primary stamp is higher than the current state's stamp on that index), or zero */
+ ReplacementPointer firstUnapplied( uint index ) const;
+
+ /** @return the last replacement with the given primary index, or zero */
+ ReplacementPointer last( uint index ) const;
+
+ /** @return the last replacement with the given primary index, that is currently applied to the text(its primary stamp is same as the current state's stamp on that index), or zero */
+ ReplacementPointer lastApplied( uint index ) const;
+
+ /**
+ * @return the highest stamp with that index
+ * */
+ Timestamp highestStamp( uint index ) const;
+
+ /**Returns the internal replacement-objects that can be used for example to disable
+ * a single replacement. This is dangerous, they should not be altered.
+ ///Returns the offset from the 'from' position to the 'to' one. If position is set, all replacements that are behind that position(given in from-space) will be excluded while computation.
+ OffsetMap offset( VectorTimestamp from, VectorTimestamp to, int position = INVALID_POSITION );
+
+ ReplacementPointer m_dummy;
+
+ ///Changes the state to the newest one available
+ ///Checks whether "link" should be put into the "links"-map. If it should
+ void updateLink( uint index, ReplacementPointer link );
+#endif
+
+ friend class DynamicText;
+ VectorTimestamp m_state; ///Each Replacement has a unique primary stamp, m_next has the same plus 1, m_prev the same minus one.
+
+ SimpleReplacement m_replacement;
+
+ ///One is weak one is not, so a chain of replacements cannot keep itself alive. Once the first is lost, all are lost.
+ ReplacementPointer m_next;
+ WeakReplacementPointer m_prev;
+
+#ifdef USELINKS
+ std::vector<WeakReplacementPointer> m_links; ///This maps the index-numbers of other Collaborators to their first replacement that uses the timestamp of this Replacement.
+#endif
+
+ bool m_enabled;
+};
+
+struct DYNAMICTEXT_EXPORT ReplacementChain {
+ ReplacementPointer first, last;
+ template<class Archive>
+ void serialize( Archive& arch, const uint ) {
+ arch & first & last;
+ }
+};
+
+struct DYNAMICTEXT_EXPORT ReplacementId {
+ uint primaryIndex;
+ Timestamp stamp;
+ ReplacementId( uint i = 0, Timestamp st = 0 ) : primaryIndex( i ), stamp( st ) {}
+///A pair that contains an index and the sum of all values before that index
+struct DYNAMICTEXT_EXPORT IndexAndSum {
+ int index;
+ int sum;
+};
+
+///Everything may throw DynamicTextError. Every pointer to Nodes, except those from parent-node to slave-node, must be weak-pointers.(because the ref-count is important for ownership-stuff)
+class DYNAMICTEXT_EXPORT Node : public Shared {
+ typedef std::list<NodePointer> ListType;
+ public:
+ Node( bool isLeaf, Node* parent );
+
+ ///If this node is already owned by parent, returns this. Else creates a copy owned by parent.
+ inline Node* makeOwn( Node* parent );
+ Node* setParent( Node* parent );
+
+ ///Can be used to add/subtract a value from the sum(should only be directly called on end-items without children, and the index-range is only expanded, never shrinked.)
+ inline void update( const int sumDif, const int indexCountDif ) {
+ void splitRange( int splitPosition, Node* insertNode );
+
+ void removeChild( Node* n );
+
+ friend class EndIndexCompare;
+ /*WeakNodePointer*/Node* parent_; ///if this is zero, the node is available for taking, else it must be copied.
+ ListType nodes_;
+ int nodeCount_; ///Cache for nodes_.size()
+ int sum_; ///Sum over all sub-elements
+ int indexCount_; ///The count of indices this node and all subnodes cover
+ bool isLeaf_;
+};
+
+///This object can be copied around and changed at will, no other instances of it will be affected, while still staying efficient(Because of implicit node-sharing)
+class DYNAMICTEXT_EXPORT Map : public WeakShared {
+ public:
+ typedef std::vector< int > SumVector; ///Pairs of (index, sum-value). Muss dicht sein.
+ ///preferredOrder says how many slave-nodes one node should ideally have. Higher values -> faster manipulation, lower values -> faster lookup
+ Map( const SumVector& summands = SumVector() );
+ Map( const Map& rhs );
+ ~Map();
+
+ Map& operator = ( const Map& rhs );
+
+ ///Returns the sum over all indices
+ int sum() const;
+ ///Returns the values of all indices up to(not including) index summed together
+ int sum( int index ) const;
+
+ ///Returns the index that the given sum falls into. Warning: indices that have a value of zero cannot be mapped back with this function.
+ int index( int sum ) const;
+
+ void indexAndSum( int sum, IndexAndSum& targ ) const;
+
+ bool hasIndex( int index ) const;
+ // Map rebuild();
+
+ ///Complexity: O(1)
+ int indexCount()const ;
+
+ ///Returns the value of that specified index
+ int indexValue( int index ) const;
+
+ ///Returns the previous value of that index. The value must not be zero, because that would not allow consistent mapping back(exception is thrown)
+ int setIndexValue( int index, int value );
+
+ ///Returns the new value of that index. If the value becomes zero, the index cannot be mapped back through index(..) anymore.
+ int changeIndexValue( int index, int diff );
+
+ ///Inserts an index at position "index" with the value "value"
+ void insertIndex( int index, int value = 0 ) ;
+
+ /**Efficiently inserts a range of indices with
+ * same value(may be zero) into the tree.
+ * @param position Starting-position of the range
+ * @param size Count of indices the range will occupy
+ * @param value The value each index of the range will get(the whole range will have the sum size*range)
+ * $
+ */
+ void insertRange( int position, int size, int eachValue = 0 );
+
+ ///Removes one index at position index, returns the personal sum that index had associated
+///@TODO: Dispatch the messages in a more flexible way: Allow any client to register with an arbitrary message-type that he wants to get(including all sub-messages). DynamicMessageDispatcher can do this. Use that, and make the way messages are connected more flexible.
+///This is a class that helps detecting when the document is deleted and then deleting the smartcursor, also it automatically creates the cursor. @todo replace with QOwnedPointer
+ int answer = KMessageBox::warningYesNo( KDevTeamworkPlugin::staticCore()->uiController()->activeMainWindow()->window(), i18n( "The buffer of %1 is modified, should the content be replaced?" , m_fileName ) );
+ ///It might be better to model the edit by one removal and one insertion, because that allows better resolution of conflicts.(Think about if it should be like that)
+///These helpers can be used to plug own actions into the tree-structure of the collaboration-manager. To get active, a CollaborationTreeActionPointer must be set as the UserData-entry in the model.
+struct CollaborationTreeAction : public Shared {
+ virtual void fillContextMenu( QMenu* menu ) = 0;
+ virtual void doubleClicked() {
+ }
+ virtual void clicked() {
+ }
+};
+
+///This class will call a fillContextMenu-function in the targetet-class
+template <class targetet, class ValueType = int>
+struct StandardCollaborationTreeAction : public CollaborationTreeAction {
+ QPointer<targetet> target;
+ ValueType var;
+
+ StandardCollaborationTreeAction( targetet* t, const ValueType& v ) : var( v ), target( t ) {}
+ StandardCollaborationTreeAction( targetet* t ) : target( t ) {}
+ ///This can be used to speed up the search if multiple positions should be found within one text(then this object should be created outside and reached to findInText.
+///If the parent is destroyed, VectorTimestampEditor is destroyed too. Also it destroys itself if "finish" is clicked, or the dynamic text is destroyed.
+class VectorTimestampEditor : public QObject, public SafeLogger {
+ Q_OBJECT
+ public:
+ ///If embed is false, a new dialog will be created
+ if ( endLine < line || ( endLine == line && endCol < col ) ) {
+ int l = line, c = col;
+ line = endLine;
+ col = endCol;
+ endLine = l;
+ endCol = c;
+ out( Logger::Warning ) << "Found end-marker before start-marker:" << line << ":" << col << "-" << endLine << ":" << endCol;
+ }
+ }
+
+ if ( line == -1 ) {
+ out( Logger::Warning ) << "Could not find reference-position for" << l->start().asText() << "in text of length "<< m_currentSearchInstance.text().length();
+ if ( msg->info().isIncoming() && msg->info().session() ) {
+ ///Send a notification that the message arrived to the other side.
+ //globalMessageSendHelper().sendReply<KDevSystemMessage>( msg, KDevSystemMessage::ActionSuccessful ); //this is also done for KDevTeamworkTextMessage now
+ ///This can be used by messages in other threads to send a request that their state(currently only icon) has changed
+ void updateMessageInfo( MessagePointer );
+
+ signals:
+ ///This is called whenever the local client was destroyed or created, the current client is given as parameter(may be null). Whenever this is emitted, all UserPointers become invalid.
+ globalMessageSendHelper().sendReply<KDevSystemMessage>( msg, KDevSystemMessage::ActionFailed, "no fitting patch available, or patch could not be locked" );
+ log( "got a patch-request, but the requested patch could not be found or could not be locked", Warning );
+This header implements a very simple signalling-system that uses the SafeSharedPtr or WeakSafeSharedPtr-facilities to be thread-safe.
+*/
+
+#ifndef SAFESIGNALLER_H
+#define SAFESIGNALLER_H
+
+#include <QObject>
+#include <ext/hash_set>
+#include "lib/network/safesharedptr.h"
+#include "lib/network/weaksafesharedptr.h"
+
+struct SignalProxyBase {
+ virtual void signal() = 0;
+ virtual ~SignalProxyBase() {
+ };
+};
+
+template<class Type>
+struct hashCall {
+ size_t operator() ( const Type& rhs ) const {
+ return (size_t)rhs.unsafe();
+ }
+};
+
+///An object of this type represents a signal that multiple receiver-objects can be bound to. To get a function similar to qt's auto-disconnect, WeakSharedPtr<...> may be used as Target-type. If SafeSharedPtr is used, connected objects will be kept alive until the SafeSignal is destroyed or the object disconnected.
+ SignalProxy( const TargetType& target, const Signal& sig ) : sign( sig ) {
+ s.connect( target );
+ }
+ virtual void signal() {
+ s( sign );
+ }
+};
+
+///This is a very simple safe-signaller object that can be used to easily bind safe signals into QActions etc. The signal-type may be any copyable object. The given object will be copied, and sent once the signal is emitted.
+///This file contains a few classes that I currently don't know where else to put
+
+using namespace Teamwork;
+
+///Since deleting the client by a reference-counter in some meta-object leads to crashes, this is used to keep the client alive longer and delete it as last.
+class LaterDeleter : public QObject {
+ Q_OBJECT
+ public:
+ LaterDeleter( const KDevTeamworkClientPointer& c );
+ ~LaterDeleter();
+ KDevTeamworkClientPointer m_c;
+};
+
+class SafeTeamworkEmitter : public QObject, public Shared {
+ * - Once developer starts a collaboration-session on an arbitrary set of files, he can invite an arbitrary count of collaborating developers to join it.
+ * - He can only host one collaboration-session at a time.
+ * - Once the session is closed, he is asked whether he'd like to store the changes of the session as a patch to the patches-list(that way he may also unapply the changes if he saved them).
+ * Client:
+ * - A client gets an invitation and can accept it.
+ * - The client can only be part of one collaboration-session at a time.
+ * - Once the session is closed, he is asked whether the result of the session should be stored as a diff-file to the patches-list.(that way it may be applied to the local tree)
+ *
+ * Implementation: See DynamicText
+ *
+ * */
+
+/**Algorithm for the FileCollaboration:
+ * - Each FileCollaboration-message that is sent gets a personal sequence-number(which is like a timestamp, the "count of locally happened events")
+ * that can be used to see which state of the communication it was sent in(and can be used to resolve causalities)
+ * - Each FileCollaboration-session has a vector containing all current sequence-numbers
+ * - Each FileCollaboration-message is sent together with that vector, so conflicts may be resolved.
+ * - Whenever the master-session sends a FileResynchronize-message, the local version of the slave-session is totally updated
+ ///Tries to find out whether the patch is applied by using the patch-command in dry-run mode. Only works with patch-files(not commands). Fills the result into the given patch
+ ///Tries to determine the patch-depth(by searching for -pX parameters in the apply-command. Defaults to zero.
+ uint patchDepth() const;
+
+ ///Tries to determine the tool to be used for applying the patch. Defaults to "patch"
+ string patchTool( bool reverse = false ) const;
+
+ ///Tries to determine the params for applying the patch. If none are given, uses reasonable default-parameters. If reverse is true, the unapply-parameters are given.
+ ///This returns the LocalPatchSourcePointer which was used to request the patch(only valid on sender-side, to cache the apply-commands etc. for security)
+ out( Logger::Warning ) << "got a file-synchronization from" << userName << "for \"" << smsg->fileName() << "\", but new files from collaborators are not allowed.";
+///For higher orders to work, the sum-type has to be signed
+#define DEFAULTSUMTYPE int
+#define DEFAULTORDER 2
+
+
+///State-based-build can only nearly complete with extreme compiler-parameters set, although it should theoretically be faster, if the compile would optimize it the right way.
+
+//#define STATEBASEDBUILD
+
+namespace FuzzySearch {
+
+/**
+ * How should all the differences be weighed together to a compound difference?
+ *
+ * The weighting still needs some work.
+ *
+ * */
+
+template < class Compare1, class Compare2, class Then, class Else >
+class IfEqual {
+public:
+ typedef Else Result;
+};
+
+template < class Compare, class Then, class Else >
+class IfEqual<Compare, Compare, Then, Else> {
+public:
+ typedef Then Result;
+};
+
+template <class Item>
+class PrimitiveVector {
+ Item* data_;
+ uint size_;
+ public:
+ PrimitiveVector() : data_( 0 ), size_( 0 ) {}
+ ;
+
+ ~PrimitiveVector() {
+ if ( data_ )
+ delete[] data_;
+ }
+
+ ///All data is lost when this is called
+ void rawResize( unsigned int i ) {
+ if ( size_ == i )
+ return ;
+ size_ = i;
+ if ( data_ )
+ delete[] data_;
+ if ( !i ) {
+ data_ = 0;
+ } else {
+ data_ = new Item[ i ];
+ }
+ };
+
+ Item& operator [] ( uint index ) {
+ return data_[ index ];
+ }
+
+ const Item& operator [] ( uint index ) const {
+ return data_[ index ];
+ }
+
+ uint size() const {
+ return size_;
+ }
+};
+
+///unsigned int is ok for document-sizes of up to about 16 Megabytes, 64-bit integers create problems here
+using namespace std;
+template <int maxDepth, class SumType = DEFAULTSUMTYPE>
+ /** This takes a complete reference-filename which may include folders(those will be created), and from which extension and name will be extracted.(see function above)
+/**This cares about the "send message"-tab in the kdevteamwork user-interface by updating it, according to the current selection in the current document.
+ container.appendChild( doc.firstChildElement().cloneNode() ); ///While serialization, there is one "boost_serialization"-child created. Only that should be exported.
+}
+
+/**This deletes the previous element of the given name, and replaces it with a new one containing the data.
+ *the given object-type must already be a name-value-pair(see NVP(...) )
+Some notes about this plugin from commit-digest/2006-09-10:
+When I first heard about Summer Of Code I thought about proposing a project called "Advanced Code Completion for KDevelop 3"(with full support for templates, comments, etc.), but when that didn't go down well with most of the KDevelop developers (since they were already focused on KDevelop 4), I just started implementing it. I spent a lot of time working on that until SOC started (and even quite some time since then), and you can see the result in the current KDevelop 3.4 SVN tree. I finished everything I planned and more.
+
+Some of the features:
+Intelligent resolution of types.
+Support for templates like for example shared pointers.
+Support for implicit template-instatiation
+Nicer and more useful completion-list with items ordered in a useful way and indented by inheritance-depth, with popups that include comments and any other interesting information
+Many improvements in the parser, for example all comments are extracted and used in any possible way, macros are dealt with correctly, Enums are handled in a more useful way, and much more
+A powerful navigation-menu: Click any item within a function and see it's real type, a trace of all typedefs on the way to that type, information on all involved typedefs, classes, variables, functions, etc., and the same as a submenu for all involved template-parameters, argument-types, base-classes, etc.
+Improved jump-to-menus and navigation-bar.
+Highlighting of function-names in the navigation-bar and class-tree.
+And countless other major improvements in code-completion and navigation.. see the feature list of the beta releases or the commit log to see all of them.
+
+KDevelop 3 is doing well feature-wise, but currently lacks developers since the focus already is on KDevelop 4, but it'll take a long time until that is really usable, so I hereby encourage anyone interested to start using the SVN version of KDevelop 3.4 and hunt down a few bugs, to make sure that a stable version can be released soon.
+
+Collaboration through the internet is fundamental to most open-source-software. Almost any open- and even closed-source-software might profit from better collaboration-possibilities. If you work for a project that has a collaboration-server, you can directly ask other developers working on the same project for very specific help, patches can be reviewed very quickly, and discussion can instantly take place within the documents themselves. File Collaboration may also be useful for discussion of new ideas, teaching, for friends less experienced in programming requesting help (Or am I the only one who is asked how to program something through ICQ again and again?), and simply because it's cool ;)
+
+So I took the basic Idea for the Summer Of Code project "KDevelop Teamwork" from the Wiki where someone proposed it, and developed it using my own Ideas, trying to add some of the teamwork features I always missed in any IDE I ever used. :)
+
+Generally it consists of four parts:
+Client/Server Architecture
+I created a multi-threaded library for networking, including client/server- and user-management, and a standalone server not dependent on Qt which can be run on any webserver and administrated using the console.
+
+File Collaboration
+An arbitrary count of developers can collaboratively edit a dynamic set of files, and the edited documents can be dynamically transformed (for example chosen changes made by exactly one user could be undone, which will allow single-user undo, redo, etc.)
+
+Conversation
+All users connected to any of the connected servers, as well as the servers themselves (in the case they are not standalone) can be contacted by using instant messages, collaboration-requests, patch-requests, in-document messages, etc.
+
+The most interesting message for conversation is the in-document message: It can reference a position or piece of text within any document, and the receiver of the message automatically jumps to that document and highlights the referenced piece of text as the message is selected, and pops up a chat-window within the document itself at the found position, where other messages of the same thread may be selected and discussion can take place.
+
+Any answers written into the chat will automatically reference the currently selected text. Referencing is simply done by marking a piece of text before sending a message, and the reference-position is being found by a fuzzy algorithm I developed which tries to find the correct place even within totally different documents (and is pretty successful at doing so).
+
+Patch Management
+Every user can manage a set of patches (or other file types) for each project. They can either be files or dynamic patches which are automatically retrieved from commands on request (for example "svn diff"). Patches can be easily shared directly through the developer-list, using different access-levels.
+
+A modified version of Kompare's diff3-library is used to get information from patches. Using that the patch-manager can automatically highlight all changes made by an applied patch within all documents, and allows you to easily browse through those positions so you can review the patch within the correct context and directly discuss about it using in-document messages.
+
+They can be applied/reverted to the local tree using single buttons, and for diff-files it is possible to automatically determine whether the patch is already applied or not. If problems arise within the patching process they can be dealt with using an embedded console in the patch-management-window.
+It is important that all those features are well integrated: For example you can store the results of a file-collaboration-session as a patch into your local patches-list, and thereby share it with other developers and easily revert it at any time, and you can use in-document messages directly within the temporary file-collaboration files.
+
+To store all the project-specific data (like patches), a ".teamwork" subfolder is created within the project directory.
+
+I encountered many problems during development. Apart from one harddisk crash, the most annoying problem was the very unstable and (in the begginning) difficult to compile kdelibs/qt-copy/qdbus/kdesupport etc. combination, which again and again cost me days and hours just to get it working.
+
+The most challenging part was the file-collaboration. Getting a simple form of collaborative editing to work was quite fast, but making the document-transformation work correctly in all test-cases really took some time, and I had to finish it after the deadline without stress (luckily I didn't mention anything like it in my application ;)). The trick was writing everything down and trying to solve it mathematically as I learnt at university, unfortunately I got that idea after days of unsuccessful hacking and trying - well... you live and learn :)
+
+I was able to finish nearly everything I planned until the deadline, but unfortunately I missed the week I planned in my application for "debug, make it perfect", so that work is missing, and it shows :) Most of the work I did after the Summer Of Code ended was in other, more important parts (finishing the text-transformation algorithm, or fixing file-collaboration which stopped working after a kdelibs-update), but it is work I'll surely do. Then there's one other big problem, the executable-size when the executable is built with debug-information. During my work on this project I fell in love with templates and meta-programming, but I think the main reason is my use of boost serialization, I'll still have to work on that. Then of course i'll need some nice icons. :)
+
+ Now that the Summer Of Code has concluded, the first thing I will do is working intensively for the institute of my university that paid me the whole year, and that I neglected since March because of my work for KDevelop 3 Code Completion and then the Summer Of Code. Of course, I won't forget KDevelop and KDE in general, since I like the Open-Source Idea a lot. I started working on Open-Source Software before I started the Summer Of Code, and I won't stop it now that it's over :) I'll keep maintaining the teamwork-module (and of course finish it), I'll keep caring about KDevelop, and maybe I'll start a project to make KDE more Tablet PC friendly if I can find the time for it.
Property changes on: tags/unmaintained/4/kdevelop4-extra-plugins/teamwork/README
+ ///@todo create a sub-class that contains macroExpansion. It is only needed in the location-table and everything using not, not actually in the anchors.
+ KDevelop::SimpleCursor macroExpansion; //Zero if this position was not transformed through a macro-expansion, else a number that identifies the expansion
+ * Is called when the header-section ended. The header-section is the top of the file, that consists only if #include, #define, and #ifdef statements, or comments.
+ * It ends as soon as anything else is found. You can use stream.toEnd() to stop the preprocessing.
-K_EXPORT_PLUGIN(QtDesignerPluginFactory(KAboutData("kdevqtdesigner","kdevqtdesigner", ki18n("Qt Designer"), "0.1", ki18n("A GUI form designer for the Qt toolkit"), KAboutData::License_GPL)))
-
-class QtDesignerDocumentFactory : public KDevelop::IDocumentFactory
-# run valgrind's memory error checker on all tests.
-# filter uninteresting errors and known false positives
-# eg staticly initialized memory from libraries like libfontconfig
-#
-
-from os import system, remove
-from sys import exit, stdout
-from subprocess import Popen, PIPE
-from xml.dom.minidom import parse, parseString
-
-def garbage(line):
- ''' filter for valgridn output'''
- return not line.startswith('<unknown program name>') and \
- not line.startswith('profiling:') and \
- line.find('</valgrindoutput>') # problem is that valgrind erroneously puts multiple of these end-document entries if processes are spawned _inside_ the exe under investigation
-
-def isValgrind3_5OrHigher():
- process = Popen("valgrind --version", stdout=PIPE, shell=True)
- process.wait()
- valgrindOutput = process.stdout.read().strip()
-
- import re, string
- version = re.search("[0-9]+(.[0-9]+)*", valgrindOutput).group(0)
- version = string.split(version, ".")
-
- if map(int, version) < [3, 5]:
- return False
- else:
- return True
-
-def memcheck(test):
- ''' run valgrind-memcheck on test in testdir. return xml output as string '''
- //i18nc can't be used. It seems that at this moment (2009-09-04) only
- //plain text can be used in the outputview
- //errorList << i18nc("@info", "Failed to start <filename>%1</filename>. Make sure that the path to <command>geninfo</command> is specified correctly in <interface>Settings->Configure KDevelop...->Lcov Preferences->geninfo Executable</interface>.", m_lcov->program().first());
- errorList << i18n("Failed to start '%1'. Make sure that the path to geninfo is specified correctly in Settings->Configure KDevelop...->Lcov Preferences->geninfo Executable.", m_lcov->program().first());
- } else if (error == QProcess::Crashed) {
- errorList << i18n("geninfo process crashed.");
- } else if (error == QProcess::Timedout) {
- errorList << i18n("geninfo process timed out.");
- } else if (error == QProcess::WriteError) {
- errorList << i18n("Failed to write to geninfo process.");
- } else if (error == QProcess::ReadError) {
- errorList << i18n("Failed to read from geninfo process.");
- } else if (error == QProcess::UnknownError) {
- errorList << i18n("Unknown geninfo process error.");
- <string comment="@info:whatsthis"><para>Configuration for coverage report colors.</para>
-
-<para>In the directory view of the coverage report, each directory coverage percentage is represented using a color.</para>
-
-<para>The color associated to each percentage is taken from a color range, made up of several stop points. Stop points represent a color at a specific percentage.</para>
-
-<para>A color range has two different and independent modes: discrete and gradient. In discrete type, all percentage values between the previous stop point and the current one have the color of the current one. In gradient type, the values are interpolated between the previous stop point's color and the current stop point's color.</para></string>
- if (KMessageBox::warningContinueCancel(this, i18nc("@info", "Remove all the .gcda files in <filename>%1</filename> directory and, recursively, in its subdirectories?", m_targetDirectory->url().toLocalFile()),
-Set the directory to generate the report for and start the scan.
-
-Once finished, you can select the directories in the coverage report to see their statistics. A more detailed report can be seen for each directory, showing all the covered files in it. Each file can also be shown in the editor, annotated with line by line coverage information.</string>
- <string comment="@info:tooltip">Use the build path from the selected project</string>
- </property>
- <property name="whatsThis">
- <string comment="@info:whatsthis">When one of the opened projects is selected, the directory to scan for <filename>.gcda</filename> files will be set to the build path of that project.</string>
- </property>
- <property name="text">
- <string comment="@label:listbox">Get from project:</string>
-In directory mode, the report summarizes the coverage with a list of all the directories that contain at least one covered file. It could include directories out of the specified path, depending on the files included in the source code.
-
-In file mode, all the files of the selected directory are shown. If several directories are selected, only the files of the last selected directory are shown. Double clicking on any of the items shows the associated file in the editor, annotated with the coverage information.
-
-You can change between directory and file mode using left and right keys.</string>
-Comment=This plugin displays a graphical view of the definition-use chain produced by the C++ support
-Comment[bs]=Ovaj dodatak prikazuje grafički prikaz definicije lanca upotrebe, izrađenog od strane C++ podrške
-Comment[ca]=Aquest connector mostra una vista gràfica de la cadena de definició-ús produïda per la implementació del llenguatge C++
-Comment[ca@valencia]=Aquest connector mostra una vista gràfica de la cadena de definició-ús produïda per la implementació del llenguatge C++
-Comment[de]=Dieses Modul zeigt eine grafische Ansicht der Definition-Use-Chain, die durch die Unterstützung für C++ erzeugt wurde.
-Comment[en_GB]=This plugin displays a graphical view of the definition-use chain produced by the C++ support
-Comment[es]=Este complemento muestra una vista gráfica de la cadena definición-uso producida por la implementación de C++
-Comment[et]=See plugin näitab graafiliselt C++ toetusel loodud definitsiooni-kasutuse ahelat.
-Comment[fr]=Ce module externe affiche une vue graphique de la chaîne définition-utilisation produite par la prise en charge du C++
-Comment[gl]=Este complemento mostra unha vista gráfica da cadea de definicións e usos producida pola compatibilidade con C++.
-Comment[it]=Questa estensione mostra graficamente la definition-use chain (DUChain) prodotta dal supporto per il linguaggio C++.
-Comment[nl]=Deze plugin geeft een grafische weergave van door C++ ondersteuning geproduceerde definition-use Chain
-Comment[pl]=Wtyczka ta wyświetla widok graficzny łańcucha definicji-użycia wyprodukowany przez obsługę C++
-Comment[pt]=Este 'plugin' apresenta uma vista gráfica sobre a sequência de definições-usos que é produzida pelo componente da linguagem C++
-Comment[pt_BR]=Este plugin apresenta uma vista gráfica sobre a sequência de definições-usos que é produzida pelo suporte ao C++
-Comment[sv]=Insticksprogrammet visar en grafisk vy av definition-användningskedjan skapad av C++ stödet.
-Comment[uk]=За допомогою цього додатка можна переглянути у графічному вигляді ланцюжок «Визначення-Використання», створений частиною, що відповідає за мову програмування C++.
-Comment[x-test]=xxThis plugin displays a graphical view of the definition-use chain produced by the C++ supportxx
-Name=DUChain View
-Name[bs]=DUChain pregled
-Name[ca]=Visualització de cadena DU
-Name[ca@valencia]=Visualització de cadena DU
-Name[de]=DUChain-Ansicht
-Name[en_GB]=DUChain View
-Name[es]=Vista DUChain
-Name[et]=DU-ahela vaade
-Name[fr]=Affichage DUChain
-Name[ga]=Amharc DUChain
-Name[gl]=Vista de DUChain
-Name[it]=Vista DUChain
-Name[nl]=DUChain weergave
-Name[pl]=Widok DUChain
-Name[pt]=Área de Definições-Usos
-Name[pt_BR]=Área de Definições-Usos
-Name[sk]=Prehliadať DUChain
-Name[sv]=Visning av definition-användningskedja
-Name[uk]=Перегляд ВВ-ланцюжка
-Name[x-test]=xxDUChain Viewxx
-GenericName=DUChain View
-GenericName[bs]=DUChain pregled
-GenericName[ca]=Visualització de cadena DU
-GenericName[ca@valencia]=Visualització de cadena DU
-GenericName[de]=DUChain-Ansicht
-GenericName[en_GB]=DUChain View
-GenericName[es]=Vista DUChain
-GenericName[et]=DU-ahela vaade
-GenericName[fr]=Afficheur DUChain
-GenericName[ga]=Amharc DUChain
-GenericName[gl]=Vista de DUChain
-GenericName[it]=Vista DUChain
-GenericName[ja]=DUChain ビュー
-GenericName[nds]=Dbkeed-Ansicht
-GenericName[nl]=DUChain weergave
-GenericName[pl]=Widok DUChain
-GenericName[pt]=Área de Definições-Usos
-GenericName[pt_BR]=Área de Definições-Usos
-GenericName[sk]=Prehliadať DUChain
-GenericName[sv]=Visning av definition-användningskedja
-GenericName[tr]=DUChain Görünümü
-GenericName[uk]=Перегляд ВВ-ланцюжка
-GenericName[x-test]=xxDUChain Viewxx
-ServiceTypes=KDevelop/Plugin
-X-KDE-Library=kdevduchainview
-X-KDevelop-Version=7
-X-KDevelop-Category=Project
-X-KDE-PluginInfo-Name=kdevduchainview
-X-KDE-PluginInfo-Author=Hamish Rodda
-X-KDE-PluginInfo-License=GPL
-X-KDevelop-Mode=GUI
Property changes on: trunk/playground/devtools/kdevelop4-extra-plugins/duchainviewer/kdevduchainview.desktop
-K_EXPORT_PLUGIN(KDevDUChainViewFactory(KAboutData("kdevduchainview","kdevduchainviewer",ki18n("DUChain View"), "0.1", ki18n("A simple tool to view the raw DUChain"), KAboutData::License_GPL)))
-
-class DUChainViewFactory: public KDevelop::IToolViewFactory
- * Is called when the header-section ended. The header-section is the top of the file, that consists only if #include, #define, and #ifdef statements, or comments.
- * It ends as soon as anything else is found. You can use stream.toEnd() to stop the preprocessing.
- ///@todo create a sub-class that contains macroExpansion. It is only needed in the location-table and everything using not, not actually in the anchors.
- KDevelop::SimpleCursor macroExpansion; //Zero if this position was not transformed through a macro-expansion, else a number that identifies the expansion
-K_EXPORT_PLUGIN (KdevPlugFactory (KAboutData ("kdevpreprocessor","kdevpreprocessor", ki18n ("Preprocess the Current File"), "0.1", ki18n ("Preprocess the Current File"), KAboutData::License_GPL)))
- connect (m_actionPreprocess, SIGNAL (triggered (bool)), this, SLOT (preprocess()));
- m_actionPreprocess->setToolTip (i18n ("Preprocess the Current File"));
- m_actionPreprocess->setWhatsThis (i18n ("<b>Preprocessor</b><p> View the preprocessor ouput, the content of included files will not be displayed</p>"));
- container.appendChild( doc.firstChildElement().cloneNode() ); ///While serialization, there is one "boost_serialization"-child created. Only that should be exported.
-}
-
-/**This deletes the previous element of the given name, and replaces it with a new one containing the data.
- *the given object-type must already be a name-value-pair(see NVP(...) )
- ///This can be used by messages in other threads to send a request that their state(currently only icon) has changed
- void updateMessageInfo( MessagePointer );
-
- signals:
- ///This is called whenever the local client was destroyed or created, the current client is given as parameter(may be null). Whenever this is emitted, all UserPointers become invalid.
-///These helpers can be used to plug own actions into the tree-structure of the collaboration-manager. To get active, a CollaborationTreeActionPointer must be set as the UserData-entry in the model.
-struct CollaborationTreeAction : public Shared {
- virtual void fillContextMenu( QMenu* menu ) = 0;
- virtual void doubleClicked() {
- }
- virtual void clicked() {
- }
-};
-
-///This class will call a fillContextMenu-function in the targetet-class
-template <class targetet, class ValueType = int>
-struct StandardCollaborationTreeAction : public CollaborationTreeAction {
- QPointer<targetet> target;
- ValueType var;
-
- StandardCollaborationTreeAction( targetet* t, const ValueType& v ) : var( v ), target( t ) {}
- StandardCollaborationTreeAction( targetet* t ) : target( t ) {}
- out( Logger::Warning ) << "got a file-synchronization from" << userName << "for \"" << smsg->fileName() << "\", but new files from collaborators are not allowed.";
-Some notes about this plugin from commit-digest/2006-09-10:
-When I first heard about Summer Of Code I thought about proposing a project called "Advanced Code Completion for KDevelop 3"(with full support for templates, comments, etc.), but when that didn't go down well with most of the KDevelop developers (since they were already focused on KDevelop 4), I just started implementing it. I spent a lot of time working on that until SOC started (and even quite some time since then), and you can see the result in the current KDevelop 3.4 SVN tree. I finished everything I planned and more.
-
-Some of the features:
-Intelligent resolution of types.
-Support for templates like for example shared pointers.
-Support for implicit template-instatiation
-Nicer and more useful completion-list with items ordered in a useful way and indented by inheritance-depth, with popups that include comments and any other interesting information
-Many improvements in the parser, for example all comments are extracted and used in any possible way, macros are dealt with correctly, Enums are handled in a more useful way, and much more
-A powerful navigation-menu: Click any item within a function and see it's real type, a trace of all typedefs on the way to that type, information on all involved typedefs, classes, variables, functions, etc., and the same as a submenu for all involved template-parameters, argument-types, base-classes, etc.
-Improved jump-to-menus and navigation-bar.
-Highlighting of function-names in the navigation-bar and class-tree.
-And countless other major improvements in code-completion and navigation.. see the feature list of the beta releases or the commit log to see all of them.
-
-KDevelop 3 is doing well feature-wise, but currently lacks developers since the focus already is on KDevelop 4, but it'll take a long time until that is really usable, so I hereby encourage anyone interested to start using the SVN version of KDevelop 3.4 and hunt down a few bugs, to make sure that a stable version can be released soon.
-
-Collaboration through the internet is fundamental to most open-source-software. Almost any open- and even closed-source-software might profit from better collaboration-possibilities. If you work for a project that has a collaboration-server, you can directly ask other developers working on the same project for very specific help, patches can be reviewed very quickly, and discussion can instantly take place within the documents themselves. File Collaboration may also be useful for discussion of new ideas, teaching, for friends less experienced in programming requesting help (Or am I the only one who is asked how to program something through ICQ again and again?), and simply because it's cool ;)
-
-So I took the basic Idea for the Summer Of Code project "KDevelop Teamwork" from the Wiki where someone proposed it, and developed it using my own Ideas, trying to add some of the teamwork features I always missed in any IDE I ever used. :)
-
-Generally it consists of four parts:
-Client/Server Architecture
-I created a multi-threaded library for networking, including client/server- and user-management, and a standalone server not dependent on Qt which can be run on any webserver and administrated using the console.
-
-File Collaboration
-An arbitrary count of developers can collaboratively edit a dynamic set of files, and the edited documents can be dynamically transformed (for example chosen changes made by exactly one user could be undone, which will allow single-user undo, redo, etc.)
-
-Conversation
-All users connected to any of the connected servers, as well as the servers themselves (in the case they are not standalone) can be contacted by using instant messages, collaboration-requests, patch-requests, in-document messages, etc.
-
-The most interesting message for conversation is the in-document message: It can reference a position or piece of text within any document, and the receiver of the message automatically jumps to that document and highlights the referenced piece of text as the message is selected, and pops up a chat-window within the document itself at the found position, where other messages of the same thread may be selected and discussion can take place.
-
-Any answers written into the chat will automatically reference the currently selected text. Referencing is simply done by marking a piece of text before sending a message, and the reference-position is being found by a fuzzy algorithm I developed which tries to find the correct place even within totally different documents (and is pretty successful at doing so).
-
-Patch Management
-Every user can manage a set of patches (or other file types) for each project. They can either be files or dynamic patches which are automatically retrieved from commands on request (for example "svn diff"). Patches can be easily shared directly through the developer-list, using different access-levels.
-
-A modified version of Kompare's diff3-library is used to get information from patches. Using that the patch-manager can automatically highlight all changes made by an applied patch within all documents, and allows you to easily browse through those positions so you can review the patch within the correct context and directly discuss about it using in-document messages.
-
-They can be applied/reverted to the local tree using single buttons, and for diff-files it is possible to automatically determine whether the patch is already applied or not. If problems arise within the patching process they can be dealt with using an embedded console in the patch-management-window.
-It is important that all those features are well integrated: For example you can store the results of a file-collaboration-session as a patch into your local patches-list, and thereby share it with other developers and easily revert it at any time, and you can use in-document messages directly within the temporary file-collaboration files.
-
-To store all the project-specific data (like patches), a ".teamwork" subfolder is created within the project directory.
-
-I encountered many problems during development. Apart from one harddisk crash, the most annoying problem was the very unstable and (in the begginning) difficult to compile kdelibs/qt-copy/qdbus/kdesupport etc. combination, which again and again cost me days and hours just to get it working.
-
-The most challenging part was the file-collaboration. Getting a simple form of collaborative editing to work was quite fast, but making the document-transformation work correctly in all test-cases really took some time, and I had to finish it after the deadline without stress (luckily I didn't mention anything like it in my application ;)). The trick was writing everything down and trying to solve it mathematically as I learnt at university, unfortunately I got that idea after days of unsuccessful hacking and trying - well... you live and learn :)
-
-I was able to finish nearly everything I planned until the deadline, but unfortunately I missed the week I planned in my application for "debug, make it perfect", so that work is missing, and it shows :) Most of the work I did after the Summer Of Code ended was in other, more important parts (finishing the text-transformation algorithm, or fixing file-collaboration which stopped working after a kdelibs-update), but it is work I'll surely do. Then there's one other big problem, the executable-size when the executable is built with debug-information. During my work on this project I fell in love with templates and meta-programming, but I think the main reason is my use of boost serialization, I'll still have to work on that. Then of course i'll need some nice icons. :)
-
- Now that the Summer Of Code has concluded, the first thing I will do is working intensively for the institute of my university that paid me the whole year, and that I neglected since March because of my work for KDevelop 3 Code Completion and then the Summer Of Code. Of course, I won't forget KDevelop and KDE in general, since I like the Open-Source Idea a lot. I started working on Open-Source Software before I started the Summer Of Code, and I won't stop it now that it's over :) I'll keep maintaining the teamwork-module (and of course finish it), I'll keep caring about KDevelop, and maybe I'll start a project to make KDE more Tablet PC friendly if I can find the time for it.
Property changes on: trunk/playground/devtools/kdevelop4-extra-plugins/teamwork/README
-///For higher orders to work, the sum-type has to be signed
-#define DEFAULTSUMTYPE int
-#define DEFAULTORDER 2
-
-
-///State-based-build can only nearly complete with extreme compiler-parameters set, although it should theoretically be faster, if the compile would optimize it the right way.
-
-//#define STATEBASEDBUILD
-
-namespace FuzzySearch {
-
-/**
- * How should all the differences be weighed together to a compound difference?
- *
- * The weighting still needs some work.
- *
- * */
-
-template < class Compare1, class Compare2, class Then, class Else >
-class IfEqual {
-public:
- typedef Else Result;
-};
-
-template < class Compare, class Then, class Else >
-class IfEqual<Compare, Compare, Then, Else> {
-public:
- typedef Then Result;
-};
-
-template <class Item>
-class PrimitiveVector {
- Item* data_;
- uint size_;
- public:
- PrimitiveVector() : data_( 0 ), size_( 0 ) {}
- ;
-
- ~PrimitiveVector() {
- if ( data_ )
- delete[] data_;
- }
-
- ///All data is lost when this is called
- void rawResize( unsigned int i ) {
- if ( size_ == i )
- return ;
- size_ = i;
- if ( data_ )
- delete[] data_;
- if ( !i ) {
- data_ = 0;
- } else {
- data_ = new Item[ i ];
- }
- };
-
- Item& operator [] ( uint index ) {
- return data_[ index ];
- }
-
- const Item& operator [] ( uint index ) const {
- return data_[ index ];
- }
-
- uint size() const {
- return size_;
- }
-};
-
-///unsigned int is ok for document-sizes of up to about 16 Megabytes, 64-bit integers create problems here
-using namespace std;
-template <int maxDepth, class SumType = DEFAULTSUMTYPE>
-///@TODO: Dispatch the messages in a more flexible way: Allow any client to register with an arbitrary message-type that he wants to get(including all sub-messages). DynamicMessageDispatcher can do this. Use that, and make the way messages are connected more flexible.
- globalMessageSendHelper().sendReply<KDevSystemMessage>( msg, KDevSystemMessage::ActionFailed, "no fitting patch available, or patch could not be locked" );
- log( "got a patch-request, but the requested patch could not be found or could not be locked", Warning );
- ///Tries to determine the patch-depth(by searching for -pX parameters in the apply-command. Defaults to zero.
- uint patchDepth() const;
-
- ///Tries to determine the tool to be used for applying the patch. Defaults to "patch"
- string patchTool( bool reverse = false ) const;
-
- ///Tries to determine the params for applying the patch. If none are given, uses reasonable default-parameters. If reverse is true, the unapply-parameters are given.
- ///This returns the LocalPatchSourcePointer which was used to request the patch(only valid on sender-side, to cache the apply-commands etc. for security)
-///This file contains a few classes that I currently don't know where else to put
-
-using namespace Teamwork;
-
-///Since deleting the client by a reference-counter in some meta-object leads to crashes, this is used to keep the client alive longer and delete it as last.
-class LaterDeleter : public QObject {
- Q_OBJECT
- public:
- LaterDeleter( const KDevTeamworkClientPointer& c );
- ~LaterDeleter();
- KDevTeamworkClientPointer m_c;
-};
-
-class SafeTeamworkEmitter : public QObject, public Shared {
- ///This can be used to speed up the search if multiple positions should be found within one text(then this object should be created outside and reached to findInText.
-# macro_log_feature( COMMONCPP2_FOUND "Common C++2" "Support for Teamwork plugin integration" "http://ftp.gnu.org/pub/gnu/commoncpp/" FALSE "1.5.9" "The commoncpp2 libraries are needed for the Teamwork plugin" )
-# macro_log_feature( Boost_FOUND "Boost" "Support for Teamwork plugin integration" "http://www.boost.org/" FALSE "1.34.0" "The iostreams and serialization components of the boost C++ libraries are needed for the Teamwork plugin" )
- if ( endLine < line || ( endLine == line && endCol < col ) ) {
- int l = line, c = col;
- line = endLine;
- col = endCol;
- endLine = l;
- endCol = c;
- out( Logger::Warning ) << "Found end-marker before start-marker:" << line << ":" << col << "-" << endLine << ":" << endCol;
- }
- }
-
- if ( line == -1 ) {
- out( Logger::Warning ) << "Could not find reference-position for" << l->start().asText() << "in text of length "<< m_currentSearchInstance.text().length();
- if ( msg->info().isIncoming() && msg->info().session() ) {
- ///Send a notification that the message arrived to the other side.
- //globalMessageSendHelper().sendReply<KDevSystemMessage>( msg, KDevSystemMessage::ActionSuccessful ); //this is also done for KDevTeamworkTextMessage now
-This header implements a very simple signalling-system that uses the SafeSharedPtr or WeakSafeSharedPtr-facilities to be thread-safe.
-*/
-
-#ifndef SAFESIGNALLER_H
-#define SAFESIGNALLER_H
-
-#include <QObject>
-#include <ext/hash_set>
-#include "lib/network/safesharedptr.h"
-#include "lib/network/weaksafesharedptr.h"
-
-struct SignalProxyBase {
- virtual void signal() = 0;
- virtual ~SignalProxyBase() {
- };
-};
-
-template<class Type>
-struct hashCall {
- size_t operator() ( const Type& rhs ) const {
- return (size_t)rhs.unsafe();
- }
-};
-
-///An object of this type represents a signal that multiple receiver-objects can be bound to. To get a function similar to qt's auto-disconnect, WeakSharedPtr<...> may be used as Target-type. If SafeSharedPtr is used, connected objects will be kept alive until the SafeSignal is destroyed or the object disconnected.
- SignalProxy( const TargetType& target, const Signal& sig ) : sign( sig ) {
- s.connect( target );
- }
- virtual void signal() {
- s( sign );
- }
-};
-
-///This is a very simple safe-signaller object that can be used to easily bind safe signals into QActions etc. The signal-type may be any copyable object. The given object will be copied, and sent once the signal is emitted.
- int result = KMessageBox::warningContinueCancel( m_editDlg, i18n( "You are about to unapply a dynamic patch created by the command \"%1\". That can be very dangerous. If the same command will not produce the same text after the unapply, the patch cannot be reapplied and all data may be lost. \nRecommendation: Make the patch a file-patch before unapplying it.", l->command.c_str() ), i18n("Warning") );
-///If the parent is destroyed, VectorTimestampEditor is destroyed too. Also it destroys itself if "finish" is clicked, or the dynamic text is destroyed.
-class VectorTimestampEditor : public QObject, public SafeLogger {
- Q_OBJECT
- public:
- ///If embed is false, a new dialog will be created
- err() << "the reconstruction of a message of type \"" << mp->name() << "\" is wrong, the serialized content does not match!" ;
- compare( buffer, buffer2 );
- } else {
- err() << "the reconstruction of a message of type \"" << mp->name() << "\" is wrong!(mismatch in size: " << buffer.size() << " -> " << buffer2.size() << ")" ;
- compare( buffer, buffer2 );
- }
- } else {
- err() << "a message that is being sent could not be reconstructed for debugging: \"" << mp->name() << "\"";
- }
- } catch ( const CannotReserialize& )
- {}
- catch( const boost::archive::archive_exception& e ) {
- err() << "archive-exception while reconstructing message: " << e.what();
- }
-#ifndef DISABLEUNIVERSALCATCH
-
- catch ( ... ) {
- err() << "exception while serializing the reconstructed message";
- throw;
- }
-#endif
-#endif
- processOutgoingMessage( buffer );
- sendData_ = binaryInt( buffer.size() );
- sendData_ += buffer;
- //out() << "sending: " << toString( buffer );
-
- DEBUGLOG( "serialized outgoing message of size " << sendData_.size() << " and type " << messages_.identify( mp ) );
- //The following message indicates that the message's constructor does not correctly fill it's message-info. When this error happens, probably MessageConstructionInfo is not used correctly.
-/**The MessageType holds all information necessary to Identify a Message and build an Object from it.
- The IdList is an inheritance-chain. Messages whose list begins with IDs of other Messages must be specializations of those, and the parent-types should be able to handle those too.
-*/
-
-void BasicServer::buildSocket() {
- closeSocket();
- failed_ = false;
-
- try {
- server_ = new BasicTCPSocket( addr, port_ );
- out() << "server is listening on " << addr << ":" << port_;
-///Action must have a member-template called Action, that has a typedef called Result. Action will be applied to each item, and the result bound together.
- ///This walks the tree until it cannot go on, then applies the given Action to the current node(additionally giving the type at the node as template-argument), and gives back the return-type(Action::ReturnType).
- public:
-
- inline void buildFullId( const std::string& pre ) {
- ///Searches the tree. Returns 0 if the action could be applied to no node, 1 if the action was applied but not to the searched leaf, and 2 if it was applied to the exact searched target
-/**Stuff is the list of types that define the tree
-in form of multiple Chain<Type, Parent-Type, int preferredIndex>, and EntryTemplate is a class which embeds
-a template-class called "Entry" which will be inherited by every single node, with the current type of the node as template-parameter(See StandardEntryTemplate).
-Instead of using the explicit Chain<...>-notation, just a type can be used, and the chain will be extracted by using the type's Precursor"-Typedef, and it's preferredIndex constant/enum. Every item MUST have an explicit sub-id, the automatic generation of ID's was abandoned to make building partial trees easiert.
-Stuff is a set of "Chain"'s or Types, bound together with "Binder". It can be incomplete, only the important leafs have to be there, and the tree leading to them is extracted automatically.
- */
-template < class Master, class Stuff, class EntryTemplate = StandardEntryTemplate >
- CustomMessage( const MessageConstructionInfo& info, MyDataType& data ) : RawMessage( info(this) ), myData( data ) {
-}
-
- CustomMessage( InArchive& arch, const MessageInfo& info ) : RawMessage( arch, info ) {
- serial( arch );
-}
-
- virtual void serialize( OutArchive& arch ) {
- Precursor::serialize( arch );
- serial( arch );
-}
-};
- */
-
- class MessageConstructionInfo;
- /**MessageConstructionInfo is a class used while constructing messages, that makes sure that the name of the most derived message will be passed on to RawMessage.
- *Use it by simply passing the this-pointer of each constructed message while passing it to the parent-message. */
-
- class NETWORK_EXPORT MessageConstructionInfo {
- public:
- //This is the constructor you are supposed to use when creating a message(use the automatic conversion from MessageTypeSet&)
- RawMessage( const MessageConstructionInfo& messageTypes, const DataVector& data );
-
- ///This should be used to indicate that this message is a reply to the other message(replyTarget)
- void setReply( MessageInterface* replyTarget );
-
- RawMessage( InArchive& from, const MessageInfo& info );
-
- virtual void serialize( OutArchive& target );
-
- virtual const MessageInfo& info() const;
-
- virtual MessageInfo& info();
-
- /**This is called once a message has been tried to be sent, with the appropriate result, and can be used by the message to give some feedback to the sender. The Session used to send the message is still locked.
- */
- virtual void result( bool success );
-
- /**Returns a reference to the data-store of this raw message. It does not include data serialized to inherited messages. */
- DataVector& body();
-
- /**Returns a reference to the data-store of this raw message. It does not include data serialized to inherited messages. */
- const DataVector& body() const;
- };
-
-
- class NETWORK_EXPORT TextMessage : public RawMessage {
- /**The unique id is the identity of a message-instance, not of the message-type */
- UniqueMessageId uniqueId() const;
-
- /**Since the uniqueId is not used for sorting this casts away constness so the id of a MessageType that is used as Key in a Map can be changed */
- void setUniqueId( UniqueMessageId newId ) const;
-
- /** if the message is a reply to another message, this should be the uniqueId of the other message.
- this function is thread-safe.(because after creation, this value should not be changed anymore) */
- UniqueMessageId isReplyTo() const;
-
- /** to make one message a reply to another while sending(to the other side), this is enough. To mark the message for local use, setReplyMessage(...) should be set too.*/
- void setReply( UniqueMessageId replyId );
-
- /** this does not automatically set the reply-id, it just sets a message-pointer. */
- ///If the reply is not handled directly by the message that the reply has gone to, the message this is a reply to is stored here.(The message with the id isReplyTo() ), may be invalid
- const MessagePointer& replyToMessage() const;
-
- void setId( const MessageType& id );
-
- /**Removes all kept references to important objects like sessions(those might keep the sessions alive too long)
- this should be called before a message is stored permanently */
-
- void makePersistent();
-
- ///Returns whether the message was constructed from a stream(if false, it was created locally)
- bool isIncoming() const;
-
- ///This can be used to set the isIncoming()-flag. The application or messages may use the flag as indication whether the message is incoming or outgoing.
- void setIsIncoming( bool b );
-};
-
-/**Since messages can have different IDs in different Message-Sets, the id's cannot be hardcoded and must be given with each creation.
-That is simplified by using MessageTypeSet::create which directly fills the correct id
-To create and use an own message there's three things to do:
-1. Implement a message based on MessageInterface(or simpler based on RawMessage)
-2. Within the class-declaration, use the DECLARE_MESSAGE(name, parent, subindex)-macro to define the inheritance used in the message-tree
-3. Register the message to the used MessageTypeSet, to register it to globalMessageTypeSet() simply use the REGISTER_MESSAGE(Message)-macro(within an implementation-file).
-Now the message can be sent and received. */
-
-class NETWORK_EXPORT MessageInterface : public SafeShared /*, public virtual Serializable*/ {
- ///this function must be thread-safe(so the message does not need to be locked when it is called)
- virtual MessageInfo& info() = 0;
-
- virtual const MessageInfo& info() const = 0;
-
- /**This is called once a message has been tried to be send, with the appropriate result, and can be used by the message to give some feedback to the sender. The Session used to send the message is still locked.
- */
- virtual void result( bool success ) = 0;
-
- virtual ~MessageInterface();
-
- ///This function is thread-safe
- virtual const char* name();
-
- ///This function must be implemented for all messages, it is atomatically cared about by the DECLARE_MESSAGE(..) macros etc.
- static const char* staticName();
-
- ///This is just a convenience-function that redirects to info().type()
- const MessageType& type() const;
-
- ///This is just a convenience-function that redirects to info().uniqueId()
- UniqueMessageId uniqueId() const;
-
- ///This should return "true" when the message wants a reply. gotReply will then be called once a reply has been received. The default-implementation returns false.
- virtual bool needReply() const;
-
- struct NETWORK_EXPORT ReplyResult {
- bool messageHandled; ///This should indicate that the message was used locally and should not be handled on by higher instances
- bool awaitingMore; ///whether the message is awaiting more replies.(if this is true, the message will not be deleted and needReply will be called again as soon as another reply arrives)
- cout << "possible commands configuration-manipulation-commands(everything within the [] is optional): \n";
- cout << "--adduser username [password] | Add the user to the list of known users\n";
- cout << "--serverpassword [password] | Change the server-wide password which is used for users without an own password. If empty, access is made public.\n";
- cout << "--servername name | Change the name of the server\n";
- cout << "--deluser username | delete a user from the list of known users\n";
- cout << "--list | list all registered users\n";
- cout << "--show | show current settings of the server\n";
- cout << "--setrights username [banned][admin][trusted] | change the rights of the user(no argument for normal user-rights)\n";
- cout << "--setport [port] | change the port the server is opened on(if the port is left away the default-port("<<STANDARDPORT<<") is used)\n";
- cout << "--setbind [address] | change the address the server is bound to(if it is left away the default(0.0.0.0) is used)\n";
- cout << "\nAll these commands manipulate the configuration-file created in the run-directory. \nThe settings will then apply for the next start of the server.\n";
- cout << "only one of the commands can be called at one time.\n";
-///strips away all information that should stay private, but leaves things like description etc.
-void User::stripForPublic() {
- password_ = "";
-}
-
-///this function strips all information that is not necessary to generally identify a user(this might strip away more than stripForTarget, and includes passwords and such)
- needUserUpdate_ = true; ///The connected client may have been a client that created a direct connection to us, and which may still be reachable through an indirect connection, so an update is needed
-}
-
-
-///this is called whenever a connection is successfully established to a server
- needUserUpdate_ = true; ///The connected server may have been a client we created a direct connection to, and which is still reachable through an indirect connection, so an update is needed
-}
-
-
-bool Client::think() {
- for ( ClientSessionMap::iterator it = clientSessions_.begin(); it != clientSessions_.end(); ) {
- if ( !( *it ).second.session.unsafe() ->isRunning() ) {
- out() << "closing outgoing session because it stopped running";
- err() << "could not get/create indirect user " << ( *it ).name();
- continue;
- }
- if ( l->online() )
- continue; ///The user is already online, maybe through a direct connection
-
- ForwardSessionPointer s = lsession->getForwardSession( l );
-
- allReceivedUsers.insert( l );
-
- if ( s ) {
- ///There already is an open session to the user
- } else {
- ///Create a new session to the user
- users.push_back( l );
-
- l->setSession( new ForwardSession( identity(), l, msg->info().session().cast<MultiSession>(), logger(), messageTypes(), new HandlerProxy<BasicServer>( this ) ) );
- registerSessionUser( l ); ///Register the user together with its session, so it's noticed once the session is down.
- }
- }
-
- ///now invalidate all users that the session has a forward-session to but that were not listed by the server, because those probably are offline.
-
- for ( list<UserPointer::Locked>::iterator it = sessionUsers.begin(); it != sessionUsers.end(); ++it ) {
- UserPointer::Locked user = getUser( createUser( &msg->source() ) );
- if ( !user ) {
- err() << "could not get/lock the user for a forward-message";
- return 1;
- }
-
- ForwardSession* f = new ForwardSession( identity(), user, msg->info().session().cast<MultiSession>(), logger(), messageTypes(), new HandlerProxy<BasicServer>( this ) );
- f->setUser( f->target() );
- cl->info().setSession( f );
-
- if ( user->online() ) {
- out( Logger::Warning ) << "got indirect message from directly connected user " << user->name() << ", keeping communication indirect";
- } else {
- user->setSession( f );
- }
-
- processMessage( cl.data() );
- } else {
- out() << "could not handle a forwarded message";
-///This file defines a multi-indexed set(called CrossMap) similar to boost's multi-index, but with simpler api, with support for index-lists, and less efficient.
- void serialize( Archive & arch, uint version ) {
- arch & id_;
- }
-
- operator uint() const {
- return id_;
- }
-};
-
-/**This is a kind of in-memory database that allows storing/sorting items by an arbitrary count of keys
- * and key-types. The keys are extracted in
- * the moment an item is inserted. If the keys change, update(..) should be called on the item.
- *
- *
- * It is very similar to the boost multi-index, but the api is a bit easier.
- *
- * Advantage against boost's multi-index: One item can be reachable by many indices in the same category,
- * by using CROSSMAP_DEFINE_CONTAINER(..) and giving such a key-container as to the key-list.
- * Then the item will be searchable by each key in the list.
- * (If the value-type is used as key, it will be filled with the key's value by default and no key-extractor needs to be defined for that case)
- * (Example: multiple filenames may be associated to users, and it is possible to get a list of users for each filename)
- *
- * Disadvantage: Less efficient, bigger binary
- *
- * @param Value The value-type, should be a type with a default-constructor(is used as Dummy for Functions like operator[] if the key cannot be found)
- * @param Keys a meta-list containing all keys(using BIND_LIST or Binder<...,...>
- * @param KeyExtractor (optional) a class that helps extracting the keys from the values
- * @param rebuildAfterLoad whether serialization should only store a list of values, without the additional maps and the cross-link-data etc.(then every key has to be re-extracted after the archive was loaded, and the structure may be different)
- */
-
-template <class Value, class Keys, class KeyExtractor = StandardCrossMapKeyExtractor>
- ///Creates a copy of all key-values which can be used to reference items. This might be used to store a consistent representation of the keys a value was stored under.
- static KeyValues copyKeyValues( const Value & value ) {
- return KeyValues( value );
- }
-
- ///When KeyValues are given from outside, they do not have to be recomputed by using the KeyExtractor.
- Id insert( const KeyValues & keyValues, const Value & value ) {
- uint id = currentId_++;
- values_.insert( make_pair( id, value ) );
- insertToData( keyValues, value, id );
- return id;
- }
-
- Id insert( const Value & value ) {
- KeyValues keys( value );
- return insert( keys, value );
- }
-
- ///Returns the Id of the removed Value, or zero on fail
- Id remove
- ( Id id ) {
- if ( id ) {
- typename ValueMap::iterator it = values_.find( id );
- if ( it == values_.end() )
- return 0;
-
- removeFromData( ( *it ).second.keyValues, id );
- values_.erase( id );
- return id;
- } else {
- return 0;
- }
- }
-
- ///Removes the item the iterator currently points at
- bool remove
- ( const Iterator& it ) {
- if ( !it )
- return false;
- return ( bool ) remove
- ( it.id() );
- }
-
- ///Removes all items the iterator iterates over
- uint removeAll( const Iterator& it ) {
- if ( !it )
- return false;
- Iterator i = it;
- i.restart();
- uint ret = 0;
- while ( i ) {
- if ( remove
- ( i.id() ) ) ret++;
- }
- return ret;
- }
-
- ///Returns the Id of the removed Value, or zero on fail
- Id remove
- ( const KeyValues & keyValues, const Value & value ) {
- Id id = find( keyValues, value );
- return remove
- ( id );
- }
-
- ///Returns the Id of the removed Value, or zero on fail
- Id remove
- ( const Value & value ) {
- KeyValues keys( value );
- return remove
- ( keys, value );
- }
-
- ///@return 0 if the item was not found, else the id of a matching value */
- Id find( const KeyValues & values, const Value & value ) {
-///This macro simplifies the syntax of defining a static type-list. The first parameter is the name of the new type, the other parameters are the types.
- ///This can be overridden to do some work on a regular basis. Returns whether more time is needed.
- virtual bool think() = 0;
-
- ///This can be overridden to do some cleanup-work within the session-thread. By default it tries to lock the associated user, and call setSession(this) so the user has a chance to notice the difference.
- virtual void final();
- };
-}
-#endif
Property changes on: trunk/playground/devtools/kdevelop4-extra-plugins/teamwork/lib/network/sessioninterface.h
-///this class represents one line of logger-output. On its destruction the line is given to the logger. When it is copied, the copy-source is invalidated.
- out() << "got forward-message from unknown session";
- return 0;
- }
-
- try {
- if ( it != users_.end() ) {
- ///@todo check if the given session (user) is authorized to send data to the given target(check for connection), and check whether the source-user-information in the message fits the real source
- UserPointer::Locked l = *it;
- if ( l ) {
- if ( l->online() && l->online().session() ) {
- out( Logger::Debug ) << "forwarding a message from " << msg->source().name() << " to " << msg->target().name();
- l->online().session().unsafe() ->send( msg );
- } else {
- if ( msg->storeOnServer() ) {
- out( Logger::Debug ) << "failed to forward a message from " << msg->source().name() << " to " << msg->target().name() << ", storing it on the server";
- out( Logger::Debug ) << "failed to forward a message from " << msg->source().name() << " to " << msg->target().name() << " because the target is not online";
- for( ServerConfiguration::UserSet::iterator it = configuration_.registeredUsers.begin(); it != configuration_.registeredUsers.end(); ++it ) {
- UserPointer::Locked u = new User( *it );
- UserPointer ru = findUser( u );
- if( ru ) {
- ///The user already exists, update it
- UserPointer::Locked rlu = ru;
- if( rlu ) {
- (*rlu) = *it;
- rlu->setSession( rlu->online().session() ); ///Session is used to track the state of the user, so give a hint using that interface that something about the user changed.
-//The first 4 lines of the following macros are used to store the values for the implementation, so they must not be given to the implementation again
-/**This is called once a message has been tried to be sent, with the appropriate result, and can be used by the message to give some feedback to the sender. The Session used to send the message is still locked.
- */
-void RawMessage::result( bool /*success*/ ) {
-}
-
-/**Returns a reference to the data-store of this raw message. It does not include data serialized to inherited messages. */
-DataVector& RawMessage::body() {
- return body_;
-}
-
-/**Returns a reference to the data-store of this raw message. It does not include data serialized to inherited messages. */
-A client-server-system is needed, which will be implemented as a static C++-library.
-
-The library will provide classes and functions to:
-- run a client in a seperate thread.
-- run a server in a seperate thread.
-
-The final link between the program using the library and the library will be established by virtual member-functions.
-
-The library will then be used by kdevelop to connect to a server, or to open an own server. The whole library will only depend on STL and common-c++.
-Additionally a standalone server-program will be developed that opens a server using the library, independent from kdevelop.
-
-Objects that have the same number will share one implementation
-
-What the server implemented in the library has to do:
-- keep a list of (user, password, additional authentication-date, additional user-information, user-log) tuples
-- [2] store, manage, and use some options like whether anonymous users are allowed using a storage-class that allows simple changing, storing and restoring of the settings(the storage is done by the program that implements the server)
-- [3] provide a unified message-class for messages to either the server, or to other clients(the clients can communicate through the server or directly, but always moderated by the server). It will allow the clients sending each other messages of types the server does not know and would not understand.
-- provide a set of administrative messages for communications with clients.
-- store messages that are flagged to be safely delivered until the target-client comes online and gives a reply that it got the message
-
-What the client implemented in the library has to do:
-- keep a log of all interesting communication communication
-- keep and manage list of connected users
-- care about most of the implementation-details, and offer the client-program a simple interface to just override interesting high-level functions
-- [2] store, manage, etc. settings
-- [3] provide additional derived message-classes to communicate with other clients through the server
-- implementation of the client will be finished together with the kdevelop-plugin
Property changes on: trunk/playground/devtools/kdevelop4-extra-plugins/teamwork/lib/network/plan
- //Returns the message-type mapped to a message-name. A message-name in rtti (typeid(Message).name()) format is also accepted for messages derived from MessageInterface
- const MessageType& idFromName( const std::string& name ) const;
-
- std::string stats() const;
-
- ///returns the class-name of the message(the most specialized one registered in this type-set)
- /** registers a type as slave of another given type, for simlicity registerMessageTypes should be used instead, together with a whole list of types */
- template <class Message, class ParentMessage>
- MessageType registerMessageType( int preferredSubId = 0 ) {
- if ( ids_.find( staticMessageName<Message>() ) != ids_.end() )
- std::cout << "while registering \"" << staticMessageName<Message>() << "\" the id of \"" << staticMessageName<ParentMessage>() << "\" could not be allocated!" << endl;
- if ( myId ) {
- //std::cout << "registering message-type " << staticMessageName<Message>() << " with id " << myId.desc() << endl;
- ids_[ staticMessageName<Message>() ] = myId;
- ids_[ typeid(Message).name() ] = myId;
- if ( types_.find( myId ) != types_.end() )
- delete types_[ myId ];
- types_[ myId ] = new MessageFactory<Message>();
- } else {
- std::cout << "could not allocate id for message-type " << staticMessageName<Message>() << endl;
- return MessageInfo( idFromName( name ), currentUniqueMessageId_++ );
- }
- /*
- //For now the following is disabled to test whether it can be conveniently replaced with something that isn't that bad for executable-size
- ///Conveniently create a new message with the correct Message-Id and unique-Id filled. All parameters are passed to the constructor of the created message.
- ///Conveniently create a new message with the correct Message-Id and unique-Id filled. All parameters are passed to the constructor of the created message.
- ///Conveniently create a new message with the correct Message-Id and unique-Id filled. All parameters are passed to the constructor of the created message.
- template <class MessageType, class ParamType1, class ParamType2>
- ///Conveniently create a new message with the correct Message-Id and unique-Id filled. All parameters are passed to the constructor of the created message.
- template <class MessageType, class ParamType1, class ParamType2, class ParamType3>
- ///Conveniently create a new message with the correct Message-Id and unique-Id filled. All parameters are passed to the constructor of the created message.
- template <class MessageType, class ParamType1, class ParamType2, class ParamType3, class ParamType4>
- ///Conveniently create a new message with the correct Message-Id and unique-Id filled. All parameters are passed to the constructor of the created message.
- template <class MessageType, class ParamType1, class ParamType2, class ParamType3, class ParamType4, class ParamType5>
- ///Conveniently create a new message with the correct Message-Id and unique-Id filled. All parameters are passed to the constructor of the created message.
- template <class MessageType, class ParamType1, class ParamType2, class ParamType3, class ParamType4, class ParamType5, class ParamType6>
- cerr << "serious error in the message-type-system!";
- return 0;
- }
-};
-
-
-///This message-type-set contains all messages that were registered by a call to REGISTER_MESSAGE, and may be used instead of the local type-sets, for simplicity. That way messages can be serialized/deserialized without the core-parts being aware that they exist.
-class NETWORK_EXPORT BasicTCPSocket : public ost::TCPSocket {
- protected:
- bool onAccept( const ost::InetHostAddress &ia, ost::tpport_t port );
-
- public:
- BasicTCPSocket( ost::InetAddress &ia, int port );
-};
-
-/**This class runs the server as the run()-method is called in the same ost::Thread.
-This class never deletes itself, it can be deleted from outside once isRunning() returns false or the threads are joined, or it can be deleted through a SharedPtr/SafeSharedPtr.
-For each client that connects, it creates a session derived from BasicSession, which can also be
-created by a derived class.
- */
-class NETWORK_EXPORT BasicServer : protected ost::Thread, public WeakSafeShared {
- ///returns the reference to a synchronized list of messages that are waiting for being processed. Processed messages should be removed from that list.
- SafeList<MessagePointer>& messages();
-
- /**After this function was called, the ost::Thread is going to exit soon.
- once isRunning() returns false, it can be deleted.*/
- void stopRunning();
-
- ///Returns whether the ost::Thread is running
- using ost::Thread::isRunning;
-
- ///Starts the ost::Thread, should be called after the ost::Thread was constructed
- using ost::Thread::start;
-
- using ost::Thread::join;
-
- ///This can be used to allow/disallow incoming connections. Already connected clients are not kicked on deactivation.
- void allowIncoming( bool allow );
-
- protected:
-
- ///this one is called from within another Thread, so it is more useful to override processMessage(...) in the teamwork-server than this one
-/// A teamwork-client generally is the same as a teamwork-server, except it not only supports incoming connections, but also outgoing ones and connections forwarded through a server, and may be associated with a user-identity.
-/** This header gives an additional type of pointer with a higher level. It's functionality is similar to that of QPointer.
- Holding a pointer of type WeakSafeShared, does not increase the reference-count of the pointed object. If the object is deleted,
- the pointer is set to zero. This comes with additional cost. The pointed object must be based on WeakSafeShared, and for each creation of
- that type one additional allocation of an internal SafeShared-object(especially a mutex) is done.
-
- WeakSafeSharedPtr itself does not consume more memory than SafeSharedPtr, but locking-operations are more costly, because two locks are done instead of one.
- */
-
-template <class Item, class Serialization>
-class NETWORK_EXPORT WeakSafeSharedPtr {
- SafeSharedPtr<WeakReference> ref_;
- public:
- WeakSafeSharedPtr() {}
-
- template <class Input>
- WeakSafeSharedPtr( const Input& ptr ) {
- set
- ( ptr );
- }
-
- SafeSharedPtr<Item, Serialization> get
- () const {
- typename SafeSharedPtr<WeakReference>::Locked l = ref_;
-///This header defines a serialization-class that can be used as template-parameter to SafeSharedPtr so it uses the message-serialization-system and the MessageTypeSet to serialize and deserialize messages(it stores and loads the messages as vectors). It automatically uses the global message-set stored in globalMessageTypeSet(). A hard lock is done while saving. Warning: May throw exceptions on errors
-
-#include "serialization.h"
-#include "messagetypeset.h"
-#include "helpers.h"
-#include <vector>
-
-#define USE_BUFFER_SERIALIZATION
-
-struct NETWORK_EXPORT MessageSerialization {
- template <class Type, class Archive, class Target>
- ///If the server-name in the configuration is not empty, and there currently is no local identity std::set, the local identity is std::set to that name.
- ///The following two functions can be used to make UserPointers consistent through a longer session where the server may be closed/opened multiple times:
- void getUserSet( UserSet& users );
-
- ///Insert the given user-std::set into the server's own.
- void insertUserSet( const UserSet& users );
-
-
- ///If the user is not registered yet, the user is either created, copied and returned, or zero is returned.
- virtual UserPointer getUser( const UserPointer& user );
-
- ///Creates and registers a user with that identity if it does not already exist. May return zero on conflict.
- virtual UserPointer getUser( const UserIdentity& user );
-
- MessageTypeSet& messageTypes();
-
- ///These two should be overridden to use derived user-classes.
- virtual UserPointer createUser( const User* user );
-
-
- int receiveMessage( SystemMessage* msg );
- int receiveMessage( ForwardMessage* msg );
- int receiveMessage( IdentificationMessage* msg );
- int receiveMessage( TextMessage* msg );
- int receiveMessage( MessageInterface* msg );
-
- ///Tries to find the user(together with appropriately filled online-information) among connected users, servers, and users available through another connected server
- UserPointer findUser( const UserPointer& user );
-
- UserPointer findUser( const UserIdentity& user );
-
- ///Returns the user associated with the given session, may return invalid pointer.
- /**Associate this client with a user-identity. May be invalid( is initialized as such ).
- Without this identity correctly std::set, forwarded messages can not be dispatched. The identity will also be broadcasted to new clients that connect to the server, but not to already connected ones */
- void setIdentity( const UserPointer& user );
- ///Returns the user-identity currently associated with this client. May be invalid.
- ///strips away all information that should stay private, but leaves things like description etc.
- virtual void stripForPublic();
-
- ///this function strips all information that is not necessary to generally identify a user(this might strip away more than stripForTarget, and removes passwords and such). It should not be called on derived classes, because the User-class is enough for simple Identification.
- void stripForIdentification();
-
- ///the structure can be changed through this.
- OnlineInformation& online();
-
- ///To set the user offline, this should be called with a zero-pointer
- * Use this to register your class for receiving all messages based on a given one.
- *
- * When a callback is registered using this function, the target will be locked before the target-function is called.
- *
- * @param Message(template-param 1) The message-type your class should receive
- * @param target a weak-pointer to the target the message should be delivered to(the weak pointer makes it safe to register and later delete the object without notification)
- * @param function pointer to a member-function of the taget-class, that must have the signature "int function( const SafeSharedPtr<Message>& )"
- *
- * For an example see main.cpp, there's a version of StandaloneServer that uses this.
- /** Call this to dispatch the message to the registered targets
- * @return 0 if there is no fitting target, or the value returned by the target's dispatch-function
- */
- int operator() ( const MessagePointer& msg );
-
- protected:
- /** Call this to dispatch the message to the registered targets. It is the same as operator(), but looks cleaner when called from an inherited class.
- * @return 0 if there is no fitting target, or the value returned by the target's dispatch-function
- result = KIO::NetAccess::upload( temp->name(), KUrl( m_destination ), (QWidget*)parent() );
- }
-
- if ( !result )
- {
- emit error( i18n( "<qt>Could not upload the temporary file to the destination location <b>%1</b>. The temporary file is still available under: <b>%2</b>. You can manually copy it to the right place.</qt>", m_destination, temp->name() ) );
- * @param state The state which the text should have after the change. The default-parameter changes to the current state.
- * If force is enabled, conflicts will be ignored instead of stopping.(The resulting text may be damaged)
- */
- bool changeState( const VectorTimestamp& state = VectorTimestamp(), bool force = false );
-
- /**
- * Removes everything above the current state.
- * */
- void cut();
-
- /**rewinds to a position that is smaller/same than state in every index
- * @param state the state of the document will be smaller than that state
- * */
- bool rewind( const VectorTimestamp& state );
- ///The given state must be bigger/same than the current state in every stamp
- bool advance( const VectorTimestamp& state );
-
- void dump() const;
-
- /** @return the first replacement with the given primary index, or zero */
- ReplacementPointer first( uint index ) const;
-
- /** @return the first replacement with the given primary index, that is currently not applied to the text(its primary stamp is higher than the current state's stamp on that index), or zero */
- ReplacementPointer firstUnapplied( uint index ) const;
-
- /** @return the last replacement with the given primary index, or zero */
- ReplacementPointer last( uint index ) const;
-
- /** @return the last replacement with the given primary index, that is currently applied to the text(its primary stamp is same as the current state's stamp on that index), or zero */
- ReplacementPointer lastApplied( uint index ) const;
-
- /**
- * @return the highest stamp with that index
- * */
- Timestamp highestStamp( uint index ) const;
-
- /**Returns the internal replacement-objects that can be used for example to disable
- * a single replacement. This is dangerous, they should not be altered.
- ///Returns the offset from the 'from' position to the 'to' one. If position is set, all replacements that are behind that position(given in from-space) will be excluded while computation.
- OffsetMap offset( VectorTimestamp from, VectorTimestamp to, int position = INVALID_POSITION );
-
- ReplacementPointer m_dummy;
-
- ///Changes the state to the newest one available
-///A pair that contains an index and the sum of all values before that index
-struct DYNAMICTEXT_EXPORT IndexAndSum {
- int index;
- int sum;
-};
-
-///Everything may throw DynamicTextError. Every pointer to Nodes, except those from parent-node to slave-node, must be weak-pointers.(because the ref-count is important for ownership-stuff)
-class DYNAMICTEXT_EXPORT Node : public Shared {
- typedef std::list<NodePointer> ListType;
- public:
- Node( bool isLeaf, Node* parent );
-
- ///If this node is already owned by parent, returns this. Else creates a copy owned by parent.
- inline Node* makeOwn( Node* parent );
- Node* setParent( Node* parent );
-
- ///Can be used to add/subtract a value from the sum(should only be directly called on end-items without children, and the index-range is only expanded, never shrinked.)
- inline void update( const int sumDif, const int indexCountDif ) {
- void splitRange( int splitPosition, Node* insertNode );
-
- void removeChild( Node* n );
-
- friend class EndIndexCompare;
- /*WeakNodePointer*/Node* parent_; ///if this is zero, the node is available for taking, else it must be copied.
- ListType nodes_;
- int nodeCount_; ///Cache for nodes_.size()
- int sum_; ///Sum over all sub-elements
- int indexCount_; ///The count of indices this node and all subnodes cover
- bool isLeaf_;
-};
-
-///This object can be copied around and changed at will, no other instances of it will be affected, while still staying efficient(Because of implicit node-sharing)
-class DYNAMICTEXT_EXPORT Map : public WeakShared {
- public:
- typedef std::vector< int > SumVector; ///Pairs of (index, sum-value). Muss dicht sein.
- ///preferredOrder says how many slave-nodes one node should ideally have. Higher values -> faster manipulation, lower values -> faster lookup
- Map( const SumVector& summands = SumVector() );
- Map( const Map& rhs );
- ~Map();
-
- Map& operator = ( const Map& rhs );
-
- ///Returns the sum over all indices
- int sum() const;
- ///Returns the values of all indices up to(not including) index summed together
- int sum( int index ) const;
-
- ///Returns the index that the given sum falls into. Warning: indices that have a value of zero cannot be mapped back with this function.
- int index( int sum ) const;
-
- void indexAndSum( int sum, IndexAndSum& targ ) const;
-
- bool hasIndex( int index ) const;
- // Map rebuild();
-
- ///Complexity: O(1)
- int indexCount()const ;
-
- ///Returns the value of that specified index
- int indexValue( int index ) const;
-
- ///Returns the previous value of that index. The value must not be zero, because that would not allow consistent mapping back(exception is thrown)
- int setIndexValue( int index, int value );
-
- ///Returns the new value of that index. If the value becomes zero, the index cannot be mapped back through index(..) anymore.
- int changeIndexValue( int index, int diff );
-
- ///Inserts an index at position "index" with the value "value"
- void insertIndex( int index, int value = 0 ) ;
-
- /**Efficiently inserts a range of indices with
- * same value(may be zero) into the tree.
- * @param position Starting-position of the range
- * @param size Count of indices the range will occupy
- * @param value The value each index of the range will get(the whole range will have the sum size*range)
- * $
- */
- void insertRange( int position, int size, int eachValue = 0 );
-
- ///Removes one index at position index, returns the personal sum that index had associated
- /** unregister a previously registered notifier */
- void unregisterNotifier() const {
- notify_ = 0;
- }
-
- BOOST_SERIALIZATION_SPLIT_MEMBER()
- private:
-
- ///Erase and insert could be public, the only problem is that the change-notification would become more complicated(currently notification is done in linear measure)
-
- void insert( int line, int column, const String& text ) {
-#ifdef EXTREMDEBUG
- cout << "insertion at " << line << ":" << column << " length " << text.length() << " of \"" << text << "\"" << endl;
- checkConsistency();
-#endif
- uint len = text.length();
- if( len == 0 ) return;
- int currentStart = 0;
- bool nobreak = true;
- String endAppend; ///Needs to be appended to the last line inserted
- int l = line + 1;
-
- for ( uint a = 0; a < len; a++ ) {
- if ( text[ a ] == lineBreak ) {
- if( nobreak ) {
- ///It is the first line, put it into the insertion-line and break.
- int insertLength = a - currentStart;
- String& curLine( *text_[line] );
- int removeLength = curLine.length() - column;
- DYN_VERIFY_SMALLERSAME( 0, removeLength );
- ///Copy the last part of the line it is inserted to, and append it to the last line inserted.
- ///Remove 'length' characters in line 'line', starting at column 'column'. If the length is longer than the rest of the line, this will continue deleting in the next line.
- void erase( int line, int column, int length ) {
- ///Checks whether "link" should be put into the "links"-map. If it should
- void updateLink( uint index, ReplacementPointer link );
-#endif
-
- friend class DynamicText;
- VectorTimestamp m_state; ///Each Replacement has a unique primary stamp, m_next has the same plus 1, m_prev the same minus one.
-
- SimpleReplacement m_replacement;
-
- ///One is weak one is not, so a chain of replacements cannot keep itself alive. Once the first is lost, all are lost.
- ReplacementPointer m_next;
- WeakReplacementPointer m_prev;
-
-#ifdef USELINKS
- std::vector<WeakReplacementPointer> m_links; ///This maps the index-numbers of other Collaborators to their first replacement that uses the timestamp of this Replacement.
-#endif
-
- bool m_enabled;
-};
-
-struct DYNAMICTEXT_EXPORT ReplacementChain {
- ReplacementPointer first, last;
- template<class Archive>
- void serialize( Archive& arch, const uint ) {
- arch & first & last;
- }
-};
-
-struct DYNAMICTEXT_EXPORT ReplacementId {
- uint primaryIndex;
- Timestamp stamp;
- ReplacementId( uint i = 0, Timestamp st = 0 ) : primaryIndex( i ), stamp( st ) {}
- ///Tries to find out whether the patch is applied by using the patch-command in dry-run mode. Only works with patch-files(not commands). Fills the result into the given patch
-/**This cares about the "send message"-tab in the kdevteamwork user-interface by updating it, according to the current selection in the current document.
- int answer = KMessageBox::warningYesNo( KDevTeamworkPlugin::staticCore()->uiController()->activeMainWindow()->window(), i18n( "The buffer of %1 is modified, should the content be replaced?" , m_fileName ) );
- ///It might be better to model the edit by one removal and one insertion, because that allows better resolution of conflicts.(Think about if it should be like that)
-///This is a class that helps detecting when the document is deleted and then deleting the smartcursor, also it automatically creates the cursor. @todo replace with QOwnedPointer
- /** This takes a complete reference-filename which may include folders(those will be created), and from which extension and name will be extracted.(see function above)
- * - Once developer starts a collaboration-session on an arbitrary set of files, he can invite an arbitrary count of collaborating developers to join it.
- * - He can only host one collaboration-session at a time.
- * - Once the session is closed, he is asked whether he'd like to store the changes of the session as a patch to the patches-list(that way he may also unapply the changes if he saved them).
- * Client:
- * - A client gets an invitation and can accept it.
- * - The client can only be part of one collaboration-session at a time.
- * - Once the session is closed, he is asked whether the result of the session should be stored as a diff-file to the patches-list.(that way it may be applied to the local tree)
- *
- * Implementation: See DynamicText
- *
- * */
-
-/**Algorithm for the FileCollaboration:
- * - Each FileCollaboration-message that is sent gets a personal sequence-number(which is like a timestamp, the "count of locally happened events")
- * that can be used to see which state of the communication it was sent in(and can be used to resolve causalities)
- * - Each FileCollaboration-session has a vector containing all current sequence-numbers
- * - Each FileCollaboration-message is sent together with that vector, so conflicts may be resolved.
- * - Whenever the master-session sends a FileResynchronize-message, the local version of the slave-session is totally updated
- * Compile an identifier for the specified AstNode \a id.
- *
- * \note this reference will only be valid until the next time the function
- * is called, so you need to create a copy (store as non-reference).
- * @param typeSpecifier a pointer that will eventually be filled with a type-specifier that can be found in the name(for example the return-type of a cast-operator)
- classTypeOpened( currentAbstractType() ); //This callback is needed, because the type of the class-declaration needs to be set early so the class can be referenced from within itself
- classTypeOpened( TypeRepository::self()->registerType(currentAbstractType()) ); //This callback is needed, because the type of the class-declaration needs to be set early so the class can be referenced from within itself
-K_EXPORT_PLUGIN(AutomakeBuilderFactory(KAboutData("kdevautomakebuilder","kdevautomakebuilder", ki18n("Automake Builder"), "0.1", ki18n("Support for building Automake projects"), KAboutData::License_GPL)))