Relationship::Relationship(Distribution *d, Guideline *g1, Guideline *g2, bool no_undo)
{
    commonInit();

    relType = REL_Distr;
    assert(g1);
    assert(g2);
    distro = d;
    guide = g1;
    guide2 = g2;
    
    activate(no_undo);
}

MBlockChunk::MBlockChunk(const CkArrayID &threads_)
{
  commonInit();

  threads=threads_;
  migInit();
  
  update.nRecd = 0;
  update.wait_seqnum = -1;
  messages = CmmNew();
  
  thread->semaPut(MBLOCK_TCHARM_SEMAID,this);
}

 RawKeyword::RawKeyword(const std::string& name , const std::string& filename, size_t lineNR , size_t inputSize, bool isTableCollection ) {
     commonInit(name,filename,lineNR);
     if (isTableCollection) {
         m_sizeType = Raw::TABLE_COLLECTION;
         m_numTables = inputSize;
     } else {
         m_sizeType = Raw::FIXED;
         m_fixedSize = inputSize;
         if (m_fixedSize == 0)
             m_isFinished = true;
         else
             m_isFinished = false;
     }
 }

 RFunction(const std::string& name,
           const Param1Type& param1,
           const Param2Type& param2,
           const Param3Type& param3,
           const Param4Type& param4,
           const Param5Type& param5)
    : functionSEXP_(R_UnboundValue)
 {
    commonInit(name);
    addParam(param1);
    addParam(param2);
    addParam(param3);
    addParam(param4);
    addParam(param5);
 }

void pixyInit(void)
#endif
{
	// write stack guard word
 //	STACK_GUARD = STACK_GUARD_WORD;

	commonInit();

#ifdef KEIL
	IPC_haltSlave();
#endif

	// clear RC servo registers to prevent and glitches upon initialization
	rcs_enable(0, 0);
	rcs_enable(1, 0);

	ADCInit();
   	SCTInit();
	CameraInit();

	// initialize shared memory interface before running M0
	SMLink *smLink = new SMLink;

	// start slave
#ifdef KEIL
	if (slaveRomStart && slaveImage && imageSize)
	{
		IPC_downloadSlaveImage(slaveRomStart, slaveImage, imageSize);
		IPC_startSlave();
	}
#else
    cr_start_m0(SLAVE_M0APP,&__core_m0app_START__);
#endif

	// initialize chirp objects
	USBLink *usbLink = new USBLink;
	g_chirpUsb = new Chirp(false, false, usbLink);
	g_chirpUsb->setSendTimeout(3000); // set a high timeout because the host can sometimes go AWOL for a second or two....
	g_chirpUsb->setRecvTimeout(3000); // set a high timeout because the host can sometimes go AWOL for a second or two....

  	g_chirpM0 = new Chirp(false, true, smLink);

	// initialize devices/modules
	led_init();
	prm_init(g_chirpUsb);
	pwr_init();
	cam_init();
}

RKEditorDataFrame::RKEditorDataFrame (RContainerObject* object, QWidget *parent) : TwinTable (parent) {
	RK_TRACE (EDITOR);

	commonInit ();

	RK_ASSERT (!object->isPending ());
	RKEditor::object = object;
	RK_ASSERT (object->isDataFrame ());
	setGlobalContextProperty ("current_object", object->getFullName());

	RKVarEditDataFrameModel* model = new RKVarEditDataFrameModel (object, this);
	initTable (model, object);
	connect (model, SIGNAL (modelObjectDestroyed()), this, SLOT (detachModel()));

	waitForLoad ();
}

RKCaughtX11Window::RKCaughtX11Window (RKGraphicsDevice* rkward_device, int device_number) : RKMDIWindow (0, X11Window) {
	RK_TRACE (MISC);

	commonInit (device_number);
	rk_native_device = rkward_device;
	xembed_container->setFixedSize (rk_native_device->viewPort ()->size ());
	resize (xembed_container->size ());
	rk_native_device->viewPort ()->setParent (xembed_container);
	connect (rkward_device, SIGNAL (captionChanged(QString)), this, SLOT (setCaption(QString)));
	connect (rkward_device, SIGNAL (goingInteractive(bool,QString)), this, SLOT (deviceInteractive(bool,QString)));
	stop_interaction->setVisible (true);
	stop_interaction->setEnabled (false);
	setCaption (rkward_device->viewPort ()->windowTitle ());

	QTimer::singleShot (0, this, SLOT (doEmbed()));
}

int main(int argc, char **argv)
{
    new QApplication(argc, argv);
    commonInit();
    progname = argv[0];

    if(argc >= 2) {
        for(int i = 0; modules[i].name != NULL; i++) {
            if(!strcasecmp(argv[1], modules[i].name)) {
                return modules[i].main(argc - 1, &argv[1]);
            }
        }
    }

    return usage();
}

 UserPrompt(int type,
            const std::string& caption,
            const std::string& message,
            const std::string& yesLabel,
            const std::string& noLabel,
            bool includeCancel,
            bool yesIsDefault)
 {
    commonInit(type,
               caption,
               message,
               yesLabel,
               noLabel,
               includeCancel,
               yesIsDefault);
 }

/**
    \fn ctor
    \brief this one is used when converting a type 1 avi to type 2
*/
aviIndexOdml::aviIndexOdml(aviWrite *father,aviIndexAvi *cousin )
    : aviIndexBase(father,cousin->_masterList,cousin->odmlChunkPosition)  
{
    commonInit();
    ADM_info("Creating Odml file from avi/type1... \n");
    LMovie = cousin->LMovie; // steal movie from cousin
    cousin->LMovie=NULL;
    nbVideoFrame=cousin->nbVideoFrame;
    
    for(int i=0;i<ADM_AVI_MAX_AUDIO_TRACK;i++)
        audioFrameCount[i]=cousin->audioFrameCount[i];
  
    // Convert cousin's index
    int n=cousin->myIndex.size();
  
    bool done[1+ADM_AVI_MAX_AUDIO_TRACK];
    for(int j=0;j<ADM_AVI_MAX_AUDIO_TRACK+1;j++)
    {
        indexes[j].indexPosition=cousin->placeHolder[j];
    }
    for(int j=0;j<ADM_AVI_MAX_AUDIO_TRACK+1;j++)
    {
        uint32_t trackFcc=superIndex.trackIndeces[j].fcc;
        for(int i=0;i<n;i++)
        {
            IdxEntry trx=cousin->myIndex[i];            
            // 
            if(trx.fcc==trackFcc)
            {
                odmIndexEntry ix;
                ix.flags=trx.flags;
                ix.offset=trx.offset;
                ix.size=trx.len;
                indexes[j].listOfChunks.push_back(ix);
                convertIndex(indexes+j,j);
            }
        }
    }
    
    //
    
    cousin->myIndex.clear(); // empty cousin index
    for(int j=0;j<ADM_AVI_MAX_AUDIO_TRACK+1;j++)
        printf("Track %d, found %d entries\n",j,(int)indexes[j].listOfChunks.size());
    startNewRiff();
}

Evolvable :: Evolvable(int numChr, int sizeD, int sizeB, int sizeI, int sizeC, const double& loBound,
	const double& hiBound, Chromosome* extraModifier, long& setSeed, const pStr& thePars)
{
	Btrue = elem(thePars.intGlob,"NUM_INPUTS");
	numChromosomes_ = numChr;
	boolStart_ = sizeD;
	intStart_ = boolStart_ + sizeB;
	charStart_ = intStart_ + sizeI;
	sizeChromosome_ = charStart_ + sizeC;
	currentSelection_ = 0;
	myChromosomes_.resize(numChr);

	for (int i = 0; i < numChr; ++i) {
		myChromosomes_[i] = new Chromosome(sizeD, sizeB, sizeI, sizeC, loBound, hiBound, setSeed, thePars);
	};
	commonInit(extraModifier, thePars);
};

//void pixyInit(uint32_t slaveRomStart, const unsigned char slaveImage[], uint32_t imageSize)
void pixyInit(void)
{
	// write stack guard word
 //	STACK_GUARD = STACK_GUARD_WORD;

	commonInit();

	IPC_haltSlave();

	ADCInit();
   	SCTInit();
	CameraInit();
/*	IPC_startSlave(); */
	// start slave
/*	if (slaveRomStart && slaveImage && imageSize)
	{
		IPC_downloadSlaveImage(slaveRomStart, slaveImage, imageSize);

	} */

	// initialize shared memory interface before running M0
	SMLink *smLink = new SMLink;

	// run M0
    cr_start_m0(SLAVE_M0APP,&__core_m0app_START__);

	// initialize chirp objects
	USBLink *usbLink = new USBLink;
	g_chirpUsb = new Chirp(false, false, usbLink);
  	g_chirpM0 = new Chirp(false, true, smLink);

	// initialize devices/modules
	led_init();
	if (prm_init(g_chirpUsb)<0) // error, let user know (don't just continue like nothing's happened)
		showError(1, 0x0000ff, "Flash is corrupt, parameters have been lost\n");
	pwr_init();
	cam_init();
	rcs_init();
	//cc_init();
}

void MetavoxelServer::run() {
    commonInit(METAVOXEL_SERVER_LOGGING_NAME, NodeType::MetavoxelServer);
    
    NodeList* nodeList = NodeList::getInstance();
    nodeList->addNodeTypeToInterestSet(NodeType::Agent);
    
    connect(nodeList, &NodeList::nodeAdded, this, &MetavoxelServer::maybeAttachSession);
    connect(nodeList, &NodeList::nodeKilled, this, &MetavoxelServer::maybeDeleteSession);
    
    // initialize Bitstream before using it in multiple threads
    Bitstream::preThreadingInit();
    
    // create the senders, each with its own thread
    int threadCount = QThread::idealThreadCount();
    if (threadCount == -1) {
        const int DEFAULT_THREAD_COUNT = 4;
        threadCount = DEFAULT_THREAD_COUNT;
    }
    qDebug() << "Creating" << threadCount << "sender threads";
    for (int i = 0; i < threadCount; i++) {
        QThread* thread = new QThread(this);
        MetavoxelSender* sender = new MetavoxelSender(this);
        sender->moveToThread(thread);
        connect(thread, &QThread::finished, sender, &QObject::deleteLater);
        thread->start();
        QMetaObject::invokeMethod(sender, "start");
        _senders.append(sender);
    }
    
    // create the persister and start it in its own thread
    _persister = new MetavoxelPersister(this);
    QThread* persistenceThread = new QThread(this);
    _persister->moveToThread(persistenceThread);
    connect(persistenceThread, &QThread::finished, _persister, &QObject::deleteLater);
    persistenceThread->start();
    
    // queue up the load
    QMetaObject::invokeMethod(_persister, "load");
}

void pixyInit(uint32_t slaveRomStart, const unsigned char slaveImage[], uint32_t imageSize)
{
	// write stack guard word
 	STACK_GUARD = STACK_GUARD_WORD;

	commonInit();

	IPC_haltSlave();

	// clear RC servo registers to prevent and glitches upon initialization
	rcs_enable(0, 0);
	rcs_enable(1, 0);

	ADCInit();
   	SCTInit();
	CameraInit();

	// start slave
	if (slaveRomStart && slaveImage && imageSize)
	{
		IPC_downloadSlaveImage(slaveRomStart, slaveImage, imageSize);
		IPC_startSlave();
	}

	// initialize chirp objects
	USBLink *usbLink = new USBLink;
	g_chirpUsb = new Chirp(false, false, usbLink);
	g_chirpUsb->setSendTimeout(3000); // set a high timeout because the host can sometimes go AWOL for a second or two....
	SMLink *smLink = new SMLink;
  	g_chirpM0 = new Chirp(false, true, smLink);

	// initialize devices/modules
	led_init();
	prm_init(g_chirpUsb);
	pwr_init();
	cam_init();
	rcs_init();
	//cc_init();
}

//------------ST7735_InitR------------
// Initialization for ST7735R screens (green or red tabs).
// Input: option one of the enumerated options depending on tabs
// Output: none
void ST7735_InitR(enum initRFlags option) {
  commonInit(Rcmd1);
  if(option == INITR_GREENTAB) {
    commandList(Rcmd2green);
    ColStart = 2;
    RowStart = 1;
  } else {
    // colstart, rowstart left at default '0' values
    commandList(Rcmd2red);
  }
  commandList(Rcmd3);

  // if black, change MADCTL color filter
  if (option == INITR_BLACKTAB) {
    writecommand(ST7735_MADCTL);
    writedata(0xC0);
  }
  TabColor = option;
  ST7735_SetCursor(0,0);
  StTextColor = ST7735_YELLOW;
  ST7735_FillScreen(0);                 // set screen to black
}

void MetavoxelServer::run() {
    commonInit(METAVOXEL_SERVER_LOGGING_NAME, NodeType::MetavoxelServer);
    
    NodeList* nodeList = NodeList::getInstance();
    nodeList->addNodeTypeToInterestSet(NodeType::Agent);
    
    connect(nodeList, SIGNAL(nodeAdded(SharedNodePointer)), SLOT(maybeAttachSession(const SharedNodePointer&)));
    
    _lastSend = QDateTime::currentMSecsSinceEpoch();
    _sendTimer.start(SEND_INTERVAL);
    
    // initialize Bitstream before using it in multiple threads
    Bitstream::preThreadingInit();
    
    // create the persister and start it in its own thread
    _persister = new MetavoxelPersister(this);
    QThread* persistenceThread = new QThread(this);
    _persister->moveToThread(persistenceThread);
    persistenceThread->start();
    
    // queue up the load
    QMetaObject::invokeMethod(_persister, "load");
}

void Adafruit_ST7789::init(uint16_t width, uint16_t height, uint8_t mode) {
  // Save SPI data mode. commonInit() calls begin() (in Adafruit_ST77xx.cpp),
  // which in turn calls initSPI() (in Adafruit_SPITFT.cpp), passing it the
  // value of spiMode. It's done this way because begin() really should not
  // be modified at this point to accept an SPI mode -- it's a virtual
  // function required in every Adafruit_SPITFT subclass and would require
  // updating EVERY such library...whereas, at the moment, we know that
  // certain ST7789 displays are the only thing that may need a non-default
  // SPI mode, hence this roundabout approach...
  spiMode = mode;
  // (Might get added similarly to other display types as needed on a
  // case-by-case basis.)

  commonInit(NULL);

  _colstart = ST7789_240x240_XSTART;
  _rowstart = ST7789_240x240_YSTART;
  _width    = width;
  _height   = height;

  displayInit(cmd_240x240);

  setRotation(0);
}

	void initForApplication(const std::string& dir)
	{
		commonInit(dir);
	}

 MapGrid::MapGrid(unsigned int size_x, unsigned int size_y, double s, double x, double y)
   : size_x_(size_x), size_y_(size_y), scale(s), origin_x(x), origin_y(y)
 {
   commonInit();
 }

 explicit RFunction(const std::string& name)
    : functionSEXP_(R_UnboundValue)
 {
    commonInit(name);
 }