déplacement de la partie network

+<application mode="event">
+    <context>
+        <libraries>
+		<library path="../../libs/sample"/>
+		<library path="../../libs/network"/>
+        </libraries>
+        <components>
+		<component id="b" type="Loop"></component>
+		<component id="n" type="Network">arcs://localhost:2031</component>
+            <component id="s" type="StateMachine">
+                <statemachine>
+                    <first name="start"/>
+                    <last name="end"/>
+                    <transitions>
+                        <transition source="start" token="end" destination="end"/>
+                    </transitions>
+                </statemachine>
+            </component>
+    </components>
+    <constants>
+	    <constant id="iterations" type="int">5</constant>
+	</constants>
+    </context>
+
+    <processes>
+    <process controller="s">
+        <sheet id="start">
+            <connections>
+                <link source="b" signal="newIteration(int)" destination="n" slot="display(int)"/>
+                <link source="b" signal="sendToken(QString)" destination="s" slot="setToken(QString)" />
+            </connections>
+            <postconnections>
+                <invoke destination="b" slot="setIterations(int)" type="constant">iterations</invoke>
+            </postconnections>
+        </sheet>
+        <sheet id="end"/>
+    </process>
+</processes>
+
+</application>

+<application mode="event">
+    <context>
+        <libraries>
+		<library path="../../libs/sample"/>
+		<library path="../../libs/network"/>
+        </libraries>
+        <components>
+                <component id="n" type="Network">arcs://localhost:2030</component>
+                <component id="d" type="DisplayInt"></component>
+            <component id="s" type="StateMachine">
+                <statemachine>
+                    <first name="start"/>
+                    <last name="end"/>
+                    <transitions>
+                        <transition source="start" token="end" destination="end"/>
+                    </transitions>
+                </statemachine>
+            </component>
+    </components>
+    <constants>
+	    <constant id="iterations" type="int">5</constant>
+	</constants>
+    </context>
+
+    <processes>
+    <process controller="s">
+        <sheet id="start">
+            <connections>
+                <link source="n" signal="newIteration(int)" destination="d" slot="display(int)"/>
+            </connections>
+            <postconnections>
+                <invoke destination="n" slot="setIterations(int)" type="constant">iterations</invoke>
+                <invoke destination="s" slot="setToken(QString)" type="string">end</invoke>
+            </postconnections>
+        </sheet>
+        <sheet id="end"/>
+    </process>
+</processes>
+
+</application>

+<application mode="event">
+    <context>
+        <libraries>
+		<library path="../../libs/sample"/>
+		<library path="../../libs/network"/>
+        </libraries>
+        <components>
+            <component id="n_l" type="Network">arcs://localhost:2030</component>
+            <component id="n_di" type="Network">arcs://localhost:2031</component>
+            <component id="s" type="StateMachine">
+                <statemachine>
+                    <first name="start"/>
+                    <last name="end"/>
+                    <transitions>
+                        <transition source="start" token="end" destination="end"/>
+                    </transitions>
+                </statemachine>
+            </component>
+    </components>
+    <constants>
+	    <constant id="iterations" type="int">5</constant>
+	</constants>
+    </context>
+
+    <processes>
+    <process controller="s">
+        <sheet id="start">
+            <connections>
+                <link source="n_l" signal="newIteration(int)" destination="n_di" slot="display(int)"/>
+            </connections>
+            <postconnections>
+                <invoke destination="n_l" slot="setIterations(int)" type="constant">iterations</invoke>
+                <invoke destination="s" slot="setToken(QString)" type="string">end</invoke>
+            </postconnections>
+        </sheet>
+        <sheet id="end"/>
+    </process>
+</processes>
+
+</application>

+<application mode="event">
+    <context>
+        <libraries>
+            <library path="../../libs/sample"/>
+            <library path="../../libs/network"/>
+        </libraries>
+        <components>
+            <component id="d" type="DisplayInt"></component>
+            <component id="n" type="ARCSNetworkConfigurator"></component>
+            <component id="s" type="StateMachine">
+                <statemachine>
+                    <first name="start"/>
+                    <last name="end"/>
+                    <transitions>
+                        <transition source="start" token="end" destination="end"/>
+                    </transitions>
+                </statemachine>
+            </component>
+    </components>
+    </context>
+
+    <processes>
+    <process controller="s">
+        <sheet id="start">
+            <preconnections>
+                <invoke destination="n" slot="setPort(int)" type="int">2031</invoke>
+                <invoke destination="n" slot="setInterface(QString)" type="string">d</invoke>
+            </preconnections>
+        </sheet>
+        <sheet id="end"/>
+    </process>
+</processes>
+
+</application>

+<application mode="event">
+    <context>
+        <libraries>
+            <library path="../../libs/sample"/>
+            <library path="../../libs/network"/>
+        </libraries>
+        <components>
+            <component id="l" type="Loop"></component>
+            <component id="n" type="ARCSNetworkConfigurator"></component>
+            <component id="s" type="StateMachine">
+                <statemachine>
+                    <first name="start"/>
+                    <last name="end"/>
+                    <transitions>
+                        <transition source="start" token="end" destination="end"/>
+                    </transitions>
+                </statemachine>
+            </component>
+    </components>
+    </context>
+
+    <processes>
+    <process controller="s">
+        <sheet id="start">
+            <preconnections>
+                <invoke destination="n" slot="setPort(int)" type="int">2030</invoke>
+                <invoke destination="n" slot="setInterface(QString)" type="string">l</invoke>
+            </preconnections>
+        </sheet>
+        <sheet id="end"/>
+    </process>
+</processes>
+
+</application>

+#include<arcs/arcslibtoolkit.h>
+#include<QMetaType>
+#include<arcsnetworkfamily.h>
+#include<arcsnetworkcomponent.h>
+#include<arcsnetworkconfigurator.h>
+
+extern "C" DLL_EXPORT void arcsLibraryRegister(ARCSComponentMap* cmap, ARCSFamilyMap* fmap, ARCSTypeMap* )
+{
+	cmap->insert("ARCSNetworkConfigurator",new ARCSNativeComponentTemplate<ARCSNetworkConfigurator>());
+
+	fmap->insert("ARCSNetworkFamily",new ARCSNetworkFamily());
+
+}
+
+extern "C" DLL_EXPORT void arcsLibraryUnregister(ARCSComponentMap* cmap, ARCSFamilyMap* fmap, ARCSTypeMap* )
+{
+	delete cmap->take("ARCSNetworkConfigurator");
+
+	delete fmap->take("ARCSNetworkFamily");
+
+}
+

+#include "arcsnetworkcomponent.h"
+#include <arcs/arcsfactory.h>
+#include "arcsnetworkproxyslot.h"
+#include "arcsnetworkproxysignal.h"
+#include "arcsnetworkframes.h"
+
+#include <QTcpSocket>
+
+/********************************************************
+  * ARCSRemote Component
+  ************************************************************/
+
+ARCSNetworkComponent::ARCSNetworkComponent()
+{
+     setType("Network");
+     setFamily("Network");
+
+     hostName = "localhost";
+     port = 2020;
+     connectStatus = false;
+}
+
+
+ARCSNetworkComponent::~ARCSNetworkComponent()
+{
+
+
+}
+
+QString ARCSNetworkComponent::toString()
+{
+     return "arcs://" + hostName +":" + QString::number(port) + "/" ; //+ interface;
+}
+
+bool ARCSNetworkComponent::parseString(QString s)
+{
+     // arcs://host:port/interface
+
+     QString inter = s.section("/", 2,2);
+     hostName = inter.section(":",0,0);
+     QString portString = inter.section(":",1,1);
+     interface = inter.section("/",3);
+
+     if (!portString.isEmpty())
+     {
+          int tmp = portString.toInt();
+          if (tmp > 0 && tmp < 65536)
+               port = tmp;
+     }
+
+     if ( hostName.isEmpty() )
+          return false;
+
+
+     return true;
+}
+
+QStringList ARCSNetworkComponent::getSignals()
+{
+     QStringList res;
+     QTcpSocket* socket = new QTcpSocket();
+     socket->connectToHost(hostName, port);
+     if (!socket->waitForConnected(ARCSNetworkFrame::TimeOut))
+     {
+          std::cerr << "[Network] interface request error " << qPrintable(socket->errorString()) << std::endl;
+          return res;
+     }
+
+     ARCSNetworkFrame request(ARCSNetworkFrame::IFACE_REQUEST);
+     request.writeFrame(socket);
+
+     ARCSNetworkFrame* response = ARCSNetworkFrame::readFrame(socket);
+     if (response )
+     {
+          if (response->getType() != ARCSNetworkFrame::IFACE_RESPONSE)
+               std::cerr << "[Network] invalid response recieved to interface request." << std::endl;
+          else
+               res = ((ARCSNetworkInterfaceResponse*)response->getData())->getSignals();
+     }
+     else
+          std::cerr << "[Network] Null interface response recieved ! " << std::endl;
+
+     socket->disconnectFromHost();
+     if (response)
+          delete response;
+
+     return res;
+}
+
+
+QStringList ARCSNetworkComponent::getSlots()
+{
+     QStringList res;
+     QTcpSocket* socket = new QTcpSocket();
+     socket->connectToHost(hostName, port);
+     if (!socket->waitForConnected(ARCSNetworkFrame::TimeOut))
+     {
+          std::cerr << "[Network] interface request error " << qPrintable(socket->errorString()) << std::endl;
+          return res;
+     }
+
+     ARCSNetworkFrame request(ARCSNetworkFrame::IFACE_REQUEST);
+     request.writeFrame(socket);
+
+     ARCSNetworkFrame* response = ARCSNetworkFrame::readFrame(socket);
+     if (response )
+     {
+          if (response->getType() != ARCSNetworkFrame::IFACE_RESPONSE)
+               std::cerr << "[Network] invalid response recieved to interface request." << std::endl;
+          else
+               res = ((ARCSNetworkInterfaceResponse*)response->getData())->getSlots();
+     }
+     else
+          std::cerr << "[Network] Null interface response recieved ! " << std::endl;
+
+     socket->disconnectFromHost();
+     if (response)
+          delete response;
+
+     return res;
+}
+
+
+void	ARCSNetworkComponent::getProxySlot (QString slot, ObjectList &obj, QStringList &proxySlot)
+{
+     ARCSNetworkProxySlot* proxy;
+     if (proxySlots.contains(slot))
+          proxy = proxySlots[slot];
+     else
+     {
+          proxy = new ARCSNetworkProxySlot(this);
+          proxy->setHostname(hostName);
+          proxy->setPort(port);
+          proxySlots.insert(slot, proxy);
+     }
+
+     obj << proxy;
+     proxy->setSlot(slot);
+     proxySlot << slot ;
+}
+
+
+void ARCSNetworkComponent::requestSlotConnect(ARCSNetworkProxySlot* anps)
+{
+     QTcpSocket* socket = new QTcpSocket(anps);
+     socket->connectToHost(hostName, port);
+     if (!socket->waitForConnected(ARCSNetworkFrame::TimeOut))
+     {
+          std::cerr << "[Network] slot request error " << qPrintable(socket->errorString()) << std::endl;
+          return ;
+     }
+
+     ARCSNetworkFrame request(ARCSNetworkFrame::SLOT_REQUEST);
+     ((ARCSNetworkSlotRequest*)request.getData())->setSlot(anps->getSlot());
+     request.writeFrame(socket);
+
+     ARCSNetworkFrame* response = ARCSNetworkFrame::readFrame(socket);
+     if (response )
+     {
+          if (response->getType() != ARCSNetworkFrame::CONNECT_RESPONSE)
+               std::cerr << "[Network] invalid response recieved to connect request." << std::endl;
+          else
+               anps->setSlotId(((ARCSNetworkConnectResponse*)response->getData())->getId());
+     }
+     else
+          std::cerr << "[Network] Null connect response recieved ! " << std::endl;
+
+     socket->disconnectFromHost();
+     if (response)
+          delete response;
+}
+
+
+void ARCSNetworkComponent::requestSignalConnect(ARCSNetworkProxySignal* anps)
+{
+     QTcpSocket* socket = new QTcpSocket();
+     socket->connectToHost(hostName, port);
+     if (!socket->waitForConnected(ARCSNetworkFrame::TimeOut))
+     {
+          std::cerr << "[Network] signal request error " << qPrintable(socket->errorString()) << std::endl;
+          return ;
+     }
+
+     ARCSNetworkFrame request(ARCSNetworkFrame::SIGNAL_REQUEST);
+     ((ARCSNetworkSignalRequest*)request.getData())->setParams(
+               anps->getId(),
+               ARCSNetworkServer::getInstance()->getPort(),
+               anps->getSignal()
+               );
+
+     request.writeFrame(socket);
+
+     ARCSNetworkFrame* response = ARCSNetworkFrame::readFrame(socket);
+     if (response)
+          delete response;
+
+     socket->disconnectFromHost();
+     delete socket;
+}
+
+void ARCSNetworkComponent::requestSignalDisconnect(ARCSNetworkProxySignal* anps)
+{
+     QTcpSocket* socket = new QTcpSocket();
+     socket->connectToHost(hostName, port);
+     if (!socket->waitForConnected(ARCSNetworkFrame::TimeOut))
+     {
+          std::cerr << "[Network] signal request error " << qPrintable(socket->errorString()) << std::endl;
+          return ;
+     }
+
+     ARCSNetworkFrame request(ARCSNetworkFrame::DISCONNECT_REQUEST);
+     ((ARCSNetworkDisconnectRequest*)request.getData())->setSignal(anps->getSignal());
+
+     request.writeFrame(socket);
+
+     ARCSNetworkFrame* response = ARCSNetworkFrame::readFrame(socket);
+     if (response)
+          delete response;
+
+     socket->disconnectFromHost();
+     delete socket;
+}
+
+
+
+void ARCSNetworkComponent::getProxySignal (QString signal, ObjectList &obj, QStringList &proxySignal)
+{
+     QString id = getProperty("id").toString();
+     ARCSNetworkProxySignal* proxy = ARCSNetworkServer::getInstance()->getProxySignal(signal);
+     proxy->setHome(this);
+     obj << proxy;
+     proxySignal << signal;
+}
+
+
+bool ARCSNetworkComponent::genuineConnect (QString sig, ARCSAbstractComponent *dst, QString slt, bool )
+{
+     QTcpSocket* socket = new QTcpSocket();
+     socket->connectToHost(hostName, port);
+     if (!socket->waitForConnected(ARCSNetworkFrame::TimeOut))
+     {
+          std::cerr << "[Network] call error " << qPrintable(socket->errorString()) << std::endl;
+          return false;
+     }
+
+
+     ARCSNetworkFrame request(ARCSNetworkFrame::CONNECT_REQUEST);
+     ((ARCSNetworkConnectRequest*)request.getData())->setParams(sig, dst->toString(), slt);
+
+     request.writeFrame(socket);
+     ARCSNetworkFrame* response = ARCSNetworkFrame::readFrame(socket);
+     if (response)
+          delete response;
+
+     socket->disconnectFromHost();
+     delete socket;
+
+     return true;
+}
+
+
+bool ARCSNetworkComponent::genuineDisconnect(QString sig, ARCSAbstractComponent* , QString )
+{
+     QTcpSocket* socket = new QTcpSocket();
+     socket->connectToHost(hostName, port);
+     if (!socket->waitForConnected(ARCSNetworkFrame::TimeOut))
+     {
+          std::cerr << "[Network] call error " << qPrintable(socket->errorString()) << std::endl;
+          return false;
+     }
+
+
+     ARCSNetworkFrame request(ARCSNetworkFrame::DISCONNECT_REQUEST);
+     ((ARCSNetworkDisconnectRequest*)request.getData())->setSignal(sig);
+
+     request.writeFrame(socket);
+     ARCSNetworkFrame* response = ARCSNetworkFrame::readFrame(socket);
+     if (response)
+          delete response;
+
+     socket->disconnectFromHost();
+     delete socket;
+
+     return true;
+}
+
+
+

+#ifndef __ARCSREMOTECOMPONENT_H__
+#define __ARCSREMOTECOMPONENT_H__
+
+#include <arcs/arcsabstractcomponent.h>
+#include <arcs/arcsnativecomponent.h>
+#include <QHash>
+#include <QObject>
+#include "arcsnetworkserver.h"
+#include <iostream>
+
+
+class ARCSNetworkProxySlot;
+
+//! Class describing a remote component
+/*! This description is only intended to used at the master side of the application.
+  *\author Jean-Yves Didier and Mehdi Chouiten
+  * \ingroup network
+  * \date July, the 9th, 2009
+  */
+  class ARCSNetworkComponent : public ARCSAbstractComponent
+  {
+   public:
+    ARCSNetworkComponent();
+    ~ARCSNetworkComponent();
+
+    virtual QString toString();
+    virtual bool parseString(QString s);
+    virtual QStringList getSignals();
+    virtual QStringList getSlots();
+
+    void requestSlotConnect(ARCSNetworkProxySlot* anps);
+    void requestSignalConnect(ARCSNetworkProxySignal* anps);
+     void requestSignalDisconnect(ARCSNetworkProxySignal* anps);
+
+
+    void clearProxySlots();
+
+
+ protected:
+    virtual void 	getProxySlot (QString slot, ObjectList &obj, QStringList &proxySlot);
+
+    virtual void 	getProxySignal (QString signal, ObjectList &obj, QStringList &proxySignal);
+
+    virtual bool 	genuineConnect (QString sig, ARCSAbstractComponent *dst, QString slt, bool queued=false);
+
+    virtual bool 	genuineDisconnect (QString sig, ARCSAbstractComponent *dst, QString slt);
+
+    virtual bool 	genuineInstanciate ()
+    {
+         if (!ARCSNetworkServer::getInstance()->isListening())
+              ARCSNetworkServer::getInstance()->start();
+          return true;
+    }
+
+    virtual void 	genuineDestroy ()
+    {
+    }
+
+    virtual ARCSAbstractComponent * 	genuineClone ()
+    {
+         return 0;
+    }
+
+private:
+    QString hostName;
+    QString interface;
+    int port;
+    bool connectStatus;
+    QHash<QString, ARCSNetworkProxySlot*> proxySlots;
+};
+
+#endif // __ARCSREMOTECOMPONENT_H__

+#ifndef __ARCSNETWORKCONFIGURATOR_H__
+#define __ARCSNETWORKCONFIGURATOR_H__
+
+#include <QObject>
+#include "arcsnetworkserver.h"
+
+
+//! Simple component intended to configure a network server.
+/*! This should mainly be used in the slave side.
+ * \author Jean-Yves Didier
+ * \ingroup network
+ * \date November, the 5th, 2009
+ */
+class ARCSNetworkConfigurator : public QObject
+{
+     Q_OBJECT
+
+     public:
+          ARCSNetworkConfigurator(QObject* parent=0) : QObject(parent) {} //!< ARCS Constructor
+
+     public slots:
+          /*! \brief Sets the interface to use and that will be seen from afar.
+            * \param s The component name implementing the interface.
+            */
+          void setInterface(QString s) { ARCSNetworkServer::getInstance()->setInterface(s); }
+          /*! \brief Sets the port to which the server is listening to.
+            * \param i a port number ( 0 < i < 65536)
+            */
+          void setPort(int i) { ARCSNetworkServer::getInstance()->setPort(i); }
+};
+
+
+#endif // __ARCSNETWORKCONFIGURATOR_H__

+#ifndef __ARCSNETWORKFAMILY_H__
+#define __ARCSNETWORKFAMILY_H__
+
+#include <arcs/arcsabstractfamily.h>
+#include "arcsnetworkcomponent.h"
+
+
+/*!
+ * \defgroup network Network distribution in ARCS
+ *
+ * This library is defining a very basic distributed protocol for ARCS applications.
+ */
+
+//! Network component family
+/*!
+  * \author Jean-Yves Didier
+  * \date November, the 5th, 2009
+  * \ingroup network
+  */
+class ARCSNetworkFamily : public ARCSAbstractFamily
+{
+   public:
+    ARCSNetworkFamily() { }
+    ~ARCSNetworkFamily() { }
+
+    virtual QStringList factoryList() { return QStringList("Network"); }
+    virtual bool addFactory(QString, ARCSAbstractComponent*) { return false; }
+    virtual void removeFactory(QString) { }
+    virtual ARCSAbstractComponent* instanciate(QString type)
+    {
+         if (type == "Network")
+              return new ARCSNetworkComponent();
+         return 0;
+    }
+
+    virtual void destroy(ARCSAbstractComponent* component)
+    {
+         delete component;
+    }
+
+    virtual QString name() const { return "ARCSNetworkFamily"; }
+
+};
+
+#endif // __ARCSNETWORKFAMILY_H__

+#include "arcsnetworkframes.h"
+#include <QDataStream>
+#include <QByteArray>
+#include <iostream>
+
+
+int ARCSNetworkFrame::TimeOut = -1; // 5000;
+
+
+void ARCSNetworkFrame::setType(ARCSNetworkFrames t)
+{
+     if (data)
+          delete data;
+
+     type = t;
+     switch(type)
+     {
+     case IFACE_REQUEST:
+          data = new ARCSNetworkInterfaceRequest();
+          break;
+     case IFACE_RESPONSE:
+          data = new ARCSNetworkInterfaceResponse();
+          break;
+     case CONNECT_REQUEST:
+          data = new ARCSNetworkConnectRequest();
+          break;
+     case DISCONNECT_REQUEST:
+          data = new ARCSNetworkDisconnectRequest();
+          break;
+     case CONNECT_RESPONSE:
+          data = new ARCSNetworkConnectResponse();
+          break;
+     case CALL_REQUEST:
+          data = new ARCSNetworkCallRequest();
+          break;
+     case CALL_RESPONSE:
+          data = new ARCSNetworkCallResponse();
+          break;
+
+     case SLOT_REQUEST:
+          data = new ARCSNetworkSlotRequest();
+          break;
+     case SIGNAL_REQUEST:
+          data = new ARCSNetworkSignalRequest();
+          break;
+
+     default:
+          type = INVALID;
+          data = 0 ;
+     }
+
+}
+
+
+
+
+ARCSNetworkFrame* ARCSNetworkFrame::readFrame(QIODevice* device)
+{
+     // lecture de la taille
+     while (device->bytesAvailable() < (int)sizeof(quint32))
+     {
+          if (!device->waitForReadyRead(TimeOut))
+          {
+               std::cerr << "[Network] Read type - " << qPrintable(device->errorString()) << std::endl;
+               return 0;
+          }
+     }
+
+     quint32 blockSize;
+     QDataStream in(device);
+     in.setVersion(QDataStream::Qt_4_5);
+     in >> blockSize;
+
+
+     while (device->bytesAvailable() < blockSize)
+     {
+          if (!device->waitForReadyRead(TimeOut))
+          {
+               std::cerr << "[Network] Read data - " << qPrintable(device->errorString()) << std::endl;
+               return 0;
+          }
+     }
+
+     ARCSNetworkFrame* frame = new ARCSNetworkFrame();
+     in >> *frame;
+     return frame;
+}
+
+
+void ARCSNetworkFrame::writeFrame(QIODevice* device)
+{
+     QByteArray block;
+
+     QDataStream out(&block, QIODevice::WriteOnly);
+     out.setVersion(QDataStream::Qt_4_5);
+     out << (quint32)0 ;
+     out << *this ;
+     out.device()->seek(0);
+     out << (quint32)(block.size() - sizeof(quint32)) ;
+
+     device->write(block);
+
+     if (!device->waitForBytesWritten(TimeOut))
+     {
+          std::cerr << "[Network] Didn't wait enough to write all bytes" << std::endl;
+     }
+}
+
+
+
+QDataStream &operator>>(QDataStream & stream, ARCSNetworkFrame& frame)
+{
+     int type ;
+     stream >> type ;
+     frame.setType((ARCSNetworkFrame::ARCSNetworkFrames)type);
+     frame.getData()->deserialize(stream);
+     return stream;
+}
+
+
+QDataStream &operator<<(QDataStream & stream, const ARCSNetworkFrame& frame)
+{
+     stream << (int)frame.getType();
+     frame.getData()->serialize(stream);
+     return stream;
+}

+#ifndef __ARCSNETWORKFRAMES_H__
+#define __ARCSNETWORKFRAMES_H__
+
+#include <QByteArray>
+#include <QStringList>
+#include <QDataStream>
+
+//! Base class for data in network frames.
+/*! It describes serialization/deserialization methods for data frames.
+  * \author Jean-Yves Didier
+  * \date November, the 5th, 2009
+  * \ingroup network
+  */
+class ARCSNetworkData
+{
+public:
+    virtual ~ARCSNetworkData() {}
+     virtual void serialize(QDataStream& stream) = 0;
+     virtual void deserialize(QDataStream& stream) = 0;
+};
+
+//! Class implementing ARCS network frames
+/*! A frame is characterized by a type id and data depending on the type.
+  * \author Jean-Yves Didier
+  * \date November, the 5th, 2009
+  * \ingroup network
+  */
+class ARCSNetworkFrame
+{
+public:
+     enum ARCSNetworkFrames {
+          INVALID,
+          CALL_REQUEST,
+          SLOT_REQUEST,
+          SIGNAL_REQUEST,
+          CONNECT_REQUEST,
+          DISCONNECT_REQUEST,
+          IFACE_REQUEST,
+
+          SLOT_RESPONSE,
+          CONNECT_RESPONSE, /* A revoir, peut-tre un SLOT response */
+          CALL_RESPONSE,  /* A revoir, peut-tre un ACK response */
+          ACK_RESPONSE,
+          IFACE_RESPONSE
+     };
+
+     ARCSNetworkFrame() { type = INVALID; data = 0;}
+     ARCSNetworkFrame(ARCSNetworkFrames t) { data = 0; setType(t); }
+     ~ARCSNetworkFrame() { if (data != 0) delete data; }
+     void setType(ARCSNetworkFrames t);
+
+     bool isValid() { return type != INVALID; }
+
+     ARCSNetworkFrames getType() const { return type; }
+     ARCSNetworkData* getData() const { return data; }
+
+     static ARCSNetworkFrame* readFrame(QIODevice* device);
+     void writeFrame(QIODevice* device);
+     static int TimeOut ;
+
+private:
+     ARCSNetworkFrames  type;
+     ARCSNetworkData* data;
+};
+
+QDataStream &operator>>(QDataStream & stream, ARCSNetworkFrame& frame);
+QDataStream &operator<<(QDataStream & stream, const ARCSNetworkFrame& frame);
+
+
+class ARCSNetworkInterfaceRequest : public ARCSNetworkData
+{
+public:
+     ARCSNetworkInterfaceRequest() {}
+     virtual void serialize(QDataStream& ) {}
+     void deserialize(QDataStream& ) {}
+};
+
+class ARCSNetworkInterfaceResponse : public ARCSNetworkData
+{
+     public:
+     ARCSNetworkInterfaceResponse() {}
+     QStringList getSignals() { return signalList; }
+     QStringList getSlots() { return slotList; }
+     void setSignals(QStringList sl) { signalList = sl; }
+     void setSlots(QStringList sl) { slotList = sl; }
+
+     virtual void serialize(QDataStream& stream) { stream << slotList << signalList; }
+     virtual void deserialize(QDataStream& stream) { stream >> slotList >> signalList; }
+
+     private:
+     QStringList signalList;
+     QStringList slotList;
+};
+
+class ARCSNetworkConnectRequest : public ARCSNetworkData
+{
+     public:
+     ARCSNetworkConnectRequest() {}
+     //QString getSource() { return source; }
+     QString getDestination() { return destination; }
+     QString getSignal() { return signalName; }
+     QString getSlot() { return slotName; }
+
+     void setParams(/*QString host,*/ QString sig, QString dst, QString slt)
+     {
+          //source = src;
+          destination = dst;
+          signalName = sig;
+          slotName = slt;
+     }
+
+     virtual void serialize(QDataStream& stream) { stream /*<< source*/ << signalName << destination << slotName; }
+     virtual void deserialize(QDataStream& stream) { stream /*>> source*/ >> signalName >> destination >> slotName; }
+
+private:
+     //QString source;
+     QString destination;
+     QString slotName;
+     QString signalName;
+};
+
+class ARCSNetworkConnectResponse : public ARCSNetworkData
+{
+     public:
+     ARCSNetworkConnectResponse() {}
+
+     int getId() { return id; }
+     void setId(int i) { id = i ;}
+     virtual void serialize(QDataStream& stream) { stream << id ; }
+     virtual void deserialize(QDataStream& stream) { stream >> id; }
+
+     private:
+     int id;
+};
+
+
+class ARCSNetworkSignalRequest : public ARCSNetworkData
+{
+     public:
+     ARCSNetworkSignalRequest() {}
+
+     virtual void serialize(QDataStream& stream) { stream << id << port << signalName; }
+     virtual void deserialize(QDataStream& stream) { stream >> id >> port >> signalName; }
+
+     quint16 getPort() { return port;}
+     void setPort(quint16 p) { port = p  ;}
+     int getId() { return id; }
+     void setId(int i) { id = i ; }
+     QString getSignal() { return signalName; }
+     void setSignal(QString s) { signalName = s; }
+     void setParams(int i, quint16 p, QString s) { id = i; port = p; signalName = s; }
+
+     private:
+     int id ;
+     quint16 port;
+     QString signalName;
+
+
+};
+
+
+//! Frame encapsulating a slot request.
+/*! Such frame is emitted when a master needs specific slot from a remote component.
+ *
+ * \author Jean-Yves Didier
+ * \date November, the 12th, 2009
+ * \ingroup network
+ */
+class ARCSNetworkSlotRequest : public ARCSNetworkData
+{
+     public:
+     ARCSNetworkSlotRequest() {}
+
+     QString getSlot() { return slotName; }
+     void setSlot(QString s) { slotName = s ; }
+     virtual void serialize(QDataStream& stream) { stream << slotName ; }
+     virtual void deserialize(QDataStream& stream) { stream >> slotName; }
+
+     private:
+     QString slotName;
+};
+
+
+class ARCSNetworkDisconnectRequest : public ARCSNetworkData
+{
+     public:
+     ARCSNetworkDisconnectRequest() {}
+
+     QString getSignal() { return signalName; }
+     void setSignal(QString s) { signalName = s ; }
+     virtual void serialize(QDataStream& stream) { stream << signalName ; }
+     virtual void deserialize(QDataStream& stream) { stream >> signalName; }
+
+     private:
+     QString signalName;
+};
+
+
+
+
+class ARCSNetworkCallRequest : public ARCSNetworkData
+{
+     public:
+     ARCSNetworkCallRequest() {}
+
+     int getId() { return id; }
+     void setId(int i) { id = i ;}
+     QStringList getParams() { return params; }
+     void setParams(QStringList sl) { params = sl; }
+     void setParams(int i, QStringList sl) { id = i; params = sl; }
+
+     virtual void serialize(QDataStream& stream) { stream << id << params; }
+     virtual void deserialize(QDataStream& stream) { stream >> id >> params; }
+
+     private:
+     int id;
+     QStringList params;
+};
+
+
+class ARCSNetworkCallResponse : public ARCSNetworkData
+{
+     public:
+     ARCSNetworkCallResponse() {}
+
+     virtual void serialize(QDataStream& ) { }
+     virtual void deserialize(QDataStream& ) { }
+};
+
+
+
+#endif // ARCSNETWORKFRAMES_H

+#include "arcsnetworkproxysignal.h"
+#include <arcs/arcsfactory.h>
+#include "arcsnetworkserver.h"
+#include "arcsnetworkframes.h"
+#include "arcsnetworkcomponent.h"
+#include <arcs/arcsabstractcomponent.h>
+#include <QTcpSocket>
+
+
+int ARCSNetworkProxySignal::qt_metacall(QMetaObject::Call call, int id, void ** arguments)
+{
+     id = QObject::qt_metacall(call,id, arguments);
+
+     if (id == -1 || call != QMetaObject::InvokeMetaMethod)
+          return -1;
+
+     if (id < 0)
+          return -1;
+
+     QMetaObject::activate(this, metaObject(), id + metaObject()->methodCount(), arguments);
+
+     return -1;
+}
+
+
+
+void ARCSNetworkProxySignal::setSignal(QString s)
+{
+     paramTypes = s.section("(",1,1).section(")", 0,0).split(",");
+     typeIds.clear();
+
+     for (int i=0; i < paramTypes.count(); i++)
+          typeIds.append(QMetaType::type(qPrintable(paramTypes.at(i))));
+
+     signalName = s;
+}
+
+
+
+int ARCSNetworkProxySignal::prepareSignalConnect(QString, QString, QString, QString, bool)
+{
+     ARCSNetworkComponent* anc = dynamic_cast<ARCSNetworkComponent*>(home);
+     if (anc)
+          anc->requestSignalConnect(this);
+
+
+     return metaObject()->methodCount();
+}
+
+
+int ARCSNetworkProxySignal::cleanSignalConnect(QString, QString, QString, QString)
+{
+     ARCSNetworkComponent* anc = dynamic_cast<ARCSNetworkComponent*>(home);
+     if (anc)
+          anc->requestSignalDisconnect(this);
+
+     return metaObject()->methodCount();
+}
+
+
+void ARCSNetworkProxySignal::call(QStringList sl)
+{
+          //1 prparer les donnes
+     int nbargs = sl.count();
+     void * args[nbargs+1];
+     args[0] = 0 ;
+
+     // dump des paramtres passs
+     /*std::cout << "[Network] Obtained parameters: " ;
+     for (int k = 0; k < sl.count(); k++)
+     {
+          std::cout << qPrintable(sl[k]) << " ";
+     }
+     std::cout << std::endl;*/
+
+
+     if (nbargs > typeIds.count())
+     {
+          std::cerr << "[Network] Argument and type count mismatch (" << nbargs << ", "<< typeIds.count() << ")" << std::endl;
+          return ;
+     }
+
+     for (int i = 0; i < nbargs; i++)
+     {
+          QVariant var =  ARCSFactory::getInstance()->dataDeserialize(paramTypes[i],sl[i]); //ctx->argument(i).toVariant();
+          var.convert((QVariant::Type)typeIds[i]);
+          args[i+1] = var.data() ;
+     }
+
+     //2 lancer l'appel  l'aide de qt_metacall() ou qt_activate()
+     qt_metacall( QMetaObject::InvokeMetaMethod ,metaObject()->methodCount(),args);
+}

+#ifndef __ARCSNETWORKPROXYSIGNAL_H__
+#define __ARCSNETWORKPROXYSIGNAL_H__
+
+#include <arcs/arcsqdynamicobject.h>
+#include <QObject>
+
+class ARCSAbstractComponent;
+
+//! Class implementing a proxy for network signals
+/*!
+  * \author Jean-Yves Didier
+  * \date November, the 5th, 2009
+  * \ingroup network
+  */
+class ARCSNetworkProxySignal : public QObject, public ARCSQDynamicObject
+{
+public:
+     ARCSNetworkProxySignal(ARCSAbstractComponent* aac, QObject* parent=0) : QObject(parent) { home = aac;}
+
+     virtual int qt_metacall(QMetaObject::Call call, int id, void ** arguments);
+     virtual QStringList getSignalList() { return QStringList(signalName); }
+     virtual QStringList getSlotList() { return QStringList(); }
+     virtual int prepareSlotConnect(QString, QString, QString, QString, bool) { return -1;}
+     virtual int prepareSignalConnect(QString sigName, QString sltName, QString objectName, QString actualSlot, bool simulate = false);// { return 0;}
+     virtual int cleanSlotConnect(QString, QString, QString, QString) { return 0;}
+     virtual int cleanSignalConnect(QString, QString, QString, QString);
+
+     void setSignal(QString s);
+     void call(QStringList sl);
+     QString getSignal() { return signalName; }
+     void setId(int i) { id = i; }
+     int getId() { return id; }
+     void setHome(ARCSAbstractComponent* cmp) { home = cmp; }
+
+
+private:
+     QList<int> typeIds;
+     QStringList paramTypes;
+     QString signalName;
+     int id;
+     ARCSAbstractComponent* home;
+};
+
+
+#endif // __ARCSNETWORKPROXYSIGNAL_H__

+#include "arcsnetworkproxyslot.h"
+#include "arcsnetworkframes.h"
+#include "arcsnetworkserver.h"
+#include "arcsnetworkcomponent.h"
+#include <arcs/arcsfactory.h>
+#include <QTcpSocket>
+#include <iostream>
+
+ARCSNetworkProxySlot::ARCSNetworkProxySlot(ARCSAbstractComponent* cmp, QObject* parent) : QObject(parent)
+{
+     slotId = -1;
+     home = cmp;
+}
+
+
+
+int ARCSNetworkProxySlot::qt_metacall(QMetaObject::Call call,int id, void** arguments)
+{
+     // should implement a call here !
+     id = QObject::qt_metacall(call,id, arguments);
+     if (id < 0 || call != QMetaObject::InvokeMetaMethod)
+          return id;
+
+     if (id != 0)
+          return -1;
+
+     if (slotId == -1)
+          return -1;
+
+     QStringList request;
+     for (int i =0; i < typeIds.count(); i++)
+     {
+          int it = typeIds[i];
+
+          if (it != QMetaType::Void)
+          {
+               QVariant v(it, arguments[i+1]);
+               request << ARCSFactory::getInstance()->dataSerialize(v);
+          }
+     }
+
+     // call here slot with all its params.
+     QTcpSocket* socket = new QTcpSocket(this);
+     socket->connectToHost(hostName, port);
+     if (!socket->waitForConnected(ARCSNetworkFrame::TimeOut))
+     {
+             std::cerr << "[Network] call error " << qPrintable(socket->errorString()) << std::endl;
+             std::cerr << "[Network] params are " << qPrintable(hostName) << ": " << port
+                       << " (" << this << ")" << std::endl;
+             return -1;
+     }
+     // cration de la frame
+     ARCSNetworkFrame frameRequest(ARCSNetworkFrame::CALL_REQUEST);
+     ((ARCSNetworkCallRequest*)frameRequest.getData())->setParams(slotId, request);
+     frameRequest.writeFrame(socket);
+
+     ARCSNetworkFrame* response = ARCSNetworkFrame::readFrame(socket);
+
+     // traitement de response -> Non c'est juste pour attendre de manire bloquante !
+     socket->disconnectFromHost();
+     if (response)
+          delete response;
+    delete socket;
+     return -1;
+}
+
+
+void ARCSNetworkProxySlot::setSlot(QString s)
+{
+     QStringList paramTypes = s.section("(",1,1).section(")", 0,0).split(",");
+     typeIds.clear();
+
+     for (int i=0; i < paramTypes.count(); i++)
+          typeIds.append(QMetaType::type(qPrintable(paramTypes.at(i))));
+
+     slotName = s;
+}
+
+
+
+
+int ARCSNetworkProxySlot::prepareSlotConnect(QString , QString sltName, QString , QString , bool simulate)
+{
+     if (simulate)
+          return 0;
+
+     ARCSNetworkComponent* anc = dynamic_cast<ARCSNetworkComponent*>(home);
+     if (anc)
+          anc->requestSlotConnect(this);
+
+
+
+     if (metaObject()->indexOfSlot(qPrintable(sltName)) != -1)
+     {
+          return metaObject()->indexOfSlot(qPrintable(sltName));
+     }
+
+     return metaObject()->methodCount();
+}
+
+
+
+

+#ifndef __ARCSNETWORKPROXYSLOT_H__
+#define __ARCSNETWORKPROXYSLOT_H__
+
+#include <arcs/arcsqdynamicobject.h>
+#include <QObject>
+
+class ARCSAbstractComponent;
+
+//! Class implementing a proxy for slots
+/*! \author Jean-Yves Didier
+  * \date November, the 16th, 2009
+  * \ingroup network
+  */
+class ARCSNetworkProxySlot : public QObject, public ARCSQDynamicObject
+{
+public:
+     ARCSNetworkProxySlot(ARCSAbstractComponent* aac, QObject* parent=0);
+
+     virtual int qt_metacall(QMetaObject::Call call, int id, void ** arguments);
+
+     virtual QStringList getSignalList() { return QStringList(); }
+
+     virtual QStringList getSlotList() { return QStringList(slotName);}
+
+     virtual int prepareSlotConnect(QString sigName, QString sltName, QString objectName = QString::null, QString actualSignal = QString::null, bool simulate = false) ;
+
+     virtual int prepareSignalConnect(QString, QString, QString, QString, bool)
+     { return -1;}
+
+     virtual int cleanSlotConnect(QString, QString, QString, QString)
+     { return metaObject()->methodCount(); }
+
+     virtual int cleanSignalConnect(QString, QString, QString, QString)
+     { return -1; }
+
+     void setSlot(QString s ); // { slotName = s ;}
+     void setHostname(QString s) { hostName = s; }
+     void setPort(int i) { port = i; }
+     void setSlotId(int i) { slotId = i;}
+     QString getSlot() { return slotName; }
+
+private:
+     QList<int> typeIds;
+     QString slotName;
+     QString hostName;
+     int port;
+     int slotId;
+     ARCSAbstractComponent* home;
+};
+
+#endif // __ARCSNETWORKPROXYSLOT_H__

+#ifndef __ARCSNETWORKSERVER_H__
+#define __ARCSNETWORKSERVER_H__
+
+#include <QTcpServer>
+#include <QObject>
+#include <arcs/arcsabstractcomponent.h>
+#include <QThread>
+#include <iostream>
+
+
+class ARCSNetworkConnectRequest;
+class ARCSNetworkDisconnectRequest;
+class ARCSNetworkCallRequest;
+class ARCSNetworkSignalRequest;
+class ARCSNetworkSlotRequest;
+class ARCSNetworkProxySignal;
+class ARCSNetworkProxySlot;
+
+//! A thread processing requests performed on the server
+/*! \author Jean-Yves Didier
+  * \date November, the 13th, 2009
+  * \ingroup network
+  */
+class ARCSNetworkServerThread : public QThread
+{
+     Q_OBJECT
+
+     public:
+     /*! Constructor
+       * \param sd  a socket descriptor to which the thread will listen.
+       * \param parent a QObject which is parent to the thread.
+       */
+     ARCSNetworkServerThread(int sd, QObject* parent) : QThread(parent), socketDescriptor(sd) {}
+
+     protected:
+     virtual void run();//!< Thread main loop
+
+     private:
+     void handleRequest(QTcpSocket* socket);
+     void handleConnectRequest(ARCSNetworkConnectRequest* ancr, QTcpSocket* socket);
+     void handleCallRequest(ARCSNetworkCallRequest* ancr, QTcpSocket* socket);
+     void handleSlotRequest(ARCSNetworkSlotRequest* ansr, QTcpSocket* socket);
+     void handleSignalRequest(ARCSNetworkSignalRequest* ansr, QTcpSocket* socket);
+     void handleDisconnectRequest(ARCSNetworkDisconnectRequest* andr, QTcpSocket* socket);
+     void handleInterfaceRequest(QTcpSocket* socket);
+
+
+     int socketDescriptor;
+};
+
+//! Actual implementation of the server
+/*! This class is a trick in order to have a server generated in the right thread.
+ * \author Jean-Yves Didier
+ * \date November, the 13th, 2009
+ * \ingroup network
+ */
+class ARCSNetworkThreadedServer : public QTcpServer
+{
+     Q_OBJECT
+
+     public:
+     ARCSNetworkThreadedServer(QObject* parent = 0) : QTcpServer(parent) {} //!< Default constructor
+
+     protected:
+     /*!
+       */
+     void incomingConnection(int socketDescriptor)
+     {
+          ARCSNetworkServerThread* thread  = new ARCSNetworkServerThread(socketDescriptor, this);
+          connect(thread, SIGNAL(finished()), thread, SLOT(deleteLater()));
+          thread->start();
+     }
+};
+
+
+
+//!  Class implementing a server for each network component, as well as applications needing network support.
+/*! This class is implemented as a singleton since we only need one instance of a server running for an application.
+  * The server is, at the same time a thread and an abstract component which is not directly exposed.
+  * \author Jean-Yves Didier
+  * \date November, the 13th, 2009
+  * \ingroup network
+  */
+class ARCSNetworkServer : public QThread, public ARCSAbstractComponent
+{
+Q_OBJECT
+
+public:
+     static ARCSNetworkServer* getInstance(); //!< Singleton design pattern: mainly for lazy instanciation
+     int getPort() { return port; } //!< Returns the port which is listened by the server
+     void setInterface(QString name);//!< Sets the interface, i.e. the name of the component to which we want to apply distributed properties.
+     void setPort(int i) { port= (quint16)i; start(); } //!< Sets the port, the server will listen to.
+     bool isListening() { return server?server->isListening():false; } //!< Tells wether the server is active or not.
+
+     /*! Construct and return a proxy for a given signal
+       * \param s the name of the signal for which we will generate a proxy
+       * \return a proxy signal
+       */
+     ARCSNetworkProxySignal* getProxySignal(QString s);
+
+     QString getHostName() ; //!< Returns the host name of the current machine.
+     QString getURL(); //!< Returns the url of the current server
+
+     /*! \brief Triggers and calls a list of params to perform a call on a given slot.
+       * \param id id of the slot to call
+       * \param params serialized parameters of the slot
+       */
+     void call(int id, QStringList params);
+
+     /*! \brief Creates a signal stub to connect to a slot of the interface
+       * \param s the name of the slot of the interface
+       * \return an id
+       */
+     int createSignalStub(QString s);
+
+     /*! \brief Creates a slot stub to connect from a signal of the interface
+       * Such a stub has to connect to another server
+       * \param signal name of the signal to connect from
+       * \param id id of the signal generated
+       * \param port port number of the remote server
+       * \param peer hostname of the remote server
+       */
+     int createSlotStub(QString signal, int id, quint16 port, QString peer);
+
+
+     void destroySlotStub(QString s);
+
+     void getInterface(QStringList& slotList, QStringList& signalList);
+
+
+     // importé de ARCSNetworkStub
+     virtual QString toString() { return QString(); }
+     virtual bool parseString(QString) { return false; }
+     virtual QStringList getSignals() { return QStringList(); }
+     virtual QStringList getSlots() {return QStringList(); }
+
+
+protected:
+     virtual void run();//< server thread.
+
+     // importé de ARCSNetworkStub
+     virtual void getProxySlot (QString slot, ObjectList &obj, QStringList &proxySlot);
+     virtual void getProxySignal (QString signal, ObjectList &obj, QStringList &proxySignal);
+     virtual bool genuineConnect (QString, ARCSAbstractComponent *, QString, bool) { return false; }
+     virtual bool genuineDisconnect (QString, ARCSAbstractComponent *, QString) { return false; }
+     virtual bool genuineInstanciate () { return true; }
+     virtual void genuineDestroy () { }
+     virtual ARCSAbstractComponent* genuineClone () { return 0; }
+     virtual QVariant getGenuineComponentInstance() { return QVariant(); }
+
+
+
+private:
+     ARCSNetworkServer();
+     static ARCSNetworkServer* instance;
+     bool inEventMode;
+
+     ARCSNetworkThreadedServer* server;
+
+
+     quint16 port;
+     ARCSAbstractComponent* interface;
+
+     // a server will have to maintain a list of proxy objects.
+     QList<ARCSNetworkProxySignal*> proxySignals ;
+     QHash<QString, int> proxySignalsMap;
+
+     QHash<QString, ARCSNetworkProxySlot*> proxySlots;
+
+
+};
+
+
+#endif // __ARCSNETWORKSERVER_H__

+<library>
+    <headers>
+        <header name="arcsnetworkfamily.h"/>
+        <header name="arcsnetworkcomponent.h"/>
+        <header name="arcsnetworkconfigurator.h"/>
+
+    </headers>
+    <components>
+        <component name="ARCSNetworkConfigurator"/>
+    </components>
+    <families>
+        <family name="ARCSNetworkFamily"/>
+    </families>
+</library>

+/****************************************************************************
+** Meta object code from reading C++ file 'arcsnetworkconfigurator.h'
+**
+** Created: Thu Jul 25 19:38:39 2013
+**      by: The Qt Meta Object Compiler version 63 (Qt 4.8.4)
+**
+** WARNING! All changes made in this file will be lost!
+*****************************************************************************/
+
+#include "arcsnetworkconfigurator.h"
+#if !defined(Q_MOC_OUTPUT_REVISION)
+#error "The header file 'arcsnetworkconfigurator.h' doesn't include <QObject>."
+#elif Q_MOC_OUTPUT_REVISION != 63
+#error "This file was generated using the moc from 4.8.4. It"
+#error "cannot be used with the include files from this version of Qt."
+#error "(The moc has changed too much.)"
+#endif
+
+QT_BEGIN_MOC_NAMESPACE
+static const uint qt_meta_data_ARCSNetworkConfigurator[] = {
+
+ // content:
+       6,       // revision
+       0,       // classname
+       0,    0, // classinfo
+       2,   14, // methods
+       0,    0, // properties
+       0,    0, // enums/sets
+       0,    0, // constructors
+       0,       // flags
+       0,       // signalCount
+
+ // slots: signature, parameters, type, tag, flags
+      27,   25,   24,   24, 0x0a,
+      51,   49,   24,   24, 0x0a,
+
+       0        // eod
+};
+
+static const char qt_meta_stringdata_ARCSNetworkConfigurator[] = {
+    "ARCSNetworkConfigurator\0\0s\0"
+    "setInterface(QString)\0i\0setPort(int)\0"
+};
+
+void ARCSNetworkConfigurator::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
+{
+    if (_c == QMetaObject::InvokeMetaMethod) {
+        Q_ASSERT(staticMetaObject.cast(_o));
+        ARCSNetworkConfigurator *_t = static_cast<ARCSNetworkConfigurator *>(_o);
+        switch (_id) {
+        case 0: _t->setInterface((*reinterpret_cast< QString(*)>(_a[1]))); break;
+        case 1: _t->setPort((*reinterpret_cast< int(*)>(_a[1]))); break;
+        default: ;
+        }
+    }
+}
+
+const QMetaObjectExtraData ARCSNetworkConfigurator::staticMetaObjectExtraData = {
+    0,  qt_static_metacall 
+};
+
+const QMetaObject ARCSNetworkConfigurator::staticMetaObject = {
+    { &QObject::staticMetaObject, qt_meta_stringdata_ARCSNetworkConfigurator,
+      qt_meta_data_ARCSNetworkConfigurator, &staticMetaObjectExtraData }
+};
+
+#ifdef Q_NO_DATA_RELOCATION
+const QMetaObject &ARCSNetworkConfigurator::getStaticMetaObject() { return staticMetaObject; }
+#endif //Q_NO_DATA_RELOCATION
+
+const QMetaObject *ARCSNetworkConfigurator::metaObject() const
+{
+    return QObject::d_ptr->metaObject ? QObject::d_ptr->metaObject : &staticMetaObject;
+}
+
+void *ARCSNetworkConfigurator::qt_metacast(const char *_clname)
+{
+    if (!_clname) return 0;
+    if (!strcmp(_clname, qt_meta_stringdata_ARCSNetworkConfigurator))
+        return static_cast<void*>(const_cast< ARCSNetworkConfigurator*>(this));
+    return QObject::qt_metacast(_clname);
+}
+
+int ARCSNetworkConfigurator::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
+{
+    _id = QObject::qt_metacall(_c, _id, _a);
+    if (_id < 0)
+        return _id;
+    if (_c == QMetaObject::InvokeMetaMethod) {
+        if (_id < 2)
+            qt_static_metacall(this, _c, _id, _a);
+        _id -= 2;
+    }
+    return _id;
+}
+QT_END_MOC_NAMESPACE

+/****************************************************************************
+** Meta object code from reading C++ file 'arcsnetworkserver.h'
+**
+** Created: Thu Jul 25 19:38:39 2013
+**      by: The Qt Meta Object Compiler version 63 (Qt 4.8.4)
+**
+** WARNING! All changes made in this file will be lost!
+*****************************************************************************/
+
+#include "arcsnetworkserver.h"
+#if !defined(Q_MOC_OUTPUT_REVISION)
+#error "The header file 'arcsnetworkserver.h' doesn't include <QObject>."
+#elif Q_MOC_OUTPUT_REVISION != 63
+#error "This file was generated using the moc from 4.8.4. It"
+#error "cannot be used with the include files from this version of Qt."
+#error "(The moc has changed too much.)"
+#endif
+
+QT_BEGIN_MOC_NAMESPACE
+static const uint qt_meta_data_ARCSNetworkServerThread[] = {
+
+ // content:
+       6,       // revision
+       0,       // classname
+       0,    0, // classinfo
+       0,    0, // methods
+       0,    0, // properties
+       0,    0, // enums/sets
+       0,    0, // constructors
+       0,       // flags
+       0,       // signalCount
+
+       0        // eod
+};
+
+static const char qt_meta_stringdata_ARCSNetworkServerThread[] = {
+    "ARCSNetworkServerThread\0"
+};
+
+void ARCSNetworkServerThread::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
+{
+    Q_UNUSED(_o);
+    Q_UNUSED(_id);
+    Q_UNUSED(_c);
+    Q_UNUSED(_a);
+}
+
+const QMetaObjectExtraData ARCSNetworkServerThread::staticMetaObjectExtraData = {
+    0,  qt_static_metacall 
+};
+
+const QMetaObject ARCSNetworkServerThread::staticMetaObject = {
+    { &QThread::staticMetaObject, qt_meta_stringdata_ARCSNetworkServerThread,
+      qt_meta_data_ARCSNetworkServerThread, &staticMetaObjectExtraData }
+};
+
+#ifdef Q_NO_DATA_RELOCATION
+const QMetaObject &ARCSNetworkServerThread::getStaticMetaObject() { return staticMetaObject; }
+#endif //Q_NO_DATA_RELOCATION
+
+const QMetaObject *ARCSNetworkServerThread::metaObject() const
+{
+    return QObject::d_ptr->metaObject ? QObject::d_ptr->metaObject : &staticMetaObject;
+}
+
+void *ARCSNetworkServerThread::qt_metacast(const char *_clname)
+{
+    if (!_clname) return 0;
+    if (!strcmp(_clname, qt_meta_stringdata_ARCSNetworkServerThread))
+        return static_cast<void*>(const_cast< ARCSNetworkServerThread*>(this));
+    return QThread::qt_metacast(_clname);
+}
+
+int ARCSNetworkServerThread::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
+{
+    _id = QThread::qt_metacall(_c, _id, _a);
+    if (_id < 0)
+        return _id;
+    return _id;
+}
+static const uint qt_meta_data_ARCSNetworkThreadedServer[] = {
+
+ // content:
+       6,       // revision
+       0,       // classname
+       0,    0, // classinfo
+       0,    0, // methods
+       0,    0, // properties
+       0,    0, // enums/sets
+       0,    0, // constructors
+       0,       // flags
+       0,       // signalCount
+
+       0        // eod
+};
+
+static const char qt_meta_stringdata_ARCSNetworkThreadedServer[] = {
+    "ARCSNetworkThreadedServer\0"
+};
+
+void ARCSNetworkThreadedServer::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
+{
+    Q_UNUSED(_o);
+    Q_UNUSED(_id);
+    Q_UNUSED(_c);
+    Q_UNUSED(_a);
+}
+
+const QMetaObjectExtraData ARCSNetworkThreadedServer::staticMetaObjectExtraData = {
+    0,  qt_static_metacall 
+};
+
+const QMetaObject ARCSNetworkThreadedServer::staticMetaObject = {
+    { &QTcpServer::staticMetaObject, qt_meta_stringdata_ARCSNetworkThreadedServer,
+      qt_meta_data_ARCSNetworkThreadedServer, &staticMetaObjectExtraData }
+};
+
+#ifdef Q_NO_DATA_RELOCATION
+const QMetaObject &ARCSNetworkThreadedServer::getStaticMetaObject() { return staticMetaObject; }
+#endif //Q_NO_DATA_RELOCATION
+
+const QMetaObject *ARCSNetworkThreadedServer::metaObject() const
+{
+    return QObject::d_ptr->metaObject ? QObject::d_ptr->metaObject : &staticMetaObject;
+}
+
+void *ARCSNetworkThreadedServer::qt_metacast(const char *_clname)
+{
+    if (!_clname) return 0;
+    if (!strcmp(_clname, qt_meta_stringdata_ARCSNetworkThreadedServer))
+        return static_cast<void*>(const_cast< ARCSNetworkThreadedServer*>(this));
+    return QTcpServer::qt_metacast(_clname);
+}
+
+int ARCSNetworkThreadedServer::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
+{
+    _id = QTcpServer::qt_metacall(_c, _id, _a);
+    if (_id < 0)
+        return _id;
+    return _id;
+}
+static const uint qt_meta_data_ARCSNetworkServer[] = {
+
+ // content:
+       6,       // revision
+       0,       // classname
+       0,    0, // classinfo
+       0,    0, // methods
+       0,    0, // properties
+       0,    0, // enums/sets
+       0,    0, // constructors
+       0,       // flags
+       0,       // signalCount
+
+       0        // eod
+};
+
+static const char qt_meta_stringdata_ARCSNetworkServer[] = {
+    "ARCSNetworkServer\0"
+};
+
+void ARCSNetworkServer::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
+{
+    Q_UNUSED(_o);
+    Q_UNUSED(_id);
+    Q_UNUSED(_c);
+    Q_UNUSED(_a);
+}
+
+const QMetaObjectExtraData ARCSNetworkServer::staticMetaObjectExtraData = {
+    0,  qt_static_metacall 
+};
+
+const QMetaObject ARCSNetworkServer::staticMetaObject = {
+    { &QThread::staticMetaObject, qt_meta_stringdata_ARCSNetworkServer,
+      qt_meta_data_ARCSNetworkServer, &staticMetaObjectExtraData }
+};
+
+#ifdef Q_NO_DATA_RELOCATION
+const QMetaObject &ARCSNetworkServer::getStaticMetaObject() { return staticMetaObject; }
+#endif //Q_NO_DATA_RELOCATION
+
+const QMetaObject *ARCSNetworkServer::metaObject() const
+{
+    return QObject::d_ptr->metaObject ? QObject::d_ptr->metaObject : &staticMetaObject;
+}
+
+void *ARCSNetworkServer::qt_metacast(const char *_clname)
+{
+    if (!_clname) return 0;
+    if (!strcmp(_clname, qt_meta_stringdata_ARCSNetworkServer))
+        return static_cast<void*>(const_cast< ARCSNetworkServer*>(this));
+    if (!strcmp(_clname, "ARCSAbstractComponent"))
+        return static_cast< ARCSAbstractComponent*>(const_cast< ARCSNetworkServer*>(this));
+    return QThread::qt_metacast(_clname);
+}
+
+int ARCSNetworkServer::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
+{
+    _id = QThread::qt_metacall(_c, _id, _a);
+    if (_id < 0)
+        return _id;
+    return _id;
+}
+QT_END_MOC_NAMESPACE

+unix:TEMPLATE = lib
+win32:TEMPLATE = lib
+INCLUDEPATH += $$(ARCSDIR)/include
+INCLUDEPATH +=.
+LIBRARIES += -L$$(ARCSDIR)/lib \
+    -larcs
+LIBS += -L$$(ARCSDIR)/lib \
+    -larcs
+CONFIG += dll
+QT = core \
+    network
+
+DESTDIR=../libs
+DLLDESTDIR=../libs
+
+HEADERS += arcsnetworkcomponent.h \
+    arcsnetworkfamily.h \
+    arcsnetworkserver.h \
+    arcsnetworkframes.h \
+    arcsnetworkconfigurator.h \
+    arcsnetworkproxyslot.h \
+    arcsnetworkproxysignal.h
+HEADERS += 
+SOURCES += arcsnetworkcomponent.cpp \
+    arcsnetworkserver.cpp \
+    arcsnetworkframes.cpp \
+    arcsnetworkproxyslot.cpp \
+    arcsnetworkproxysignal.cpp
+SOURCES += 
+ALXFILE = libnetwork.alx
+OTHER_FILES += libnetwork.alx
+arcslibrary.output = alm_${QMAKE_FILE_BASE}.cpp
+arcslibrary.input = ALXFILE
+arcslibrary.commands = arcslibmaker \
+    ${QMAKE_FILE_NAME}
+arcslibrary.variable_out = SOURCES
+QMAKE_EXTRA_COMPILERS += arcslibrary