// --------- This code has been automatically generated !!! 2018-09-03T20:28:03.524Z
"use strict";
/**
 * @module opcua.address_space.types
 */
const assert = require("node-opcua-assert").assert;
const util = require("util");
const _  = require("underscore");
const makeNodeId = require("node-opcua-nodeid").makeNodeId;
const schema_helpers =  require("node-opcua-factory/src/factories_schema_helpers");
const extract_all_fields                       = schema_helpers.extract_all_fields;
const resolve_schema_field_types               = schema_helpers.resolve_schema_field_types;
const initialize_field                         = schema_helpers.initialize_field;
const initialize_field_array                   = schema_helpers.initialize_field_array;
const check_options_correctness_against_schema = schema_helpers.check_options_correctness_against_schema;
const _defaultTypeMap = require("node-opcua-factory/src/factories_builtin_types")._defaultTypeMap;
const ec = require("node-opcua-basic-types");
const encodeArray = ec.encodeArray;
const decodeArray = ec.decodeArray;
const makeExpandedNodeId = require("node-opcua-nodeid/src/expanded_nodeid").makeExpandedNodeId;
const generate_new_id = require("node-opcua-factory").generate_new_id;
const _enumerations = require("node-opcua-factory/src/factories_enumerations")._private._enumerations;
const schema = require("../schemas/BrowseDescription_schema").BrowseDescription_Schema;
const getFactory = require("node-opcua-factory/src/factories_factories").getFactory;
const BaseUAObject = require("node-opcua-factory/src/factories_baseobject").BaseUAObject;

/**
 * A request to browse the the references from a node.
 * 
 * @class BrowseDescription
 * @constructor
 * @extends BaseUAObject
 * @param  options {Object}
 */
function BrowseDescription(options)
{
    options = options || {};
    /* istanbul ignore next */
    if (schema_helpers.doDebug) { check_options_correctness_against_schema(this,schema,options); }
    const self = this;
    assert(this instanceof BaseUAObject); //  ' keyword "new" is required for constructor call')
    resolve_schema_field_types(schema);

    BaseUAObject.call(this,options);
    if (options === null) { 
        BaseUAObject.call(this,options);
        return ;
    }

    /**
      * The id of the node to browse.
      * @property nodeId
      * @type {NodeId}
      */
    self.nodeId = initialize_field(schema.fields[0], options.nodeId);

    /**
      * The direction of the references to return.
      * @property browseDirection
      * @type {BrowseDirection}
      */
    self.setBrowseDirection(initialize_field(schema.fields[1], options.browseDirection));

    /**
      * The type of references to return.Specifies the NodeId of the ReferenceType to follow. Only instances of this ReferenceType or its subtype are returned.If not specified then all ReferenceTypes are returned and includeSubtypes is ignored.
      * @property referenceTypeId
      * @type {NodeId}
      */
    self.referenceTypeId = initialize_field(schema.fields[2], options.referenceTypeId);

    /**
      * Includes subtypes of the reference type.
      * @property includeSubtypes
      * @type {Boolean}
      */
    self.includeSubtypes = initialize_field(schema.fields[3], options.includeSubtypes);

    /**
      * A mask indicating which node classes to return. 0 means return all nodes.
      * @property nodeClassMask
      * @type {UInt32}
      */
    self.nodeClassMask = initialize_field(schema.fields[4], options.nodeClassMask);

    /**
      * A mask indicating which fields in the ReferenceDescription should be returned in the results.
      * @property resultMask
      * @type {UInt32}
      * @default  0
      */
    self.resultMask = initialize_field(schema.fields[5], options.resultMask);

   // Object.preventExtensions(self);
}
util.inherits(BrowseDescription,BaseUAObject);

//## Define Enumeration setters
BrowseDescription.prototype.setBrowseDirection = function(value) {
   const coercedValue = _enumerations.BrowseDirection.typedEnum.get(value);
   /* istanbul ignore next */
   if (coercedValue === undefined || coercedValue === null) {
      throw new Error("value cannot be coerced to BrowseDirection: " + value);
   }
   this.browseDirection = coercedValue;
};
BrowseDescription.prototype.encodingDefaultBinary = makeExpandedNodeId(516,0);
BrowseDescription.prototype.encodingDefaultXml = makeExpandedNodeId(515,0);
BrowseDescription.prototype._schema = schema;

const encode_NodeId = _defaultTypeMap.NodeId.encode;
const decode_NodeId = _defaultTypeMap.NodeId.decode;
const encode_BrowseDirection = _enumerations.BrowseDirection.encode;
const decode_BrowseDirection = _enumerations.BrowseDirection.decode;
const encode_Boolean = _defaultTypeMap.Boolean.encode;
const decode_Boolean = _defaultTypeMap.Boolean.decode;
const encode_UInt32 = _defaultTypeMap.UInt32.encode;
const decode_UInt32 = _defaultTypeMap.UInt32.decode;
/**
 * encode the object into a binary stream
 * @method encode
 *
 * @param stream {BinaryStream} 
 */
BrowseDescription.prototype.encode = function(stream,options) {
    // call base class implementation first
    BaseUAObject.prototype.encode.call(this,stream,options);
    encode_NodeId(this.nodeId,stream);
    encode_BrowseDirection(this.browseDirection,stream);
    encode_NodeId(this.referenceTypeId,stream);
    encode_Boolean(this.includeSubtypes,stream);
    encode_UInt32(this.nodeClassMask,stream);
    encode_UInt32(this.resultMask,stream);
};
/**
 * decode the object from a binary stream
 * @method decode
 *
 * @param stream {BinaryStream} 
 */
BrowseDescription.prototype.decode = function(stream) {
    // call base class implementation first
    BaseUAObject.prototype.decode.call(this,stream);
    this.nodeId = decode_NodeId(stream);
    this.browseDirection = decode_BrowseDirection(stream);
    this.referenceTypeId = decode_NodeId(stream);
    this.includeSubtypes = decode_Boolean(stream);
    this.nodeClassMask = decode_UInt32(stream);
    this.resultMask = decode_UInt32(stream);
};
BrowseDescription.possibleFields = [
  "nodeId",
         "browseDirection",
         "referenceTypeId",
         "includeSubtypes",
         "nodeClassMask",
         "resultMask"
];


exports.BrowseDescription = BrowseDescription;
const register_class_definition = require("node-opcua-factory/src/factories_factories").register_class_definition;
register_class_definition("BrowseDescription",BrowseDescription);