Class with several helper function for communication and work with xbee-api
@param debug
@constructor
437209
function(debug, milliseconds)
{

    if(debug == null)
    {
        this_debug = false;
    }
    else
    {
        this._debug = debug;
    }

    if(milliseconds == null)
    {
        this._milliseconds = false;
    }
    else
    {
        this._milliseconds = true;
    }


}
1271717
function debug(message) {
            if (enplug.debug) {
                arguments[0] = TAG + arguments[0];
                console.log.apply(console, arguments);
            }
        }
634076
function(options) {

	this.options = {
		"debug": false,
		"verbose": false,
		"socket": "/tmp/node-mpv.sock"
	}

	this.options = _.defaults(options || {}, this.options);

	// intialize the event emitter
	eventEmitter.call(this);

	// socket object
	this.socket = new net.Socket();

	// partially "fixes" the EventEmitter leak
	// the leaking listeners is "close", but I did not yet find any solution to fix it
	this.socket.setMaxListeners(0);

	// connect
	this.socket.connect({path: this.options.socket}, function() {
		if(this.options.debug){
			console.log("Connected to socket " + this.options.socket);
		}
	}.bind(this));


	// reestablish connection when lost
	this.socket.on('close', function() {
		if(this.options.debug){
			console.log("Lost connection to socket. Atemping to reconnect");
		}
		// properly close the connection
		this.socket.end();
		// reconnect
		this.socket.connect({path: this.options.socket}, function() {
			if(this.options.verbose || this.options.debug){
				console.log("Connected to socket " + this.options.socket);
			}
		}.bind(this));
	}.bind(this));

	//  catch errors when occurrings
	this.socket.on('error', function(error) {
		if(this.options.debug){
			console.log(error);
		}
	}.bind(this));

	// received data is delivered upwards by an event
	this.socket.on('data', function(data) {
		// various messages might be fetched at once
		var messages = data.toString().split('\n');

		// each message is emitted seperately
		messages.forEach(function (message) {
			// empty messages may occur
			if(message.length > 0){
				this.emit('message', JSON.parse(message));
			}
		}.bind(this));

	}.bind(this));

}
1284883
private void showNewDebugger(EnhancedDebugger debugger) {
        if (frame == null) {
            createDebug();
        }
        debugger.tabbedPane.setName("XMPPConnection_" + tabbedPane.getComponentCount());
        tabbedPane.add(debugger.tabbedPane, tabbedPane.getComponentCount() - 1);
        tabbedPane.setIconAt(tabbedPane.indexOfComponent(debugger.tabbedPane), connectionCreatedIcon);
        frame.setTitle(
                "Smack Debug Window -- Total connections: " + (tabbedPane.getComponentCount() - 1));
        // Keep the added debugger for later access
        debuggers.add(debugger);
    }
733664
function debugLog(browserWindow, message) {
  // need the timeout as it takes time for the preload javascript to be loaded in the window
  setTimeout(() => {
    browserWindow.webContents.send('debug', message);
  }, 3000);
  log.info(message);
}
801556
function(options) {
  this.debug = options.debug;

  this.board = options.board;
  this.connection = options.connection;

  this.chip = new options.protocol({ quiet: true });
}
551476
function enableDebugger() {
        try {
            _nodeConnection.domains.base.enableDebugger();
        } catch (e) {
            window.alert("Failed trying to enable Node debugger: " + e.message);
        }
    }
661028
def DEBUG(msg, *args, **kwargs):
    """"""
    logger = getLogger("DEBUG")
    if len(logger.handlers) == 0:
        logger.addHandler(StreamHandler())
    logger.propagate = False
    logger.setLevel(logging.DEBUG)
    logger.DEV(msg, *args, **kwargs)
67265
@Deprecated
    public static void logDebug(String tag, String message) {
        LogManager.d(tag, message);
    }
224912
function(opts) {
  opts = opts || {};

  this.options = {
    debug: opts.debug || false,
    board: opts.board || 'uno',
    port: opts.port || '',
    manualReset: opts.manualReset || false
  };

  // this here checks for 3 conditions:
  // if debug option is simply true, we want to fall back to default debug function
  // if a custom debug function is passed in, we want to assign debug to be that
  // if debug option is false, then run debug as a no-op
  if (this.options.debug === true) {
    this.debug = console.log.bind(console);
  } else if (typeof this.options.debug === 'function') {
    this.debug = this.options.debug;
  } else {
    this.debug = function() {};
  }

  if (typeof this.options.board === 'string') {
    this.options.board = boards[this.options.board];
  } else if (typeof this.options.board === 'object') {
    this.options.board = this.options.board;
  }

  if (this.options.board && !this.options.board.manualReset) {
    this.options.board.manualReset = this.options.manualReset;
  }

  this.connection = new Connection(this.options);

  if (this.options.board) {
    var Protocol = protocols[this.options.board.protocol] || function() {};

    this.protocol = new Protocol({
      board: this.options.board,
      connection: this.connection,
      debug: this.debug
    });
  }
}
605784
public Context debug(final Vars vars, final BreakpointListener listener) {
        return debug(vars, DiscardOut.INSTANCE, listener);
    }
951322
@Override
    public void debug(Object object, Object... objects) {
        if (isDebugEnabled()) {
            StringBuilder result = new StringBuilder();
            result.append(object.toString());
            for (Object obj : objects) {
                if (obj == null) {
                    result.append("null");
                } else {
                    result.append(obj.toString());
                }
            }
            debugString(result.toString());
        }
    }
145263
def debug(self, debug):
        

        yield from self._hypervisor.send("nio set_debug {name} {debug}".format(name=self._name, debug=debug))
682607
private static Main mainEmbeddedImpl(ContextFactory factory,
                                         Object scopeProvider,
                                         String title) {
        if (title == null) {
            title = "Rhino JavaScript Debugger (embedded usage)";
        }
        Main main = new Main(title);
        main.doBreak();
        main.setExitAction(new IProxy(IProxy.EXIT_ACTION));

        main.attachTo(factory);
        if (scopeProvider instanceof ScopeProvider) {
            main.setScopeProvider((ScopeProvider)scopeProvider);
        } else {
            Scriptable scope = (Scriptable)scopeProvider;
            if (scope instanceof Global) {
                Global global = (Global)scope;
                global.setIn(main.getIn());
                global.setOut(main.getOut());
                global.setErr(main.getErr());
            }
            main.setScope(scope);
        }

        main.pack();
        main.setSize(600, 460);
        main.setVisible(true);
        return main;
    }
270781
function () {
        var prefix = 'DEBUG';
        this.output(prefix, prefix.blue, Array.prototype.slice.call(arguments));
    }
1216127
function BasicConnection() {
  var _this = this

  this._disconnected = false
  this._messageHandler = function() {
  }
  this._disconnectHandler = function() {
  }

  var childArgs = []

  process.execArgv.forEach(function(arg) {
    if (arg.indexOf('--debug-brk') !== -1) {
      var _debugPort = parseInt(arg.substr(12)) + 1
      debug('Child process debugger listening on port %d', _debugPort)
      childArgs.push('--debug-brk=' + _debugPort)
    }
  })

  this._process = child_process.fork(__dirname + '/../sandbox/sandbox.js', childArgs)

  this._startHeartBeat()

  this._process.on('message', function(data) {
    var m = codec.decode(data);
    debug('Recibing message: %j', m)
    _this._messageHandler(m)
  })

  this._process.on('exit', function(m) {
    debug('Exit process: %j', m)
    _this._stopHeartBeat()
    _this._disconnected = true
    _this._disconnectHandler(m)
  })
}
620468
function init(debug) {
	debug.inspectOpts = {};

	const keys = Object.keys(exports.inspectOpts);
	for (let i = 0; i < keys.length; i++) {
		debug.inspectOpts[keys[i]] = exports.inspectOpts[keys[i]];
	}
}