///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// Copyright (c) 2000-2019 Ericsson Telecom AB                               //
//                                                                           //
// All rights reserved. This program and the accompanying materials          //
// are made available under the terms of the Eclipse Public License v2.0     //
// which accompanies this distribution, and is available at                  //
// https://www.eclipse.org/org/documents/epl-2.0/EPL-2.0.html                                 //
///////////////////////////////////////////////////////////////////////////////

#include "EPTF_CLL_Base_Functions.hh"
#include "EPTF_CLL_NQueue_Functions.hh"

// may be specified in makefile
#ifndef EPTF_NQUEUE_ITEMGROWBY
#define EPTF_NQUEUE_ITEMGROWBY 64
#endif

#if EPTF_NQUEUE_ITEMGROWBY < 1
#error "EPTF_NQUEUE_ITEMGROWBY must be a positive integer number"
#endif

#ifdef EPTF_DEBUG
#define EPTF_NQUEUE_DEBUG
#endif

#ifdef EPTF_NQUEUE_DEBUG
#include "EPTF_CLL_Common_Definitions.hh"
#endif

using namespace EPTF__CLL__NQueue__Definitions;

namespace EPTF__CLL__NQueue__Functions {

typedef struct {
  int next;
  int prev;
  int chain;
} EPTF_NQueue_Item;

typedef struct {
  int head;
  int tail;
  int itemCount;
  #ifdef EPTF_NQUEUE_DEBUG
  int maxItemCount;
  #endif    
} EPTF_NQueue_Chain;

typedef struct {
  EPTF_NQueue_Item *items;
  EPTF_NQueue_Chain *chains;
  int chainCount;
  int itemCount;
  int itemAllocCount;
  char *name;
  bool deleted;
  #ifdef EPTF_NQUEUE_DEBUG
  int maxItemCount;
  int maxChainCount;
  #endif    
} EPTF_NQueue_Queue;

static EPTF_NQueue_Queue *EPTF_NQueue_queues = NULL;
static int EPTF_NQueue_queueCount = 0;

static int *EPTF_NQueue_deletedQueues = NULL;
static int EPTF_NQueue_deletedQueuesCount = 0;
static int EPTF_NQueue_deletedQueuesAllocCount = 0;

#ifdef EPTF_NQUEUE_DEBUG
static int EPTF_NQueue_maxCount;
static double EPTF_NQueue_increaseRate;
#endif

#include <stdio.h>
#include <stdarg.h>
void f_EPTF_NQueue_error(const char *msg, ...)
{
  va_list ap;
  va_start(ap, msg);
  char err_str[4096];
  vsprintf(err_str, msg, ap);
  va_end(ap);
#ifdef EPTF_DEBUG
  EPTF__CLL__Base__Functions::f__EPTF__Base__assert(CHARSTRING(err_str), BOOLEAN(FALSE));
#else
  TTCN_Logger::log_str(TTCN_Logger::ERROR_UNQUALIFIED, err_str);
  EPTF__CLL__Base__Functions::f__EPTF__Base__stop(FAIL);
  //TTCN_error(err_str);
#endif
}

void f_EPTF_NQueue_addDeletedQueueToList(int queueId)
{
  if(EPTF_NQueue_deletedQueues == NULL) {
    EPTF_NQueue_deletedQueuesAllocCount = EPTF_NQUEUE_ITEMGROWBY;
    EPTF_NQueue_deletedQueues = (int*) Malloc(sizeof(int) * EPTF_NQueue_deletedQueuesAllocCount);
  } else if(EPTF_NQueue_deletedQueuesCount+1 >= EPTF_NQueue_deletedQueuesAllocCount) {
    EPTF_NQueue_deletedQueuesAllocCount += EPTF_NQUEUE_ITEMGROWBY;
    EPTF_NQueue_deletedQueues = (int*) Realloc(EPTF_NQueue_deletedQueues,
      sizeof(int) * EPTF_NQueue_deletedQueuesAllocCount);
  }
  EPTF_NQueue_deletedQueues[EPTF_NQueue_deletedQueuesCount] = queueId;
  EPTF_NQueue_deletedQueuesCount++;
}

int f_EPTF_NQueue_getDeletedQueueFromList() // returns -1 if none, also removes from list!
{
  int ret_val = -1;
  if(EPTF_NQueue_deletedQueuesCount > 0) {
    EPTF_NQueue_deletedQueuesCount--;
    ret_val = EPTF_NQueue_deletedQueues[EPTF_NQueue_deletedQueuesCount];
/*    if(EPTF_NQueue_deletedQueuesCount == 0) {
      Free(EPTF_NQueue_deletedQueues);
      EPTF_NQueue_deletedQueues = NULL;
      EPTF_NQueue_deletedQueuesAllocCount = 0;
    }*/
  }
  return ret_val;
}

void f_EPTF_NQueue_logQueue(int queueId);
void f_EPTF_NQueue_logChain(int queueId, int chainId);
void f_EPTF_NQueue_logChainFields(int queueId, int chainId);

inline void f_EPTF_NQueue_checkQueueId(const char *fn, int queueId)
{
//#ifdef EPTF_DEBUG
  if(queueId<0 || queueId>=EPTF_NQueue_queueCount) {
    f_EPTF_NQueue_error("%s: invalid queue %d, number of queues: %d", fn, queueId, EPTF_NQueue_queueCount);
  }
  if(EPTF_NQueue_queues[queueId].deleted) {
    f_EPTF_NQueue_error("%s: invalid queue %d, queue has been deleted.", fn, queueId);
  }
  //#endif
}

inline void f_EPTF_NQueue_checkChainId(const char *fn, int queueId, int chainId)
{
//#ifdef EPTF_DEBUG
  if(chainId<0 || chainId>=EPTF_NQueue_queues[queueId].chainCount) {
    if(EPTF_NQueue_queues[queueId].name) {
      f_EPTF_NQueue_error("%s: invalid chain %d, number of chains in queue \"%s\": %d",
        fn, chainId, EPTF_NQueue_queues[queueId].name, EPTF_NQueue_queues[queueId].chainCount);
    } else {
      f_EPTF_NQueue_error("%s: invalid chain %d, number of chains in queue: %d",
        fn, chainId, EPTF_NQueue_queues[queueId].chainCount);
    }
  }
  //#endif
}

inline void f_EPTF_NQueue_checkItemIdx(const char *fn, int queueId, int itemIdx)
{
//#ifdef EPTF_DEBUG
  if(itemIdx<0 || itemIdx>=EPTF_NQueue_queues[queueId].itemCount) {
    if(EPTF_NQueue_queues[queueId].name) {
      f_EPTF_NQueue_error("%s: invalid item %d, number of items in queue \"%s\": %d",
        fn, itemIdx, EPTF_NQueue_queues[queueId].name, EPTF_NQueue_queues[queueId].itemCount);
    } else {
      f_EPTF_NQueue_error("%s: invalid item %d, number of items in queue: %d",
        fn, itemIdx, EPTF_NQueue_queues[queueId].itemCount);
    }
  }
  //#endif
}

#ifdef EPTF_NQUEUE_DEBUG
inline void f_EPTF_NQueue_checkQueueSize(int queueId)
{
  if((EPTF_NQueue_maxCount != -1) && (EPTF_NQueue_queues[queueId].maxItemCount <  EPTF_NQueue_queues[queueId].itemCount))
  {
  	TTCN_warning("NQueue: queue with id: %d has exceeded the maximum item count! "
          "New maxItemCount of queue is being increased by a rate of %f on the basis of new item count, from %d to %d.",
          queueId, EPTF_NQueue_increaseRate, EPTF_NQueue_queues[queueId].maxItemCount,
          (int) (EPTF_NQueue_queues[queueId].itemCount * (1+EPTF_NQueue_increaseRate)));
  	EPTF_NQueue_queues[queueId].maxItemCount = (int) (EPTF_NQueue_queues[queueId].itemCount * (1+EPTF_NQueue_increaseRate));
  }
  
}

inline void f_EPTF_NQueue_checkChainSize(int queueId, int chainId)
{
  if((EPTF_NQueue_maxCount != -1) && (EPTF_NQueue_queues[queueId].chains[chainId].maxItemCount < EPTF_NQueue_queues[queueId].chains[chainId].itemCount))
  {
  	TTCN_warning("NQueue: chain with id: %d in queue: %d has exceeded the maximum item count! "
          "New maxItemCount of chain is being increased by a rate of %f on the basis of new item count, from %d to %d.",
          chainId, queueId, EPTF_NQueue_increaseRate, EPTF_NQueue_queues[queueId].chains[chainId].maxItemCount,
          (int) (EPTF_NQueue_queues[queueId].chains[chainId].itemCount * (1+EPTF_NQueue_increaseRate)));
  	EPTF_NQueue_queues[queueId].chains[chainId].maxItemCount = (int) (EPTF_NQueue_queues[queueId].chains[chainId].itemCount * (1+EPTF_NQueue_increaseRate));
  }
}

inline void f_EPTF_NQueue_checkChainCount(int queueId)
{
  if((EPTF_NQueue_maxCount != -1) && (EPTF_NQueue_queues[queueId].maxChainCount < EPTF_NQueue_queues[queueId].chainCount))
  {
  	TTCN_warning("NQueue: queue with id: %d has exceeded the maximum chain count! "
          "New maxChainCount of queue is being increased by a rate of %f, from %d to %d.",
          queueId, EPTF_NQueue_increaseRate, EPTF_NQueue_queues[queueId].maxChainCount,
          (int) (EPTF_NQueue_queues[queueId].maxChainCount * (1+EPTF_NQueue_increaseRate)));
  	EPTF_NQueue_queues[queueId].maxChainCount = (int) (EPTF_NQueue_queues[queueId].maxChainCount * (1+EPTF_NQueue_increaseRate));
  }
}
#endif

void f__EPTF__NQueue__init()
{
  EPTF_NQueue_queues = NULL;
  EPTF_NQueue_queueCount = 0;
  EPTF_NQueue_deletedQueues = NULL;
  EPTF_NQueue_deletedQueuesCount = 0;
  EPTF_NQueue_deletedQueuesAllocCount = 0;
    
  #ifdef EPTF_NQUEUE_DEBUG
  EPTF_NQueue_maxCount = (int)EPTF__CLL__Common__Definitions::tsp__CLL__debug__acceptableMaxSizeOfGrowingVariables;
  EPTF_NQueue_increaseRate = (double)EPTF__CLL__Common__Definitions::tsp__CLL__debug__increasePercentage4AcceptableMaxSize;
  if(EPTF_NQueue_maxCount == -1)
  {  	 	
  	return;
  }
  if(EPTF_NQueue_increaseRate <= 0)
  {
  	EPTF_NQueue_increaseRate = 0.1;
  }
  if(EPTF_NQueue_maxCount * EPTF_NQueue_increaseRate < 1.0)
  {
  	EPTF_NQueue_maxCount = ((int) 1 / EPTF_NQueue_increaseRate) +1;
  }  
  #endif
}

void f_EPTF_NQueue_cleanupQueue(int queueId)
{
  if(EPTF_NQueue_queues[queueId].deleted) { return; }
  if(EPTF_NQueue_queues[queueId].items) {
    Free(EPTF_NQueue_queues[queueId].items);
  }
  if(EPTF_NQueue_queues[queueId].chains) {
    Free(EPTF_NQueue_queues[queueId].chains);
  }
  EPTF_NQueue_queues[queueId].items = NULL;
  EPTF_NQueue_queues[queueId].chains = NULL;
  if(EPTF_NQueue_queues[queueId].name) {
    Free(EPTF_NQueue_queues[queueId].name);
  }
  EPTF_NQueue_queues[queueId].name = NULL;
  EPTF_NQueue_queues[queueId].deleted = true;
}

void f__EPTF__NQueue__cleanup()
{
  if(EPTF_NQueue_queues) {
    for(int queueId=0; queueId<EPTF_NQueue_queueCount; queueId++) {
      f_EPTF_NQueue_cleanupQueue(queueId);
    }
    Free(EPTF_NQueue_queues);
  }
  if(EPTF_NQueue_deletedQueues) {
    Free(EPTF_NQueue_deletedQueues);
  }
  EPTF_NQueue_queues = NULL;
  EPTF_NQueue_queueCount = 0;
  EPTF_NQueue_deletedQueues = NULL;
  EPTF_NQueue_deletedQueuesCount = 0;
  EPTF_NQueue_deletedQueuesAllocCount = 0;
}

EPTF__NQueue__QueueId f__EPTF__NQueue__createQueue(const CHARSTRING& pl__name)
{
  int queueId = f_EPTF_NQueue_getDeletedQueueFromList();
  if(queueId < 0) {
    queueId = EPTF_NQueue_queueCount;
    EPTF_NQueue_queueCount++;
    if(EPTF_NQueue_queues == NULL) EPTF_NQueue_queues = (EPTF_NQueue_Queue*) Malloc(sizeof(EPTF_NQueue_Queue));
    else EPTF_NQueue_queues = (EPTF_NQueue_Queue*) Realloc(EPTF_NQueue_queues, EPTF_NQueue_queueCount * sizeof(EPTF_NQueue_Queue));
  }
  EPTF_NQueue_queues[queueId].items = NULL;
  EPTF_NQueue_queues[queueId].chains = NULL;
  EPTF_NQueue_queues[queueId].chainCount = 0;
  EPTF_NQueue_queues[queueId].itemCount = 0;
  EPTF_NQueue_queues[queueId].itemAllocCount = 0;
  #ifdef EPTF_NQUEUE_DEBUG
  EPTF_NQueue_queues[queueId].maxItemCount = EPTF_NQueue_maxCount;
  EPTF_NQueue_queues[queueId].maxChainCount = EPTF_NQueue_maxCount; 
  #endif  
  EPTF_NQueue_queues[queueId].name = NULL;
  if(pl__name.lengthof() != 0) {
    EPTF_NQueue_queues[queueId].name = (char*)Malloc(pl__name.lengthof() + 1);
    memcpy(EPTF_NQueue_queues[queueId].name, (const char*)pl__name, pl__name.lengthof());
    EPTF_NQueue_queues[queueId].name[pl__name.lengthof()] = 0;
  }
  EPTF_NQueue_queues[queueId].deleted = false;
  return EPTF__NQueue__QueueId(queueId);
}

void f__EPTF__NQueue__deleteQueue(const EPTF__NQueue__QueueId &pl__queue)
{
  int queueId = (int)pl__queue;
  f_EPTF_NQueue_checkQueueId("f_EPTF_NQueue_deleteQueue", queueId);
  f_EPTF_NQueue_cleanupQueue(queueId);
  f_EPTF_NQueue_addDeletedQueueToList(queueId);
}

CHARSTRING f__EPTF__NQueue__getNameOfQueue(const EPTF__NQueue__QueueId &pl__queue)
{
  int queueId = (int)pl__queue;
  f_EPTF_NQueue_checkQueueId("f_EPTF_NQueue_getNameOfQueue", queueId);
  return CHARSTRING(EPTF_NQueue_queues[queueId].name);
}

EPTF__NQueue__ChainId f__EPTF__NQueue__createChain(
  const EPTF__NQueue__QueueId &pl__queue)
{
  int queueId = (int)pl__queue, chainId;
  f_EPTF_NQueue_checkQueueId("f_EPTF_NQueue_createChain", queueId);
  if(EPTF_NQueue_queues[queueId].chains == NULL) {
    EPTF_NQueue_queues[queueId].chains = (EPTF_NQueue_Chain*) Malloc(sizeof(EPTF_NQueue_Chain));
    EPTF_NQueue_queues[queueId].chainCount = 1;
    chainId = 0;
  } else {
    chainId = EPTF_NQueue_queues[queueId].chainCount;
    EPTF_NQueue_queues[queueId].chainCount++;
    EPTF_NQueue_queues[queueId].chains = (EPTF_NQueue_Chain*) Realloc(EPTF_NQueue_queues[queueId].chains, EPTF_NQueue_queues[queueId].chainCount * sizeof(EPTF_NQueue_Chain));
  }
  EPTF_NQueue_queues[queueId].chains[chainId].head = -1;
  EPTF_NQueue_queues[queueId].chains[chainId].tail = -1;
  EPTF_NQueue_queues[queueId].chains[chainId].itemCount = 0;
  #ifdef EPTF_NQUEUE_DEBUG
  EPTF_NQueue_queues[queueId].chains[chainId].maxItemCount = EPTF_NQueue_maxCount;
  f_EPTF_NQueue_checkChainCount(queueId);
  #endif
  return EPTF__NQueue__ChainId(chainId);
}

int f_EPTF_NQueue_createItem(int queueId)
{
  f_EPTF_NQueue_checkQueueId("f_EPTF_NQueue_createItem", queueId);
  int itemIdx;
  if(EPTF_NQueue_queues[queueId].items == NULL) {
    EPTF_NQueue_queues[queueId].items = (EPTF_NQueue_Item*) Malloc(EPTF_NQUEUE_ITEMGROWBY * sizeof(EPTF_NQueue_Item));
    EPTF_NQueue_queues[queueId].itemCount = 1;
    EPTF_NQueue_queues[queueId].itemAllocCount = EPTF_NQUEUE_ITEMGROWBY;
    itemIdx = 0;
  } else {
    itemIdx = EPTF_NQueue_queues[queueId].itemCount;
    EPTF_NQueue_queues[queueId].itemCount++;
    if(itemIdx >= EPTF_NQueue_queues[queueId].itemAllocCount) {
      EPTF_NQueue_queues[queueId].itemAllocCount += EPTF_NQUEUE_ITEMGROWBY;
      EPTF_NQueue_queues[queueId].items = (EPTF_NQueue_Item*) Realloc(EPTF_NQueue_queues[queueId].items, EPTF_NQueue_queues[queueId].itemAllocCount * sizeof(EPTF_NQueue_Item));
    }
  }
  #ifdef EPTF_NQUEUE_DEBUG
  f_EPTF_NQueue_checkQueueSize(queueId);
  #endif
  return itemIdx;
}

void f_EPTF_NQueue_createItems(int queueId, int count)
{
  f_EPTF_NQueue_checkQueueId("f_EPTF_NQueue_createItems", queueId);
  // round up to nearest EPTF_NQUEUE_ITEMGROWBY granularity:
  int allocCount = ((count + EPTF_NQueue_queues[queueId].itemCount + EPTF_NQUEUE_ITEMGROWBY - 1) / EPTF_NQUEUE_ITEMGROWBY) * EPTF_NQUEUE_ITEMGROWBY;
  //TTCN_Logger::log(TTCN_USER, "f_EPTF_NQueue_createItems: count: %d, itemCount: %d, current alloc: %d, allocCount = %d", count, EPTF_NQueue_queues[queueId].itemCount, EPTF_NQueue_queues[queueId].itemAllocCount, allocCount);

  if(EPTF_NQueue_queues[queueId].items == NULL) {
    EPTF_NQueue_queues[queueId].items = (EPTF_NQueue_Item*) Malloc(allocCount * sizeof(EPTF_NQueue_Item));
    EPTF_NQueue_queues[queueId].itemCount = count;
    EPTF_NQueue_queues[queueId].itemAllocCount = allocCount;
  } else {
    EPTF_NQueue_queues[queueId].itemCount += count;
    if(allocCount >= EPTF_NQueue_queues[queueId].itemAllocCount) {
      EPTF_NQueue_queues[queueId].itemAllocCount = allocCount;
      EPTF_NQueue_queues[queueId].items = (EPTF_NQueue_Item*) Realloc(EPTF_NQueue_queues[queueId].items, EPTF_NQueue_queues[queueId].itemAllocCount * sizeof(EPTF_NQueue_Item));
    }
  }
  #ifdef EPTF_NQUEUE_DEBUG
  f_EPTF_NQueue_checkQueueSize(queueId);
  #endif
//  TTCN_Logger::log(TTCN_USER, "f_EPTF_NQueue_createItems: itemCount = %d", EPTF_NQueue_queues[queueId].itemCount);
//  TTCN_Logger::log(TTCN_USER, "f_EPTF_NQueue_createItems: itemAllocCount = %d", EPTF_NQueue_queues[queueId].itemAllocCount);
}

void f_EPTF_NQueue_chainItemsFwd(int queueId, int chainId, int itemIdx, int itemCount) // itemCount MUST be >0
{
  int firstIdx = itemIdx;
  int lastIdx = itemIdx + itemCount - 1;

  while(itemCount--) {
    EPTF_NQueue_Item &item = EPTF_NQueue_queues[queueId].items[itemIdx];
    item.next = itemIdx + 1;
    item.prev = itemIdx - 1;
    item.chain = chainId;
    itemIdx++;
  }

  EPTF_NQueue_queues[queueId].items[firstIdx].prev = firstIdx; // first item's prev points to self
  EPTF_NQueue_queues[queueId].items[lastIdx].next = lastIdx; // last item's next points to self
}

void f_EPTF_NQueue_chainItemsBwd(int queueId, int chainId, int itemIdx, int itemCount) // itemCount MUST be >0
{
  int firstIdx = itemIdx;
  int lastIdx = itemIdx + itemCount - 1;

  while(itemCount--) {
    EPTF_NQueue_Item &item = EPTF_NQueue_queues[queueId].items[itemIdx];
    item.next = itemIdx - 1;
    item.prev = itemIdx + 1;
    item.chain = chainId;
    itemIdx++;
  }

  EPTF_NQueue_queues[queueId].items[firstIdx].next = firstIdx; // first item's next points to self
  EPTF_NQueue_queues[queueId].items[lastIdx].prev = lastIdx; // last item's prev points to self
}

EPTF__NQueue__ItemIdx f__EPTF__NQueue__createItemAtChainHead(
  const EPTF__NQueue__QueueId &pl__queue,
  const EPTF__NQueue__ChainId &pl__chain)
{
  int queueId = (int)pl__queue;
  int chainId = (int)pl__chain;
  f_EPTF_NQueue_checkQueueId("f_EPTF_NQueue_createItemAtChainHead", queueId);
  int itemIdx = f_EPTF_NQueue_createItem(queueId);
  f_EPTF_NQueue_checkChainId("f_EPTF_NQueue_createItemAtChainHead", queueId, chainId);
  EPTF_NQueue_Item &item = EPTF_NQueue_queues[queueId].items[itemIdx];
  EPTF_NQueue_Chain &chain = EPTF_NQueue_queues[queueId].chains[chainId];
  if(chain.head < 0) { chain.head = chain.tail = itemIdx; }
  item.next = chain.head;
  item.prev = itemIdx;
  item.chain = chainId;
  EPTF_NQueue_queues[queueId].items[chain.head].prev = itemIdx;
  chain.head = itemIdx;
  chain.itemCount++;
  #ifdef EPTF_NQUEUE_DEBUG  
  f_EPTF_NQueue_checkChainSize(queueId, chainId);
  #endif
  return EPTF__NQueue__ItemIdx(itemIdx);
}

EPTF__NQueue__ItemIdx f__EPTF__NQueue__createItemAtChainTail(
  const EPTF__NQueue__QueueId &pl__queue,
  const EPTF__NQueue__ChainId &pl__chain)
{
  int queueId = (int)pl__queue;
  int chainId = (int)pl__chain;
  f_EPTF_NQueue_checkQueueId("f_EPTF_NQueue_createItemAtChainTail", queueId);
  int itemIdx = f_EPTF_NQueue_createItem(queueId);
  f_EPTF_NQueue_checkChainId("f_EPTF_NQueue_createItemAtChainTail", queueId, chainId);
  EPTF_NQueue_Item &item = EPTF_NQueue_queues[queueId].items[itemIdx];
  EPTF_NQueue_Chain &chain = EPTF_NQueue_queues[queueId].chains[chainId];
  if(chain.head < 0) { chain.head = chain.tail = itemIdx; }
  item.next = itemIdx;
  item.prev = chain.tail;
  item.chain = chainId;
  EPTF_NQueue_queues[queueId].items[chain.tail].next = itemIdx;
  chain.tail = itemIdx;
  chain.itemCount++;
  #ifdef EPTF_NQUEUE_DEBUG  
  f_EPTF_NQueue_checkChainSize(queueId, chainId);
  #endif
  return EPTF__NQueue__ItemIdx(itemIdx);
}

EPTF__NQueue__ItemIdx f__EPTF__NQueue__createItemAfter(
  const EPTF__NQueue__QueueId &pl__queue,
  const EPTF__NQueue__ItemIdx &pl__afterIdx)
{
  int queueId = (int)pl__queue;
  int afterIdx = (int)pl__afterIdx;
  f_EPTF_NQueue_checkQueueId("f_EPTF_NQueue_createItemAfter", queueId);
  f_EPTF_NQueue_checkItemIdx("f_EPTF_NQueue_createItemAfter", queueId, afterIdx);
  int itemIdx = f_EPTF_NQueue_createItem(queueId);

  EPTF_NQueue_Item &item = EPTF_NQueue_queues[queueId].items[itemIdx];
  EPTF_NQueue_Item &after = EPTF_NQueue_queues[queueId].items[afterIdx];
  int chainId = after.chain;
  item.chain = chainId;
  EPTF_NQueue_Chain &chain = EPTF_NQueue_queues[queueId].chains[chainId];
  if(afterIdx == chain.tail) {
    chain.tail = itemIdx;
    item.next = itemIdx;
  } else {
    item.next = after.next;
    EPTF_NQueue_queues[queueId].items[after.next].prev = itemIdx;
  }
  item.prev = afterIdx;
  chain.itemCount++;
  after.next = itemIdx;
  #ifdef EPTF_NQUEUE_DEBUG  
  f_EPTF_NQueue_checkChainSize(queueId, chainId);
  #endif
  return EPTF__NQueue__ItemIdx(itemIdx);
}

EPTF__NQueue__ItemIdx f__EPTF__NQueue__createItemBefore(
  const EPTF__NQueue__QueueId &pl__queue,
  const EPTF__NQueue__ItemIdx &pl__beforeIdx)
{
  int queueId = (int)pl__queue;
  int beforeIdx = (int)pl__beforeIdx;
  f_EPTF_NQueue_checkQueueId("f_EPTF_NQueue_createItemBefore", queueId);
  f_EPTF_NQueue_checkItemIdx("f_EPTF_NQueue_createItemBefore", queueId, beforeIdx);
  int itemIdx = f_EPTF_NQueue_createItem(queueId);

  EPTF_NQueue_Item &item = EPTF_NQueue_queues[queueId].items[itemIdx];
  EPTF_NQueue_Item &before = EPTF_NQueue_queues[queueId].items[beforeIdx];
  int chainId = before.chain;
  item.chain = chainId;
  EPTF_NQueue_Chain &chain = EPTF_NQueue_queues[queueId].chains[chainId];
  if(beforeIdx == chain.head) {
    chain.head = itemIdx;
    item.prev = itemIdx;
  } else {
    item.prev = before.prev;
    EPTF_NQueue_queues[queueId].items[before.prev].next = itemIdx;
  }
  item.next = beforeIdx;
  chain.itemCount++;
  before.prev = itemIdx;
  #ifdef EPTF_NQUEUE_DEBUG  
  f_EPTF_NQueue_checkChainSize(queueId, chainId);
  #endif
  return EPTF__NQueue__ItemIdx(itemIdx);
}

void f__EPTF__NQueue__createItemsAtChainHead(
  const EPTF__NQueue__QueueId &pl__queue,
  const EPTF__NQueue__ChainId &pl__chain,
  const INTEGER &pl__count)
{
  int queueId = (int)pl__queue;
  int chainId = (int)pl__chain;
  int count = (int)pl__count;
  if(count < 1) return;
  f_EPTF_NQueue_checkQueueId("f_EPTF_NQueue_createItemsAtChainHead", queueId);
  f_EPTF_NQueue_checkChainId("f_EPTF_NQueue_createItemsAtChainHead", queueId, chainId);
  int newItem = EPTF_NQueue_queues[queueId].itemCount;
  f_EPTF_NQueue_createItems(queueId, count);
  f_EPTF_NQueue_chainItemsBwd(queueId, chainId, newItem, count);
  EPTF_NQueue_Chain &chain = EPTF_NQueue_queues[queueId].chains[chainId];
  if(chain.head < 0) {
    chain.head = newItem + count - 1;
    chain.tail = newItem;
  } else {
    EPTF_NQueue_queues[queueId].items[newItem].next = chain.head; // first new item's next points to old head
    EPTF_NQueue_queues[queueId].items[chain.head].prev = newItem; // previous head's prev points to first new item
    chain.head = newItem + count - 1; // last new item becomes head
  }
  // EPTF_NQueue_queues[queueId].items[chain.head].prev = chain.head; // chain head's prev points to self - note: already done by chainItemsBwd
  chain.itemCount += count;
  #ifdef EPTF_NQUEUE_DEBUG  
  f_EPTF_NQueue_checkChainSize(queueId, chainId);
  #endif
//  f_EPTF_NQueue_logChainFields(queueId, chainId);
}

void f__EPTF__NQueue__createItemsAtChainTail(
  const EPTF__NQueue__QueueId &pl__queue,
  const EPTF__NQueue__ChainId &pl__chain,
  const INTEGER &pl__count)
{
  int queueId = (int)pl__queue;
  int chainId = (int)pl__chain;
  int count = (int)pl__count;
  if(count < 1) return;
  f_EPTF_NQueue_checkQueueId("f_EPTF_NQueue_createItemsAtChainTail", queueId);
  f_EPTF_NQueue_checkChainId("f_EPTF_NQueue_createItemsAtChainTail", queueId, chainId);
  int newItem = EPTF_NQueue_queues[queueId].itemCount;
  f_EPTF_NQueue_createItems(queueId, count);
  f_EPTF_NQueue_chainItemsFwd(queueId, chainId, newItem, count);
  EPTF_NQueue_Chain &chain = EPTF_NQueue_queues[queueId].chains[chainId];
  if(chain.head < 0) {
    chain.head = newItem;
    chain.tail = newItem + count - 1;
  } else {
    EPTF_NQueue_queues[queueId].items[newItem].prev = chain.tail; // first new item's prev points to old tail
    EPTF_NQueue_queues[queueId].items[chain.tail].next = newItem; // previous tail's next points to first new item
    chain.tail = newItem + count - 1; // last new item becomes tail
  }
  // EPTF_NQueue_queues[queueId].items[chain.tail].next = chain.tail; // chain tail's next points to self - note: already done by chainItemsFwd
  chain.itemCount += count;
  #ifdef EPTF_NQUEUE_DEBUG  
  f_EPTF_NQueue_checkChainSize(queueId, chainId);
  #endif
//  f_EPTF_NQueue_logChainFields(queueId, chainId);
}

void f_EPTF_NQueue_unchainItem(int queueId, int itemIdx)
{
  EPTF_NQueue_Item &item = EPTF_NQueue_queues[queueId].items[itemIdx];
  EPTF_NQueue_Chain &chain = EPTF_NQueue_queues[queueId].chains[item.chain];
  item.chain = -1;
  EPTF_NQueue_queues[queueId].items[item.next].prev = item.prev;
  EPTF_NQueue_queues[queueId].items[item.prev].next = item.next;
  chain.itemCount--;
  if(chain.itemCount) {
    if(itemIdx == chain.head) {
      chain.head = item.next;
      EPTF_NQueue_queues[queueId].items[chain.head].prev = chain.head;
    }
    if(itemIdx == chain.tail) {
      chain.tail = item.prev;
      EPTF_NQueue_queues[queueId].items[chain.tail].next = chain.tail;
    }
  } else {
    chain.head = -1;
    chain.tail = -1;
  }
}

void f__EPTF__NQueue__moveToHead(
  const EPTF__NQueue__QueueId &pl__queue,
  const EPTF__NQueue__ChainId &pl__toChain, // note: can be the same chain -> move to front
  const EPTF__NQueue__ItemIdx &pl__item)
{
  int queueId = (int)pl__queue;
  int chainId = (int)pl__toChain;
  int itemIdx = (int)pl__item;
  f_EPTF_NQueue_checkQueueId("f_EPTF_NQueue_moveToHead", queueId);
  f_EPTF_NQueue_checkChainId("f_EPTF_NQueue_moveToHead", queueId, chainId);
  f_EPTF_NQueue_checkItemIdx("f_EPTF_NQueue_moveToHead", queueId, itemIdx);
  EPTF_NQueue_Item &item = EPTF_NQueue_queues[queueId].items[itemIdx];
  f_EPTF_NQueue_unchainItem(queueId, itemIdx);
  EPTF_NQueue_Chain &chain = EPTF_NQueue_queues[queueId].chains[chainId];
  if(chain.head < 0) { chain.head = chain.tail = itemIdx; }
  else {
    EPTF_NQueue_queues[queueId].items[chain.head].prev = itemIdx;
  }
  item.next = chain.head;
  item.prev = itemIdx;
  item.chain = chainId;
  chain.head = itemIdx;
  chain.itemCount++;
  #ifdef EPTF_NQUEUE_DEBUG  
  f_EPTF_NQueue_checkChainSize(queueId, chainId);
  #endif
}

void f__EPTF__NQueue__moveToTail(
  const EPTF__NQueue__QueueId &pl__queue,
  const EPTF__NQueue__ChainId &pl__toChain, // note: can be the same chain -> move to back
  const EPTF__NQueue__ItemIdx &pl__item)
{
  int queueId = (int)pl__queue;
  int chainId = (int)pl__toChain;
  int itemIdx = (int)pl__item;
  f_EPTF_NQueue_checkQueueId("f_EPTF_NQueue_moveToTail", queueId);
  f_EPTF_NQueue_checkChainId("f_EPTF_NQueue_moveToTail", queueId, chainId);
  f_EPTF_NQueue_checkItemIdx("f_EPTF_NQueue_moveToTail", queueId, itemIdx);
  f_EPTF_NQueue_unchainItem(queueId, itemIdx);
  EPTF_NQueue_Item &item = EPTF_NQueue_queues[queueId].items[itemIdx];
  EPTF_NQueue_Chain &chain = EPTF_NQueue_queues[queueId].chains[chainId];
  if(chain.head < 0) { chain.head = chain.tail = itemIdx; }
  else {
    EPTF_NQueue_queues[queueId].items[chain.tail].next = itemIdx;
  }
  item.next = itemIdx;
  item.prev = chain.tail;
  item.chain = chainId;
  chain.tail = itemIdx;
  chain.itemCount++;
  #ifdef EPTF_NQUEUE_DEBUG  
  f_EPTF_NQueue_checkChainSize(queueId, chainId);
  #endif
}

// note: target chain is the chain of the item at pl__afterIdx
void f__EPTF__NQueue__moveAfter(
  const EPTF__NQueue__QueueId &pl__queue,
  const EPTF__NQueue__ItemIdx &pl__afterIdx, // index of the item in &pl__toChain after which to move item &pl__item
  const EPTF__NQueue__ItemIdx &pl__item)
{
  int queueId = (int)pl__queue;
  int afterIdx = (int)pl__afterIdx;
  int itemIdx = (int)pl__item;
  f_EPTF_NQueue_checkQueueId("f_EPTF_NQueue_moveAfter", queueId);
  f_EPTF_NQueue_checkItemIdx("f_EPTF_NQueue_moveAfter", queueId, itemIdx);
  f_EPTF_NQueue_checkItemIdx("f_EPTF_NQueue_moveAfter", queueId, afterIdx);
  if(itemIdx == afterIdx) { return; }
  EPTF_NQueue_Item &item = EPTF_NQueue_queues[queueId].items[itemIdx];
  EPTF_NQueue_Item &after = EPTF_NQueue_queues[queueId].items[afterIdx];
  f_EPTF_NQueue_unchainItem(queueId, itemIdx);

  int chainId = after.chain;
  item.chain = chainId;
  EPTF_NQueue_Chain &chain = EPTF_NQueue_queues[queueId].chains[chainId];

  if(afterIdx == chain.tail) {
    chain.tail = itemIdx;
    item.next = itemIdx;
  } else {
    item.next = after.next;
    EPTF_NQueue_queues[queueId].items[after.next].prev = itemIdx;
  }
  item.prev = afterIdx;
  chain.itemCount++;
  after.next = itemIdx;
  #ifdef EPTF_NQUEUE_DEBUG  
  f_EPTF_NQueue_checkChainSize(queueId, chainId);
  #endif
}

// note: target chain is the chain of the item at pl__beforeIdx
void f__EPTF__NQueue__moveBefore(
  const EPTF__NQueue__QueueId &pl__queue,
  const EPTF__NQueue__ItemIdx &pl__beforeIdx, // index of the item in &pl__toChain before which to move item &pl__item
  const EPTF__NQueue__ItemIdx &pl__item)
{
  int queueId = (int)pl__queue;
  int beforeIdx = (int)pl__beforeIdx;
  int itemIdx = (int)pl__item;
  f_EPTF_NQueue_checkQueueId("f_EPTF_NQueue_moveBefore", queueId);
  f_EPTF_NQueue_checkItemIdx("f_EPTF_NQueue_moveBefore", queueId, itemIdx);
  f_EPTF_NQueue_checkItemIdx("f_EPTF_NQueue_moveBefore", queueId, beforeIdx);
  if(itemIdx == beforeIdx) { return; }
  EPTF_NQueue_Item &item = EPTF_NQueue_queues[queueId].items[itemIdx];
  EPTF_NQueue_Item &before = EPTF_NQueue_queues[queueId].items[beforeIdx];
  f_EPTF_NQueue_unchainItem(queueId, itemIdx);

  int chainId = before.chain;
  item.chain = chainId;
  EPTF_NQueue_Chain &chain = EPTF_NQueue_queues[queueId].chains[chainId];

  if(beforeIdx == chain.head) {
    chain.head = itemIdx;
    item.prev = itemIdx;
  } else {
    item.prev = before.prev;
    EPTF_NQueue_queues[queueId].items[before.prev].next = itemIdx;
  }
  item.next = beforeIdx;
  chain.itemCount++;
  before.prev = itemIdx;
  #ifdef EPTF_NQUEUE_DEBUG  
  f_EPTF_NQueue_checkChainSize(queueId, chainId);
  #endif
}

EPTF__NQueue__ChainId f__EPTF__NQueue__getChainOfItem(
  const EPTF__NQueue__QueueId &pl__queue,
  const EPTF__NQueue__ItemIdx &pl__item)
{
  int queueId = (int)pl__queue;
  int itemIdx = (int)pl__item;
  f_EPTF_NQueue_checkQueueId("f_EPTF_NQueue_getChainOfItem", queueId);
  f_EPTF_NQueue_checkItemIdx("f_EPTF_NQueue_getChainOfItem", queueId, itemIdx);
  return EPTF__NQueue__ChainId(EPTF_NQueue_queues[queueId].items[itemIdx].chain);
}

INTEGER f__EPTF__NQueue__getLengthOfQueue(
  const EPTF__NQueue__QueueId &pl__queue)
{
  int queueId = (int)pl__queue;
  f_EPTF_NQueue_checkQueueId("f_EPTF_NQueue_getLengthOfQueue", queueId);
  return INTEGER(EPTF_NQueue_queues[queueId].itemCount);
}

INTEGER f__EPTF__NQueue__getLengthOfChain(
  const EPTF__NQueue__QueueId &pl__queue,
  const EPTF__NQueue__ChainId &pl__chain)
{
  int queueId = (int)pl__queue;
  int chainId = (int)pl__chain;
  f_EPTF_NQueue_checkQueueId("f_EPTF_NQueue_getLengthOfChain", queueId);
  f_EPTF_NQueue_checkChainId("f_EPTF_NQueue_getLengthOfChain", queueId, chainId);
  return INTEGER(EPTF_NQueue_queues[queueId].chains[chainId].itemCount);
}

EPTF__NQueue__ItemIdx f__EPTF__NQueue__getHeadOfChain(
  const EPTF__NQueue__QueueId &pl__queue,
  const EPTF__NQueue__ChainId &pl__chain)
{
  int queueId = (int)pl__queue;
  int chainId = (int)pl__chain;
  f_EPTF_NQueue_checkQueueId("f_EPTF_NQueue_getHeadOfChain", queueId);
  f_EPTF_NQueue_checkChainId("f_EPTF_NQueue_getHeadOfChain", queueId, chainId);
  return INTEGER(EPTF_NQueue_queues[queueId].chains[chainId].head);
}

EPTF__NQueue__ItemIdx f__EPTF__NQueue__getTailOfChain(
  const EPTF__NQueue__QueueId &pl__queue,
  const EPTF__NQueue__ChainId &pl__chain)
{
  int queueId = (int)pl__queue;
  int chainId = (int)pl__chain;
  f_EPTF_NQueue_checkQueueId("f_EPTF_NQueue_getTailOfChain", queueId);
  f_EPTF_NQueue_checkChainId("f_EPTF_NQueue_getTailOfChain", queueId, chainId);
  return INTEGER(EPTF_NQueue_queues[queueId].chains[chainId].tail);
}

BOOLEAN f__EPTF__NQueue__getNextItemIdx(
  const EPTF__NQueue__QueueId &pl__queue,
  EPTF__NQueue__ItemIdx &pl__item) // changed to next item index if any
{
  int queueId = (int)pl__queue;
  int itemIdx = (int)pl__item;
  f_EPTF_NQueue_checkQueueId("f_EPTF_NQueue_getNextItemIdx", queueId);
  f_EPTF_NQueue_checkItemIdx("f_EPTF_NQueue_getNextItemIdx", queueId, itemIdx);
  if(itemIdx == EPTF_NQueue_queues[queueId].items[itemIdx].next) return BOOLEAN(FALSE);
  pl__item = EPTF_NQueue_queues[queueId].items[itemIdx].next;
  return BOOLEAN(TRUE);
}

BOOLEAN f__EPTF__NQueue__getPrevItemIdx(
  const EPTF__NQueue__QueueId &pl__queue,
  EPTF__NQueue__ItemIdx &pl__item) // changed to previous item index if any
{
  int queueId = (int)pl__queue;
  int itemIdx = (int)pl__item;
  f_EPTF_NQueue_checkQueueId("f_EPTF_NQueue_getPrevItemIdx", queueId);
  f_EPTF_NQueue_checkItemIdx("f_EPTF_NQueue_getPrevItemIdx", queueId, itemIdx);
  if(itemIdx == EPTF_NQueue_queues[queueId].items[itemIdx].prev) return BOOLEAN(FALSE);
  pl__item = EPTF_NQueue_queues[queueId].items[itemIdx].prev;
  return BOOLEAN(TRUE);
}

void f_EPTF_NQueue_logQueue(int queueId)
{
//  TTCN_Logger::log(TTCN_USER, "f_EPTF_NQueue_logQueue: queue %d: { items = %p, chain = %p, chainCount = %d, itemCount = %d, itemAllocCount = %d, deleted = %s }",
  #ifdef EPTF_NQUEUE_DEBUG
  TTCN_Logger::log(TTCN_USER, "f_EPTF_NQueue_logQueue: queue %d: { items = %p, chain = %p, chainCount = %d, itemCount = %d, itemAllocCount = %d, maxItemCount = %d, maxChainCount = %d }",
    queueId,
    EPTF_NQueue_queues[queueId].items,
    EPTF_NQueue_queues[queueId].chains,
    EPTF_NQueue_queues[queueId].chainCount,
    EPTF_NQueue_queues[queueId].itemCount,
    EPTF_NQueue_queues[queueId].itemAllocCount,
    EPTF_NQueue_queues[queueId].maxItemCount,
    EPTF_NQueue_queues[queueId].maxChainCount/*,
    EPTF_NQueue_queues[queueId].deleted?"true":"false"*/);
  #else
  TTCN_Logger::log(TTCN_USER, "f_EPTF_NQueue_logQueue: queue %d: { items = %p, chain = %p, chainCount = %d, itemCount = %d, itemAllocCount = %d }",
    queueId,
    EPTF_NQueue_queues[queueId].items,
    EPTF_NQueue_queues[queueId].chains,
    EPTF_NQueue_queues[queueId].chainCount,
    EPTF_NQueue_queues[queueId].itemCount,
    EPTF_NQueue_queues[queueId].itemAllocCount/*,
    EPTF_NQueue_queues[queueId].deleted?"true":"false"*/);
  #endif  
  for(int i=0; i<EPTF_NQueue_queues[queueId].chainCount; i++) {
    f_EPTF_NQueue_logChain(queueId, i);
  }
}

void f__EPTF__NQueue__logQueue(
  const EPTF__NQueue__QueueId &pl__queue)
{
  int queueId = (int)pl__queue;
  f_EPTF_NQueue_checkQueueId("f_EPTF_NQueue_logQueue", queueId);
  
  f_EPTF_NQueue_logQueue(queueId);
}

void f_EPTF_NQueue_logChain(int queueId, int chainId)
{
  #ifdef EPTF_NQUEUE_DEBUG
  TTCN_Logger::log(TTCN_USER, "f_EPTF_NQueue_logChain: queue %d, chain %d: { head = %d, tail = %d, itemCount = %d, maxItemCount = %d }",
    queueId, chainId, EPTF_NQueue_queues[queueId].chains[chainId].head, EPTF_NQueue_queues[queueId].chains[chainId].tail,
    EPTF_NQueue_queues[queueId].chains[chainId].itemCount, EPTF_NQueue_queues[queueId].chains[chainId].maxItemCount );
  #else
  TTCN_Logger::log(TTCN_USER, "f_EPTF_NQueue_logChain: queue %d, chain %d: { head = %d, tail = %d, itemCount = %d }",
    queueId, chainId, EPTF_NQueue_queues[queueId].chains[chainId].head, EPTF_NQueue_queues[queueId].chains[chainId].tail,
    EPTF_NQueue_queues[queueId].chains[chainId].itemCount);
  #endif  
  if(EPTF_NQueue_queues[queueId].chains[chainId].itemCount > 0) {
    int itemIdx = EPTF_NQueue_queues[queueId].chains[chainId].head;
    f_EPTF_NQueue_checkItemIdx("f_EPTF_NQueue_logChain", queueId, itemIdx);
    int count = EPTF_NQueue_queues[queueId].chains[chainId].itemCount;
    while(count--) {
      TTCN_Logger::log(TTCN_USER, "f_EPTF_NQueue_logChain: item at index %d: { next = %d, prev = %d, chain = %d }",
        itemIdx,
        EPTF_NQueue_queues[queueId].items[itemIdx].next,
        EPTF_NQueue_queues[queueId].items[itemIdx].prev,
        EPTF_NQueue_queues[queueId].items[itemIdx].chain);
      if(EPTF_NQueue_queues[queueId].items[itemIdx].next == itemIdx) break;
      itemIdx = EPTF_NQueue_queues[queueId].items[itemIdx].next;
      f_EPTF_NQueue_checkItemIdx("f_EPTF_NQueue_logChain", queueId, itemIdx);
    }
  }
}

void f__EPTF__NQueue__logChain(
  const EPTF__NQueue__QueueId &pl__queue,
  const EPTF__NQueue__ChainId &pl__chain)
{
  int queueId = (int)pl__queue;
  int chainId = (int)pl__chain;
  f_EPTF_NQueue_checkQueueId("f_EPTF_NQueue_logChain", queueId);
  f_EPTF_NQueue_checkChainId("f_EPTF_NQueue_logChain", queueId, chainId);

  f_EPTF_NQueue_logChain(queueId, chainId);
}

void f_EPTF_NQueue_logChainFields(int queueId, int chainId)
{
  TTCN_Logger::log(TTCN_USER, "f_EPTF_NQueue_logChainFields: queue %d, chain %d: { head = %d, tail = %d, itemCount = %d }",
    queueId, chainId, EPTF_NQueue_queues[queueId].chains[chainId].head, EPTF_NQueue_queues[queueId].chains[chainId].tail,
    EPTF_NQueue_queues[queueId].chains[chainId].itemCount);
}

void f__EPTF__NQueue__logChainFields(
  const EPTF__NQueue__QueueId &pl__queue,
  const EPTF__NQueue__ChainId &pl__chain)
{
  int queueId = (int)pl__queue;
  int chainId = (int)pl__chain;
  f_EPTF_NQueue_checkQueueId("f_EPTF_NQueue_logChainFields", queueId);
  f_EPTF_NQueue_checkChainId("f_EPTF_NQueue_logChainFields", queueId, chainId);

  f_EPTF_NQueue_logChainFields(queueId, chainId);
}

void dump_item(FILE *fp, int queueId, int itemIdx)
{
  fprintf(fp, "node%d [label=\"%d\", shape=box]\n", itemIdx, itemIdx);
  if(EPTF_NQueue_queues[queueId].items[itemIdx].prev >= 0)
    fprintf(fp, "node%d->node%d [label=\"p\"]\n", itemIdx, EPTF_NQueue_queues[queueId].items[itemIdx].prev);
  if(EPTF_NQueue_queues[queueId].items[itemIdx].next >= 0)
    fprintf(fp, "node%d->node%d [label=\"n\"]\n", itemIdx, EPTF_NQueue_queues[queueId].items[itemIdx].next);
}

void dump_chain(FILE*fp, int queueId, int chainId)
{
  int iter = EPTF_NQueue_queues[queueId].chains[chainId].head;
  fprintf(fp, "chain%d [label=\"chain %d (len: %d)\", shape=box]\n",
    chainId, chainId, EPTF_NQueue_queues[queueId].chains[chainId].itemCount);
  if(EPTF_NQueue_queues[queueId].chains[chainId].itemCount) {
    fprintf(fp, "chain%d->node%d [style=dashed, label=\"h\"]\n", chainId, EPTF_NQueue_queues[queueId].chains[chainId].head);
    fprintf(fp, "chain%d->node%d [style=dashed, label=\"t\"]\n", chainId, EPTF_NQueue_queues[queueId].chains[chainId].tail);
    for(int i=0; i<EPTF_NQueue_queues[queueId].chains[chainId].itemCount; i++) {
      dump_item(fp, queueId, iter);
      iter = EPTF_NQueue_queues[queueId].items[iter].next;
    }
  }
}

void dump_queue_to_png(int queueId, const char *name) // name of the graph - ".dot" will be appended for filename
{
  char *fn_dot = new char[strlen(name) + 5];
  strcpy(fn_dot, name);
  strcat(fn_dot, ".dot");
  FILE *fp = fopen(fn_dot, "w");
  if(!fp) {
    TTCN_warning("could not open file %s for writing", fn_dot);
    delete []fn_dot;
    return;
  }
  char *fn_png = new char[strlen(name) + 5];
  strcpy(fn_png, name);
  strcat(fn_png, ".png");

  fprintf(fp, "digraph %s {\n", name);
  fprintf(fp, "rankdir=LR;\n"); // top to buttom layout, other options: BT, LR, RL
  if(EPTF_NQueue_queues[queueId].itemCount < 1) {
    fprintf(fp, "empty [shape=box]\n");
  } else {
/*    for(int i=0; i<EPTF_NQueue_queues[queueId].itemCount; i++) {
      dump_item(fp, queueId, i);
    }*/
    for(int i=0; i<EPTF_NQueue_queues[queueId].chainCount; i++) {
      dump_chain(fp, queueId, i);
    }
  }
  fprintf(fp, "}\n");
  fclose(fp);
  const char cmd[]="dot -Tpng %s > %s";
  char *tmp = new char[strlen(cmd) + strlen(fn_dot) + strlen(fn_png) + 1];
  sprintf(tmp, cmd, fn_dot, fn_png);
  system(tmp);
  
  delete []fn_dot;
  delete []fn_png;
  delete []tmp;
}

void f__EPTF__NQueue__dumpToPng(
  const EPTF__NQueue__QueueId &pl__queue,
  const CHARSTRING &pl__name)
{
  f_EPTF_NQueue_checkQueueId("f_EPTF_NQueue_dumpToPng", pl__queue);
  dump_queue_to_png(pl__queue, pl__name);
}

} // namespace EPTF____NQueue____Functions