mh5tokenmanager.c

Go to the documentation of this file.

/*******************************************************************************
 * Copyright © 2014 The DTVKit Open Software Foundation Ltd (www.dtvkit.org)
 * Copyright © 2004 Ocean Blue Software Ltd
 * Copyright © 2000 Koninklijke Philips Electronics N.V
 *
 * This file is part of a DTVKit Software Component
 * You are permitted to copy, modify or distribute this file subject to the terms
 * of the DTVKit 1.0 Licence which can be found in licence.txt or at www.dtvkit.org
 * 
 * THIS CODE AND INFORMATION ARE PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND,
 * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE.
 * 
 * If you or your organisation is not a member of DTVKit then you have access
 * to this source code outside of the terms of the licence agreement
 * and you are expected to delete this and any associated files immediately.
 * Further information on DTVKit, membership and terms can be found at www.dtvkit.org
 *******************************************************************************/
/*---includes for this file--------------------------------------------------*/
#include "mh5variable.h"        /* for actions              */
#include "mh5object.h"          /* for actions              */
#include "mh5memory.h"          /* Constructor / Destructor */
#include "mh5queue.h"           /* Events           */
#include "mh5tokenmanager.h"
#include "mh5tokengroup.h"
#include "mh5listgroup.h"
#include <stdlib.h>

/*
   Debug
 */
#ifdef MH5PRINTOUT

#include <string.h>

static MHEG5IntList* MHEG5rowCopy(MHEG5IntList *source);

void MHEG5intListPrint(MHEG5IntList *intList, char *out)
{
   MHEG5IntList *currIntList = intList;

   MHEG_PRINT(out, "( ");
   while (currIntList != NULL)
   {
      MHEG5intPrint(currIntList->number, out);
      MHEG_PRINT(out, " ");
      currIntList = currIntList->next;
   }
   MHEG_PRINT(out, ")");
}

#if 0

void MHEG5movementTablePrint(MHEG5MovementTable *movementTable, char *out)
{
   MHEG5MovementTable *currMovementTable = movementTable;

   MHEG5incIndent();
   MHEG5newLine(out);
   while (currMovementTable != NULL)
   {
      MHEG5indent(out);
      MHEG5intListPrint(currMovementTable->row, out);
      currMovementTable = currMovementTable->next;
      MHEG5newLine(out);
   }
   MHEG5decIndent();
}

#endif //0

void MHEG5tokenManagerPrint(MHEG5TokenManager *tokenManager, char *out)
{
#if 0
   MHEG5indent(out);
   MHEG_PRINT(out, ":movementTable: ");
   MHEG5movementTablePrint(tokenManager->movementTable, out);
   MHEG5newLine(out);

   MHEG5indent(out);
   MHEG_PRINT(out, "// TokenPosition:\t");
   MHEG5intPrint(tokenManager->tokenPosition, out);
   MHEG5newLine(out);
#endif
}

#endif /* MH5PRINTOUT */


void MHEG5tokenManagerInit(MHEG5TokenManager *tokenManager)
{
   assert(tokenManager);

   assert(tokenManager->movementTable == 0);
}

void MHEG5tokenManagerPrepare(MHEG5TokenManager *tokenManager)
{
   assert(tokenManager);

   tokenManager->tokenPosition = 1;
}

void MHEG5tokenManagerFree(MHEG5TokenManager *tokenManager)
{
   MHEG5MovementTable *lastMTEntry, *mtEntry;
   MHEG5IntList *lastILEntry, *ilEntry;

   assert(tokenManager);

   mtEntry = tokenManager->movementTable;
   while (mtEntry)
   {
      ilEntry = mtEntry->row;
      while (ilEntry)
      {
         lastILEntry = ilEntry;
         ilEntry = ilEntry->next;
         MHEG5freeMem(lastILEntry);
      }
      lastMTEntry = mtEntry;
      mtEntry = mtEntry->next;
      MHEG5freeMem(lastMTEntry);
   }
}

void MHEG5tokenManagerAddRow(MHEG5TokenManager *tokenManager)
{
   MHEG5MovementTable *row, *find = 0;

   assert(tokenManager);
   row = MHEG5getMem(sizeof(MHEG5MovementTable));
   if (!row)
      return;
   row->next = 0;
   row->row = 0;

   find = tokenManager->movementTable;

   if (find == NULL)
   {
      tokenManager->movementTable = row;
      return;
   }

   while (find->next)
      find = find->next;
   find->next = row;
}

void MHEG5tokenManagerAddNumber(MHEG5TokenManager *tokenManager, MHEG5Int number)
{
   MHEG5MovementTable *find = 0;
   MHEG5IntList *row, *newItem;

   assert(tokenManager);
   find = tokenManager->movementTable;
   if (!find)
      return;
   while (find->next)
      find = find->next;
   newItem = MHEG5getMem(sizeof(MHEG5IntList));
   if (!newItem)
      return;
   newItem->next = 0;
   newItem->number = number;
   row = find->row;
   if (!row)
   {
      find->row = newItem;
      return;
   }
   while (row->next)
      row = row->next;
   row->next = newItem;
}

/*
   Clone Help
 */
static MHEG5IntList* MHEG5rowCopy(MHEG5IntList *source)
{
   MHEG5IntList *newList = 0, *prev = 0, *item = 0;

   while (source)
   {
      item = MHEG5getMem(sizeof(MHEG5IntList));
      if (!item)
         return newList;
      if (!newList)
         newList = item;
      if (prev)
         prev->next = item;
      item->number = source->number;
      item->next = 0;
      prev = item;
      source = source->next;
   }
   return newList;
}

static MHEG5MovementTable* MHEG5movementTableCopy(MHEG5MovementTable *source)
{
   MHEG5MovementTable *newTable = 0, *table = 0, *prev = 0;

   while (source)
   {
      table = MHEG5getMem(sizeof(MHEG5MovementTable));
      if (!newTable)
         newTable = table;
      if (prev)
         prev->next = table;
      if (!table)
         return newTable;
      table->row = MHEG5rowCopy(source->row);
      table->next = 0;
      prev = table;
      source = source->next;
   }
   return newTable;
}

void MHEG5tokenManagerCopy(MHEG5TokenManager *destination, MHEG5TokenManager *source)
{
   assert(destination);
   assert(source);
   destination->tokenPosition = source->tokenPosition;
   destination->movementTable = MHEG5movementTableCopy(source->movementTable);
}

/*
   Internal behaviours
 */
void MHEG5tokenManagerDestruct(MHEG5TokenManager *tokenManager)
{
   assert(tokenManager);
}

/*
   TransferToken (TargetElement)
   Execute the following sequence of actions:
   1. Generate a TokenMovedFrom event with the value of the TokenPosition
   attribute as associated data.
   2. Set the TokenPosition attribute to the value of the TargetElement
   parameter..
   3. Generate a TokenMovedTo event with the value of the TokenPosition
   attribute as associated data.
   The TokenMovedTo and TokenMovedFrom events will be generated even if
   the value of TokenPosition after (before) the token moved was 0.
 */
static void MHEG5tokenManagerTransferToken( MHEG5Root *source, MHEG5Int targetElement )
{
   MHEG5TokenManager *tokenManager = &((MHEG5TokenGroup *) source)->tokenManager;

   if ((source->clazz != MHEG5LISTGROUP) ||
       (targetElement <= ((MHEG5ListGroup *)source)->positionCount))
   {
      MHEG5sendSync(source, MHEG5TOKENMOVEDFROM, tokenManager->tokenPosition );
      tokenManager->tokenPosition = targetElement;
      MHEG5sendSync(source, MHEG5TOKENMOVEDTO, targetElement);
   }
}

/*
   Actions
 */
/*
   Move
   Move the token between elements of the group. The movement to apply from any
   particular element location is described in the MovementTable attribute.
   Execute the following sequence of actions:
   1. Determine the TargetElement by using the MovementTable.
   2. If the TargetElement does not have the token yet, apply the Transfer-
   Token(TargetElement) behaviour of the TokenManager.

   Provisions of use:
   The Target object shall be an available TokenManager.
 */
MHEG5ErrorCode MHEG5move(MHEG5Root *target, MHEG5GList *params)
{
   MHEG5Int movementId = 0, row = 1, col = 1;
   MHEG5MovementTable *movementTable;
   MHEG5IntList *oneRow = 0;

   assert(target);

   if (!params)
      return MHEG5ERR_WRONGNUMBEROFPARAMS;

   if ((target->clazz != MHEG5TOKENGROUP) &&
       (target->clazz != MHEG5LISTGROUP))
      return MHEG5ERR_WRONGTARGET;

   if (((MHEG5TokenGroup *) target)->tokenManager.tokenPosition < 1)
      return MHEG5ERR_NOERROR;

   MHEG5resolveGenericInteger(params, &movementId);
   movementTable = ((MHEG5TokenGroup *) target)->tokenManager.movementTable;

   while ((movementTable) && (row < movementId))
   {
      movementTable = movementTable->next;
      row++;
   }
   if ((movementTable) && (row == movementId))
   {
      oneRow = movementTable->row;
      while ((oneRow) && (col != ((MHEG5TokenGroup *) target)->tokenManager.tokenPosition))
      {
         oneRow = oneRow->next;
         col++;
      }
      if ((oneRow) && (col == ((MHEG5TokenGroup *) target)->tokenManager.tokenPosition))
      {
         if (((MHEG5TokenGroup *) target)->tokenManager.tokenPosition != oneRow->number)
         {
            MHEG5tokenManagerTransferToken( target, oneRow->number );
         }
      }
   }
   return MHEG5ERR_NOERROR;
}

/*
   MoveTo (Index)
   Move the token to a specific element of the group.
   Execute the following sequence of actions:
   1. Determine the TargetElement by using the Index parameter of the MoveTo
   action
   2. If the target element does not have the token yet, apply the Transfer-
   Token(TargetElement) behaviour of the TokenManager.

   Provisions of use:
   The Target object shall be an available TokenManager.
   Index shall be set within the range [0, N], where N is the number of elements in
   the group.
 */
MHEG5ErrorCode MHEG5moveTo(MHEG5Root *target, MHEG5GList *params)
{
   MHEG5Int movementId = 0;

   assert(target);

   if (!params)
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   if ((target->clazz != MHEG5TOKENGROUP) && (target->clazz != MHEG5LISTGROUP))
      return MHEG5ERR_WRONGTARGET;
   MHEG5resolveGenericInteger(params, &movementId);
   if (((MHEG5TokenGroup *) target)->tokenManager.tokenPosition != movementId)
   {
      MHEG5tokenManagerTransferToken( target, movementId );
   }
   return MHEG5ERR_NOERROR;
}

/*
   GetTokenPosition (TokenPositionVar)

   Provisions of use:
   The Target object shall be an available TokenManager.
   TokenPositionVar shall refer to an active IntegerVariable object.
 */
MHEG5ErrorCode MHEG5getTokenPosition(MHEG5Root *target, MHEG5GList *params)
{
   MHEG5Root *tpVar = 0;

   assert(target);

   if (!params)
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   if ((target->clazz != MHEG5TOKENGROUP) && (target->clazz != MHEG5LISTGROUP))
      return MHEG5ERR_WRONGTARGET;

   MHEG5resolveORef(params, &tpVar);

   if (!tpVar)
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   if (tpVar->clazz != MHEG5INTEGERVARIABLE)
      return MHEG5ERR_WRONGPARAM;
   ((MHEG5IntegerVariable *) tpVar)->value =
      ((MHEG5TokenGroup *) target)->tokenManager.tokenPosition;
   return MHEG5ERR_NOERROR;
}