aqbanking/types/transactionlimits.c

/**********************************************************
 * This file has been automatically created by "typemaker2"
 * from the file "transactionlimits.xml".
 * Please do not edit this file, all changes will be lost.
 * Better edit the mentioned source file instead.
 **********************************************************/

#ifdef HAVE_CONFIG_H
# include <config.h>
#endif

#include "./transactionlimits_p.h"

#include <gwenhywfar/misc.h>
#include <gwenhywfar/debug.h>

/* code headers */

/* macro functions */
GWEN_LIST_FUNCTIONS(AB_TRANSACTION_LIMITS, AB_TransactionLimits)
GWEN_LIST2_FUNCTIONS(AB_TRANSACTION_LIMITS, AB_TransactionLimits)


AB_TRANSACTION_LIMITS *AB_TransactionLimits_new(void)
{
  AB_TRANSACTION_LIMITS *p_struct;

  GWEN_NEW_OBJECT(AB_TRANSACTION_LIMITS, p_struct)
  p_struct->_refCount=1;
  GWEN_LIST_INIT(AB_TRANSACTION_LIMITS, p_struct)
  /* members */
  p_struct->command=0;
  p_struct->maxLenLocalName=0;
  p_struct->minLenLocalName=0;
  p_struct->maxLenRemoteName=0;
  p_struct->minLenRemoteName=0;
  p_struct->maxLenCustomerReference=0;
  p_struct->minLenCustomerReference=0;
  p_struct->maxLenBankReference=0;
  p_struct->minLenBankReference=0;
  p_struct->maxLenPurpose=0;
  p_struct->minLenPurpose=0;
  p_struct->maxLinesPurpose=0;
  p_struct->minLinesPurpose=0;
  p_struct->needDate=0;
  p_struct->minValueSetupTime=0;
  p_struct->maxValueSetupTime=0;
  p_struct->minValueSetupTimeFirst=0;
  p_struct->maxValueSetupTimeFirst=0;
  p_struct->minValueSetupTimeOnce=0;
  p_struct->maxValueSetupTimeOnce=0;
  p_struct->minValueSetupTimeRecurring=0;
  p_struct->maxValueSetupTimeRecurring=0;
  p_struct->minValueSetupTimeFinal=0;
  p_struct->maxValueSetupTimeFinal=0;
  memset(p_struct->valuesCycleWeek, 0, 64);
  p_struct->valuesCycleWeekUsed=0;
  memset(p_struct->valuesCycleMonth, 0, 64);
  p_struct->valuesCycleMonthUsed=0;
  memset(p_struct->valuesExecutionDayWeek, 0, 16);
  p_struct->valuesExecutionDayWeekUsed=0;
  memset(p_struct->valuesExecutionDayMonth, 0, 64);
  p_struct->valuesExecutionDayMonthUsed=0;
  p_struct->allowMonthly=0;
  p_struct->allowWeekly=0;
  p_struct->allowChangeRecipientAccount=0;
  p_struct->allowChangeRecipientName=0;
  p_struct->allowChangeValue=0;
  p_struct->allowChangeTextKey=0;
  p_struct->allowChangePurpose=0;
  p_struct->allowChangeFirstExecutionDate=0;
  p_struct->allowChangeLastExecutionDate=0;
  p_struct->allowChangeCycle=0;
  p_struct->allowChangePeriod=0;
  p_struct->allowChangeExecutionDay=0;
  /* virtual functions */

  return p_struct;
}

void AB_TransactionLimits_free(AB_TRANSACTION_LIMITS *p_struct)
{
  if (p_struct) {
    assert(p_struct->_refCount);
    if (p_struct->_refCount==1) {
      GWEN_LIST_FINI(AB_TRANSACTION_LIMITS, p_struct)
      /* members */
      p_struct->_refCount=0;
      GWEN_FREE_OBJECT(p_struct);
    }
    else
      p_struct->_refCount--;
  }
}

void AB_TransactionLimits_Attach(AB_TRANSACTION_LIMITS *p_struct)
{
  assert(p_struct);
  assert(p_struct->_refCount);
  p_struct->_refCount++;
}

AB_TRANSACTION_LIMITS *AB_TransactionLimits_dup(const AB_TRANSACTION_LIMITS *p_src)
{
  AB_TRANSACTION_LIMITS *p_struct;

  assert(p_src);
  p_struct=AB_TransactionLimits_new();
  /* member "command" */
  p_struct->command=p_src->command;

  /* member "maxLenLocalName" */
  p_struct->maxLenLocalName=p_src->maxLenLocalName;

  /* member "minLenLocalName" */
  p_struct->minLenLocalName=p_src->minLenLocalName;

  /* member "maxLenRemoteName" */
  p_struct->maxLenRemoteName=p_src->maxLenRemoteName;

  /* member "minLenRemoteName" */
  p_struct->minLenRemoteName=p_src->minLenRemoteName;

  /* member "maxLenCustomerReference" */
  p_struct->maxLenCustomerReference=p_src->maxLenCustomerReference;

  /* member "minLenCustomerReference" */
  p_struct->minLenCustomerReference=p_src->minLenCustomerReference;

  /* member "maxLenBankReference" */
  p_struct->maxLenBankReference=p_src->maxLenBankReference;

  /* member "minLenBankReference" */
  p_struct->minLenBankReference=p_src->minLenBankReference;

  /* member "maxLenPurpose" */
  p_struct->maxLenPurpose=p_src->maxLenPurpose;

  /* member "minLenPurpose" */
  p_struct->minLenPurpose=p_src->minLenPurpose;

  /* member "maxLinesPurpose" */
  p_struct->maxLinesPurpose=p_src->maxLinesPurpose;

  /* member "minLinesPurpose" */
  p_struct->minLinesPurpose=p_src->minLinesPurpose;

  /* member "needDate" */
  p_struct->needDate=p_src->needDate;

  /* member "minValueSetupTime" */
  p_struct->minValueSetupTime=p_src->minValueSetupTime;

  /* member "maxValueSetupTime" */
  p_struct->maxValueSetupTime=p_src->maxValueSetupTime;

  /* member "minValueSetupTimeFirst" */
  p_struct->minValueSetupTimeFirst=p_src->minValueSetupTimeFirst;

  /* member "maxValueSetupTimeFirst" */
  p_struct->maxValueSetupTimeFirst=p_src->maxValueSetupTimeFirst;

  /* member "minValueSetupTimeOnce" */
  p_struct->minValueSetupTimeOnce=p_src->minValueSetupTimeOnce;

  /* member "maxValueSetupTimeOnce" */
  p_struct->maxValueSetupTimeOnce=p_src->maxValueSetupTimeOnce;

  /* member "minValueSetupTimeRecurring" */
  p_struct->minValueSetupTimeRecurring=p_src->minValueSetupTimeRecurring;

  /* member "maxValueSetupTimeRecurring" */
  p_struct->maxValueSetupTimeRecurring=p_src->maxValueSetupTimeRecurring;

  /* member "minValueSetupTimeFinal" */
  p_struct->minValueSetupTimeFinal=p_src->minValueSetupTimeFinal;

  /* member "maxValueSetupTimeFinal" */
  p_struct->maxValueSetupTimeFinal=p_src->maxValueSetupTimeFinal;

  /* member "valuesCycleWeek" */
  memmove(p_struct->valuesCycleWeek, p_src->valuesCycleWeek, 64);

  /* member "valuesCycleWeekUsed" */
  p_struct->valuesCycleWeekUsed=p_src->valuesCycleWeekUsed;

  /* member "valuesCycleMonth" */
  memmove(p_struct->valuesCycleMonth, p_src->valuesCycleMonth, 64);

  /* member "valuesCycleMonthUsed" */
  p_struct->valuesCycleMonthUsed=p_src->valuesCycleMonthUsed;

  /* member "valuesExecutionDayWeek" */
  memmove(p_struct->valuesExecutionDayWeek, p_src->valuesExecutionDayWeek, 16);

  /* member "valuesExecutionDayWeekUsed" */
  p_struct->valuesExecutionDayWeekUsed=p_src->valuesExecutionDayWeekUsed;

  /* member "valuesExecutionDayMonth" */
  memmove(p_struct->valuesExecutionDayMonth, p_src->valuesExecutionDayMonth, 64);

  /* member "valuesExecutionDayMonthUsed" */
  p_struct->valuesExecutionDayMonthUsed=p_src->valuesExecutionDayMonthUsed;

  /* member "allowMonthly" */
  p_struct->allowMonthly=p_src->allowMonthly;

  /* member "allowWeekly" */
  p_struct->allowWeekly=p_src->allowWeekly;

  /* member "allowChangeRecipientAccount" */
  p_struct->allowChangeRecipientAccount=p_src->allowChangeRecipientAccount;

  /* member "allowChangeRecipientName" */
  p_struct->allowChangeRecipientName=p_src->allowChangeRecipientName;

  /* member "allowChangeValue" */
  p_struct->allowChangeValue=p_src->allowChangeValue;

  /* member "allowChangeTextKey" */
  p_struct->allowChangeTextKey=p_src->allowChangeTextKey;

  /* member "allowChangePurpose" */
  p_struct->allowChangePurpose=p_src->allowChangePurpose;

  /* member "allowChangeFirstExecutionDate" */
  p_struct->allowChangeFirstExecutionDate=p_src->allowChangeFirstExecutionDate;

  /* member "allowChangeLastExecutionDate" */
  p_struct->allowChangeLastExecutionDate=p_src->allowChangeLastExecutionDate;

  /* member "allowChangeCycle" */
  p_struct->allowChangeCycle=p_src->allowChangeCycle;

  /* member "allowChangePeriod" */
  p_struct->allowChangePeriod=p_src->allowChangePeriod;

  /* member "allowChangeExecutionDay" */
  p_struct->allowChangeExecutionDay=p_src->allowChangeExecutionDay;

  return p_struct;
}

AB_TRANSACTION_LIMITS *AB_TransactionLimits_copy(AB_TRANSACTION_LIMITS *p_struct, const AB_TRANSACTION_LIMITS *p_src)
{
  assert(p_struct);
  assert(p_src);
  /* member "command" */
  p_struct->command=p_src->command;

  /* member "maxLenLocalName" */
  p_struct->maxLenLocalName=p_src->maxLenLocalName;

  /* member "minLenLocalName" */
  p_struct->minLenLocalName=p_src->minLenLocalName;

  /* member "maxLenRemoteName" */
  p_struct->maxLenRemoteName=p_src->maxLenRemoteName;

  /* member "minLenRemoteName" */
  p_struct->minLenRemoteName=p_src->minLenRemoteName;

  /* member "maxLenCustomerReference" */
  p_struct->maxLenCustomerReference=p_src->maxLenCustomerReference;

  /* member "minLenCustomerReference" */
  p_struct->minLenCustomerReference=p_src->minLenCustomerReference;

  /* member "maxLenBankReference" */
  p_struct->maxLenBankReference=p_src->maxLenBankReference;

  /* member "minLenBankReference" */
  p_struct->minLenBankReference=p_src->minLenBankReference;

  /* member "maxLenPurpose" */
  p_struct->maxLenPurpose=p_src->maxLenPurpose;

  /* member "minLenPurpose" */
  p_struct->minLenPurpose=p_src->minLenPurpose;

  /* member "maxLinesPurpose" */
  p_struct->maxLinesPurpose=p_src->maxLinesPurpose;

  /* member "minLinesPurpose" */
  p_struct->minLinesPurpose=p_src->minLinesPurpose;

  /* member "needDate" */
  p_struct->needDate=p_src->needDate;

  /* member "minValueSetupTime" */
  p_struct->minValueSetupTime=p_src->minValueSetupTime;

  /* member "maxValueSetupTime" */
  p_struct->maxValueSetupTime=p_src->maxValueSetupTime;

  /* member "minValueSetupTimeFirst" */
  p_struct->minValueSetupTimeFirst=p_src->minValueSetupTimeFirst;

  /* member "maxValueSetupTimeFirst" */
  p_struct->maxValueSetupTimeFirst=p_src->maxValueSetupTimeFirst;

  /* member "minValueSetupTimeOnce" */
  p_struct->minValueSetupTimeOnce=p_src->minValueSetupTimeOnce;

  /* member "maxValueSetupTimeOnce" */
  p_struct->maxValueSetupTimeOnce=p_src->maxValueSetupTimeOnce;

  /* member "minValueSetupTimeRecurring" */
  p_struct->minValueSetupTimeRecurring=p_src->minValueSetupTimeRecurring;

  /* member "maxValueSetupTimeRecurring" */
  p_struct->maxValueSetupTimeRecurring=p_src->maxValueSetupTimeRecurring;

  /* member "minValueSetupTimeFinal" */
  p_struct->minValueSetupTimeFinal=p_src->minValueSetupTimeFinal;

  /* member "maxValueSetupTimeFinal" */
  p_struct->maxValueSetupTimeFinal=p_src->maxValueSetupTimeFinal;

  /* member "valuesCycleWeek" */
  memmove(p_struct->valuesCycleWeek, p_src->valuesCycleWeek, 64);

  /* member "valuesCycleWeekUsed" */
  p_struct->valuesCycleWeekUsed=p_src->valuesCycleWeekUsed;

  /* member "valuesCycleMonth" */
  memmove(p_struct->valuesCycleMonth, p_src->valuesCycleMonth, 64);

  /* member "valuesCycleMonthUsed" */
  p_struct->valuesCycleMonthUsed=p_src->valuesCycleMonthUsed;

  /* member "valuesExecutionDayWeek" */
  memmove(p_struct->valuesExecutionDayWeek, p_src->valuesExecutionDayWeek, 16);

  /* member "valuesExecutionDayWeekUsed" */
  p_struct->valuesExecutionDayWeekUsed=p_src->valuesExecutionDayWeekUsed;

  /* member "valuesExecutionDayMonth" */
  memmove(p_struct->valuesExecutionDayMonth, p_src->valuesExecutionDayMonth, 64);

  /* member "valuesExecutionDayMonthUsed" */
  p_struct->valuesExecutionDayMonthUsed=p_src->valuesExecutionDayMonthUsed;

  /* member "allowMonthly" */
  p_struct->allowMonthly=p_src->allowMonthly;

  /* member "allowWeekly" */
  p_struct->allowWeekly=p_src->allowWeekly;

  /* member "allowChangeRecipientAccount" */
  p_struct->allowChangeRecipientAccount=p_src->allowChangeRecipientAccount;

  /* member "allowChangeRecipientName" */
  p_struct->allowChangeRecipientName=p_src->allowChangeRecipientName;

  /* member "allowChangeValue" */
  p_struct->allowChangeValue=p_src->allowChangeValue;

  /* member "allowChangeTextKey" */
  p_struct->allowChangeTextKey=p_src->allowChangeTextKey;

  /* member "allowChangePurpose" */
  p_struct->allowChangePurpose=p_src->allowChangePurpose;

  /* member "allowChangeFirstExecutionDate" */
  p_struct->allowChangeFirstExecutionDate=p_src->allowChangeFirstExecutionDate;

  /* member "allowChangeLastExecutionDate" */
  p_struct->allowChangeLastExecutionDate=p_src->allowChangeLastExecutionDate;

  /* member "allowChangeCycle" */
  p_struct->allowChangeCycle=p_src->allowChangeCycle;

  /* member "allowChangePeriod" */
  p_struct->allowChangePeriod=p_src->allowChangePeriod;

  /* member "allowChangeExecutionDay" */
  p_struct->allowChangeExecutionDay=p_src->allowChangeExecutionDay;

  return p_struct;
}

int AB_TransactionLimits_GetCommand(const AB_TRANSACTION_LIMITS *p_struct)
{
  assert(p_struct);
  return p_struct->command;
}

int AB_TransactionLimits_GetMaxLenLocalName(const AB_TRANSACTION_LIMITS *p_struct)
{
  assert(p_struct);
  return p_struct->maxLenLocalName;
}

int AB_TransactionLimits_GetMinLenLocalName(const AB_TRANSACTION_LIMITS *p_struct)
{
  assert(p_struct);
  return p_struct->minLenLocalName;
}

int AB_TransactionLimits_GetMaxLenRemoteName(const AB_TRANSACTION_LIMITS *p_struct)
{
  assert(p_struct);
  return p_struct->maxLenRemoteName;
}

int AB_TransactionLimits_GetMinLenRemoteName(const AB_TRANSACTION_LIMITS *p_struct)
{
  assert(p_struct);
  return p_struct->minLenRemoteName;
}

int AB_TransactionLimits_GetMaxLenCustomerReference(const AB_TRANSACTION_LIMITS *p_struct)
{
  assert(p_struct);
  return p_struct->maxLenCustomerReference;
}

int AB_TransactionLimits_GetMinLenCustomerReference(const AB_TRANSACTION_LIMITS *p_struct)
{
  assert(p_struct);
  return p_struct->minLenCustomerReference;
}

int AB_TransactionLimits_GetMaxLenBankReference(const AB_TRANSACTION_LIMITS *p_struct)
{
  assert(p_struct);
  return p_struct->maxLenBankReference;
}

int AB_TransactionLimits_GetMinLenBankReference(const AB_TRANSACTION_LIMITS *p_struct)
{
  assert(p_struct);
  return p_struct->minLenBankReference;
}

int AB_TransactionLimits_GetMaxLenPurpose(const AB_TRANSACTION_LIMITS *p_struct)
{
  assert(p_struct);
  return p_struct->maxLenPurpose;
}

int AB_TransactionLimits_GetMinLenPurpose(const AB_TRANSACTION_LIMITS *p_struct)
{
  assert(p_struct);
  return p_struct->minLenPurpose;
}

int AB_TransactionLimits_GetMaxLinesPurpose(const AB_TRANSACTION_LIMITS *p_struct)
{
  assert(p_struct);
  return p_struct->maxLinesPurpose;
}

int AB_TransactionLimits_GetMinLinesPurpose(const AB_TRANSACTION_LIMITS *p_struct)
{
  assert(p_struct);
  return p_struct->minLinesPurpose;
}

int AB_TransactionLimits_GetNeedDate(const AB_TRANSACTION_LIMITS *p_struct)
{
  assert(p_struct);
  return p_struct->needDate;
}

int AB_TransactionLimits_GetMinValueSetupTime(const AB_TRANSACTION_LIMITS *p_struct)
{
  assert(p_struct);
  return p_struct->minValueSetupTime;
}

int AB_TransactionLimits_GetMaxValueSetupTime(const AB_TRANSACTION_LIMITS *p_struct)
{
  assert(p_struct);
  return p_struct->maxValueSetupTime;
}

int AB_TransactionLimits_GetMinValueSetupTimeFirst(const AB_TRANSACTION_LIMITS *p_struct)
{
  assert(p_struct);
  return p_struct->minValueSetupTimeFirst;
}

int AB_TransactionLimits_GetMaxValueSetupTimeFirst(const AB_TRANSACTION_LIMITS *p_struct)
{
  assert(p_struct);
  return p_struct->maxValueSetupTimeFirst;
}

int AB_TransactionLimits_GetMinValueSetupTimeOnce(const AB_TRANSACTION_LIMITS *p_struct)
{
  assert(p_struct);
  return p_struct->minValueSetupTimeOnce;
}

int AB_TransactionLimits_GetMaxValueSetupTimeOnce(const AB_TRANSACTION_LIMITS *p_struct)
{
  assert(p_struct);
  return p_struct->maxValueSetupTimeOnce;
}

int AB_TransactionLimits_GetMinValueSetupTimeRecurring(const AB_TRANSACTION_LIMITS *p_struct)
{
  assert(p_struct);
  return p_struct->minValueSetupTimeRecurring;
}

int AB_TransactionLimits_GetMaxValueSetupTimeRecurring(const AB_TRANSACTION_LIMITS *p_struct)
{
  assert(p_struct);
  return p_struct->maxValueSetupTimeRecurring;
}

int AB_TransactionLimits_GetMinValueSetupTimeFinal(const AB_TRANSACTION_LIMITS *p_struct)
{
  assert(p_struct);
  return p_struct->minValueSetupTimeFinal;
}

int AB_TransactionLimits_GetMaxValueSetupTimeFinal(const AB_TRANSACTION_LIMITS *p_struct)
{
  assert(p_struct);
  return p_struct->maxValueSetupTimeFinal;
}

const uint8_t *AB_TransactionLimits_GetValuesCycleWeek(const AB_TRANSACTION_LIMITS *p_struct)
{
  assert(p_struct);
  return p_struct->valuesCycleWeek;
}

int AB_TransactionLimits_GetValuesCycleWeekUsed(const AB_TRANSACTION_LIMITS *p_struct)
{
  assert(p_struct);
  return p_struct->valuesCycleWeekUsed;
}

const uint8_t *AB_TransactionLimits_GetValuesCycleMonth(const AB_TRANSACTION_LIMITS *p_struct)
{
  assert(p_struct);
  return p_struct->valuesCycleMonth;
}

int AB_TransactionLimits_GetValuesCycleMonthUsed(const AB_TRANSACTION_LIMITS *p_struct)
{
  assert(p_struct);
  return p_struct->valuesCycleMonthUsed;
}

const uint8_t *AB_TransactionLimits_GetValuesExecutionDayWeek(const AB_TRANSACTION_LIMITS *p_struct)
{
  assert(p_struct);
  return p_struct->valuesExecutionDayWeek;
}

int AB_TransactionLimits_GetValuesExecutionDayWeekUsed(const AB_TRANSACTION_LIMITS *p_struct)
{
  assert(p_struct);
  return p_struct->valuesExecutionDayWeekUsed;
}

const uint8_t *AB_TransactionLimits_GetValuesExecutionDayMonth(const AB_TRANSACTION_LIMITS *p_struct)
{
  assert(p_struct);
  return p_struct->valuesExecutionDayMonth;
}

int AB_TransactionLimits_GetValuesExecutionDayMonthUsed(const AB_TRANSACTION_LIMITS *p_struct)
{
  assert(p_struct);
  return p_struct->valuesExecutionDayMonthUsed;
}

int AB_TransactionLimits_GetAllowMonthly(const AB_TRANSACTION_LIMITS *p_struct)
{
  assert(p_struct);
  return p_struct->allowMonthly;
}

int AB_TransactionLimits_GetAllowWeekly(const AB_TRANSACTION_LIMITS *p_struct)
{
  assert(p_struct);
  return p_struct->allowWeekly;
}

int AB_TransactionLimits_GetAllowChangeRecipientAccount(const AB_TRANSACTION_LIMITS *p_struct)
{
  assert(p_struct);
  return p_struct->allowChangeRecipientAccount;
}

int AB_TransactionLimits_GetAllowChangeRecipientName(const AB_TRANSACTION_LIMITS *p_struct)
{
  assert(p_struct);
  return p_struct->allowChangeRecipientName;
}

int AB_TransactionLimits_GetAllowChangeValue(const AB_TRANSACTION_LIMITS *p_struct)
{
  assert(p_struct);
  return p_struct->allowChangeValue;
}

int AB_TransactionLimits_GetAllowChangeTextKey(const AB_TRANSACTION_LIMITS *p_struct)
{
  assert(p_struct);
  return p_struct->allowChangeTextKey;
}

int AB_TransactionLimits_GetAllowChangePurpose(const AB_TRANSACTION_LIMITS *p_struct)
{
  assert(p_struct);
  return p_struct->allowChangePurpose;
}

int AB_TransactionLimits_GetAllowChangeFirstExecutionDate(const AB_TRANSACTION_LIMITS *p_struct)
{
  assert(p_struct);
  return p_struct->allowChangeFirstExecutionDate;
}

int AB_TransactionLimits_GetAllowChangeLastExecutionDate(const AB_TRANSACTION_LIMITS *p_struct)
{
  assert(p_struct);
  return p_struct->allowChangeLastExecutionDate;
}

int AB_TransactionLimits_GetAllowChangeCycle(const AB_TRANSACTION_LIMITS *p_struct)
{
  assert(p_struct);
  return p_struct->allowChangeCycle;
}

int AB_TransactionLimits_GetAllowChangePeriod(const AB_TRANSACTION_LIMITS *p_struct)
{
  assert(p_struct);
  return p_struct->allowChangePeriod;
}

int AB_TransactionLimits_GetAllowChangeExecutionDay(const AB_TRANSACTION_LIMITS *p_struct)
{
  assert(p_struct);
  return p_struct->allowChangeExecutionDay;
}

void AB_TransactionLimits_SetCommand(AB_TRANSACTION_LIMITS *p_struct, int p_src)
{
  assert(p_struct);
  p_struct->command=p_src;
}

void AB_TransactionLimits_SetMaxLenLocalName(AB_TRANSACTION_LIMITS *p_struct, int p_src)
{
  assert(p_struct);
  p_struct->maxLenLocalName=p_src;
}

void AB_TransactionLimits_SetMinLenLocalName(AB_TRANSACTION_LIMITS *p_struct, int p_src)
{
  assert(p_struct);
  p_struct->minLenLocalName=p_src;
}

void AB_TransactionLimits_SetMaxLenRemoteName(AB_TRANSACTION_LIMITS *p_struct, int p_src)
{
  assert(p_struct);
  p_struct->maxLenRemoteName=p_src;
}

void AB_TransactionLimits_SetMinLenRemoteName(AB_TRANSACTION_LIMITS *p_struct, int p_src)
{
  assert(p_struct);
  p_struct->minLenRemoteName=p_src;
}

void AB_TransactionLimits_SetMaxLenCustomerReference(AB_TRANSACTION_LIMITS *p_struct, int p_src)
{
  assert(p_struct);
  p_struct->maxLenCustomerReference=p_src;
}

void AB_TransactionLimits_SetMinLenCustomerReference(AB_TRANSACTION_LIMITS *p_struct, int p_src)
{
  assert(p_struct);
  p_struct->minLenCustomerReference=p_src;
}

void AB_TransactionLimits_SetMaxLenBankReference(AB_TRANSACTION_LIMITS *p_struct, int p_src)
{
  assert(p_struct);
  p_struct->maxLenBankReference=p_src;
}

void AB_TransactionLimits_SetMinLenBankReference(AB_TRANSACTION_LIMITS *p_struct, int p_src)
{
  assert(p_struct);
  p_struct->minLenBankReference=p_src;
}

void AB_TransactionLimits_SetMaxLenPurpose(AB_TRANSACTION_LIMITS *p_struct, int p_src)
{
  assert(p_struct);
  p_struct->maxLenPurpose=p_src;
}

void AB_TransactionLimits_SetMinLenPurpose(AB_TRANSACTION_LIMITS *p_struct, int p_src)
{
  assert(p_struct);
  p_struct->minLenPurpose=p_src;
}

void AB_TransactionLimits_SetMaxLinesPurpose(AB_TRANSACTION_LIMITS *p_struct, int p_src)
{
  assert(p_struct);
  p_struct->maxLinesPurpose=p_src;
}

void AB_TransactionLimits_SetMinLinesPurpose(AB_TRANSACTION_LIMITS *p_struct, int p_src)
{
  assert(p_struct);
  p_struct->minLinesPurpose=p_src;
}

void AB_TransactionLimits_SetNeedDate(AB_TRANSACTION_LIMITS *p_struct, int p_src)
{
  assert(p_struct);
  p_struct->needDate=p_src;
}

void AB_TransactionLimits_SetMinValueSetupTime(AB_TRANSACTION_LIMITS *p_struct, int p_src)
{
  assert(p_struct);
  p_struct->minValueSetupTime=p_src;
}

void AB_TransactionLimits_SetMaxValueSetupTime(AB_TRANSACTION_LIMITS *p_struct, int p_src)
{
  assert(p_struct);
  p_struct->maxValueSetupTime=p_src;
}

void AB_TransactionLimits_SetMinValueSetupTimeFirst(AB_TRANSACTION_LIMITS *p_struct, int p_src)
{
  assert(p_struct);
  p_struct->minValueSetupTimeFirst=p_src;
}

void AB_TransactionLimits_SetMaxValueSetupTimeFirst(AB_TRANSACTION_LIMITS *p_struct, int p_src)
{
  assert(p_struct);
  p_struct->maxValueSetupTimeFirst=p_src;
}

void AB_TransactionLimits_SetMinValueSetupTimeOnce(AB_TRANSACTION_LIMITS *p_struct, int p_src)
{
  assert(p_struct);
  p_struct->minValueSetupTimeOnce=p_src;
}

void AB_TransactionLimits_SetMaxValueSetupTimeOnce(AB_TRANSACTION_LIMITS *p_struct, int p_src)
{
  assert(p_struct);
  p_struct->maxValueSetupTimeOnce=p_src;
}

void AB_TransactionLimits_SetMinValueSetupTimeRecurring(AB_TRANSACTION_LIMITS *p_struct, int p_src)
{
  assert(p_struct);
  p_struct->minValueSetupTimeRecurring=p_src;
}

void AB_TransactionLimits_SetMaxValueSetupTimeRecurring(AB_TRANSACTION_LIMITS *p_struct, int p_src)
{
  assert(p_struct);
  p_struct->maxValueSetupTimeRecurring=p_src;
}

void AB_TransactionLimits_SetMinValueSetupTimeFinal(AB_TRANSACTION_LIMITS *p_struct, int p_src)
{
  assert(p_struct);
  p_struct->minValueSetupTimeFinal=p_src;
}

void AB_TransactionLimits_SetMaxValueSetupTimeFinal(AB_TRANSACTION_LIMITS *p_struct, int p_src)
{
  assert(p_struct);
  p_struct->maxValueSetupTimeFinal=p_src;
}

void AB_TransactionLimits_SetValuesCycleWeekUsed(AB_TRANSACTION_LIMITS *p_struct, int p_src)
{
  assert(p_struct);
  p_struct->valuesCycleWeekUsed=p_src;
}

void AB_TransactionLimits_SetValuesCycleMonthUsed(AB_TRANSACTION_LIMITS *p_struct, int p_src)
{
  assert(p_struct);
  p_struct->valuesCycleMonthUsed=p_src;
}

void AB_TransactionLimits_SetValuesExecutionDayWeekUsed(AB_TRANSACTION_LIMITS *p_struct, int p_src)
{
  assert(p_struct);
  p_struct->valuesExecutionDayWeekUsed=p_src;
}

void AB_TransactionLimits_SetValuesExecutionDayMonthUsed(AB_TRANSACTION_LIMITS *p_struct, int p_src)
{
  assert(p_struct);
  p_struct->valuesExecutionDayMonthUsed=p_src;
}

void AB_TransactionLimits_SetAllowMonthly(AB_TRANSACTION_LIMITS *p_struct, int p_src)
{
  assert(p_struct);
  p_struct->allowMonthly=p_src;
}

void AB_TransactionLimits_SetAllowWeekly(AB_TRANSACTION_LIMITS *p_struct, int p_src)
{
  assert(p_struct);
  p_struct->allowWeekly=p_src;
}

void AB_TransactionLimits_SetAllowChangeRecipientAccount(AB_TRANSACTION_LIMITS *p_struct, int p_src)
{
  assert(p_struct);
  p_struct->allowChangeRecipientAccount=p_src;
}

void AB_TransactionLimits_SetAllowChangeRecipientName(AB_TRANSACTION_LIMITS *p_struct, int p_src)
{
  assert(p_struct);
  p_struct->allowChangeRecipientName=p_src;
}

void AB_TransactionLimits_SetAllowChangeValue(AB_TRANSACTION_LIMITS *p_struct, int p_src)
{
  assert(p_struct);
  p_struct->allowChangeValue=p_src;
}

void AB_TransactionLimits_SetAllowChangeTextKey(AB_TRANSACTION_LIMITS *p_struct, int p_src)
{
  assert(p_struct);
  p_struct->allowChangeTextKey=p_src;
}

void AB_TransactionLimits_SetAllowChangePurpose(AB_TRANSACTION_LIMITS *p_struct, int p_src)
{
  assert(p_struct);
  p_struct->allowChangePurpose=p_src;
}

void AB_TransactionLimits_SetAllowChangeFirstExecutionDate(AB_TRANSACTION_LIMITS *p_struct, int p_src)
{
  assert(p_struct);
  p_struct->allowChangeFirstExecutionDate=p_src;
}

void AB_TransactionLimits_SetAllowChangeLastExecutionDate(AB_TRANSACTION_LIMITS *p_struct, int p_src)
{
  assert(p_struct);
  p_struct->allowChangeLastExecutionDate=p_src;
}

void AB_TransactionLimits_SetAllowChangeCycle(AB_TRANSACTION_LIMITS *p_struct, int p_src)
{
  assert(p_struct);
  p_struct->allowChangeCycle=p_src;
}

void AB_TransactionLimits_SetAllowChangePeriod(AB_TRANSACTION_LIMITS *p_struct, int p_src)
{
  assert(p_struct);
  p_struct->allowChangePeriod=p_src;
}

void AB_TransactionLimits_SetAllowChangeExecutionDay(AB_TRANSACTION_LIMITS *p_struct, int p_src)
{
  assert(p_struct);
  p_struct->allowChangeExecutionDay=p_src;
}

/* list1 functions */
AB_TRANSACTION_LIMITS_LIST *AB_TransactionLimits_List_dup(const AB_TRANSACTION_LIMITS_LIST *p_src)
{
  AB_TRANSACTION_LIMITS_LIST *p_dest;
  AB_TRANSACTION_LIMITS *p_elem;

  assert(p_src);
  p_dest=AB_TransactionLimits_List_new();
  p_elem=AB_TransactionLimits_List_First(p_src);
  while (p_elem) {
    AB_TRANSACTION_LIMITS *p_cpy;

    p_cpy=AB_TransactionLimits_dup(p_elem);
    AB_TransactionLimits_List_Add(p_cpy, p_dest);
    p_elem=AB_TransactionLimits_List_Next(p_elem);
  }

  return p_dest;
}

void AB_TransactionLimits_ReadDb(AB_TRANSACTION_LIMITS *p_struct, GWEN_DB_NODE *p_db)
{
  assert(p_struct);
  /* member "command" */
  p_struct->command=GWEN_DB_GetIntValue(p_db, "command", 0, 0);

  /* member "maxLenLocalName" */
  p_struct->maxLenLocalName=GWEN_DB_GetIntValue(p_db, "maxLenLocalName", 0, 0);

  /* member "minLenLocalName" */
  p_struct->minLenLocalName=GWEN_DB_GetIntValue(p_db, "minLenLocalName", 0, 0);

  /* member "maxLenRemoteName" */
  p_struct->maxLenRemoteName=GWEN_DB_GetIntValue(p_db, "maxLenRemoteName", 0, 0);

  /* member "minLenRemoteName" */
  p_struct->minLenRemoteName=GWEN_DB_GetIntValue(p_db, "minLenRemoteName", 0, 0);

  /* member "maxLenCustomerReference" */
  p_struct->maxLenCustomerReference=GWEN_DB_GetIntValue(p_db, "maxLenCustomerReference", 0, 0);

  /* member "minLenCustomerReference" */
  p_struct->minLenCustomerReference=GWEN_DB_GetIntValue(p_db, "minLenCustomerReference", 0, 0);

  /* member "maxLenBankReference" */
  p_struct->maxLenBankReference=GWEN_DB_GetIntValue(p_db, "maxLenBankReference", 0, 0);

  /* member "minLenBankReference" */
  p_struct->minLenBankReference=GWEN_DB_GetIntValue(p_db, "minLenBankReference", 0, 0);

  /* member "maxLenPurpose" */
  p_struct->maxLenPurpose=GWEN_DB_GetIntValue(p_db, "maxLenPurpose", 0, 0);

  /* member "minLenPurpose" */
  p_struct->minLenPurpose=GWEN_DB_GetIntValue(p_db, "minLenPurpose", 0, 0);

  /* member "maxLinesPurpose" */
  p_struct->maxLinesPurpose=GWEN_DB_GetIntValue(p_db, "maxLinesPurpose", 0, 0);

  /* member "minLinesPurpose" */
  p_struct->minLinesPurpose=GWEN_DB_GetIntValue(p_db, "minLinesPurpose", 0, 0);

  /* member "needDate" */
  p_struct->needDate=GWEN_DB_GetIntValue(p_db, "needDate", 0, 0);

  /* member "minValueSetupTime" */
  p_struct->minValueSetupTime=GWEN_DB_GetIntValue(p_db, "minValueSetupTime", 0, 0);

  /* member "maxValueSetupTime" */
  p_struct->maxValueSetupTime=GWEN_DB_GetIntValue(p_db, "maxValueSetupTime", 0, 0);

  /* member "minValueSetupTimeFirst" */
  p_struct->minValueSetupTimeFirst=GWEN_DB_GetIntValue(p_db, "minValueSetupTimeFirst", 0, 0);

  /* member "maxValueSetupTimeFirst" */
  p_struct->maxValueSetupTimeFirst=GWEN_DB_GetIntValue(p_db, "maxValueSetupTimeFirst", 0, 0);

  /* member "minValueSetupTimeOnce" */
  p_struct->minValueSetupTimeOnce=GWEN_DB_GetIntValue(p_db, "minValueSetupTimeOnce", 0, 0);

  /* member "maxValueSetupTimeOnce" */
  p_struct->maxValueSetupTimeOnce=GWEN_DB_GetIntValue(p_db, "maxValueSetupTimeOnce", 0, 0);

  /* member "minValueSetupTimeRecurring" */
  p_struct->minValueSetupTimeRecurring=GWEN_DB_GetIntValue(p_db, "minValueSetupTimeRecurring", 0, 0);

  /* member "maxValueSetupTimeRecurring" */
  p_struct->maxValueSetupTimeRecurring=GWEN_DB_GetIntValue(p_db, "maxValueSetupTimeRecurring", 0, 0);

  /* member "minValueSetupTimeFinal" */
  p_struct->minValueSetupTimeFinal=GWEN_DB_GetIntValue(p_db, "minValueSetupTimeFinal", 0, 0);

  /* member "maxValueSetupTimeFinal" */
  p_struct->maxValueSetupTimeFinal=GWEN_DB_GetIntValue(p_db, "maxValueSetupTimeFinal", 0, 0);

  /* member "valuesCycleWeek" */
  {
    int i;
    memset(p_struct->valuesCycleWeek, 0, (64)*sizeof(uint8_t));
    for (i=0; i < 64; i++) {
      int v;
      v=GWEN_DB_GetIntValue(p_db, "valuesCycleWeek", i, 0);
      if (v==0)
        break;
      p_struct->valuesCycleWeek[i]=v;
    }
  }

  /* member "valuesCycleWeekUsed" */
  p_struct->valuesCycleWeekUsed=GWEN_DB_GetIntValue(p_db, "valuesCycleWeekUsed", 0, 0);

  /* member "valuesCycleMonth" */
  {
    int i;
    memset(p_struct->valuesCycleMonth, 0, (64)*sizeof(uint8_t));
    for (i=0; i < 64; i++) {
      int v;
      v=GWEN_DB_GetIntValue(p_db, "valuesCycleMonth", i, 0);
      if (v==0)
        break;
      p_struct->valuesCycleMonth[i]=v;
    }
  }

  /* member "valuesCycleMonthUsed" */
  p_struct->valuesCycleMonthUsed=GWEN_DB_GetIntValue(p_db, "valuesCycleMonthUsed", 0, 0);

  /* member "valuesExecutionDayWeek" */
  {
    int i;
    memset(p_struct->valuesExecutionDayWeek, 0, (16)*sizeof(uint8_t));
    for (i=0; i < 16; i++) {
      int v;
      v=GWEN_DB_GetIntValue(p_db, "valuesExecutionDayWeek", i, 0);
      if (v==0)
        break;
      p_struct->valuesExecutionDayWeek[i]=v;
    }
  }

  /* member "valuesExecutionDayWeekUsed" */
  p_struct->valuesExecutionDayWeekUsed=GWEN_DB_GetIntValue(p_db, "valuesExecutionDayWeekUsed", 0, 0);

  /* member "valuesExecutionDayMonth" */
  {
    int i;
    memset(p_struct->valuesExecutionDayMonth, 0, (64)*sizeof(uint8_t));
    for (i=0; i < 64; i++) {
      int v;
      v=GWEN_DB_GetIntValue(p_db, "valuesExecutionDayMonth", i, 0);
      if (v==0)
        break;
      p_struct->valuesExecutionDayMonth[i]=v;
    }
  }

  /* member "valuesExecutionDayMonthUsed" */
  p_struct->valuesExecutionDayMonthUsed=GWEN_DB_GetIntValue(p_db, "valuesExecutionDayMonthUsed", 0, 0);

  /* member "allowMonthly" */
  p_struct->allowMonthly=GWEN_DB_GetIntValue(p_db, "allowMonthly", 0, 0);

  /* member "allowWeekly" */
  p_struct->allowWeekly=GWEN_DB_GetIntValue(p_db, "allowWeekly", 0, 0);

  /* member "allowChangeRecipientAccount" */
  p_struct->allowChangeRecipientAccount=GWEN_DB_GetIntValue(p_db, "allowChangeRecipientAccount", 0, 0);

  /* member "allowChangeRecipientName" */
  p_struct->allowChangeRecipientName=GWEN_DB_GetIntValue(p_db, "allowChangeRecipientName", 0, 0);

  /* member "allowChangeValue" */
  p_struct->allowChangeValue=GWEN_DB_GetIntValue(p_db, "allowChangeValue", 0, 0);

  /* member "allowChangeTextKey" */
  p_struct->allowChangeTextKey=GWEN_DB_GetIntValue(p_db, "allowChangeTextKey", 0, 0);

  /* member "allowChangePurpose" */
  p_struct->allowChangePurpose=GWEN_DB_GetIntValue(p_db, "allowChangePurpose", 0, 0);

  /* member "allowChangeFirstExecutionDate" */
  p_struct->allowChangeFirstExecutionDate=GWEN_DB_GetIntValue(p_db, "allowChangeFirstExecutionDate", 0, 0);

  /* member "allowChangeLastExecutionDate" */
  p_struct->allowChangeLastExecutionDate=GWEN_DB_GetIntValue(p_db, "allowChangeLastExecutionDate", 0, 0);

  /* member "allowChangeCycle" */
  p_struct->allowChangeCycle=GWEN_DB_GetIntValue(p_db, "allowChangeCycle", 0, 0);

  /* member "allowChangePeriod" */
  p_struct->allowChangePeriod=GWEN_DB_GetIntValue(p_db, "allowChangePeriod", 0, 0);

  /* member "allowChangeExecutionDay" */
  p_struct->allowChangeExecutionDay=GWEN_DB_GetIntValue(p_db, "allowChangeExecutionDay", 0, 0);

}

int AB_TransactionLimits_WriteDb(const AB_TRANSACTION_LIMITS *p_struct, GWEN_DB_NODE *p_db)
{
  int p_rv;

  assert(p_struct);
  /* member "command" */
  p_rv=GWEN_DB_SetIntValue(p_db, GWEN_DB_FLAGS_OVERWRITE_VARS, "command", p_struct->command);
  if (p_rv<0) {
    DBG_INFO(GWEN_LOGDOMAIN, "here (%d)\n", p_rv);
    return p_rv;
  }

  /* member "maxLenLocalName" */
  p_rv=GWEN_DB_SetIntValue(p_db, GWEN_DB_FLAGS_OVERWRITE_VARS, "maxLenLocalName", p_struct->maxLenLocalName);
  if (p_rv<0) {
    DBG_INFO(GWEN_LOGDOMAIN, "here (%d)\n", p_rv);
    return p_rv;
  }

  /* member "minLenLocalName" */
  p_rv=GWEN_DB_SetIntValue(p_db, GWEN_DB_FLAGS_OVERWRITE_VARS, "minLenLocalName", p_struct->minLenLocalName);
  if (p_rv<0) {
    DBG_INFO(GWEN_LOGDOMAIN, "here (%d)\n", p_rv);
    return p_rv;
  }

  /* member "maxLenRemoteName" */
  p_rv=GWEN_DB_SetIntValue(p_db, GWEN_DB_FLAGS_OVERWRITE_VARS, "maxLenRemoteName", p_struct->maxLenRemoteName);
  if (p_rv<0) {
    DBG_INFO(GWEN_LOGDOMAIN, "here (%d)\n", p_rv);
    return p_rv;
  }

  /* member "minLenRemoteName" */
  p_rv=GWEN_DB_SetIntValue(p_db, GWEN_DB_FLAGS_OVERWRITE_VARS, "minLenRemoteName", p_struct->minLenRemoteName);
  if (p_rv<0) {
    DBG_INFO(GWEN_LOGDOMAIN, "here (%d)\n", p_rv);
    return p_rv;
  }

  /* member "maxLenCustomerReference" */
  p_rv=GWEN_DB_SetIntValue(p_db, GWEN_DB_FLAGS_OVERWRITE_VARS, "maxLenCustomerReference",
                           p_struct->maxLenCustomerReference);
  if (p_rv<0) {
    DBG_INFO(GWEN_LOGDOMAIN, "here (%d)\n", p_rv);
    return p_rv;
  }

  /* member "minLenCustomerReference" */
  p_rv=GWEN_DB_SetIntValue(p_db, GWEN_DB_FLAGS_OVERWRITE_VARS, "minLenCustomerReference",
                           p_struct->minLenCustomerReference);
  if (p_rv<0) {
    DBG_INFO(GWEN_LOGDOMAIN, "here (%d)\n", p_rv);
    return p_rv;
  }

  /* member "maxLenBankReference" */
  p_rv=GWEN_DB_SetIntValue(p_db, GWEN_DB_FLAGS_OVERWRITE_VARS, "maxLenBankReference", p_struct->maxLenBankReference);
  if (p_rv<0) {
    DBG_INFO(GWEN_LOGDOMAIN, "here (%d)\n", p_rv);
    return p_rv;
  }

  /* member "minLenBankReference" */
  p_rv=GWEN_DB_SetIntValue(p_db, GWEN_DB_FLAGS_OVERWRITE_VARS, "minLenBankReference", p_struct->minLenBankReference);
  if (p_rv<0) {
    DBG_INFO(GWEN_LOGDOMAIN, "here (%d)\n", p_rv);
    return p_rv;
  }

  /* member "maxLenPurpose" */
  p_rv=GWEN_DB_SetIntValue(p_db, GWEN_DB_FLAGS_OVERWRITE_VARS, "maxLenPurpose", p_struct->maxLenPurpose);
  if (p_rv<0) {
    DBG_INFO(GWEN_LOGDOMAIN, "here (%d)\n", p_rv);
    return p_rv;
  }

  /* member "minLenPurpose" */
  p_rv=GWEN_DB_SetIntValue(p_db, GWEN_DB_FLAGS_OVERWRITE_VARS, "minLenPurpose", p_struct->minLenPurpose);
  if (p_rv<0) {
    DBG_INFO(GWEN_LOGDOMAIN, "here (%d)\n", p_rv);
    return p_rv;
  }

  /* member "maxLinesPurpose" */
  p_rv=GWEN_DB_SetIntValue(p_db, GWEN_DB_FLAGS_OVERWRITE_VARS, "maxLinesPurpose", p_struct->maxLinesPurpose);
  if (p_rv<0) {
    DBG_INFO(GWEN_LOGDOMAIN, "here (%d)\n", p_rv);
    return p_rv;
  }

  /* member "minLinesPurpose" */
  p_rv=GWEN_DB_SetIntValue(p_db, GWEN_DB_FLAGS_OVERWRITE_VARS, "minLinesPurpose", p_struct->minLinesPurpose);
  if (p_rv<0) {
    DBG_INFO(GWEN_LOGDOMAIN, "here (%d)\n", p_rv);
    return p_rv;
  }

  /* member "needDate" */
  p_rv=GWEN_DB_SetIntValue(p_db, GWEN_DB_FLAGS_OVERWRITE_VARS, "needDate", p_struct->needDate);
  if (p_rv<0) {
    DBG_INFO(GWEN_LOGDOMAIN, "here (%d)\n", p_rv);
    return p_rv;
  }

  /* member "minValueSetupTime" */
  p_rv=GWEN_DB_SetIntValue(p_db, GWEN_DB_FLAGS_OVERWRITE_VARS, "minValueSetupTime", p_struct->minValueSetupTime);
  if (p_rv<0) {
    DBG_INFO(GWEN_LOGDOMAIN, "here (%d)\n", p_rv);
    return p_rv;
  }

  /* member "maxValueSetupTime" */
  p_rv=GWEN_DB_SetIntValue(p_db, GWEN_DB_FLAGS_OVERWRITE_VARS, "maxValueSetupTime", p_struct->maxValueSetupTime);
  if (p_rv<0) {
    DBG_INFO(GWEN_LOGDOMAIN, "here (%d)\n", p_rv);
    return p_rv;
  }

  /* member "minValueSetupTimeFirst" */
  p_rv=GWEN_DB_SetIntValue(p_db, GWEN_DB_FLAGS_OVERWRITE_VARS, "minValueSetupTimeFirst",
                           p_struct->minValueSetupTimeFirst);
  if (p_rv<0) {
    DBG_INFO(GWEN_LOGDOMAIN, "here (%d)\n", p_rv);
    return p_rv;
  }

  /* member "maxValueSetupTimeFirst" */
  p_rv=GWEN_DB_SetIntValue(p_db, GWEN_DB_FLAGS_OVERWRITE_VARS, "maxValueSetupTimeFirst",
                           p_struct->maxValueSetupTimeFirst);
  if (p_rv<0) {
    DBG_INFO(GWEN_LOGDOMAIN, "here (%d)\n", p_rv);
    return p_rv;
  }

  /* member "minValueSetupTimeOnce" */
  p_rv=GWEN_DB_SetIntValue(p_db, GWEN_DB_FLAGS_OVERWRITE_VARS, "minValueSetupTimeOnce", p_struct->minValueSetupTimeOnce);
  if (p_rv<0) {
    DBG_INFO(GWEN_LOGDOMAIN, "here (%d)\n", p_rv);
    return p_rv;
  }

  /* member "maxValueSetupTimeOnce" */
  p_rv=GWEN_DB_SetIntValue(p_db, GWEN_DB_FLAGS_OVERWRITE_VARS, "maxValueSetupTimeOnce", p_struct->maxValueSetupTimeOnce);
  if (p_rv<0) {
    DBG_INFO(GWEN_LOGDOMAIN, "here (%d)\n", p_rv);
    return p_rv;
  }

  /* member "minValueSetupTimeRecurring" */
  p_rv=GWEN_DB_SetIntValue(p_db, GWEN_DB_FLAGS_OVERWRITE_VARS, "minValueSetupTimeRecurring",
                           p_struct->minValueSetupTimeRecurring);
  if (p_rv<0) {
    DBG_INFO(GWEN_LOGDOMAIN, "here (%d)\n", p_rv);
    return p_rv;
  }

  /* member "maxValueSetupTimeRecurring" */
  p_rv=GWEN_DB_SetIntValue(p_db, GWEN_DB_FLAGS_OVERWRITE_VARS, "maxValueSetupTimeRecurring",
                           p_struct->maxValueSetupTimeRecurring);
  if (p_rv<0) {
    DBG_INFO(GWEN_LOGDOMAIN, "here (%d)\n", p_rv);
    return p_rv;
  }

  /* member "minValueSetupTimeFinal" */
  p_rv=GWEN_DB_SetIntValue(p_db, GWEN_DB_FLAGS_OVERWRITE_VARS, "minValueSetupTimeFinal",
                           p_struct->minValueSetupTimeFinal);
  if (p_rv<0) {
    DBG_INFO(GWEN_LOGDOMAIN, "here (%d)\n", p_rv);
    return p_rv;
  }

  /* member "maxValueSetupTimeFinal" */
  p_rv=GWEN_DB_SetIntValue(p_db, GWEN_DB_FLAGS_OVERWRITE_VARS, "maxValueSetupTimeFinal",
                           p_struct->maxValueSetupTimeFinal);
  if (p_rv<0) {
    DBG_INFO(GWEN_LOGDOMAIN, "here (%d)\n", p_rv);
    return p_rv;
  }

  /* member "valuesCycleWeek" */
  {
    int i=0;
    int result=0;
    for (i=0; i < 64; i++) {
      result=GWEN_DB_SetIntValue(p_db, GWEN_DB_FLAGS_OVERWRITE_VARS, "valuesCycleWeek", p_struct->valuesCycleWeek[i]);
    }
    p_rv=result;
  }
  if (p_rv<0) {
    DBG_INFO(GWEN_LOGDOMAIN, "here (%d)\n", p_rv);
    return p_rv;
  }

  /* member "valuesCycleWeekUsed" */
  p_rv=GWEN_DB_SetIntValue(p_db, GWEN_DB_FLAGS_OVERWRITE_VARS, "valuesCycleWeekUsed", p_struct->valuesCycleWeekUsed);
  if (p_rv<0) {
    DBG_INFO(GWEN_LOGDOMAIN, "here (%d)\n", p_rv);
    return p_rv;
  }

  /* member "valuesCycleMonth" */
  {
    int i=0;
    int result=0;
    for (i=0; i < 64; i++) {
      result=GWEN_DB_SetIntValue(p_db, GWEN_DB_FLAGS_OVERWRITE_VARS, "valuesCycleMonth", p_struct->valuesCycleMonth[i]);
    }
    p_rv=result;
  }
  if (p_rv<0) {
    DBG_INFO(GWEN_LOGDOMAIN, "here (%d)\n", p_rv);
    return p_rv;
  }

  /* member "valuesCycleMonthUsed" */
  p_rv=GWEN_DB_SetIntValue(p_db, GWEN_DB_FLAGS_OVERWRITE_VARS, "valuesCycleMonthUsed", p_struct->valuesCycleMonthUsed);
  if (p_rv<0) {
    DBG_INFO(GWEN_LOGDOMAIN, "here (%d)\n", p_rv);
    return p_rv;
  }

  /* member "valuesExecutionDayWeek" */
  {
    int i=0;
    int result=0;
    for (i=0; i < 16; i++) {
      result=GWEN_DB_SetIntValue(p_db, GWEN_DB_FLAGS_OVERWRITE_VARS, "valuesExecutionDayWeek",
                                 p_struct->valuesExecutionDayWeek[i]);
    }
    p_rv=result;
  }
  if (p_rv<0) {
    DBG_INFO(GWEN_LOGDOMAIN, "here (%d)\n", p_rv);
    return p_rv;
  }

  /* member "valuesExecutionDayWeekUsed" */
  p_rv=GWEN_DB_SetIntValue(p_db, GWEN_DB_FLAGS_OVERWRITE_VARS, "valuesExecutionDayWeekUsed",
                           p_struct->valuesExecutionDayWeekUsed);
  if (p_rv<0) {
    DBG_INFO(GWEN_LOGDOMAIN, "here (%d)\n", p_rv);
    return p_rv;
  }

  /* member "valuesExecutionDayMonth" */
  {
    int i=0;
    int result=0;
    for (i=0; i < 64; i++) {
      result=GWEN_DB_SetIntValue(p_db, GWEN_DB_FLAGS_OVERWRITE_VARS, "valuesExecutionDayMonth",
                                 p_struct->valuesExecutionDayMonth[i]);
    }
    p_rv=result;
  }
  if (p_rv<0) {
    DBG_INFO(GWEN_LOGDOMAIN, "here (%d)\n", p_rv);
    return p_rv;
  }

  /* member "valuesExecutionDayMonthUsed" */
  p_rv=GWEN_DB_SetIntValue(p_db, GWEN_DB_FLAGS_OVERWRITE_VARS, "valuesExecutionDayMonthUsed",
                           p_struct->valuesExecutionDayMonthUsed);
  if (p_rv<0) {
    DBG_INFO(GWEN_LOGDOMAIN, "here (%d)\n", p_rv);
    return p_rv;
  }

  /* member "allowMonthly" */
  p_rv=GWEN_DB_SetIntValue(p_db, GWEN_DB_FLAGS_OVERWRITE_VARS, "allowMonthly", p_struct->allowMonthly);
  if (p_rv<0) {
    DBG_INFO(GWEN_LOGDOMAIN, "here (%d)\n", p_rv);
    return p_rv;
  }

  /* member "allowWeekly" */
  p_rv=GWEN_DB_SetIntValue(p_db, GWEN_DB_FLAGS_OVERWRITE_VARS, "allowWeekly", p_struct->allowWeekly);
  if (p_rv<0) {
    DBG_INFO(GWEN_LOGDOMAIN, "here (%d)\n", p_rv);
    return p_rv;
  }

  /* member "allowChangeRecipientAccount" */
  p_rv=GWEN_DB_SetIntValue(p_db, GWEN_DB_FLAGS_OVERWRITE_VARS, "allowChangeRecipientAccount",
                           p_struct->allowChangeRecipientAccount);
  if (p_rv<0) {
    DBG_INFO(GWEN_LOGDOMAIN, "here (%d)\n", p_rv);
    return p_rv;
  }

  /* member "allowChangeRecipientName" */
  p_rv=GWEN_DB_SetIntValue(p_db, GWEN_DB_FLAGS_OVERWRITE_VARS, "allowChangeRecipientName",
                           p_struct->allowChangeRecipientName);
  if (p_rv<0) {
    DBG_INFO(GWEN_LOGDOMAIN, "here (%d)\n", p_rv);
    return p_rv;
  }

  /* member "allowChangeValue" */
  p_rv=GWEN_DB_SetIntValue(p_db, GWEN_DB_FLAGS_OVERWRITE_VARS, "allowChangeValue", p_struct->allowChangeValue);
  if (p_rv<0) {
    DBG_INFO(GWEN_LOGDOMAIN, "here (%d)\n", p_rv);
    return p_rv;
  }

  /* member "allowChangeTextKey" */
  p_rv=GWEN_DB_SetIntValue(p_db, GWEN_DB_FLAGS_OVERWRITE_VARS, "allowChangeTextKey", p_struct->allowChangeTextKey);
  if (p_rv<0) {
    DBG_INFO(GWEN_LOGDOMAIN, "here (%d)\n", p_rv);
    return p_rv;
  }

  /* member "allowChangePurpose" */
  p_rv=GWEN_DB_SetIntValue(p_db, GWEN_DB_FLAGS_OVERWRITE_VARS, "allowChangePurpose", p_struct->allowChangePurpose);
  if (p_rv<0) {
    DBG_INFO(GWEN_LOGDOMAIN, "here (%d)\n", p_rv);
    return p_rv;
  }

  /* member "allowChangeFirstExecutionDate" */
  p_rv=GWEN_DB_SetIntValue(p_db, GWEN_DB_FLAGS_OVERWRITE_VARS, "allowChangeFirstExecutionDate",
                           p_struct->allowChangeFirstExecutionDate);
  if (p_rv<0) {
    DBG_INFO(GWEN_LOGDOMAIN, "here (%d)\n", p_rv);
    return p_rv;
  }

  /* member "allowChangeLastExecutionDate" */
  p_rv=GWEN_DB_SetIntValue(p_db, GWEN_DB_FLAGS_OVERWRITE_VARS, "allowChangeLastExecutionDate",
                           p_struct->allowChangeLastExecutionDate);
  if (p_rv<0) {
    DBG_INFO(GWEN_LOGDOMAIN, "here (%d)\n", p_rv);
    return p_rv;
  }

  /* member "allowChangeCycle" */
  p_rv=GWEN_DB_SetIntValue(p_db, GWEN_DB_FLAGS_OVERWRITE_VARS, "allowChangeCycle", p_struct->allowChangeCycle);
  if (p_rv<0) {
    DBG_INFO(GWEN_LOGDOMAIN, "here (%d)\n", p_rv);
    return p_rv;
  }

  /* member "allowChangePeriod" */
  p_rv=GWEN_DB_SetIntValue(p_db, GWEN_DB_FLAGS_OVERWRITE_VARS, "allowChangePeriod", p_struct->allowChangePeriod);
  if (p_rv<0) {
    DBG_INFO(GWEN_LOGDOMAIN, "here (%d)\n", p_rv);
    return p_rv;
  }

  /* member "allowChangeExecutionDay" */
  p_rv=GWEN_DB_SetIntValue(p_db, GWEN_DB_FLAGS_OVERWRITE_VARS, "allowChangeExecutionDay",
                           p_struct->allowChangeExecutionDay);
  if (p_rv<0) {
    DBG_INFO(GWEN_LOGDOMAIN, "here (%d)\n", p_rv);
    return p_rv;
  }

  return 0;
}

AB_TRANSACTION_LIMITS *AB_TransactionLimits_fromDb(GWEN_DB_NODE *p_db)
{
  AB_TRANSACTION_LIMITS *p_struct;
  p_struct=AB_TransactionLimits_new();
  AB_TransactionLimits_ReadDb(p_struct, p_db);
  return p_struct;
}

int AB_TransactionLimits_toDb(const AB_TRANSACTION_LIMITS *p_struct, GWEN_DB_NODE *p_db)
{
  return AB_TransactionLimits_WriteDb(p_struct, p_db);
}

void AB_TransactionLimits_ReadXml(AB_TRANSACTION_LIMITS *p_struct, GWEN_XMLNODE *p_db)
{
  assert(p_struct);
  /* member "command" */
  p_struct->command=GWEN_XMLNode_GetIntValue(p_db, "command", 0);

  /* member "maxLenLocalName" */
  p_struct->maxLenLocalName=GWEN_XMLNode_GetIntValue(p_db, "maxLenLocalName", 0);

  /* member "minLenLocalName" */
  p_struct->minLenLocalName=GWEN_XMLNode_GetIntValue(p_db, "minLenLocalName", 0);

  /* member "maxLenRemoteName" */
  p_struct->maxLenRemoteName=GWEN_XMLNode_GetIntValue(p_db, "maxLenRemoteName", 0);

  /* member "minLenRemoteName" */
  p_struct->minLenRemoteName=GWEN_XMLNode_GetIntValue(p_db, "minLenRemoteName", 0);

  /* member "maxLenCustomerReference" */
  p_struct->maxLenCustomerReference=GWEN_XMLNode_GetIntValue(p_db, "maxLenCustomerReference", 0);

  /* member "minLenCustomerReference" */
  p_struct->minLenCustomerReference=GWEN_XMLNode_GetIntValue(p_db, "minLenCustomerReference", 0);

  /* member "maxLenBankReference" */
  p_struct->maxLenBankReference=GWEN_XMLNode_GetIntValue(p_db, "maxLenBankReference", 0);

  /* member "minLenBankReference" */
  p_struct->minLenBankReference=GWEN_XMLNode_GetIntValue(p_db, "minLenBankReference", 0);

  /* member "maxLenPurpose" */
  p_struct->maxLenPurpose=GWEN_XMLNode_GetIntValue(p_db, "maxLenPurpose", 0);

  /* member "minLenPurpose" */
  p_struct->minLenPurpose=GWEN_XMLNode_GetIntValue(p_db, "minLenPurpose", 0);

  /* member "maxLinesPurpose" */
  p_struct->maxLinesPurpose=GWEN_XMLNode_GetIntValue(p_db, "maxLinesPurpose", 0);

  /* member "minLinesPurpose" */
  p_struct->minLinesPurpose=GWEN_XMLNode_GetIntValue(p_db, "minLinesPurpose", 0);

  /* member "needDate" */
  p_struct->needDate=GWEN_XMLNode_GetIntValue(p_db, "needDate", 0);

  /* member "minValueSetupTime" */
  p_struct->minValueSetupTime=GWEN_XMLNode_GetIntValue(p_db, "minValueSetupTime", 0);

  /* member "maxValueSetupTime" */
  p_struct->maxValueSetupTime=GWEN_XMLNode_GetIntValue(p_db, "maxValueSetupTime", 0);

  /* member "minValueSetupTimeFirst" */
  p_struct->minValueSetupTimeFirst=GWEN_XMLNode_GetIntValue(p_db, "minValueSetupTimeFirst", 0);

  /* member "maxValueSetupTimeFirst" */
  p_struct->maxValueSetupTimeFirst=GWEN_XMLNode_GetIntValue(p_db, "maxValueSetupTimeFirst", 0);

  /* member "minValueSetupTimeOnce" */
  p_struct->minValueSetupTimeOnce=GWEN_XMLNode_GetIntValue(p_db, "minValueSetupTimeOnce", 0);

  /* member "maxValueSetupTimeOnce" */
  p_struct->maxValueSetupTimeOnce=GWEN_XMLNode_GetIntValue(p_db, "maxValueSetupTimeOnce", 0);

  /* member "minValueSetupTimeRecurring" */
  p_struct->minValueSetupTimeRecurring=GWEN_XMLNode_GetIntValue(p_db, "minValueSetupTimeRecurring", 0);

  /* member "maxValueSetupTimeRecurring" */
  p_struct->maxValueSetupTimeRecurring=GWEN_XMLNode_GetIntValue(p_db, "maxValueSetupTimeRecurring", 0);

  /* member "minValueSetupTimeFinal" */
  p_struct->minValueSetupTimeFinal=GWEN_XMLNode_GetIntValue(p_db, "minValueSetupTimeFinal", 0);

  /* member "maxValueSetupTimeFinal" */
  p_struct->maxValueSetupTimeFinal=GWEN_XMLNode_GetIntValue(p_db, "maxValueSetupTimeFinal", 0);

  /* member "valuesCycleWeek" */


  /* member "valuesCycleWeekUsed" */
  p_struct->valuesCycleWeekUsed=GWEN_XMLNode_GetIntValue(p_db, "valuesCycleWeekUsed", 0);

  /* member "valuesCycleMonth" */


  /* member "valuesCycleMonthUsed" */
  p_struct->valuesCycleMonthUsed=GWEN_XMLNode_GetIntValue(p_db, "valuesCycleMonthUsed", 0);

  /* member "valuesExecutionDayWeek" */


  /* member "valuesExecutionDayWeekUsed" */
  p_struct->valuesExecutionDayWeekUsed=GWEN_XMLNode_GetIntValue(p_db, "valuesExecutionDayWeekUsed", 0);

  /* member "valuesExecutionDayMonth" */


  /* member "valuesExecutionDayMonthUsed" */
  p_struct->valuesExecutionDayMonthUsed=GWEN_XMLNode_GetIntValue(p_db, "valuesExecutionDayMonthUsed", 0);

  /* member "allowMonthly" */
  p_struct->allowMonthly=GWEN_XMLNode_GetIntValue(p_db, "allowMonthly", 0);

  /* member "allowWeekly" */
  p_struct->allowWeekly=GWEN_XMLNode_GetIntValue(p_db, "allowWeekly", 0);

  /* member "allowChangeRecipientAccount" */
  p_struct->allowChangeRecipientAccount=GWEN_XMLNode_GetIntValue(p_db, "allowChangeRecipientAccount", 0);

  /* member "allowChangeRecipientName" */
  p_struct->allowChangeRecipientName=GWEN_XMLNode_GetIntValue(p_db, "allowChangeRecipientName", 0);

  /* member "allowChangeValue" */
  p_struct->allowChangeValue=GWEN_XMLNode_GetIntValue(p_db, "allowChangeValue", 0);

  /* member "allowChangeTextKey" */
  p_struct->allowChangeTextKey=GWEN_XMLNode_GetIntValue(p_db, "allowChangeTextKey", 0);

  /* member "allowChangePurpose" */
  p_struct->allowChangePurpose=GWEN_XMLNode_GetIntValue(p_db, "allowChangePurpose", 0);

  /* member "allowChangeFirstExecutionDate" */
  p_struct->allowChangeFirstExecutionDate=GWEN_XMLNode_GetIntValue(p_db, "allowChangeFirstExecutionDate", 0);

  /* member "allowChangeLastExecutionDate" */
  p_struct->allowChangeLastExecutionDate=GWEN_XMLNode_GetIntValue(p_db, "allowChangeLastExecutionDate", 0);

  /* member "allowChangeCycle" */
  p_struct->allowChangeCycle=GWEN_XMLNode_GetIntValue(p_db, "allowChangeCycle", 0);

  /* member "allowChangePeriod" */
  p_struct->allowChangePeriod=GWEN_XMLNode_GetIntValue(p_db, "allowChangePeriod", 0);

  /* member "allowChangeExecutionDay" */
  p_struct->allowChangeExecutionDay=GWEN_XMLNode_GetIntValue(p_db, "allowChangeExecutionDay", 0);

}

void AB_TransactionLimits_WriteXml(const AB_TRANSACTION_LIMITS *p_struct, GWEN_XMLNODE *p_db)
{
  assert(p_struct);
  /* member "command" */
  GWEN_XMLNode_SetIntValue(p_db, "command", p_struct->command);

  /* member "maxLenLocalName" */
  GWEN_XMLNode_SetIntValue(p_db, "maxLenLocalName", p_struct->maxLenLocalName);

  /* member "minLenLocalName" */
  GWEN_XMLNode_SetIntValue(p_db, "minLenLocalName", p_struct->minLenLocalName);

  /* member "maxLenRemoteName" */
  GWEN_XMLNode_SetIntValue(p_db, "maxLenRemoteName", p_struct->maxLenRemoteName);

  /* member "minLenRemoteName" */
  GWEN_XMLNode_SetIntValue(p_db, "minLenRemoteName", p_struct->minLenRemoteName);

  /* member "maxLenCustomerReference" */
  GWEN_XMLNode_SetIntValue(p_db, "maxLenCustomerReference", p_struct->maxLenCustomerReference);

  /* member "minLenCustomerReference" */
  GWEN_XMLNode_SetIntValue(p_db, "minLenCustomerReference", p_struct->minLenCustomerReference);

  /* member "maxLenBankReference" */
  GWEN_XMLNode_SetIntValue(p_db, "maxLenBankReference", p_struct->maxLenBankReference);

  /* member "minLenBankReference" */
  GWEN_XMLNode_SetIntValue(p_db, "minLenBankReference", p_struct->minLenBankReference);

  /* member "maxLenPurpose" */
  GWEN_XMLNode_SetIntValue(p_db, "maxLenPurpose", p_struct->maxLenPurpose);

  /* member "minLenPurpose" */
  GWEN_XMLNode_SetIntValue(p_db, "minLenPurpose", p_struct->minLenPurpose);

  /* member "maxLinesPurpose" */
  GWEN_XMLNode_SetIntValue(p_db, "maxLinesPurpose", p_struct->maxLinesPurpose);

  /* member "minLinesPurpose" */
  GWEN_XMLNode_SetIntValue(p_db, "minLinesPurpose", p_struct->minLinesPurpose);

  /* member "needDate" */
  GWEN_XMLNode_SetIntValue(p_db, "needDate", p_struct->needDate);

  /* member "minValueSetupTime" */
  GWEN_XMLNode_SetIntValue(p_db, "minValueSetupTime", p_struct->minValueSetupTime);

  /* member "maxValueSetupTime" */
  GWEN_XMLNode_SetIntValue(p_db, "maxValueSetupTime", p_struct->maxValueSetupTime);

  /* member "minValueSetupTimeFirst" */
  GWEN_XMLNode_SetIntValue(p_db, "minValueSetupTimeFirst", p_struct->minValueSetupTimeFirst);

  /* member "maxValueSetupTimeFirst" */
  GWEN_XMLNode_SetIntValue(p_db, "maxValueSetupTimeFirst", p_struct->maxValueSetupTimeFirst);

  /* member "minValueSetupTimeOnce" */
  GWEN_XMLNode_SetIntValue(p_db, "minValueSetupTimeOnce", p_struct->minValueSetupTimeOnce);

  /* member "maxValueSetupTimeOnce" */
  GWEN_XMLNode_SetIntValue(p_db, "maxValueSetupTimeOnce", p_struct->maxValueSetupTimeOnce);

  /* member "minValueSetupTimeRecurring" */
  GWEN_XMLNode_SetIntValue(p_db, "minValueSetupTimeRecurring", p_struct->minValueSetupTimeRecurring);

  /* member "maxValueSetupTimeRecurring" */
  GWEN_XMLNode_SetIntValue(p_db, "maxValueSetupTimeRecurring", p_struct->maxValueSetupTimeRecurring);

  /* member "minValueSetupTimeFinal" */
  GWEN_XMLNode_SetIntValue(p_db, "minValueSetupTimeFinal", p_struct->minValueSetupTimeFinal);

  /* member "maxValueSetupTimeFinal" */
  GWEN_XMLNode_SetIntValue(p_db, "maxValueSetupTimeFinal", p_struct->maxValueSetupTimeFinal);

  /* member "valuesCycleWeek" */


  /* member "valuesCycleWeekUsed" */
  GWEN_XMLNode_SetIntValue(p_db, "valuesCycleWeekUsed", p_struct->valuesCycleWeekUsed);

  /* member "valuesCycleMonth" */


  /* member "valuesCycleMonthUsed" */
  GWEN_XMLNode_SetIntValue(p_db, "valuesCycleMonthUsed", p_struct->valuesCycleMonthUsed);

  /* member "valuesExecutionDayWeek" */


  /* member "valuesExecutionDayWeekUsed" */
  GWEN_XMLNode_SetIntValue(p_db, "valuesExecutionDayWeekUsed", p_struct->valuesExecutionDayWeekUsed);

  /* member "valuesExecutionDayMonth" */


  /* member "valuesExecutionDayMonthUsed" */
  GWEN_XMLNode_SetIntValue(p_db, "valuesExecutionDayMonthUsed", p_struct->valuesExecutionDayMonthUsed);

  /* member "allowMonthly" */
  GWEN_XMLNode_SetIntValue(p_db, "allowMonthly", p_struct->allowMonthly);

  /* member "allowWeekly" */
  GWEN_XMLNode_SetIntValue(p_db, "allowWeekly", p_struct->allowWeekly);

  /* member "allowChangeRecipientAccount" */
  GWEN_XMLNode_SetIntValue(p_db, "allowChangeRecipientAccount", p_struct->allowChangeRecipientAccount);

  /* member "allowChangeRecipientName" */
  GWEN_XMLNode_SetIntValue(p_db, "allowChangeRecipientName", p_struct->allowChangeRecipientName);

  /* member "allowChangeValue" */
  GWEN_XMLNode_SetIntValue(p_db, "allowChangeValue", p_struct->allowChangeValue);

  /* member "allowChangeTextKey" */
  GWEN_XMLNode_SetIntValue(p_db, "allowChangeTextKey", p_struct->allowChangeTextKey);

  /* member "allowChangePurpose" */
  GWEN_XMLNode_SetIntValue(p_db, "allowChangePurpose", p_struct->allowChangePurpose);

  /* member "allowChangeFirstExecutionDate" */
  GWEN_XMLNode_SetIntValue(p_db, "allowChangeFirstExecutionDate", p_struct->allowChangeFirstExecutionDate);

  /* member "allowChangeLastExecutionDate" */
  GWEN_XMLNode_SetIntValue(p_db, "allowChangeLastExecutionDate", p_struct->allowChangeLastExecutionDate);

  /* member "allowChangeCycle" */
  GWEN_XMLNode_SetIntValue(p_db, "allowChangeCycle", p_struct->allowChangeCycle);

  /* member "allowChangePeriod" */
  GWEN_XMLNode_SetIntValue(p_db, "allowChangePeriod", p_struct->allowChangePeriod);

  /* member "allowChangeExecutionDay" */
  GWEN_XMLNode_SetIntValue(p_db, "allowChangeExecutionDay", p_struct->allowChangeExecutionDay);

}

void AB_TransactionLimits_toXml(const AB_TRANSACTION_LIMITS *p_struct, GWEN_XMLNODE *p_db)
{
  AB_TransactionLimits_WriteXml(p_struct, p_db);
}

AB_TRANSACTION_LIMITS *AB_TransactionLimits_fromXml(GWEN_XMLNODE *p_db)
{
  AB_TRANSACTION_LIMITS *p_struct;
  p_struct=AB_TransactionLimits_new();
  AB_TransactionLimits_ReadXml(p_struct, p_db);
  return p_struct;
}

AB_TRANSACTION_LIMITS *AB_TransactionLimits_List_GetByCommand(const AB_TRANSACTION_LIMITS_LIST *p_list, int p_cmp)
{
  AB_TRANSACTION_LIMITS *p_struct;

  assert(p_list);
  p_struct = AB_TransactionLimits_List_First(p_list);
  while (p_struct) {
    int p_rv;

    if (p_struct->command==p_cmp)
      p_rv=0;
    else if (p_cmp<p_struct->command)
      p_rv=-1;
    else
      p_rv=1;
    if (p_rv == 0)
      return p_struct;
    p_struct = AB_TransactionLimits_List_Next(p_struct);
  }
  return NULL;
}

uint8_t AB_TransactionLimits_GetValuesCycleWeekAt(const AB_TRANSACTION_LIMITS *p_struct, int idx)
{
  if (p_struct && (idx < 64))
    return p_struct->valuesCycleWeek[idx];
  return 0;
}
int AB_TransactionLimits_SetValuesCycleWeekAt(AB_TRANSACTION_LIMITS *p_struct, int idx, uint8_t v)
{
  if (p_struct && (idx < 64)) {
    p_struct->valuesCycleWeek[idx]=v;
    return 0;
  }
  return GWEN_ERROR_INVALID;
}
void AB_TransactionLimits_PresetValuesCycleWeek(AB_TRANSACTION_LIMITS *p_struct, uint8_t v)
{
  memset(p_struct->valuesCycleWeek, v, 64);
}
int AB_TransactionLimits_GetValuesCycleWeekArraySize(void)
{
  return 64;
}
uint8_t AB_TransactionLimits_GetValuesCycleMonthAt(const AB_TRANSACTION_LIMITS *p_struct, int idx)
{
  if (p_struct && (idx < 64))
    return p_struct->valuesCycleMonth[idx];
  return 0;
}
int AB_TransactionLimits_SetValuesCycleMonthAt(AB_TRANSACTION_LIMITS *p_struct, int idx, uint8_t v)
{
  if (p_struct && (idx < 64)) {
    p_struct->valuesCycleMonth[idx]=v;
    return 0;
  }
  return GWEN_ERROR_INVALID;
}
void AB_TransactionLimits_PresetValuesCycleMonth(AB_TRANSACTION_LIMITS *p_struct, uint8_t v)
{
  memset(p_struct->valuesCycleMonth, v, 64);
}
int AB_TransactionLimits_GetValuesCycleMonthArraySize(void)
{
  return 64;
}
uint8_t AB_TransactionLimits_GetValuesExecutionDayWeekAt(const AB_TRANSACTION_LIMITS *p_struct, int idx)
{
  if (p_struct && (idx < 16))
    return p_struct->valuesExecutionDayWeek[idx];
  return 0;
}
int AB_TransactionLimits_SetValuesExecutionDayWeekAt(AB_TRANSACTION_LIMITS *p_struct, int idx, uint8_t v)
{
  if (p_struct && (idx < 16)) {
    p_struct->valuesExecutionDayWeek[idx]=v;
    return 0;
  }
  return GWEN_ERROR_INVALID;
}
void AB_TransactionLimits_PresetValuesExecutionDayWeek(AB_TRANSACTION_LIMITS *p_struct, uint8_t v)
{
  memset(p_struct->valuesExecutionDayWeek, v, 16);
}
int AB_TransactionLimits_GetValuesExecutionDayWeekArraySize(void)
{
  return 16;
}
uint8_t AB_TransactionLimits_GetValuesExecutionDayMonthAt(const AB_TRANSACTION_LIMITS *p_struct, int idx)
{
  if (p_struct && (idx < 64))
    return p_struct->valuesExecutionDayMonth[idx];
  return 0;
}
int AB_TransactionLimits_SetValuesExecutionDayMonthAt(AB_TRANSACTION_LIMITS *p_struct, int idx, uint8_t v)
{
  if (p_struct && (idx < 64)) {
    p_struct->valuesExecutionDayMonth[idx]=v;
    return 0;
  }
  return GWEN_ERROR_INVALID;
}
void AB_TransactionLimits_PresetValuesExecutionDayMonth(AB_TRANSACTION_LIMITS *p_struct, uint8_t v)
{
  memset(p_struct->valuesExecutionDayMonth, v, 64);
}
int AB_TransactionLimits_GetValuesExecutionDayMonthArraySize(void)
{
  return 64;
}
int AB_TransactionLimits_ValuesCycleWeekAdd(AB_TRANSACTION_LIMITS *t, uint8_t v)
{
  assert(t);
  if (t->valuesCycleWeekUsed < AB_TransactionLimits_GetValuesCycleWeekArraySize()) {
    t->valuesCycleWeek[t->valuesCycleWeekUsed++]=v;
    return 0;
  }
  else {
    DBG_ERROR(AQBANKING_LOGDOMAIN, "Too many entries (%d)", t->valuesCycleWeekUsed);
    return GWEN_ERROR_BUFFER_OVERFLOW;
  }
}
int AB_TransactionLimits_ValuesCycleWeekHas(const AB_TRANSACTION_LIMITS *t, uint8_t v)
{
  int j;
  assert(t);
  for (j=0; j<t->valuesCycleWeekUsed; j++) {
    if (t->valuesCycleWeek[j]==v)
      return 1;
  }
  return 0;
}
int AB_TransactionLimits_ValuesCycleMonthAdd(AB_TRANSACTION_LIMITS *t, uint8_t v)
{
  assert(t);
  if (t->valuesCycleMonthUsed < AB_TransactionLimits_GetValuesCycleMonthArraySize()) {
    t->valuesCycleMonth[t->valuesCycleMonthUsed++]=v;
    return 0;
  }
  else {
    DBG_ERROR(AQBANKING_LOGDOMAIN, "Too many entries (%d)", t->valuesCycleMonthUsed);
    return GWEN_ERROR_BUFFER_OVERFLOW;
  }
}
int AB_TransactionLimits_ValuesCycleMonthHas(const AB_TRANSACTION_LIMITS *t, uint8_t v)
{
  int j;
  assert(t);
  for (j=0; j<t->valuesCycleMonthUsed; j++) {
    if (t->valuesCycleMonth[j]==v)
      return 1;
  }
  return 0;
}
int AB_TransactionLimits_ValuesExecutionDayWeekAdd(AB_TRANSACTION_LIMITS *t, uint8_t v)
{
  assert(t);
  if (t->valuesExecutionDayWeekUsed < AB_TransactionLimits_GetValuesExecutionDayWeekArraySize()) {
    t->valuesExecutionDayWeek[t->valuesExecutionDayWeekUsed++]=v;
    return 0;
  }
  else {
    DBG_ERROR(AQBANKING_LOGDOMAIN, "Too many entries (%d)", t->valuesExecutionDayWeekUsed);
    return GWEN_ERROR_BUFFER_OVERFLOW;
  }
}
int AB_TransactionLimits_ValuesExecutionDayWeekHas(const AB_TRANSACTION_LIMITS *t, uint8_t v)
{
  int j;
  assert(t);
  for (j=0; j<t->valuesExecutionDayWeekUsed; j++) {
    if (t->valuesExecutionDayWeek[j]==v)
      return 1;
  }
  return 0;
}
int AB_TransactionLimits_ValuesExecutionDayMonthAdd(AB_TRANSACTION_LIMITS *t, uint8_t v)
{
  assert(t);
  if (t->valuesExecutionDayMonthUsed < AB_TransactionLimits_GetValuesExecutionDayMonthArraySize()) {
    t->valuesExecutionDayMonth[t->valuesExecutionDayMonthUsed++]=v;
    return 0;
  }
  else {
    DBG_ERROR(AQBANKING_LOGDOMAIN, "Too many entries (%d)", t->valuesExecutionDayMonthUsed);
    return GWEN_ERROR_BUFFER_OVERFLOW;
  }
}
int AB_TransactionLimits_ValuesExecutionDayMonthHas(const AB_TRANSACTION_LIMITS *t, uint8_t v)
{
  int j;
  assert(t);
  for (j=0; j<t->valuesExecutionDayMonthUsed; j++) {
    if (t->valuesExecutionDayMonth[j]==v)
      return 1;
  }
  return 0;
}

/* code headers */