knate/src/KBSCNateAbstract.js

let K = null

// is it server?
if (typeof exports !== 'undefined' && exports !== null)
{
  K = require('kcore')
  require('./KBSCNateNamespace')
}
else
{
  K = window.K
}

// -----------------------------------------------------------------------------
//                                  Prototypes
// -----------------------------------------------------------------------------

K.BSC.NateAbstractProto =
{
  USE_DEFAULT_NAMESPACE: Symbol('use_default_namespace'),

  init(parentOrElem, namespace)
  {
    this.isDeleted = false;
    this.children  = [];
    this.isNateChildAllowed = true;

    if (namespace == K.BSC.NateAbstractProto.USE_DEFAULT_NAMESPACE) {
      // Special case - ignore parent's namespace and use default one.
      this.namespace = this._getDefaultNamespace()
    } else if (namespace) {
      // Namespace is given explicitly - just use it.
      this.namespace = namespace
    } else if (parentOrElem && parentOrElem.getNamespace) {
      // Get namespace from parent if existent.
      this.namespace = parentOrElem.getNamespace()
    } else {
      // Get default namespace otherwise.
      this.namespace = this._getDefaultNamespace()
    }
  },

  _getDefaultNamespace() {
    // Overload if needed.
    return K.BSC.nateNullNamespace
  },

  getNamespace()
  {
    return this.namespace
  },

  assignNamespace(namespace)
  {
    this.namespace = namespace
  },

  _validateDataKey(key)
  {
    const IS_OK_AS_DATAKEY_REGEXP = new RegExp('^([a-zA-Z0-9\.\:_-]+)$')

    if ((typeof(key) !== 'string') || !IS_OK_AS_DATAKEY_REGEXP.test(key))
    {
      throw new K.Error({errorCode: 'invalidKey', ext: {key: key}})
    }
  },

  _confirmIsNotDeleted()
  {
    // Overload if needed.
  },

  _confirmThereAreNoNateChildren()
  {
    if (this.children.length > 0) {
      throw new K.Error({
        errorCode: 'nateChildrenAlreadyExists',
        ext: {
          namespace: this.getNamespace().name,
          nateObj: this
        }
      });
    }
  },

  _confirmIsNateChildAllowed()
  {
    if (!this.isNateChildAllowed) {
      throw new K.Error({
        errorCode: 'nateChildNotAllowed',
        ext: {
          namespace: this.getNamespace().name,
          nateObj: this
        }
      });
    }
  },

  delete()
  {
    // Call custom delete function if any.
    const deleteFunction = this.getNamespace().getDeleteFunction(this.typeName);

    if (deleteFunction) {
      deleteFunction.call(this);
    }
  },

  set(key, value)
  {
    this._confirmIsNotDeleted()

    const fct = this.namespace.getSetter(key)

    if (fct) {
      fct(this, key, value)
    } else {
      throw new K.Error({errorCode: 'unknownNateParam', ext: {param: key}})
    }

    return this;
  },

  setFromMap(map) {
    for (let key in map) {
      this.set(key, map[key])
    }
    return this
  },

  newNate(nateType, params) {
    let rv = null;

    const createFunction = this.getNamespace().getCreateFunction(nateType);

    if (createFunction) {
      // Create function found - go on.
      rv = createFunction.call(this, nateType, params);

    } else {
      // Error - there is no create function in related namespace.
      throw new K.Error({
        errorCode: 'unknownNateType',
        ext: {
          nateType: nateType,
          namespace: this.getNamespace().name
        }
      });
    }

    return rv;
  }
}