// --------- This code has been automatically generated !!! 2018-07-30T21:12:20.166Z
"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/QueryDataDescription_schema").QueryDataDescription_Schema;
const getFactory = require("node-opcua-factory/src/factories_factories").getFactory;
const RelativePath = getFactory("RelativePath");
const BaseUAObject = require("node-opcua-factory/src/factories_baseobject").BaseUAObject;

/**
 * 
 * @class QueryDataDescription
 * @constructor
 * @extends BaseUAObject
 * @param  options {Object}
 */
function QueryDataDescription(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);
        self.relativePath =  null; /* new RelativePath(null); */
        return ;
    }

    /**
      * Browse path relative to the originating Node that identifies the Node which contains the data that is being requested, where the originating Node is an instance Node of the type defined by the type definition Node. The instance Nodes are further limited by the filter provided as part of this call. 
      * @property relativePath
      * @type {RelativePath}
      */
    self.relativePath =  new RelativePath( options.relativePath);

    /**
      * Id of the Attribute. This shall be a valid Attribute Id. The IntegerId is defined in 7.14. The IntegerId for Attributes are defined in Part 6. If the RelativePath ended in a Reference then this parameter is 0 and ignored by the server.
      * @property attributeId
      * @type {IntegerId}
      */
    self.attributeId = initialize_field(schema.fields[1], options.attributeId);

    /**
      * This parameter is used to identify a single element of a structure or an array, or a single range of indexes for arrays. If a range of elements are specified, the values are returned as a composite. The first element is identified by index 0 (zero).
      * @property indexRange
      * @type {NumericRange}
      */
    self.indexRange = initialize_field(schema.fields[2], options.indexRange);

   // Object.preventExtensions(self);
}
util.inherits(QueryDataDescription,BaseUAObject);
QueryDataDescription.prototype.encodingDefaultBinary = makeExpandedNodeId(572,0);
QueryDataDescription.prototype.encodingDefaultXml = makeExpandedNodeId(571,0);
QueryDataDescription.prototype._schema = schema;

const encode_IntegerId = _defaultTypeMap.IntegerId.encode;
const decode_IntegerId = _defaultTypeMap.IntegerId.decode;
const encode_NumericRange = _defaultTypeMap.NumericRange.encode;
const decode_NumericRange = _defaultTypeMap.NumericRange.decode;
/**
 * encode the object into a binary stream
 * @method encode
 *
 * @param stream {BinaryStream} 
 */
QueryDataDescription.prototype.encode = function(stream,options) {
    // call base class implementation first
    BaseUAObject.prototype.encode.call(this,stream,options);
   this.relativePath.encode(stream,options);
    encode_IntegerId(this.attributeId,stream);
    encode_NumericRange(this.indexRange,stream);
};
/**
 * decode the object from a binary stream
 * @method decode
 *
 * @param stream {BinaryStream} 
 */
QueryDataDescription.prototype.decode = function(stream) {
    // call base class implementation first
    BaseUAObject.prototype.decode.call(this,stream);
    this.relativePath.decode(stream);
    this.attributeId = decode_IntegerId(stream);
    this.indexRange = decode_NumericRange(stream);
};
QueryDataDescription.possibleFields = [
  "relativePath",
         "attributeId",
         "indexRange"
];


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