service/bpd/tanmethod.c

/**********************************************************
 * This file has been automatically created by "typemaker2"
 * from the file "tanmethod.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 "./tanmethod_p.h"

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

/* code headers */
#include <string.h>

/* macro functions */
GWEN_LIST_FUNCTIONS(AQFINTS_TANMETHOD, AQFINTS_TanMethod)


AQFINTS_TANMETHOD *AQFINTS_TanMethod_new(void)
{
  AQFINTS_TANMETHOD *p_struct;

  GWEN_NEW_OBJECT(AQFINTS_TANMETHOD, p_struct)
  p_struct->_refCount=1;
  GWEN_LIST_INIT(AQFINTS_TANMETHOD, p_struct)
  /* members */
  p_struct->flags=0;
  p_struct->function=0;
  p_struct->process=0;
  p_struct->methodId=NULL;
  p_struct->zkaTanName=NULL;
  p_struct->zkaTanVersion=NULL;
  p_struct->methodName=NULL;
  p_struct->tanMaxLen=0;
  p_struct->formatId=0;
  p_struct->prompt=NULL;
  p_struct->returnMaxLen=0;
  p_struct->maxActiveLists=0;
  p_struct->timeShiftAllowed=0;
  p_struct->tanListMode=0;
  p_struct->needSmsAccount=0;
  p_struct->needLocalAccount=0;
  p_struct->initMode=NULL;
  p_struct->needTanMediumId=0;
  p_struct->maxActiveTanMedia=0;
  p_struct->runtimeFlags=0;
  /* virtual functions */

  return p_struct;
}

void AQFINTS_TanMethod_free(AQFINTS_TANMETHOD *p_struct)
{
  if (p_struct) {
    assert(p_struct->_refCount);
    if (p_struct->_refCount==1) {
      GWEN_LIST_FINI(AQFINTS_TANMETHOD, p_struct)
      /* members */
      free(p_struct->methodId);
      p_struct->methodId=NULL;
      free(p_struct->zkaTanName);
      p_struct->zkaTanName=NULL;
      free(p_struct->zkaTanVersion);
      p_struct->zkaTanVersion=NULL;
      free(p_struct->methodName);
      p_struct->methodName=NULL;
      free(p_struct->prompt);
      p_struct->prompt=NULL;
      free(p_struct->initMode);
      p_struct->initMode=NULL;
      p_struct->_refCount=0;
      GWEN_FREE_OBJECT(p_struct);
    }
    else
      p_struct->_refCount--;
  }
}

void AQFINTS_TanMethod_Attach(AQFINTS_TANMETHOD *p_struct)
{
  assert(p_struct);
  assert(p_struct->_refCount);
  p_struct->_refCount++;
}

AQFINTS_TANMETHOD *AQFINTS_TanMethod_dup(const AQFINTS_TANMETHOD *p_src)
{
  AQFINTS_TANMETHOD *p_struct;

  assert(p_src);
  p_struct=AQFINTS_TanMethod_new();
  /* member "flags" */
  p_struct->flags=p_src->flags;

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

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

  /* member "methodId" */
  if (p_struct->methodId) {
    free(p_struct->methodId);
    p_struct->methodId=NULL;
    p_struct->methodId=NULL;
  }
  if (p_src->methodId) {
    p_struct->methodId=strdup(p_src->methodId);
  }

  /* member "zkaTanName" */
  if (p_struct->zkaTanName) {
    free(p_struct->zkaTanName);
    p_struct->zkaTanName=NULL;
    p_struct->zkaTanName=NULL;
  }
  if (p_src->zkaTanName) {
    p_struct->zkaTanName=strdup(p_src->zkaTanName);
  }

  /* member "zkaTanVersion" */
  if (p_struct->zkaTanVersion) {
    free(p_struct->zkaTanVersion);
    p_struct->zkaTanVersion=NULL;
    p_struct->zkaTanVersion=NULL;
  }
  if (p_src->zkaTanVersion) {
    p_struct->zkaTanVersion=strdup(p_src->zkaTanVersion);
  }

  /* member "methodName" */
  if (p_struct->methodName) {
    free(p_struct->methodName);
    p_struct->methodName=NULL;
    p_struct->methodName=NULL;
  }
  if (p_src->methodName) {
    p_struct->methodName=strdup(p_src->methodName);
  }

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

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

  /* member "prompt" */
  if (p_struct->prompt) {
    free(p_struct->prompt);
    p_struct->prompt=NULL;
    p_struct->prompt=NULL;
  }
  if (p_src->prompt) {
    p_struct->prompt=strdup(p_src->prompt);
  }

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

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

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

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

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

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

  /* member "initMode" */
  if (p_struct->initMode) {
    free(p_struct->initMode);
    p_struct->initMode=NULL;
    p_struct->initMode=NULL;
  }
  if (p_src->initMode) {
    p_struct->initMode=strdup(p_src->initMode);
  }

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

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

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

  return p_struct;
}

AQFINTS_TANMETHOD *AQFINTS_TanMethod_copy(AQFINTS_TANMETHOD *p_struct, const AQFINTS_TANMETHOD *p_src)
{
  assert(p_struct);
  assert(p_src);
  /* member "flags" */
  p_struct->flags=p_src->flags;

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

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

  /* member "methodId" */
  if (p_struct->methodId) {
    free(p_struct->methodId);
    p_struct->methodId=NULL;
    p_struct->methodId=NULL;
  }
  if (p_src->methodId) {
    p_struct->methodId=strdup(p_src->methodId);
  }

  /* member "zkaTanName" */
  if (p_struct->zkaTanName) {
    free(p_struct->zkaTanName);
    p_struct->zkaTanName=NULL;
    p_struct->zkaTanName=NULL;
  }
  if (p_src->zkaTanName) {
    p_struct->zkaTanName=strdup(p_src->zkaTanName);
  }

  /* member "zkaTanVersion" */
  if (p_struct->zkaTanVersion) {
    free(p_struct->zkaTanVersion);
    p_struct->zkaTanVersion=NULL;
    p_struct->zkaTanVersion=NULL;
  }
  if (p_src->zkaTanVersion) {
    p_struct->zkaTanVersion=strdup(p_src->zkaTanVersion);
  }

  /* member "methodName" */
  if (p_struct->methodName) {
    free(p_struct->methodName);
    p_struct->methodName=NULL;
    p_struct->methodName=NULL;
  }
  if (p_src->methodName) {
    p_struct->methodName=strdup(p_src->methodName);
  }

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

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

  /* member "prompt" */
  if (p_struct->prompt) {
    free(p_struct->prompt);
    p_struct->prompt=NULL;
    p_struct->prompt=NULL;
  }
  if (p_src->prompt) {
    p_struct->prompt=strdup(p_src->prompt);
  }

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

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

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

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

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

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

  /* member "initMode" */
  if (p_struct->initMode) {
    free(p_struct->initMode);
    p_struct->initMode=NULL;
    p_struct->initMode=NULL;
  }
  if (p_src->initMode) {
    p_struct->initMode=strdup(p_src->initMode);
  }

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

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

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

  return p_struct;
}

uint32_t AQFINTS_TanMethod_GetFlags(const AQFINTS_TANMETHOD *p_struct)
{
  assert(p_struct);
  return p_struct->flags;
}

int AQFINTS_TanMethod_GetFunction(const AQFINTS_TANMETHOD *p_struct)
{
  assert(p_struct);
  return p_struct->function;
}

int AQFINTS_TanMethod_GetProcess(const AQFINTS_TANMETHOD *p_struct)
{
  assert(p_struct);
  return p_struct->process;
}

const char *AQFINTS_TanMethod_GetMethodId(const AQFINTS_TANMETHOD *p_struct)
{
  assert(p_struct);
  return p_struct->methodId;
}

const char *AQFINTS_TanMethod_GetZkaTanName(const AQFINTS_TANMETHOD *p_struct)
{
  assert(p_struct);
  return p_struct->zkaTanName;
}

const char *AQFINTS_TanMethod_GetZkaTanVersion(const AQFINTS_TANMETHOD *p_struct)
{
  assert(p_struct);
  return p_struct->zkaTanVersion;
}

const char *AQFINTS_TanMethod_GetMethodName(const AQFINTS_TANMETHOD *p_struct)
{
  assert(p_struct);
  return p_struct->methodName;
}

int AQFINTS_TanMethod_GetTanMaxLen(const AQFINTS_TANMETHOD *p_struct)
{
  assert(p_struct);
  return p_struct->tanMaxLen;
}

int AQFINTS_TanMethod_GetFormatId(const AQFINTS_TANMETHOD *p_struct)
{
  assert(p_struct);
  return p_struct->formatId;
}

const char *AQFINTS_TanMethod_GetPrompt(const AQFINTS_TANMETHOD *p_struct)
{
  assert(p_struct);
  return p_struct->prompt;
}

int AQFINTS_TanMethod_GetReturnMaxLen(const AQFINTS_TANMETHOD *p_struct)
{
  assert(p_struct);
  return p_struct->returnMaxLen;
}

int AQFINTS_TanMethod_GetMaxActiveLists(const AQFINTS_TANMETHOD *p_struct)
{
  assert(p_struct);
  return p_struct->maxActiveLists;
}

int AQFINTS_TanMethod_GetTimeShiftAllowed(const AQFINTS_TANMETHOD *p_struct)
{
  assert(p_struct);
  return p_struct->timeShiftAllowed;
}

int AQFINTS_TanMethod_GetTanListMode(const AQFINTS_TANMETHOD *p_struct)
{
  assert(p_struct);
  return p_struct->tanListMode;
}

int AQFINTS_TanMethod_GetNeedSmsAccount(const AQFINTS_TANMETHOD *p_struct)
{
  assert(p_struct);
  return p_struct->needSmsAccount;
}

int AQFINTS_TanMethod_GetNeedLocalAccount(const AQFINTS_TANMETHOD *p_struct)
{
  assert(p_struct);
  return p_struct->needLocalAccount;
}

const char *AQFINTS_TanMethod_GetInitMode(const AQFINTS_TANMETHOD *p_struct)
{
  assert(p_struct);
  return p_struct->initMode;
}

int AQFINTS_TanMethod_GetNeedTanMediumId(const AQFINTS_TANMETHOD *p_struct)
{
  assert(p_struct);
  return p_struct->needTanMediumId;
}

int AQFINTS_TanMethod_GetMaxActiveTanMedia(const AQFINTS_TANMETHOD *p_struct)
{
  assert(p_struct);
  return p_struct->maxActiveTanMedia;
}

uint32_t AQFINTS_TanMethod_GetRuntimeFlags(const AQFINTS_TANMETHOD *p_struct)
{
  assert(p_struct);
  return p_struct->runtimeFlags;
}

void AQFINTS_TanMethod_SetFlags(AQFINTS_TANMETHOD *p_struct, uint32_t p_src)
{
  assert(p_struct);
  p_struct->flags=p_src;
}

void AQFINTS_TanMethod_AddFlags(AQFINTS_TANMETHOD *p_struct, uint32_t p_src)
{
  assert(p_struct);
  p_struct->flags|=p_src;
}

void AQFINTS_TanMethod_SubFlags(AQFINTS_TANMETHOD *p_struct, uint32_t p_src)
{
  assert(p_struct);
  p_struct->flags&=~p_src;
}

void AQFINTS_TanMethod_SetFunction(AQFINTS_TANMETHOD *p_struct, int p_src)
{
  assert(p_struct);
  p_struct->function=p_src;
}

void AQFINTS_TanMethod_SetProcess(AQFINTS_TANMETHOD *p_struct, int p_src)
{
  assert(p_struct);
  p_struct->process=p_src;
}

void AQFINTS_TanMethod_SetMethodId(AQFINTS_TANMETHOD *p_struct, const char *p_src)
{
  assert(p_struct);
  if (p_struct->methodId) {
    free(p_struct->methodId);
    p_struct->methodId=NULL;
  }
  if (p_src) {
    p_struct->methodId=strdup(p_src);
  }
  else {
    p_struct->methodId=NULL;
  }
}

void AQFINTS_TanMethod_SetZkaTanName(AQFINTS_TANMETHOD *p_struct, const char *p_src)
{
  assert(p_struct);
  if (p_struct->zkaTanName) {
    free(p_struct->zkaTanName);
    p_struct->zkaTanName=NULL;
  }
  if (p_src) {
    p_struct->zkaTanName=strdup(p_src);
  }
  else {
    p_struct->zkaTanName=NULL;
  }
}

void AQFINTS_TanMethod_SetZkaTanVersion(AQFINTS_TANMETHOD *p_struct, const char *p_src)
{
  assert(p_struct);
  if (p_struct->zkaTanVersion) {
    free(p_struct->zkaTanVersion);
    p_struct->zkaTanVersion=NULL;
  }
  if (p_src) {
    p_struct->zkaTanVersion=strdup(p_src);
  }
  else {
    p_struct->zkaTanVersion=NULL;
  }
}

void AQFINTS_TanMethod_SetMethodName(AQFINTS_TANMETHOD *p_struct, const char *p_src)
{
  assert(p_struct);
  if (p_struct->methodName) {
    free(p_struct->methodName);
    p_struct->methodName=NULL;
  }
  if (p_src) {
    p_struct->methodName=strdup(p_src);
  }
  else {
    p_struct->methodName=NULL;
  }
}

void AQFINTS_TanMethod_SetTanMaxLen(AQFINTS_TANMETHOD *p_struct, int p_src)
{
  assert(p_struct);
  p_struct->tanMaxLen=p_src;
}

void AQFINTS_TanMethod_SetFormatId(AQFINTS_TANMETHOD *p_struct, int p_src)
{
  assert(p_struct);
  p_struct->formatId=p_src;
}

void AQFINTS_TanMethod_SetPrompt(AQFINTS_TANMETHOD *p_struct, const char *p_src)
{
  assert(p_struct);
  if (p_struct->prompt) {
    free(p_struct->prompt);
    p_struct->prompt=NULL;
  }
  if (p_src) {
    p_struct->prompt=strdup(p_src);
  }
  else {
    p_struct->prompt=NULL;
  }
}

void AQFINTS_TanMethod_SetReturnMaxLen(AQFINTS_TANMETHOD *p_struct, int p_src)
{
  assert(p_struct);
  p_struct->returnMaxLen=p_src;
}

void AQFINTS_TanMethod_SetMaxActiveLists(AQFINTS_TANMETHOD *p_struct, int p_src)
{
  assert(p_struct);
  p_struct->maxActiveLists=p_src;
}

void AQFINTS_TanMethod_SetTimeShiftAllowed(AQFINTS_TANMETHOD *p_struct, int p_src)
{
  assert(p_struct);
  p_struct->timeShiftAllowed=p_src;
}

void AQFINTS_TanMethod_SetTanListMode(AQFINTS_TANMETHOD *p_struct, int p_src)
{
  assert(p_struct);
  p_struct->tanListMode=p_src;
}

void AQFINTS_TanMethod_SetNeedSmsAccount(AQFINTS_TANMETHOD *p_struct, int p_src)
{
  assert(p_struct);
  p_struct->needSmsAccount=p_src;
}

void AQFINTS_TanMethod_SetNeedLocalAccount(AQFINTS_TANMETHOD *p_struct, int p_src)
{
  assert(p_struct);
  p_struct->needLocalAccount=p_src;
}

void AQFINTS_TanMethod_SetInitMode(AQFINTS_TANMETHOD *p_struct, const char *p_src)
{
  assert(p_struct);
  if (p_struct->initMode) {
    free(p_struct->initMode);
    p_struct->initMode=NULL;
  }
  if (p_src) {
    p_struct->initMode=strdup(p_src);
  }
  else {
    p_struct->initMode=NULL;
  }
}

void AQFINTS_TanMethod_SetNeedTanMediumId(AQFINTS_TANMETHOD *p_struct, int p_src)
{
  assert(p_struct);
  p_struct->needTanMediumId=p_src;
}

void AQFINTS_TanMethod_SetMaxActiveTanMedia(AQFINTS_TANMETHOD *p_struct, int p_src)
{
  assert(p_struct);
  p_struct->maxActiveTanMedia=p_src;
}

void AQFINTS_TanMethod_SetRuntimeFlags(AQFINTS_TANMETHOD *p_struct, uint32_t p_src)
{
  assert(p_struct);
  p_struct->runtimeFlags=p_src;
}

void AQFINTS_TanMethod_AddRuntimeFlags(AQFINTS_TANMETHOD *p_struct, uint32_t p_src)
{
  assert(p_struct);
  p_struct->runtimeFlags|=p_src;
}

void AQFINTS_TanMethod_SubRuntimeFlags(AQFINTS_TANMETHOD *p_struct, uint32_t p_src)
{
  assert(p_struct);
  p_struct->runtimeFlags&=~p_src;
}

/* list1 functions */
AQFINTS_TANMETHOD_LIST *AQFINTS_TanMethod_List_dup(const AQFINTS_TANMETHOD_LIST *p_src)
{
  AQFINTS_TANMETHOD_LIST *p_dest;
  AQFINTS_TANMETHOD *p_elem;

  assert(p_src);
  p_dest=AQFINTS_TanMethod_List_new();
  p_elem=AQFINTS_TanMethod_List_First(p_src);
  while (p_elem) {
    AQFINTS_TANMETHOD *p_cpy;

    p_cpy=AQFINTS_TanMethod_dup(p_elem);
    AQFINTS_TanMethod_List_Add(p_cpy, p_dest);
    p_elem=AQFINTS_TanMethod_List_Next(p_elem);
  }

  return p_dest;
}

void AQFINTS_TanMethod_ReadDb(AQFINTS_TANMETHOD *p_struct, GWEN_DB_NODE *p_db)
{
  assert(p_struct);
  /* member "flags" */
  p_struct->flags=GWEN_DB_GetIntValue(p_db, "flags", 0, 0);

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

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

  /* member "methodId" */
  if (p_struct->methodId) {
    free(p_struct->methodId);
    p_struct->methodId=NULL;
  }
  {
    const char *s;
    s=GWEN_DB_GetCharValue(p_db, "methodId", 0, NULL);
    if (s)
      p_struct->methodId=strdup(s);
  }
  if (p_struct->methodId==NULL) {
    p_struct->methodId=NULL;
  }

  /* member "zkaTanName" */
  if (p_struct->zkaTanName) {
    free(p_struct->zkaTanName);
    p_struct->zkaTanName=NULL;
  }
  {
    const char *s;
    s=GWEN_DB_GetCharValue(p_db, "zkaTanName", 0, NULL);
    if (s)
      p_struct->zkaTanName=strdup(s);
  }
  if (p_struct->zkaTanName==NULL) {
    p_struct->zkaTanName=NULL;
  }

  /* member "zkaTanVersion" */
  if (p_struct->zkaTanVersion) {
    free(p_struct->zkaTanVersion);
    p_struct->zkaTanVersion=NULL;
  }
  {
    const char *s;
    s=GWEN_DB_GetCharValue(p_db, "zkaTanVersion", 0, NULL);
    if (s)
      p_struct->zkaTanVersion=strdup(s);
  }
  if (p_struct->zkaTanVersion==NULL) {
    p_struct->zkaTanVersion=NULL;
  }

  /* member "methodName" */
  if (p_struct->methodName) {
    free(p_struct->methodName);
    p_struct->methodName=NULL;
  }
  {
    const char *s;
    s=GWEN_DB_GetCharValue(p_db, "methodName", 0, NULL);
    if (s)
      p_struct->methodName=strdup(s);
  }
  if (p_struct->methodName==NULL) {
    p_struct->methodName=NULL;
  }

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

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

  /* member "prompt" */
  if (p_struct->prompt) {
    free(p_struct->prompt);
    p_struct->prompt=NULL;
  }
  {
    const char *s;
    s=GWEN_DB_GetCharValue(p_db, "prompt", 0, NULL);
    if (s)
      p_struct->prompt=strdup(s);
  }
  if (p_struct->prompt==NULL) {
    p_struct->prompt=NULL;
  }

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

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

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

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

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

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

  /* member "initMode" */
  if (p_struct->initMode) {
    free(p_struct->initMode);
    p_struct->initMode=NULL;
  }
  {
    const char *s;
    s=GWEN_DB_GetCharValue(p_db, "initMode", 0, NULL);
    if (s)
      p_struct->initMode=strdup(s);
  }
  if (p_struct->initMode==NULL) {
    p_struct->initMode=NULL;
  }

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

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

  /* member "runtimeFlags" */
  /* member "runtimeFlags" is volatile, just presetting */
  p_struct->runtimeFlags=0;

}

int AQFINTS_TanMethod_WriteDb(const AQFINTS_TANMETHOD *p_struct, GWEN_DB_NODE *p_db)
{
  int p_rv;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  /* member "runtimeFlags" is volatile, not writing to db */

  return 0;
}

AQFINTS_TANMETHOD *AQFINTS_TanMethod_fromDb(GWEN_DB_NODE *p_db)
{
  AQFINTS_TANMETHOD *p_struct;
  p_struct=AQFINTS_TanMethod_new();
  AQFINTS_TanMethod_ReadDb(p_struct, p_db);
  return p_struct;
}

int AQFINTS_TanMethod_toDb(const AQFINTS_TANMETHOD *p_struct, GWEN_DB_NODE *p_db)
{
  return AQFINTS_TanMethod_WriteDb(p_struct, p_db);
}

AQFINTS_TANMETHOD *AQFINTS_TanMethod_List_GetByFunction(const AQFINTS_TANMETHOD_LIST *p_list, int p_cmp)
{
  AQFINTS_TANMETHOD *p_struct;

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

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


/* code headers */