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

/**
 *  A standard header included in all responses returned by servers.
 * 
 * @class RegisterServer2Response
 * @constructor
 * @extends BaseUAObject
 * @param  options {Object}
 */
function RegisterServer2Response(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.responseHeader =  null; /* new ResponseHeader(null); */
        self.diagnosticInfos =  null; /* null array */
        return ;
    }

    /**
      * A standard header included in all responses returned by servers.
      * @property responseHeader
      * @type {ResponseHeader}
      */
    self.responseHeader =  new ResponseHeader( options.responseHeader);

    /**
      * List of results for the discovery configuration parameters.
      * @property configurationResults
      * @type {StatusCode[]}
      */
    self.configurationResults = initialize_field_array(schema.fields[1], options.configurationResults);

    /**
      * List of diagnostic information for the discovery configuration
parameters. This list is empty if diagnostics information was not
requested in the request header or if no diagnostic information was
encountered in processing of the request.
      * @property diagnosticInfos
      * @type {DiagnosticInfo[]}
      */
    self.diagnosticInfos = [];
    if (options.diagnosticInfos) {
        assert(_.isArray(options.diagnosticInfos));
        self.diagnosticInfos = options.diagnosticInfos.map(function(e){ return new DiagnosticInfo(e); } );
    }

   // Object.preventExtensions(self);
}
util.inherits(RegisterServer2Response,BaseUAObject);
RegisterServer2Response.prototype.encodingDefaultBinary = makeExpandedNodeId(12212,0);
RegisterServer2Response.prototype.encodingDefaultXml = makeExpandedNodeId(12200,0);
RegisterServer2Response.prototype._schema = schema;

const encode_StatusCode = _defaultTypeMap.StatusCode.encode;
const decode_StatusCode = _defaultTypeMap.StatusCode.decode;
/**
 * encode the object into a binary stream
 * @method encode
 *
 * @param stream {BinaryStream} 
 */
RegisterServer2Response.prototype.encode = function(stream,options) {
    // call base class implementation first
    BaseUAObject.prototype.encode.call(this,stream,options);
   this.responseHeader.encode(stream,options);
    encodeArray(this.configurationResults, stream, encode_StatusCode);
    encodeArray(this.diagnosticInfos,stream,function(obj,stream){ obj.encode(stream,options); }); 
};
/**
 * decode the object from a binary stream
 * @method decode
 *
 * @param stream {BinaryStream} 
 */
RegisterServer2Response.prototype.decode = function(stream) {
    // call base class implementation first
    BaseUAObject.prototype.decode.call(this,stream);
    this.responseHeader.decode(stream);
    this.configurationResults = decodeArray(stream, decode_StatusCode);
    this.diagnosticInfos = decodeArray(stream, function(stream) { 
       const obj = new DiagnosticInfo(null);
       obj.decode(stream);
       return obj; 
    });
};
RegisterServer2Response.possibleFields = [
  "responseHeader",
         "configurationResults",
         "diagnosticInfos"
];


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