/////////////////////////////////////////////////////////////////////////////
// barrier.cc
//
// SIMLIB version: 2.18
// Date: 2004-01-25
//
// Copyright (c) 1991-2004 Petr Peringer 
//
// This library is licensed under GNU Library GPL. See the file COPYING.
//

//
//  class Barrier implementation 
//
// ###poznamky - poradi aktivace - nastavitelne ??? FIFA/LIFA

////////////////////////////////////////////////////////////////////////////
//  interface
//

#include "simlib.h"
#include "internal.h"

////////////////////////////////////////////////////////////////////////////
//  implementation
//

SIMLIB_IMPLEMENTATION

////////////////////////////////////////////////////////////////////////////
//  constructors
//
Barrier::Barrier(unsigned N) : 
    waiting(0), n(0), maxn(N)
{
  dprintf(("Barrier::Barrier()"));
  Init();
}

Barrier::Barrier(const char *name, unsigned N) : 
    waiting(0), n(0), maxn(N)
{
  dprintf(("Barrier::Barrier(\"%s\")",name));
  SetName(name);
  Init();
}


////////////////////////////////////////////////////////////////////////////
//  destructor
//
Barrier::~Barrier()
{
  dprintf(("Barrier::~Barrier()  // \"%s\" ", Name()));
  delete[] waiting;
}

////////////////////////////////////////////////////////////////////////////
// Enter - input
//
void Barrier::Enter(Entity *e)  // without parameter??? Current?
{
  dprintf(("%s.Enter(%s)", Name(), e->Name() ));
  if (n<maxn-1)
  {
    waiting[n++] = e;
    e->Passivate();
  }
  else
  {
    Break();
    Current->Activate();          // reactivation ###??? last
  }
}

////////////////////////////////////////////////////////////////////////////
// Break - activation of all waiting entities
//
// returns: number of activated entities
//
int Barrier::Break() {
  int ret = n;
  if(n==0)
    return ret;
  for(unsigned i=0; i<n; i++) // order of activation???!!!### FIFO
  {
    waiting[i]->Activate();
    waiting[i] = 0;
  }
  n = 0;
//  Current->Activate();          // reactivation ###??? last ####^^^
  return ret;
}

////////////////////////////////////////////////////////////////////////////
// Init - private barrier initializtion
//
void Barrier::Init()
{
  dprintf(("%s.Init()", Name()));
  waiting = new Entity* [maxn]; // allocation   maxn-1 ???
  if(!waiting)
    SIMLIB_error(MemoryError);  // without exceptions !!!###
  Clear();
}

////////////////////////////////////////////////////////////////////////////
// Clear - barrier reinitializtion
//
void Barrier::Clear()
{
  dprintf(("%s.Clear()", Name()));
  n = 0;
  for(unsigned i=0; i<maxn; i++)
    waiting[i] = 0;
}

////////////////////////////////////////////////////////////////////////////
// Output - barrier status print
//
void Barrier::Output()
{
  Print("Barrier: %s\n", Name());
  for(unsigned i=0; i<maxn; i++)
    Print("%d:  [%p]\n", i, waiting[i]);
  Print("\n");
}

////////////////////////////////////////////////////////////////////////////
// end of BARRIER.CPP
////////////////////////////////////////////////////////////////////////////