• Home
• org.tango-controls
• TangORB
• 9.5.6
• source code
• DeviceImpl.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

fr.esrf.TangoDs.DeviceImpl Maven / Gradle / Ivy

//+======================================================================
// $Source$
//
// Project:   Tango
//
// Description:  java source code for the TANGO client/server API.
//
// $Author: pascal_verdier $
//
// Copyright (C) :      2004,2005,2006,2007,2008,2009,2010,2011,2012,2013,2014,
//						European Synchrotron Radiation Facility
//                      BP 220, Grenoble 38043
//                      FRANCE
//
// This file is part of Tango.
//
// Tango is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// Tango is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU Lesser General Public License for more details.
// 
// You should have received a copy of the GNU Lesser General Public License
// along with Tango.  If not, see .
//
// $Revision: 25297 $
//
//-======================================================================


package fr.esrf.TangoDs;

import fr.esrf.Tango.*;
import fr.esrf.TangoApi.DbAttribute;
import fr.esrf.TangoApi.DbDatum;
import fr.esrf.TangoApi.DbDevice;
import fr.esrf.TangoApi.DeviceProxy;
import org.apache.log4j.Level;
import org.apache.log4j.Logger;
import org.omg.CORBA.Any;
import org.omg.CORBA.BAD_OPERATION;
import org.omg.CORBA.SystemException;
import org.omg.PortableServer.POA;

import java.util.Vector;

/**
 * Base class for all TANGO device
 */

public abstract class DeviceImpl extends Device_2POA implements TangoConst {

    /**
     * Reference to the device-class object associated with the device
     */
    protected final DeviceClass device_class;
    /**
     * DeviceImpl polling extention.
     */
    private final DeviceImplExt ext;
    /**
     * The device black box
     */
    protected BlackBox blackbox;
    /**
     * The device black box depth
     */
    protected int blackbox_depth;
    /**
     * The device name
     */
    protected String device_name;
    /**
     * The administration device name
     */
    protected String adm_device_name;
    /**
     * The device description
     */
    protected String desc;
    /**
     * The device status
     */
    protected String device_status;
    /**
     * The device state
     */
    protected DevState device_state;
    /**
     * The device access
     */
    protected byte[] access;
    /**
     * The device version
     */
    protected int version;
    /**
     * Reference to the multi attribute object
     */
    protected MultiAttribute dev_attr;
    /**
     * Reference to the associated DbDevice object
     */
    protected DbDevice db_dev;
    private byte[] obj_id;
    private boolean exported = false;
    /**
     * Device's logger
     */
    private Logger logger = null;
    /**
     * Device's logging level backup (for stop/start_logging)
     */
    private Level last_level = Level.OFF;
    /**
     * Device's rolling file threshold
     */
    private long rft = LOGGING_DEF_RFT;

    // +-------------------------------------------------------------------------
    //
    // method : DeviceImpl
    // 
    // description : constructor for the DeviceImpl class from the class object,
    // the device name, the description field,
    // the state and the status.
    //
    // argument : in : - cl : The class object
    // - d_name : The device name
    // - de : The device description (default to "A TANGO device")
    // - st : The device state (default to UNKNOWN)
    // - sta : The device status (default to "Not initialised")
    //
    // --------------------------------------------------------------------------

    /**
     * Constructs a newly allocated DeviceImpl object from all its creation
     * parameters.
     * 
     * The device is constructed from its name, its description, an original
     * state and status
     * 
     * @param cl
     *            Reference to the device class object
     * @param d_name
     *            The device name
     * @param de
     *            The device description field
     * @param st
     *            The device creation state
     * @param sta
     *            The device creation status
     * 
     * @exception DevFailed
     *                Re-throw of the exception thrown during the creation of
     *                the multi-attribute object. Click here to read DevFailed exception specification
     */

    public DeviceImpl(final DeviceClass cl, final String d_name, final String de,
	    final DevState st, final String sta) throws DevFailed {
	device_class = cl;
	device_name = d_name;
	desc = de;
	device_state = st;
	device_status = sta;

	version = Tango_DevVersion;
	blackbox_depth = 0;

	ext = new DeviceImplExt();

	if (Util._UseDb) {
	    db_dev = new DbDevice(device_name);
	}
	get_dev_system_resource();

	black_box_create();

	dev_attr = new MultiAttribute(device_name, device_class);

	final StringBuffer tmp_adm_name = new StringBuffer("dserver/");
	tmp_adm_name.append(Util.instance().get_ds_name());
	adm_device_name = tmp_adm_name.toString();

	init_logger();
    }

    /**
     * Constructs a newly allocated DeviceImpl object from its name.
     * 
     * The device description field is set to A Tango device. The device
     * state is set to unknown and the device status is set to Not
     * Initialised
     * 
     * @param cl
     *            Reference to the device class object
     * @param d_name
     *            The device name
     * 
     * @exception DevFailed
     *                Re-throw of the exception thrown during the creation of
     *                the multi-attribute object. Click here to read DevFailed exception specification
     */

    public DeviceImpl(final DeviceClass cl, final String d_name) throws DevFailed {
	device_class = cl;
	device_name = d_name;

	desc = "A Tango device";
	device_state = DevState.UNKNOWN;
	device_status = "Not Initialised";

	version = Tango_DevVersion;
	blackbox_depth = 0;

	ext = new DeviceImplExt();

	if (Util._UseDb) {
	    db_dev = new DbDevice(device_name);
	}
	get_dev_system_resource();

	black_box_create();

	dev_attr = new MultiAttribute(device_name, device_class);

	final StringBuffer tmp_adm_name = new StringBuffer("dserver/");
	tmp_adm_name.append(Util.instance().get_ds_name());
	adm_device_name = tmp_adm_name.toString();
	init_logger();
    }

    /**
     * Constructs a newly allocated DeviceImpl object from its name and its
     * description.
     * 
     * The device state is set to unknown and the device status is set to Not
     * Initialised
     * 
     * @param cl
     *            Reference to the device class object
     * @param d_name
     *            The device name
     * @param desc
     *            The device description
     * 
     * @exception DevFailed
     *                Re-throw of the exception thrown during the creation of
     *                the multi-attribute object. Click here to read DevFailed exception specification
     */

    public DeviceImpl(final DeviceClass cl, final String d_name, final String desc)
	    throws DevFailed {
	device_class = cl;
	device_name = d_name;

	this.desc = desc;
	device_state = DevState.UNKNOWN;
	device_status = "Not Initialised";

	version = Tango_DevVersion;
	blackbox_depth = 0;

	ext = new DeviceImplExt();

	if (Util._UseDb) {
	    db_dev = new DbDevice(device_name);
	}
	get_dev_system_resource();

	black_box_create();

	dev_attr = new MultiAttribute(device_name, device_class);

	final StringBuffer tmp_adm_name = new StringBuffer("dserver/");
	tmp_adm_name.append(Util.instance().get_ds_name());
	adm_device_name = tmp_adm_name.toString();
	init_logger();
    }

    // +-------------------------------------------------------------------------
    //
    // method : black_box_create
    // 
    // description : Private method to create the device black box.
    // The black box depth is a resource with a default
    // value if the resource is not defined
    //
    // --------------------------------------------------------------------------

    private void black_box_create() {

	//
	// If the black box depth objbect attribute is null, create one with the
	// default depth
	//

	if (blackbox_depth == 0) {
	    blackbox = new BlackBox();
	} else {
	    blackbox = new BlackBox(blackbox_depth);
	}
    }

    // +----------------------------------------------------------------------------
    //
    // method : get_dev_system_resource()
    // 
    // description : Method to retrieve some basic device resources
    // The resources to be retrived are :
    // - The black box depth
    // - The device description
    //
    // -----------------------------------------------------------------------------

    private void get_dev_system_resource() throws DevFailed {

	//
	// Try to retrieve resources for device black box depth and device
	// description
	//

	if (Util._UseDb) {
	    try {
		final String[] prop_names = { "blackbox_depth", "description", "poll_ring_depth",
			"polled_cmd", "polled_attr", "non_auto_polled_cmd", "non_auto_polled_attr",
			"poll_old_factor" };

		// Call db server
		final DbDatum[] res_value = db_dev.get_property(prop_names);

		int i = 0;
		if (res_value[i].is_empty() == false) {
		    blackbox_depth = res_value[i].extractLong();
		}
		i++;
		if (res_value[i].is_empty() == false) {
		    desc = res_value[i].extractString();
		}
		i++;

		if (res_value[i].is_empty() == false) {
		    set_poll_ring_depth(res_value[i].extractLong());
		}
		i++;
		if (res_value[i].is_empty() == false) {
		    set_polled_cmd(res_value[i].extractStringArray());
		}
		i++;
		if (res_value[i].is_empty() == false) {
		    set_polled_attr(res_value[i].extractStringArray());
		}
		i++;
		if (res_value[i].is_empty() == false) {
		    set_non_auto_polled_cmd(res_value[i].extractStringArray());
		}
		i++;
		if (res_value[i].is_empty() == false) {
		    set_non_auto_polled_attr(res_value[i].extractStringArray());
		}
		i++;
		if (res_value[i].is_empty() == false) {
		    set_poll_old_factor(res_value[i].extractLong());
		} else {
		    set_poll_old_factor(Tango_DEFAULT_POLL_OLD_FACTOR);
		}
	    } catch (final DevFailed e) {
		final StringBuffer o = new StringBuffer(
			"Database error while trying to retrieve device properties for device ");
		o.append(device_name);

		Except.throw_exception("API_DatabaseAccess", o.toString(),
			"DeviceImpl.get_dev_system_resource");
	    } catch (final BAD_OPERATION ex) {
		final StringBuffer o = new StringBuffer(
			"Database error while trying to retrieve device properties for device ");
		o.append(device_name);

		Except.throw_exception("API_DatabaseAccess", o.toString(),
			"DeviceImpl.get_dev_system_resource");
	    }
	}
    }

    // +-------------------------------------------------------------------------
    //
    // method : command_inout
    // 
    // description : Method called for each command_inout operation executed
    // from any client
    // The call to this method is in a try bloc for the
    // DevFailed exception (generated by the idl
    // compiler). Therefore, it
    // is not necessary to propagate by re-throw the exceptions
    // thrown by the underlying functions/methods.
    //
    // --------------------------------------------------------------------------

    /**
     * Execute a command.
     * 
     * It's the master method executed when a "command_inout" CORBA operation is
     * requested by a client. It updates the device black-box, call the TANGO
     * command handler and returned the output Any
     * 
     * @param in_cmd
     *            The command name
     * @param in_any
     *            The command input data packed in a CORBA Any
     * @return The command output data packed in a CORBA Any object
     * @exception DevFailed
     *                Re-throw of the exception thrown by the command_handler
     *                method. Click here to read DevFailed exception specification
     */

    public Any command_inout(final String in_cmd, final Any in_any) throws DevFailed {

	Util.out4.println("DeviceImpl.command_inout(): command received : " + in_cmd);

	//
	// Record operation request in black box
	//

	blackbox.insert_cmd(in_cmd, 1);

	//	
	// Execute command
	//
	Any out_any = null;
	try {
	    // If nb connection is closed to the maximum value,
	    // throw an exception to do not block devices.
	    Util.increaseAccessConter();
	    if (Util.getAccessConter() > Util.getPoaThreadPoolMax() - 2) {
		Util.decreaseAccessConter();
		Except.throw_exception("API_MemoryAllocation", Util.instance().get_ds_real_name()
			+ ": No thread available to connect device",
			"DeviceImpl.write_attributes()");
	    }
	    switch (Util.get_serial_model()) {
	    case BY_CLASS:
		synchronized (device_class) {
		    out_any = device_class.command_handler(this, in_cmd, in_any);
		}
		break;

	    case BY_DEVICE:
		synchronized (this) {
		    out_any = device_class.command_handler(this, in_cmd, in_any);
		}
		break;

	    default: // NO_SYNC
		out_any = device_class.command_handler(this, in_cmd, in_any);
	    }
	} catch (final DevFailed exc) {
	    Util.decreaseAccessConter();
	    throw exc;
	} catch (final Exception exc) {
	    Util.decreaseAccessConter();
	    Except.throw_exception("API_ExceptionCatched", exc.toString(),
		    "DeviceImpl.command_inout");
	}
	Util.decreaseAccessConter();

	//
	// Return value to the caller
	//

	Util.out4.println("DeviceImpl.command_inout(): leaving method for command " + in_cmd);
	return out_any;
    }

    // +-------------------------------------------------------------------------
    //
    // method : Device_2Impl.command_inout_2
    // 
    // description : Method called for each command_inout operation executed
    // from any client on a Tango device version 2.
    //
    // --------------------------------------------------------------------------
    public Any command_inout_2(final String in_cmd, final Any in_data, final DevSource source)
	    throws DevFailed, SystemException {
	Util.out4.println("Device_2Impl.command_inout_2 arrived, source = " + source
		+ ", command = " + in_cmd);

	PollObj polled_cmd = null;
	boolean polling_failed = false;

	// If the source parameter specifies device, call the command_inout
	// method
	// implemented by the DeviceImpl class
	if (source == DevSource.DEV) {
	    return command_inout(in_cmd, in_data);
	}

	try {
	    // Record operation request in black box
	    blackbox.insert_cmd(in_cmd, 2);

	    final String cmd_str = in_cmd.toLowerCase();

	    // Check that device supports this command
	    check_command_exists(cmd_str);
	    // Check that the command is polled
	    boolean found = false;
	    final Vector poll_list = get_poll_obj_list(); // PollObj
	    for (int i = 0; i < poll_list.size(); i++) {
		final PollObj poll_obj = (PollObj) poll_list.elementAt(i);
		if (poll_obj.get_type() == Tango_POLL_CMD
			&& poll_obj.get_name().equals(in_cmd.toLowerCase())) {
		    polled_cmd = poll_obj;
		    found = true;
		}
	    }
	    // If the command is not polled but its polling update period is
	    // defined, and the command is not in the device list of command
	    // which should not be polled, start to poll it
	    if (found == false) {
		final Command cmd = get_command(cmd_str);
		final int poll_period = cmd.get_polling_period();
		if (poll_period == 0) {
		    Except.throw_exception("API_CmdNotPolled", "Command " + in_cmd + " not polled",
			    "Device_2Impl.command_inout");
		}

		found = false;
		final Vector napc = get_non_auto_polled_cmd();
		for (int i = 0; i < napc.size(); i++) {
		    final String s = (String) napc.elementAt(i);
		    if (s.equals(cmd_str)) {
			found = true;
		    }
		}
		if (found == true) {
		    Except.throw_exception("API_CmdNotPolled", "Command " + in_cmd + " not polled",
			    "Device_2Impl.command_inout");
		}

		else {
		    final Util tg = Util.instance();
		    final DServer adm_dev = tg.get_dserver_device();

		    final DevVarLongStringArray send = new DevVarLongStringArray();
		    send.lvalue = new int[1];
		    send.svalue = new String[3];

		    send.lvalue[0] = poll_period;
		    send.svalue[0] = device_name;
		    send.svalue[1] = "command";
		    send.svalue[2] = in_cmd;

		    adm_dev.add_obj_polling(send, false);

		    // Wait for first polling. Release monitor during this
		    // sleep in order to give it to the polling thread
		    /*
		     * ext.only_one.rel_monitor(); try { Thread.sleep(500); }
		     * catch (InterruptedException e){}
		     * ext.only_one.get_monitor();
		     */
		    // Update the polled-cmd pointer to the new polled object
		    for (int i = 0; i < poll_list.size(); i++) {
			final PollObj poll_obj = (PollObj) poll_list.elementAt(i);
			if (poll_obj.get_type() == Tango_POLL_CMD
				&& poll_obj.get_name().equals(in_cmd)) {
			    polled_cmd = poll_obj;
			    break;
			}
		    }
		}
	    }

	    if (polled_cmd == null) {
		Except.throw_exception("API_CommandNotPolled", "Command not found.",
			"Device_2Impl.command_inout");
	    }
	    // Check that some data is available in cache
	    assert polled_cmd != null;
	    if (polled_cmd.is_ring_empty()) {
		Except.throw_exception("API_NoDataYet", "No data available in cache for command "
			+ in_cmd, "Device_2Impl.command_inout");
	    }
	    // Check that data are still refreshed by the polling thread
	    final long ctm = System.currentTimeMillis();
	    int tv_sec = (int) (ctm / 1000);
	    final int tv_usec = (int) (ctm - 1000 * tv_sec) * 1000;
	    tv_sec = tv_sec - Tango_DELTA_T;
	    final double last = polled_cmd.get_last_insert_date();
	    final double now_d = tv_sec + (double) tv_usec / 1000000;
	    final double diff_d = now_d - last;
	    if (diff_d > polled_cmd.get_authorized_delta()) {
		Except.throw_exception("API_NotUpdatedAnyMore", "Data in cache for command "
			+ in_cmd + " not updated any more", "Device_2Impl.command_inout");
	    }
	} catch (final DevFailed e) {
	    if (source == DevSource.CACHE) {
		throw e;
	    }
	    polling_failed = true;
	}
	// Get cmd result (or exception)
	if (source == DevSource.CACHE) {
	    Util.out4.println("Device_2Impl: Returning data from polling buffer");
	    assert polled_cmd != null;
	    return polled_cmd.get_last_cmd_result();
	} else {
	    if (polling_failed == false) {
		Util.out4.println("Device_2Impl: Returning data from polling buffer");
		return polled_cmd.get_last_cmd_result();
	    } else {
		return command_inout(in_cmd, in_data);
	    }
	}

    }

    // +-------------------------------------------------------------------------
    //
    // method : Device_2Impl.command_inout_history_2
    // 
    // description : CORBA operation to read command result history from
    // the polling buffer.
    //
    // argument: in : - command : command name
    // - n : history depth (in record number)
    //
    // This method returns a pointer to a DevCmdHistoryList with one
    // DevCmdHistory structure for each command record
    //
    // --------------------------------------------------------------------------
    public DevCmdHistory[] command_inout_history_2(final String command, int n) throws DevFailed,
	    SystemException {
	Util.out4.println("Device_2Impl.command_inout_history_2 arrived");

	final String cmd_str = command.toLowerCase();

	// Record operation request in black box
	blackbox.insert_op(Op_Command_inout_history_2);

	// Check that device supports this command
	check_command_exists(cmd_str);

	// Check that the command is polled
	PollObj polled_cmd = null;
	final Vector poll_list = get_poll_obj_list();
	for (int i = 0; i < poll_list.size(); i++) {
	    final PollObj poll_obj = (PollObj) poll_list.elementAt(i);
	    if (poll_obj.get_type() == Tango_POLL_CMD && poll_obj.get_name().equals(cmd_str)) {
		polled_cmd = poll_obj;
	    }
	}
	if (polled_cmd == null) // NOT found
	{
	    Except.throw_exception("API_CmdNotPolled", "Command " + cmd_str + " not polled",
		    "Device_2Impl.command_inout_history_2");
	}

	// Check that some data is available in cache

	assert polled_cmd != null;
	if (polled_cmd.is_ring_empty()) {
	    Except.throw_exception("API_NoDataYet", "No data available in cache for command "
		    + cmd_str, "Device_2Impl.command_inout_history_2");
	}
	// Set the number of returned records
	final int in_buf = polled_cmd.get_elt_nb_in_buffer();
	if (n > in_buf) {
	    n = in_buf;
	}

	// return command result history
	return polled_cmd.get_cmd_history(n);
    }

    // +-------------------------------------------------------------------------
    //
    // method : name
    // 
    // description : Method called when a client request the name attribute
    // This method is called for a IDL attribute which can
    // not throw exception to client
    //
    // --------------------------------------------------------------------------

    /**
     * Get device name.
     * 
     * It's the master method executed when the device name is requested via a
     * CORBA attribute. It updates the device black-box and return the device
     * name
     * 
     * @return The device name
     */

    public String name() {
	Util.out4.println("DeviceImpl.name() arrived");

	//
	// Record attribute request in black box
	//

	blackbox.insert_attr(Attr_Name);

	//
	// Return data to caller
	//

	Util.out4.println("Leaving DeviceImpl.name()");
	return device_name;
    }

    // +-------------------------------------------------------------------------
    //
    // method : adm_name
    // 
    // description : Method called when a client request the adm_name attribute
    // This method is called for a IDL attribute which can
    // not throw exception to client
    //
    // --------------------------------------------------------------------------

    /**
     * Get administration device name.
     * 
     * It's the master method executed when the administration device name is
     * requested via a CORBA attribute. It updates the device black-box and
     * return the administration device name
     * 
     * @return The administration device name
     */

    public String adm_name() {
	Util.out4.println("DeviceImpl.adm_name() arrived");

	//
	// Record attribute request in black box
	//

	blackbox.insert_attr(Attr_AdmName);

	//
	// Return data to caller
	//

	Util.out4.println("Leaving DeviceImpl.adm_name()");
	return adm_device_name;
    }

    // +-------------------------------------------------------------------------
    //
    // method : description
    // 
    // description : Method called when a client request the description
    // attribute
    // This method is called for a IDL attribute which can
    // not throw exception to client
    //
    // --------------------------------------------------------------------------

    /**
     * Get device description.
     * 
     * It's the master method executed when the device description is requested
     * via a CORBA attribute. It updates the device black-box and return the
     * device description field
     * 
     * @return The device description
     */

    public String description() {
	Util.out4.println("DeviceImpl.description() arrived");

	//
	// Record attribute request in black box
	//

	blackbox.insert_attr(Attr_Description);

	//
	// Return data to caller
	//

	Util.out4.println("Leaving DeviceImpl.description()");
	return desc;
    }

    // +-------------------------------------------------------------------------
    //
    // method : state
    // 
    // description : Method called when a client request the state
    // attribute
    //
    // --------------------------------------------------------------------------

    /**
     * Get device state.
     * 
     * It's the master method executed when the device state is requested via a
     * CORBA attribute. It updates the device black-box and return the device
     * state. This method calls the dev_state device method but catch all
     * the execption and does not re-throw them because exception can't be
     * thrown to a client for CORBA attribute
     * 
     * @return The device state
     */

    public DevState state() {
	Util.out4.println("DeviceImpl.state() (attribute) arrived");

	//
	// Record attribute request in black box
	//

	blackbox.insert_attr(Attr_State);

	//
	// Return data to caller. If the dev_state throw an exception, catch it
	// and do
	// not re-throw it because we are in a CORBA attribute implementation
	//

	DevState tmp = null;
	try {
	    tmp = dev_state();
	} catch (final DevFailed ex) {
	}

	Util.out4.println("Leaving DeviceImpl.state() (attribute)");
	return tmp;
    }

    // +-------------------------------------------------------------------------
    //
    // method : status
    // 
    // description : Method called when a client request the description
    // status
    // This method is called for a IDL attribute which can
    // not throw exception to client
    //
    // --------------------------------------------------------------------------

    /**
     * Get device status.
     * 
     * It's the master method executed when the device status is requested via a
     * CORBA attribute. It updates the device black-box and return the device
     * state. This method calls the dev_status device method but catch
     * all the execption and does not re-throw them because exception can't be
     * thrown to a client for CORBA attribute
     * 
     * @return The device status
     */

    public String status() {
	Util.out4.println("DeviceImpl.status() (attibute) arrived");

	//
	// Record attribute request in black box
	//

	blackbox.insert_attr(Attr_Status);

	//
	// Return data to caller. If the dev_status method throw exception,
	// catch it
	// and forget it because we are in a CORBA attribute implementation
	//

	String tmp = null;
	try {
	    tmp = dev_status();
	} catch (final DevFailed ex) {
	}

	Util.out4.println("Leaving DeviceImpl.status() (attribute)");
	return tmp;
    }

    // +-------------------------------------------------------------------------
    //
    // method : black_box
    // 
    // description : CORBA operation to read n element(s) of the black-box.
    // This method returns black box element as strings
    //
    // argument: in : - n : Number of elt to read
    //
    // --------------------------------------------------------------------------

    /**
     * Get device black box.
     * 
     * It's the master method executed when the device black box is requested.
     * It reads the device black box, update it and return black-box data to the
     * client
     * 
     * @param n
     *            The number of actions description which must be returned to
     *            the client. The number of returned element is limited to the
     *            number of elements stored in the black-box or to the complete
     *            black-box depth if it is full.
     * @return The device black box with one String for each action requested on
     *         the device
     * @exception DevFailed
     *                If it is not possible to read the device black box. Click
     *                here
     *                 to read DevFailed exception specification
     */

    public String[] black_box(final int n) throws DevFailed {

	Util.out4.println("DeviceImpl.black_box() arrived");

	final String[] ret = blackbox.read(n);

	//
	// Record operation request in black box
	//

	blackbox.insert_op(Op_BlackBox);

	Util.out4.println("Leaving DeviceImpl.black_box()");
	return ret;
    }

    // +-------------------------------------------------------------------------
    //
    // method : command_list_query
    // 
    // description : CORBA operation to read the device command list.
    // This method returns command info in a sequence of
    // DevCmdInfo
    //
    //
    // --------------------------------------------------------------------------

    /**
     * Get device command list.
     * 
     * Invoked when the client request the command_list_query CORBA operation.
     * It updates the device black box and returns an array of DevCmdInfo object
     * with one object for each command.
     * 
     * @return The device command list. One DevCmdInfo is initialised for each
     *         device command
     */

    public DevCmdInfo[] command_list_query() {

	Util.out4.println("DeviceImpl.command_list_query() arrived");

	//
	// Retrive number of command and allocate memory to send back info
	//

	final int nb_cmd = device_class.get_command_list().size();
	Util.out4.println(nb_cmd + " command(s) for device");
	final DevCmdInfo[] back = new DevCmdInfo[nb_cmd];
	for (int loop = 0; loop < nb_cmd; loop++) {
	    back[loop] = new DevCmdInfo();
	}

	//
	// Populate the sequence
	//

	for (int i = 0; i < nb_cmd; i++) {
	    back[i].cmd_name = ((Command) device_class.get_command_list().elementAt(i)).get_name();
	    back[i].cmd_tag = ((Command) device_class.get_command_list().elementAt(i)).get_tag();
	    back[i].in_type = ((Command) device_class.get_command_list().elementAt(i))
		    .get_in_type();
	    back[i].out_type = ((Command) device_class.get_command_list().elementAt(i))
		    .get_out_type();
	    String tmp_desc = ((Command) device_class.get_command_list().elementAt(i))
		    .get_in_type_desc();
	    if (tmp_desc == null) {
		back[i].in_type_desc = Tango_DescNotSet;
	    } else {
		back[i].in_type_desc = tmp_desc;
	    }
	    tmp_desc = ((Command) device_class.get_command_list().elementAt(i)).get_out_type_desc();
	    if (tmp_desc == null) {
		back[i].out_type_desc = Tango_DescNotSet;
	    } else {
		back[i].out_type_desc = tmp_desc;
	    }
	}

	//
	// Record operation request in black box
	//

	blackbox.insert_op(Op_Command_list);

	//
	// Return to caller
	//

	Util.out4.println("Leaving DeviceImpl.command_list_query()");
	return back;
    }

    // ===========================================================================
    /**
     * Get device command list.
     * 
     * Invoked when the client request the command_list_query CORBA operation.
     * It updates the device black box and returns an array of DevCmdInfo object
     * with one object for each command.
     * 
     * @return The device command list. One DevCmdInfo is initialised for each
     *         device command
     */
    // ===========================================================================
    public DevCmdInfo_2[] command_list_query_2() {
	Util.out4.println("Device_2Impl.command_list_query_2 arrived");

	// Retrieve number of command and allocate memory to send back info
	final Vector cmd_list = device_class.get_command_list();
	Util.out4.println(cmd_list.size() + " command(s) for device");
	final DevCmdInfo_2[] back = new DevCmdInfo_2[cmd_list.size()];

	for (int i = 0; i < cmd_list.size(); i++) {
	    final Command cmd = (Command) cmd_list.elementAt(i);
	    final DevCmdInfo_2 tmp = new DevCmdInfo_2();
	    tmp.cmd_name = cmd.get_name();
	    tmp.cmd_tag = cmd.get_tag();
	    tmp.level = cmd.get_disp_level();
	    tmp.in_type = cmd.get_in_type();
	    tmp.out_type = cmd.get_out_type();
	    final String str_in = cmd.get_in_type_desc();
	    if (str_in != null) {
		tmp.in_type_desc = str_in;
	    } else {
		tmp.in_type_desc = Tango_DescNotSet;
	    }
	    final String str_out = cmd.get_out_type_desc();
	    if (str_out != null) {
		tmp.out_type_desc = str_out;
	    } else {
		tmp.out_type_desc = Tango_DescNotSet;
	    }
	    back[i] = tmp;
	}
	// Record operation request in black box
	blackbox.insert_op(Op_Command_list_2);

	Util.out4.println("Device_2Impl.command_list_query_2 exiting");
	return back;

    }

    // ===========================================================================
    /**
     * Get device command list.
     * 
     * Invoked when the client request the command_list_query CORBA operation.
     * It updates the device black box and returns an array of DevCmdInfo object
     * with one object for specified command.
     * 
     * @param command
     *            The specified command name.
     * @return The device command list. One DevCmdInfo is initialised for each
     *         device command
     */
    // ===========================================================================
    public DevCmdInfo_2 command_query_2(final String command) throws DevFailed, SystemException {
	Util.out4.println("Device_2Impl.command_query_2(" + command + ") arrived");

	// Retrieve number of command and allocate memory to send back info
	final int nb_cmd = device_class.get_command_list().size();
	Util.out4.println(nb_cmd + " command(s) for device");
	DevCmdInfo_2 back = null;
	for (int i = 0; i < nb_cmd; i++) {
	    final Command cmd = (Command) device_class.get_command_list().elementAt(i);
	    if (cmd.get_name().toLowerCase().equals(command.toLowerCase())) {
		final DevCmdInfo_2 tmp = new DevCmdInfo_2();
		tmp.cmd_name = cmd.get_name();
		tmp.cmd_tag = cmd.get_tag();
		tmp.level = cmd.get_disp_level();
		tmp.in_type = cmd.get_in_type();
		tmp.out_type = cmd.get_out_type();
		final String str_in = cmd.get_in_type_desc();
		if (str_in.length() != 0) {
		    tmp.in_type_desc = str_in;
		} else {
		    tmp.in_type_desc = Tango_DescNotSet;
		}
		final String str_out = cmd.get_out_type_desc();
		if (str_out.length() != 0) {
		    tmp.out_type_desc = str_out;
		} else {
		    tmp.out_type_desc = Tango_DescNotSet;
		}
		back = tmp;
	    }
	}

	// throw an exception to client if command not found
	if (back == null) {
	    Except.throw_exception("API_CommandNotFound", "Command " + command + " not found",
		    "Device_2Impl.command_query_2");
	}

	// Record operation request in black box
	blackbox.insert_op(Op_Command_list_2);

	Util.out4.println("Device_2Impl.command_list_query_2 exiting");
	return back;

    }

    // +-------------------------------------------------------------------------
    //
    // method : command_query
    // 
    // description : CORBA operation to read a device command info.
    // This method returns command info for a specific
    // command.
    //
    //
    // --------------------------------------------------------------------------

    /**
     * Get command info.
     * 
     * Invoked when the client request the command_query CORBA operation. It
     * updates the device black box and returns a DevCmdInfo object for the
     * command with name passed to the method as parameter.
     * 
     * @param command
     *            The command name
     * @return A DevCmdInfo initialised for the wanted command
     * @exception DevFailed
     *                Thrown if the command does not exist. Click here to read DevFailed exception specification
     */

    public DevCmdInfo command_query(final String command) throws DevFailed {

	Util.out4.println("DeviceImpl.command_query() arrived");

	final DevCmdInfo back = new DevCmdInfo();

	//
	// Try to retrieve the command in the command list
	//
	final String cmd_name = command.toLowerCase();
	int i;
	final int nb_cmd = device_class.get_command_list().size();
	for (i = 0; i < nb_cmd; i++) {
	    final Command cmd = (Command) device_class.get_command_list().elementAt(i);
	    if (cmd.get_name().toLowerCase().equals(cmd_name) == true) {
		back.cmd_name = command;
		back.cmd_tag = cmd.get_tag();
		back.in_type = cmd.get_in_type();
		back.out_type = cmd.get_out_type();
		String tmp_desc = cmd.get_in_type_desc();
		if (tmp_desc == null) {
		    back.in_type_desc = Tango_DescNotSet;
		} else {
		    back.in_type_desc = tmp_desc;
		}
		tmp_desc = cmd.get_out_type_desc();
		if (tmp_desc == null) {
		    back.out_type_desc = Tango_DescNotSet;
		} else {
		    back.out_type_desc = tmp_desc;
		}
		break;
	    }
	}

	if (i == nb_cmd) {
	    Util.out3.println("DeviceImpl.command_query(): operation " + command + " not found");

	    //		
	    // throw an exception to client
	    //
	    Except.throw_exception("API_CommandNotFound", "Command " + command + " not found",
		    "DeviceImpl.command_query()");
	}

	//
	// Record operation request in black box
	//

	blackbox.insert_op(Op_Command);

	//
	// Return to caller
	//

	Util.out4.println("Leaving DeviceImpl.command_query()");
	return back;
    }

    // +-------------------------------------------------------------------------
    //
    // method : info
    // 
    // description : CORBA operation to get device info
    //
    // --------------------------------------------------------------------------

    /**
     * Get device info.
     * 
     * Invoked when the client request the info CORBA operation. It updates the
     * black box and returns a DevInfo object with miscellaneous device info
     * 
     * @return A DevInfo object
     */

    public DevInfo info() {

	Util.out4.println("DeviceImpl.info() arrived");

	final DevInfo back = new DevInfo();

	//
	// Retrieve server host
	//

	final Util tg = Util.instance();
	back.server_host = tg.get_host_name();

	//
	// Fill-in remaining structure fields
	//

	back.dev_class = device_class.get_name();
	back.server_id = tg.get_ds_real_name();
	back.server_version = Tango_DevVersion;
	back.doc_url = device_class.get_doc_url();

	//
	// Record operation request in black box
	//

	blackbox.insert_op(Op_Info);

	//
	// Return to caller
	//

	Util.out4.println("Leaving DeviceImpl.info()");
	return back;
    }

    // +-------------------------------------------------------------------------
    //
    // method : ping
    // 
    // description : CORBA operation to ping if a device to see it is alive
    //
    // --------------------------------------------------------------------------

    /**
     * Ping the device to check if it is still alive.
     * 
     * Invoked when the client request the ping CORBA operation. It updates the
     * device black box and simply returns
     * 
     */

    public void ping() {

	Util.out4.println("DeviceImpl.ping() arrived");

	//
	// Record operation request in black box
	//

	blackbox.insert_op(Op_Ping);

	//
	// Return to caller
	//

	Util.out4.println("Leaving DeviceImpl.ping()");
    }

    // +-------------------------------------------------------------------------
    //
    // method : get_attribute_config
    // 
    // description : CORBA operation to get attribute configuration.
    //
    // argument: in : - names: name of attribute(s)
    //
    // This method returns a reference to a AttributeConfig array with one
    // AttributeConfig
    // object for each attribute
    //
    // --------------------------------------------------------------------------
    /**
     * Get attribute(s) configuration.
     * 
     * Invoked when the client request the get_attribute_config CORBA operation.
     * It retrieves attribute(s) configuration and initialise a AttributeConfig
     * object for each of the wanted attribute.
     * 
     * @param names
     *            The attribute name list
     * @return An array of AttributeConfig object. One AttributeConfig object is
     *         initialised for each wanted attribute
     * @exception DevFailed
     *                Thrown if one of the attribute does not exist. Click here
     *                 to read DevFailed exception specification
     */
    public AttributeConfig[] get_attribute_config(final String[] names) throws DevFailed {
	Util.out4.println("DeviceImpl.get_attribute_config arrived");

	int nb_attr = names.length;
	boolean all_attr = false;

	//
	// Record operation request in black box
	//

	blackbox.insert_op(Op_Get_Attr_Config);

	//
	// Return exception if the device does not have any attribute
	//

	final int nb_dev_attr = dev_attr.get_attr_nb();
	if (nb_dev_attr == 0) {
	    Except.throw_exception("API_AttrNotFound", "The device does not have any attribute",
		    "DeviceImpl.get_attribute_config");
	}

	//
	// Check if the caller want to get config for all attribute
	//

	if (nb_attr == 1 && names[0].equals(Tango_AllAttr)) {
	    nb_attr = nb_dev_attr;
	    all_attr = true;
	}

	//
	// Allocate memory for the AttributeConfig objects
	//

	AttributeConfig[] back = null;
	// noinspection ErrorNotRethrown
	try {
	    back = new AttributeConfig[nb_attr];
	    for (int i = 0; i < nb_attr; i++) {
		back[i] = new AttributeConfig();
	    }
	} catch (final OutOfMemoryError ex) {
	    Util.out3.println("Bad allocation while in DeviceImpl.get_attribute_config");
	    Except.throw_exception("API_MemoryAllocation", "Can't allocate memory in server",
		    "DeviceImpl.get_attribute_config");
	}

	//
	// Fill in these objects
	//

	for (int i = 0; i < nb_attr; i++) {
	    if (all_attr == true) {
		final Attribute attr = dev_attr.get_attr_by_ind(i);
		attr.get_properties(back[i]);
	    } else {
		final Attribute attr = dev_attr.get_attr_by_name(names[i]);
		attr.get_properties(back[i]);
	    }
	}

	//
	// Return to caller
	//

	Util.out4.println("Leaving DeviceImpl.get_attribute_config");

	return back;
    }

    // +-------------------------------------------------------------------------
    //
    // method : Device_2Impl.get_attribute_config_2
    // 
    // description : CORBA operation to get attribute configuration.
    //
    // argument: in : - names: name of attribute(s)
    //
    // This method returns a pointer to a AttributeConfigList_2 with one
    // AttributeConfig_2 structure for each atribute
    //
    //
    // WARNING !!!!!!!!!!!!!!!!!!
    //
    // This is the release 2 of this CORBA operation which
    // returns one more parameter than in release 1
    // The code has been duplicated in order to keep it clean
    // (avoid many "if" on version number in a common method)
    //
    // --------------------------------------------------------------------------
    public AttributeConfig_2[] get_attribute_config_2(final String[] names) throws DevFailed,
	    SystemException {
	Util.out4.println("Device_2Impl.get_attribute_config_2 arrived");

	// Allocate memory for the AttributeConfig structures
	int nb_attr = names.length;
	boolean all_attr = false;

	// Record operation request in black box
	blackbox.insert_op(Op_Get_Attr_Config_2);

	// Get attribute number
	final int nb_dev_attr = dev_attr.get_attr_nb();

	// Check if the caller want to get config for all attribute
	final String in_name = names[0];
	if (nb_attr == 1 && in_name.equals(Tango_AllAttr)) {
	    nb_attr = nb_dev_attr;
	    all_attr = true;
	}

	final AttributeConfig_2[] back = new AttributeConfig_2[nb_attr];
	// Fill in these structures
	for (int i = 0; i < nb_attr; i++) {
	    if (all_attr == true) {
		final Attribute attr = dev_attr.get_attr_by_ind(i);
		back[i] = attr.get_properties_2();
	    } else {
		final Attribute attr = dev_attr.get_attr_by_name(names[i]);
		back[i] = attr.get_properties_2();
	    }
	}

	Util.out4.println("Leaving Device_2Impl.get_attribute_config_2");

	return back;
    }

    // +-------------------------------------------------------------------------
    //
    // method : set_attribute_config
    // 
    // description : CORBA operation to set attribute configuration locally
    // and in the Tango database
    //
    // argument: in : - new_conf: The new attribute(s) configuration. One
    // AttributeConfig object is needed for each
    // attribute to update
    //
    // --------------------------------------------------------------------------
    /**
     * Set attribute(s) configuration.
     * 
     * Invoked when the client request the set_attribute_config CORBA operation.
     * This method update the attribute configuration and also update the TANGO
     * database with the new value. This method allows to update only the
     * optional attribute properties.
     * 
     * @param new_conf
     *            The attribute(s) new configuration list. There is one
     *            AttributeConfig object for each attribute with configuration
     *            to be updated
     * @exception DevFailed
     *                Thrown if one of the attribute does not exist. Click here
     *                 to read DevFailed exception specification
     */
    public void set_attribute_config(final AttributeConfig new_conf[]) throws DevFailed {
	Util.out4.println("DeviceImpl.set_attribute_config arrived");

	//
	// Record operation request in black box
	//

	blackbox.insert_op(Op_Set_Attr_Config);

	//
	// Return exception if the device does not have any attribute
	//

	final int nb_dev_attr = dev_attr.get_attr_nb();
	if (nb_dev_attr == 0) {
	    Except.throw_exception("API_AttrNotFound", "The device does not have any attribute",
		    "DeviceImpl.set_attribute_config");
	}

	//
	// Update attribute config first in database, then locally
	//

	final int nb_attr = new_conf.length;
	int i = 0;

	try {
	    for (i = 0; i < nb_attr; i++) {
		final Attribute attr = dev_attr.get_attr_by_name(new_conf[i].name);
		if (Util._UseDb == true) {
		    attr.upd_database(new_conf[i], device_name);
		}
		attr.set_properties(new_conf[i], device_name);
	    }

	} catch (final DevFailed e) {

	    //
	    // Re build the list of "alarmable" attribute
	    //

	    dev_attr.get_alarm_list().removeAllElements();
	    for (int j = 0; j < nb_dev_attr; j++) {
		if (dev_attr.get_attr_by_ind(j).is_alarmed() == true) {
		    dev_attr.get_alarm_list().addElement(j);
		}
	    }

	    //
	    // Change the exception reason flag
	    //

	    final StringBuffer o = new StringBuffer(e.errors[0].reason);

	    if (i != 0) {
		o.append("\nAll previous attribute(s) have been successfully updated");
	    }
	    if (i != nb_attr - 1) {
		o.append("\nAll remaining attribute(s) have not been updated");
	    }

	    e.errors[0].reason = o.toString();
	    throw e;
	}

	//
	// Re build the list of "alarmable" attribute
	//

	dev_attr.get_alarm_list().removeAllElements();
	for (i = 0; i < nb_dev_attr; i++) {
	    if (dev_attr.get_attr_by_ind(i).is_alarmed()) {
		dev_attr.get_alarm_list().addElement(i);
	    }
	}

	//
	// Return to caller
	//

	Util.out4.println("Leaving DeviceImpl.set_attribute_config");
    }

    // +-------------------------------------------------------------------------
    //
    // method : read_attributes
    // 
    // description : CORBA operation to read attribute(s) value.
    //
    // argument: in : - names: name of attribute(s) to be read
    //
    // This method returns a pointer to a AttributeConfigList with one
    // AttributeValue
    // structure for each atribute. This structure contains the attribute value,
    // the
    // value quality and the date.
    //
    // --------------------------------------------------------------------------
    /**
     * Read attribute(s) value.
     * 
     * Invoked when the client request the read_attributes CORBA operation. This
     * method read attributes value and return them to the caller. A date and a
     * quality factor is added to each attribute.
     * 
     * @param names
     *            The attribute name list
     * @return An array of AttributeValue object. One AttributeValue object is
     *         initialised for each wanted attribute
     * @exception DevFailed
     *                Thrown if one of the attribute does not exist or if a
     *                problem occurs during attribute reading. Click here to read DevFailed exception specification
     */
    // =========================================================================
    public AttributeValue[] read_attributes(final String[] names) throws DevFailed {
	Util.out4.println("DeviceImpl.read_attributes arrived" + names[0]);

	// Record operation request in black box
	blackbox.insert_op(Op_Read_Attr);

	// Return exception if the device does not have any attribute
	if (dev_attr.get_attr_nb() == 0) {
	    Except.throw_exception("API_AttrNotFound", "The device does not have any attribute",
		    "DeviceImpl.read_attributes");
	}

	// Build a sequence with the names of the attribute to be read.
	// This is necessary in case of the "AllAttr" shortcut is used
	// If all attributes are wanted, build this list
	final String[] real_names = checkRealNames(names);

	// If nb connection is closed to the maximum value,
	// throw an exception to do not block devices.
	Util.increaseAccessConter();
	if (Util.getAccessConter() > Util.getPoaThreadPoolMax() - 2) {
	    Util.decreaseAccessConter();
	    Except.throw_exception("API_MemoryAllocation", Util.instance().get_ds_real_name()
		    + ": No thread available to connect device", "DeviceImpl.read_attributes()");
	}

	final Vector wanted_attr = new Vector();
	final Vector wanted_w_attr = new Vector();
	AttributeValue[] back = null;
	try {
	    switch (Util.get_serial_model()) {
	    case BY_CLASS:
		synchronized (device_class) {
		    sortAttributes(real_names, wanted_attr, wanted_w_attr);
		    back = manageReadAttrinbute(real_names, wanted_attr, wanted_w_attr);
		}
		break;

	    case BY_DEVICE:
		synchronized (this) {
		    sortAttributes(real_names, wanted_attr, wanted_w_attr);
		    back = manageReadAttrinbute(real_names, wanted_attr, wanted_w_attr);
		}
		break;

	    default: // NO_SYNC
		synchronized (this) {
		    sortAttributes(real_names, wanted_attr, wanted_w_attr);
		}
		back = manageReadAttrinbute(real_names, wanted_attr, wanted_w_attr);
	    }
	} // End of try

	catch (final DevFailed exc) {
	    Util.decreaseAccessConter();
	    setNotActive(real_names);
	    throw exc;
	} catch (final Exception exc) {
	    Util.decreaseAccessConter();
	    setNotActive(real_names);
	    exc.printStackTrace();
	    Except.throw_exception("API_ExceptionCatched", exc.toString(),
		    "DeviceImpl.read_attributes");
	}

	Util.decreaseAccessConter();
	setNotActive(real_names);

	// Return to caller
	Util.out4.println("Leaving DeviceImpl.read_attributes");
	return back;
    }

    // =========================================================================
    /**
     * Check if value has been inserted and retuens the AttributeValue objects
     */
    // =========================================================================
    private AttributeValue[] manageReadAttrinbute(final String[] real_names,
	    final Vector wanted_attr, final Vector wanted_w_attr) throws DevFailed {
	// Call the always_executed_hook method before
	always_executed_hook();

	// Read the hardware for readable attribute
	if (wanted_attr.size() != 0) {
	    read_attr_hardware(wanted_attr);
	}

	// Set attr value (for readable attribute)
	for (int i = 0; i < wanted_attr.size(); i++) {
	    final int idx = ((Integer) wanted_attr.elementAt(i)).intValue();
	    read_attr(dev_attr.get_attr_by_ind(idx));
	}
	// Set attr value for writable attribute
	for (int i = 0; i < wanted_w_attr.size(); i++) {
	    final int idx = ((Integer) wanted_w_attr.elementAt(i)).intValue();
	    final AttrWriteType w_type = dev_attr.get_attr_by_ind(idx).get_writable();
	    if (w_type == AttrWriteType.READ_WITH_WRITE || w_type == AttrWriteType.WRITE) {
		dev_attr.get_attr_by_ind(idx).set_value();
	    }
	}

	// Allocate memory for the AttributeValue structures and fill it
	return buildAttributeValue(real_names);
    }

    // =========================================================================
    /**
     * Check if value has been inserted and retuens the AttributeValue objects
     */
    // =========================================================================
    private AttributeValue[] buildAttributeValue(final String[] real_names) throws DevFailed {
	// Allocate memory for the AttributeValue structures
	AttributeValue[] back = new AttributeValue[0];
	// noinspection ErrorNotRethrown
	try {
	    back = new AttributeValue[real_names.length];
	    for (int i = 0; i < real_names.length; i++) {
		back[i] = new AttributeValue();
	    }
	} catch (final OutOfMemoryError ex) {
	    Except.throw_exception("API_MemoryAllocation", "Can't allocate memory in server",
		    "DeviceImpl.read_attributes");
	}

	// Build the sequence returned to caller for readable attributes and
	// check
	// that all the wanted attributes set value has been updated
	for (int i = 0; i < real_names.length; i++) {
	    final Attribute att = dev_attr.get_attr_by_name(real_names[i]);
	    if (att.get_value_flag()) {
		final AttrWriteType w_type = att.get_writable();
		if (w_type == AttrWriteType.READ || w_type == AttrWriteType.READ_WRITE
			|| w_type == AttrWriteType.READ_WITH_WRITE) {
		    if (w_type == AttrWriteType.READ_WRITE
			    || w_type == AttrWriteType.READ_WITH_WRITE) {
			dev_attr.add_write_value(att);
		    }

		    if (att.is_alarmed() == true
			    && att.get_quality().value() != AttrQuality._ATTR_INVALID) {
			att.check_alarm();
		    }
		}
		back[i].time = att.get_when();
		back[i].quality = att.get_quality();
		back[i].name = att.get_name();
		back[i].dim_x = att.get_x();
		back[i].dim_y = att.get_y();

		final Util tg = Util.instance();
		back[i].value = tg.get_orb().create_any();

		switch (att.get_data_type()) {
		case Tango_DEV_BOOLEAN:
		    DevVarBooleanArrayHelper.insert(back[i].value, att.get_boolean_value());
		    break;

		case Tango_DEV_SHORT:
		    DevVarShortArrayHelper.insert(back[i].value, att.get_short_value());
		    break;

		case Tango_DEV_USHORT:
		    DevVarUShortArrayHelper.insert(back[i].value, att.get_short_value());
		    break;

		case Tango_DEV_LONG:
		    DevVarLongArrayHelper.insert(back[i].value, att.get_long_value());
		    break;

		case Tango_DEV_ULONG:
		    DevVarULongArrayHelper.insert(back[i].value, att.get_long_value());
		    break;

		case Tango_DEV_LONG64:
		    DevVarLong64ArrayHelper.insert(back[i].value, att.get_long64_value());
		    break;

		case Tango_DEV_ULONG64:
		    DevVarULong64ArrayHelper.insert(back[i].value, att.get_long64_value());
		    break;

		case Tango_DEV_DOUBLE:
		    DevVarDoubleArrayHelper.insert(back[i].value, att.get_double_value());
		    break;

		case Tango_DEV_STRING:
		    DevVarStringArrayHelper.insert(back[i].value, att.get_string_value());
		    break;
		case Tango_DEV_STATE:
		    DevVarStateArrayHelper.insert(back[i].value, att.get_state_value());
		    break;

		/*
		 * //======================================================== //
		 * Not possible (DevEncoded type is not transfered inside an
		 * any)
		 * //========================================================
		 * case Tango_DEV_ENCODED :
		 * DevEncodedHelper.insert(back[i].value,att.get_enc_value());
		 * break;
		 */
		default:
		    Except.throw_exception("API_DatTypeNotSupported", "Attribute " + att.get_name()
			    + " data type not supported !", "Device_2Impl.read_attributes()");
		}
	    } else {
		Except.throw_exception("API_AttrValueNotSet", "Read value for attribute "
			+ att.get_name() + " has not been updated", "DeviceImpl.read_attributes");
	    }
	} // End of for ( ; ; )
	return back;
    }

    // =========================================================================
    /**
     * Retrieve wanted attributes in the device attribute list and check (and
     * set) their active flag, before clearing their value set flag
     */
    // =========================================================================
    private void sortAttributes(final String[] names, final Vector wanted_attr,
	    final Vector wanted_w_attr) throws DevFailed {
	for (final String name : names) {
	    final Attribute att = dev_attr.get_attr_by_name(name);
	    final int att_idx = dev_attr.get_attr_ind_by_name(name);

	    if (att.get_writable() == AttrWriteType.READ_WRITE) {
		wanted_w_attr.addElement(att_idx);
		wanted_attr.addElement(att_idx);
		att.waitEndOfRead(); // Wait a while if already reading
	    } else if (att.get_writable() == AttrWriteType.WRITE) {
		wanted_w_attr.addElement(att_idx);
	    } else {
		// READ or READ_WITH_WRITE
		wanted_attr.addElement(att_idx);
		att.waitEndOfRead(); // Wait a while if already reading
	    }
	}
    }

    // =========================================================================
    /**
     * Build a sequence with the names of the attribute to be read. This is
     * necessary in case of the "AllAttr" shortcut is used If all attributes are
     * wanted, build this list
     */
    // =========================================================================
    private String[] checkRealNames(final String[] names) {
	if (names.length == 1) {
	    if (names[0].equals(Tango_AllAttr)) {
		final String[] real_names = new String[dev_attr.get_attr_nb()];
		for (int i = 0; i < dev_attr.get_attr_nb(); i++) {
		    real_names[i] = dev_attr.get_attr_by_ind(i).get_name();
		}
		return real_names;
	    } else {
		return names;
	    }
	} else {
	    return names;
	}
    }

    // =========================================================================
    // =========================================================================
    private void setNotActive(final String[] names) throws DevFailed {
	for (final String name : names) {
	    dev_attr.get_attr_by_name(name).setActive(false);
	}
    }

    // =========================================================================
    /**
     * Read attribute(s) value.
     * 
     * Invoked when the client request the read_attributes CORBA operation with
     * a DevSource parameter. This method read attributes value and return them
     * to the caller. A date and a quality factor is added to each attribute.
     * 
     * @param names
     *            The attribute name list
     * @param source
     *            could be DevSource.CACHE, DevSource.CACHE_DEV or
     *            DevSource.DEVICE.
     * @return An array of AttributeValue object. One AttributeValue object is
     *         initialised for each wanted attribute
     * @exception DevFailed
     *                Thrown if one of the attribute does not exist or if a
     *                problem occurs during attribute reading. Click here to read DevFailed exception specification
     */
    // =========================================================================
    public AttributeValue[] read_attributes_2(final String[] names, final DevSource source)
	    throws DevFailed {
	Util.out4.println("DeviceImpl.read_attributes_2 arrived src=" + source.value());

	// If the source parameter specifies device, call the read_attribute
	// method implemented by the DeviceImpl class
	if (source == DevSource.DEV) {
	    return read_attributes(names);
	}

	// final boolean att_in_fault = false;
	boolean polling_failed = false;

	// Record operation request in black box
	blackbox.insert_op(Op_Read_Attr_2);

	AttributeValue[] back = null;

	try {
	    // Build a sequence with the names of the attribute to be read.
	    // This is necessary in case of the "AllAttr" shortcut is used
	    // If all attributes are wanted, build this list
	    int i, j;
	    boolean all_attr = false;
	    final Vector poll_list = get_poll_obj_list(); // PollObj
	    final int nb_poll = poll_list.size();
	    final int nb_names = names.length;
	    String[] real_names = names;
	    // Check if All Attr
	    if (nb_names == 1) {
		final String att_name = names[0];
		if (att_name.equals(Tango_AllAttr)) {
		    all_attr = true;
		    int nb_real = 0;
		    // Get the real number
		    for (i = 0; i < nb_poll; i++) {
			final PollObj poll_obj = (PollObj) poll_list.elementAt(i);
			if (poll_obj.get_type() == Tango_POLL_ATTR) {
			    nb_real++;
			}
		    }
		    // get the real polle object
		    real_names = new String[nb_real];
		    for (i = 0, j = 0; i < nb_poll && j < nb_real; i++) {
			final PollObj poll_obj = (PollObj) poll_list.elementAt(i);
			if (poll_obj.get_type() == Tango_POLL_ATTR) {
			    real_names[j++] = poll_obj.get_name();
			}
		    }
		}
	    }

	    // Check that device supports the wanted attribute
	    if (all_attr == false) {
		for (i = 0; i < real_names.length; i++) {
		    dev_attr.get_attr_ind_by_name(real_names[i]);
		}
	    }
	    // Check that all wanted attributes are polled.
	    // If some are non polled, store
	    // their name in the real_names sequence in a vector
	    final Vector non_polled = new Vector(); // String
	    if (all_attr == false) {
		for (i = 0; i < real_names.length; i++) {
		    for (j = 0; j < nb_poll; j++) {
			final PollObj poll_obj = (PollObj) poll_list.elementAt(j);
			if (poll_obj.get_name().equals(real_names[i].toLowerCase())) {
			    break;
			}
		    }
		    if (j == nb_poll) {
			non_polled.add(real_names[i]);
		    }
		}
	    }
	    // If some attributes are not polled but their polling update period
	    // is defined,
	    // and the attribute is not in the device list of attr which should
	    // not be
	    // polled, start to poll them
	    final Vector poll_period = new Vector();
	    if (non_polled.size() != 0) {
		// Check that it is possible to start polling for the non polled
		// attribute
		for (i = 0; i < non_polled.size(); i++) {
		    final String non_polled_name = (String) non_polled.elementAt(i);
		    final Attribute att = dev_attr.get_attr_by_name(non_polled_name);

		    poll_period.add(att.get_polling_period());

		    if (att.get_polling_period() == 0) {
			Except.throw_exception("API_AttrNotPolled", "Attribute " + non_polled_name
				+ " not polled", "Device_2Impl.read_attributes");
		    } else {
			boolean found = false;
			final Vector napa = get_non_auto_polled_attr();

			for (j = 0; j < napa.size(); j++) {
			    final String napa_str = ((String) napa.elementAt(j)).toLowerCase();
			    if (napa_str.equals(non_polled_name.toLowerCase())) {
				found = true;
			    }
			}

			if (found) {
			    Except.throw_exception("API_AttrNotPolled", "Attribute "
				    + non_polled_name + " not polled",
				    "Device_2Impl.read_attributes");
			}
		    }
		}
		// Start polling
		final Util tg = Util.instance();
		final DServer adm_dev = tg.get_dserver_device();

		final DevVarLongStringArray send = new DevVarLongStringArray();
		send.lvalue = new int[1];
		send.svalue = new String[3];
		send.svalue[0] = device_name;
		send.svalue[1] = "attribute";

		for (i = 0; i < non_polled.size(); i++) {
		    send.lvalue[0] = (Integer) poll_period.elementAt(i);
		    send.svalue[2] = (String) non_polled.elementAt(i);

		    adm_dev.add_obj_polling(send, false);
		}
	    }

	    // Allocate memory for the AttributeValue structures
	    final int nb_attr = real_names.length;
	    back = new AttributeValue[nb_attr];

	    // For each attribute, check that some data are available in cache
	    // and that they
	    // are not too old
	    for (i = 0; i < nb_attr; i++) {
		PollObj polled_attr = null;
		for (j = 0; j < poll_list.size(); j++) {
		    final PollObj poll_obj = (PollObj) poll_list.elementAt(j);
		    if (poll_obj.get_type() == Tango_POLL_ATTR
			    && poll_obj.get_name().toLowerCase()
				    .equals(real_names[i].toLowerCase())) {
			polled_attr = poll_obj;
			break;
		    }
		}

		// Check that some data is available in cache
		if (polled_attr.is_ring_empty() == true) {
		    Except.throw_exception("API_NoDataYet",
			    "No data available in cache for attribute " + real_names[i],
			    "Device_2Impl.read_attributes");
		}

		// Check that data are still refreshed by the polling thread
		final long ctm = System.currentTimeMillis();
		int tv_sec = (int) (ctm / 1000);
		final int tv_usec = (int) (ctm - 1000 * tv_sec) * 1000;
		tv_sec = tv_sec - Tango_DELTA_T;

		final double last = polled_attr.get_last_insert_date();
		final double now_d = tv_sec + (double) tv_usec / 1000000;
		final double diff_d = now_d - last;
		if (diff_d > polled_attr.get_authorized_delta()) {
		    Except.throw_exception("API_NotUpdatedAnyMore", "Data in cache for attribute "
			    + real_names[i] + " not updated any more",
			    "Device_2Impl.read_attributes");
		}

		// Finally, after all these checks, get value and store it in
		// the
		// sequence sent back to user
		// In order to avoid unnecessary copy, don't use the assignement
		// operator of the
		// AttributeValue structure which copy each element and
		// therefore also copy
		// the Any object. The Any assignement operator is a deep copy!
		// Create a new sequence using the attribute buffer and insert
		// it into the
		// Any. The sequence inside the source Any has been created
		// using the attribute
		// data buffer.
		back[i] = polled_attr.get_last_attr_value();
	    }
	} catch (final DevFailed e) {
	    if (source == DevSource.CACHE) {
		throw e;
	    }
	    // if (att_in_fault == true) {
	    // throw e;
	    // }
	    polling_failed = true;
	}

	// If the source parameter is CACHE, returned data,
	// else call method reading attribute from device
	if (source == DevSource.CACHE_DEV && polling_failed == true) {
	    back = read_attributes(names);
	}
	return back;
    }

    // +-------------------------------------------------------------------------
    //
    // method : Device_2Impl.read_attribute_history_2
    // 
    // description : CORBA operation to read attribute alue history from
    // the polling buffer.
    //
    // argument: in : - name : attribute name
    // - n : history depth (in record number)
    //
    // This method returns a pointer to a DevAttrHistoryList with one
    // DevAttrHistory structure for each attribute record
    //
    // --------------------------------------------------------------------------

    public DevAttrHistory[] read_attribute_history_2(final String name, int n) throws DevFailed,
	    SystemException {
	Util.out4.println("Device_2Impl.read_attribute_history_2 arrived");

	// Record operation request in black box
	blackbox.insert_op(Op_Read_Attr_history_2);

	final Vector poll_list = get_poll_obj_list();
	final int nb_poll = poll_list.size();

	// Check that the device supports this attribute.
	// This method returns an exception in case of unsupported attribute
	final Attribute att = dev_attr.get_attr_by_name(name);
	final String attr_str = name.toLowerCase();

	// Check that the wanted attribute is polled.
	PollObj polled_attr = null;
	for (int i = 0; i < nb_poll; i++) {
	    final PollObj poll_obj = (PollObj) poll_list.elementAt(i);
	    if (poll_obj.get_type() == Tango_POLL_ATTR && poll_obj.get_name().equals(attr_str)) {
		polled_attr = poll_obj;
		break;
	    }
	}

	if (polled_attr == null) {
	    Except.throw_exception("API_AttrNotPolled", "No data available in cache for attribute "
		    + attr_str, "Device_2Impl.read_attribute_history_2");
	}

	// Check that some data is available in cache
	assert polled_attr != null;
	if (polled_attr.is_ring_empty()) {
	    Except.throw_exception("API_NoDataYet", "No data available in cache for attribute "
		    + attr_str, "Device_2Impl.read_attribute_history_2");
	}

	// Set the number of returned records
	final int in_buf = polled_attr.get_elt_nb_in_buffer();
	if (n > in_buf) {
	    n = in_buf;
	}

	// return attribute value history
	return polled_attr.get_attr_history(n, att.get_data_type());
    }

    // +-------------------------------------------------------------------------
    //
    // method : write_attributes
    // 
    // description : CORBA operation to write attribute(s) value
    //
    // argument: in : - values: The new attribute(s) value to be set.
    //
    // --------------------------------------------------------------------------
    /**
     * Write attribute(s).
     * 
     * Invoked when the client request the write_attributes CORBA operation.
     * This method writes new attribute value.
     * 
     * @param values
     *            The attribute(s) new set value. There is one AttributeValue
     *            object for each attribute to be set
     * @exception DevFailed
     *                Thrown if one of the attribute does not exist. Click here
     *                 to read DevFailed exception specification
     */
    public void write_attributes(final AttributeValue[] values) throws DevFailed {
	Util.out4.println("DeviceImpl.write_attributes arrived");

	//
	// Record operation request in black box
	//

	blackbox.insert_op(Op_Write_Attr);

	//
	// Return exception if the device does not have any attribute
	//

	final int nb_dev_attr = dev_attr.get_attr_nb();
	if (nb_dev_attr == 0) {
	    Except.throw_exception("API_AttrNotFound", "The device does not have any attribute",
		    "DeviceImpl.write_attributes");
	}

	//
	// Retrieve index of wanted attributes in the device attribute list
	//

	final long nb_updated_attr = values.length;
	final Vector updated_attr = new Vector();

	int i;
	for (i = 0; i < nb_updated_attr; i++) {
	    updated_attr.addElement(dev_attr.get_attr_ind_by_name(values[i].name));
	}

	//
	// Check that these attributes are writable
	//

	for (i = 0; i < nb_updated_attr; i++) {
	    if (dev_attr.get_attr_by_ind((Integer) updated_attr.elementAt(i)).get_writable() == AttrWriteType.READ
		    || dev_attr.get_attr_by_ind((Integer) updated_attr.elementAt(i)).get_writable() == AttrWriteType.READ_WITH_WRITE) {
		final StringBuffer o = new StringBuffer("Attribute ");
		o.append(dev_attr.get_attr_by_ind((Integer) updated_attr.elementAt(i)).get_name());
		o.append(" is not writable");

		Except.throw_exception("API_AttrNotWritable", o.toString(),
			"DeviceImpl.write_attributes");
	    }
	}

	//
	// Set attribute internal value
	//

	for (i = 0; i < nb_updated_attr; i++) {
	    try {
		dev_attr.get_w_attr_by_ind((Integer) updated_attr.elementAt(i)).set_write_value(
			values[i].value);
	    } catch (final DevFailed ex) {
		for (int j = 0; j < i; j++) {
		    dev_attr.get_w_attr_by_ind((Integer) updated_attr.elementAt(j)).rollback();
		}
		throw ex;
	    }
	}

	//
	// Write the hardware
	//
	try {
	    // If nb connection is closed to the maximum value,
	    // throw an exception to do not block devices.
	    Util.increaseAccessConter();
	    if (Util.getAccessConter() > Util.getPoaThreadPoolMax() - 2) {
		Util.decreaseAccessConter();
		Except.throw_exception("API_MemoryAllocation", Util.instance().get_ds_real_name()
			+ ": No thread available to connect device",
			"DeviceImpl.write_attributes()");
	    }

	    // Call the always_executed_hook method before
	    always_executed_hook();

	    switch (Util.get_serial_model()) {
	    case BY_CLASS:
		synchronized (device_class) {
		    write_attr_hardware(updated_attr);
		}
		break;

	    case BY_DEVICE:
		synchronized (this) {
		    write_attr_hardware(updated_attr);
		}
		break;

	    default: // NO_SYNC
		write_attr_hardware(updated_attr);
	    }
	} catch (final DevFailed exc) {
	    Util.decreaseAccessConter();
	    throw exc;
	} catch (final Exception exc) {
	    Util.decreaseAccessConter();
	    Except.throw_exception("API_ExceptionCatched", exc.toString(),
		    "DeviceImpl.write_attributes");
	}
	Util.decreaseAccessConter();

	//
	// Return to caller.
	//

	Util.out4.println("Leaving DeviceImpl.write_attributes");
    }

    // =================================================================
    /**
     * Remove an attribute on the device attribute list.
     * 
     * @param attname
     *            Attribute's name to be removed to the list
     * @throws DevFailed .
     */
    // =================================================================
    public void remove_attribute(final String attname) throws DevFailed {
	// Remove property in database
	if (Util._UseDb) {
	    final DeviceProxy dev = new DeviceProxy(device_name);
	    final DbAttribute da = dev.get_attribute_property(attname);
	    dev.delete_attribute_property(da);

	}
	dev_attr.remove_attribute(attname);
    }

    // +-------------------------------------------------------------------------
    //
    // method : add_attribute
    // 
    // description : Add attribute to the device attribute(s) list
    //
    // argument: in : - new_attr: The new attribute to be added.
    //
    // --------------------------------------------------------------------------

    /**
     * Add a new attribute to the device attribute list.
     * 
     * Attributes are normally constructed in the
     * DeviceClass::attribute_factory() method. Nevertheless, it is still
     * possible to add a new attribute to a device with this method. Please,
     * note that if you add an attribute to a device at device creation time,
     * this attribute will be added to the device class attribute list.
     * Therefore, all devices belonging to the same class created after this
     * attribute addition will also have this attribute.
     * 
     * @param new_attr
     *            Reference to the new attribute to be added to the list
     * @exception DevFailed . Click
     *                here
     *                 to read DevFailed exception specification
     */

    public void add_attribute(final Attr new_attr) throws DevFailed {
	final Vector attr_list = device_class.get_class_attr().get_attr_list();
	final int old_attr_nb = attr_list.size();

	//
	// Check that this attribute is not already defined for this device.
	// If it is alaredy there, immediately returns.
	// Trick : If you add an attribute to a device, this attribute will be
	// inserted in the device class attribute list. Therefore, all devices
	// created after this attribute addition will also have this attribute.
	//	

	final String attr_name = new_attr.get_name();
	boolean already_there = true;

	try {
	    dev_attr.get_attr_by_name(attr_name);
	} catch (final DevFailed ex) {
	    already_there = false;
	}

	if (already_there == true) {
	    return;
	}

	//
	// Add this attribute in the MultiClassAttribute attr_list vector if it
	// does not
	// already exist
	//

	int i;
	for (i = 0; i < old_attr_nb; i++) {
	    if (((Attr) attr_list.elementAt(i)).get_name().equals(attr_name) == true) {
		break;
	    }
	}
	if (i == old_attr_nb) {

	    attr_list.addElement(new_attr);

	    //
	    // Get all the properties defined for this attribute at class level
	    //

	    device_class.get_class_attr()
		    .init_class_attribute(device_class.get_name(), old_attr_nb);
	}

	//
	// Add the attribute to the MultiAttribute object
	//

	dev_attr.add_attribute(device_name, device_class, i);
    }

    //
    // Five methods which could be redefined in each device server class
    //

    /**
     * Get device state.
     * 
     * Default method to get device state. The behaviour of this method depends
     * on the device state. If the device state is ON or ALARM, it reads the
     * attribute(s) with an alarm level defined, check if the read value is
     * above/below the alarm and eventually change the state to ALARM, return
     * the device state. For all th eother device state, ti smethod simply
     * returns the state This method can be redefined in sub-classes in case of
     * the default behaviour does not fullfill the needs
     * 
     * @return The device state
     * @exception DevFailed
     *                If it is necessary to read attribute(s) and a problem
     *                occurs during the reading. Click here to read DevFailed exception specification
     */

    public DevState dev_state() throws DevFailed {
	if (device_state.value() == DevState._ON || device_state.value() == DevState._ALARM) {

	    //
	    // Read the hardware
	    //

	    final Vector attr_list = dev_attr.get_alarm_list();
	    final int nb_wanted_attr = attr_list.size();
	    if (nb_wanted_attr != 0) {
		read_attr_hardware(attr_list);

		//
		// Set attr value
		//

		int i;
		for (i = 0; i < nb_wanted_attr; i++) {
		    final Attribute att = dev_attr
			    .get_attr_by_ind((Integer) attr_list.elementAt(i));
		    att.wanted_date(false);
		    try {
			read_attr(att);
		    } catch (final DevFailed ex) {
			att.wanted_date(true);
			throw ex;
		    }
		    att.wanted_date(true);
		}

		//
		// Check alarm level
		//

		if (dev_attr.check_alarm() == true) {
		    device_state = DevState.ALARM;
		}

	    }
	}
	return device_state;
    }

    /**
     * Get device status.
     * 
     * Default method to get device status. It returns the contents of the
     * device device_status field. If the device state is ALARM, alarm messages
     * are added to the device status. This method can be redefined in
     * sub-classes in case of the default behaviour does not fullfill the needs
     * 
     * @return The device status
     * @exception DevFailed
     *                This method does not throw exception but a redefined
     *                method can. Click here to read DevFailed exception specification
     */

    public String dev_status() throws DevFailed {
	if (device_state.value() == DevState._ALARM || device_state.value() == DevState._ON) {
	    final StringBuffer alarm_status = new StringBuffer(device_status);
	    dev_attr.read_alarm(alarm_status);
	    return alarm_status.toString();
	}
	return device_status;
    }

    /**
     * Read the hardware to return attribute value(s).
     * 
     * Default method to implement an action necessary on a device to read the
     * hardware involved in a a read attribute CORBA call. This method must be
     * redefined in sub-classes in order to support attribute reading
     * 
     * @param attr_list
     *            Reference to a vector with Integer object. Each element in
     *            this vector is the index in the device onject attribute vector
     *            of an attribute to be read.
     * @exception DevFailed
     *                This method does not throw exception but a redefined
     *                method can. Click here to read DevFailed exception specification
     */
    public void read_attr_hardware(final Vector attr_list) throws DevFailed {
    }

    /**
     * Set the attribute read value.
     * 
     * Default method to set an attribute read value. This method must be
     * redefined in sub-classes when attributes are needed
     * 
     * @param attr
     *            The attribute object
     * @exception DevFailed
     *                This method does not throw exception but a redefined
     *                method can. Click here to read DevFailed exception specification
     */
    public void read_attr(final Attribute attr) throws DevFailed {
    }

    /**
     * Write the hardware for attributes.
     * 
     * Default method to implement an action necessary on a device to write the
     * hardware involved in a a write attribute. This method must be redefined
     * in sub-classes in order to support writable attribute
     * 
     * @param attr_list
     *            Reference to a vector of Integer objects. Each element in this
     *            vector is the index in the main attribute vector of an
     *            attribute to be written.
     * @exception DevFailed
     *                This method does not throw exception but a redefined
     *                method can. Click here to read DevFailed exception specification
     */
    public void write_attr_hardware(final Vector attr_list) throws DevFailed {
    }

    /**
     * Hook method.
     * 
     * Default method to implement an action necessary on a device before any
     * command is executed. This method can be redefined in sub-classes in case
     * of the default behaviour does not fullfill the needs
     * 
     * @exception DevFailed
     *                This method does not throw exception but a redefined
     *                method can. Click here to read DevFailed exception specification
     */

    public void always_executed_hook() throws DevFailed {
    }

    //
    // one abstract method
    //

    /**
     * Intialise a device.
     * 
     * In the DeviceImpl class, this method is pure abstract and must be defined
     * in sub-class. Its rule is to initialise a device. This method is called
     * during device creation an dby the DevRestart command
     * 
     * @exception DevFailed
     *                This method does not throw exception but a redefined
     *                method can. Click here to read DevFailed exception specification
     */

    public abstract void init_device() throws DevFailed;

    /**
     * This method is called during device Init an the DevRestart command. Some
     * clean-up should be done here for stopping thread, clearing lists...
     * 
     * @throws DevFailed
     */
    public abstract void delete_device() throws DevFailed;

    /**
     * Return device POA
     * 
     * Return a reference to the device POA. This method is necessary for the
     * CORBA object implicit activation by the _this method
     * 
     * @return Reference to the device POA
     */

    @Override
    public POA _default_POA() {
	return Util.instance().get_poa();
    }

    //
    // Methods to retrieve/set some data members from outside the class and all
    // its inherited classes
    //

    /**
     * Get device status.
     * 
     * Return the device device_status field. This method does the same thing
     * than the default dev_status method.
     * 
     * @return Device status
     */

    public String get_status() {
	return device_status;
    }

    /**
     * Set device status.
     * 
     * @param new_status
     *            The new device status
     */

    public void set_status(final String new_status) {
	device_status = new_status;
    }

    /**
     * Get device state.
     * 
     * Return the device device_state field. This method does the same thing
     * than the default dev_state method.
     * 
     * @return Device state
     */

    public DevState get_state() {
	return device_state;
    }

    /**
     * Set device state.
     * 
     * @param new_state
     *            The new device state
     */

    public void set_state(final DevState new_state) {
	device_state = new_state;
    }

    /**
     * Get device name.
     * 
     * Return the device name (device_name field)
     * 
     * @return Device name
     */

    public String get_name() {
	return device_name;
    }

    /**
     * Get device class object reference.
     * 
     * Return the device class object reference
     * 
     * @return Device class
     */

    public DeviceClass get_device_class() {
	return device_class;
    }

    /**
     * Get the reference to the associated DbDevice object
     *
     * Return the DbDevice object reference
     *
     * @return DbDevice
     */

    public DbDevice get_db_device() {
	return db_dev;
    }

    /**
     * Get the associated CORBA object identifier
     *
     * @return The CORBA object identifier
     */

    public byte[] get_obj_id() {
	return obj_id;
    }

    /**
     * Set the associated CORBA object identifier
     *
     * @param id
     *            The CORBA object identifier
     */

    public void set_obj_id(final byte[] id) {
	obj_id = id;
    }

    boolean get_exported_flag() {
	return exported;
    }

    void set_exported_flag(final boolean exp) {
        exported = exp;
    }

    /**
     * Returns the device's logger
     */
    public Logger get_logger() {
	if (logger == null) {
	    logger = Logger.getLogger(get_name().toLowerCase());
	    logger.setAdditivity(false);
	    logger.setLevel(Level.WARN);
	    last_level = Level.WARN;
	}
	return logger;
    }

    /**
     * Initialize the logging for this device
     */
    @SuppressWarnings( { "NestedTryStatement" })
    public void init_logger() {
	try {
	    Util.out4.println("Initializing logging for " + get_name());
	    // - Get Util instance
	    final Util util = Util.instance();
	    // - Get cmd line logging level then ...
	    final int trace_level = util.get_trace_level();
	    // ... convert it to log4j level
	    Level cmd_line_level;
	    // does the logging level set from cmd line?
	    boolean level_set_from_cmd_line = true;
	    if (trace_level <= 0) {
		level_set_from_cmd_line = false;
		cmd_line_level = Level.OFF;
	    } else if (trace_level <= 2) {
		cmd_line_level = Level.INFO;
	    } else {
		cmd_line_level = Level.DEBUG;
	    }
	    // - Add a console target if logging level set from cmd line
	    if (level_set_from_cmd_line) {
		// add a console target if logging level set from cmd line
		try {
		    Logging.instance().add_logging_target(get_logger(), LOGGING_CONSOLE_TARGET);
		} catch (final DevFailed df) {
		    /** ignore exception */
		}
	    }
	    if (!Util._UseDb) {
		// - Done if we are not using the database
		Util.out4.println("Not using the database. Logging Intialization complete");
		return;
	    }
	    // - Get both logging level and targets from database
	    final Logging.LoggingProperties properties = Logging.instance().get_logging_properties(
		    get_logger(), util.get_database());
	    if (properties == null) {
		Util.out4.println("Failed to obtain logging properties from database");
		Util.out4.println("Aborting logging intialization");
		get_logger().setLevel(cmd_line_level);
		return;
	    }
	    // - Set logging level
	    if (level_set_from_cmd_line == false) {
		get_logger().setLevel(properties.logging_level);
		Util.out4.println("Logging level set to " + properties.logging_level.toString());
	    } else {
		get_logger().setLevel(cmd_line_level);
	    }
	    // - Save current logging level
	    last_level = get_logger().getLevel();
	    // - Get rolling threshold for file targets
	    if (rft != properties.logging_rft) {
		rft = properties.logging_rft;
		Util.out4.println("Rolling threshold changed to " + String.valueOf(rft));
	    }
	    // - Set logging targets
	    if (properties.logging_targets != null) {
		Util.out4.println("Adding logging targets (" + properties.logging_targets.length
			+ " entries in db)");
		for (final String logging_target : properties.logging_targets) {
		    try {
			Logging.instance().add_logging_target(get_logger(), logging_target);
		    } catch (final DevFailed e) { /* ignore any exception */
		    }
		}
	    }
	    // set rolling file threshold for file targets
	    Logging.instance().set_rolling_file_threshold(get_logger(), rft);
	} catch (final Exception e) {
	    // igore any exception
	}
    }

    /**
     * Backup current logging level then set it to OFF
     */
    public void stop_logging() {
	last_level = get_logger().getLevel();
	get_logger().setLevel(Level.OFF);
    }

    /**
     * Restore logging level to its backup value
     */
    public void start_logging() {
	get_logger().setLevel(last_level);
    }

    /**
     * This method check that a comamnd is supported by the device and does not
     * need input value. The method throws an exception if the command is not
     * defined or needs an input value
     */
    // ==========================================================
    void check_command_exists(final String cmd_name) throws DevFailed {
	final Vector cmd_list = device_class.get_command_list();
	for (int i = 0; i < cmd_list.size(); i++) {
	    final Command cmd = (Command) cmd_list.elementAt(i);
	    if (cmd.get_name().toLowerCase().equals(cmd_name)) {
		if (cmd.get_in_type() != Tango_DEV_VOID) {
		    Except.throw_exception("API_IncompatibleCmdArgumentType", "Command " + cmd_name
			    + " cannot be polled because it needs input value",
			    "DeviceImpl.check_command_exists");
		}
		return;
	    }
	}

	Except.throw_exception("API_CommandNotFound", "Command " + cmd_name + " not found",
		"DeviceImpl.check_command_exists");
    }

    // =======================================
    //
    // Polling part
    //
    // =======================================
    // ==========================================================

    // ==========================================================
    // ==========================================================
    int get_poll_old_factor() {
	return ext.poll_old_factor;
    }

    // ==========================================================
    // ==========================================================
    void set_poll_old_factor(final int fact) {
	ext.poll_old_factor = fact;
    }

    // ==========================================================
    // ==========================================================
    boolean is_polled() {
	return ext.polled;
    }

    // ==========================================================
    // ==========================================================
    void is_polled(final boolean b) {
	ext.polled = b;
    }

    // ==========================================================
    // ==========================================================
    Vector get_poll_obj_list() {
	return ext.poll_obj_list;
    }

    // ==========================================================
    // ==========================================================
    int get_poll_ring_depth() {
	return ext.poll_ring_depth;
    }

    // ==========================================================
    // ==========================================================
    public void set_poll_ring_depth(final int size) {
	ext.poll_ring_depth = size;
    }

    // ==========================================================
    // ==========================================================
    MultiAttribute get_device_attr() {
	return dev_attr;
    }

    /**
     * Set device state.
     *
     * @param new_multi_attr The new attribute
     */

    public void set_device_attr(final MultiAttribute new_multi_attr) {
        dev_attr = new_multi_attr;
    }

    // ==========================================================
    // ==========================================================
    Vector get_non_auto_polled_cmd() {
        return ext.non_auto_polled_cmd;
    }

    // ==========================================================
    // ==========================================================
    void set_non_auto_polled_cmd(final String[] s) {
	for (final String value : s) {
	    ext.non_auto_polled_cmd.add(value);
	}
    }

    // ==========================================================
    // ==========================================================
    Vector get_non_auto_polled_attr() {
        return ext.non_auto_polled_attr;
    }

    // ==========================================================
    // ==========================================================
    void set_non_auto_polled_attr(final String[] s) {
	for (final String value : s) {
	    ext.non_auto_polled_attr.add(value);
	}
    }

    // ==========================================================
    // ==========================================================
    Vector get_polled_cmd() {
        return ext.polled_cmd;
    }

    // ==========================================================
    // ==========================================================
    public void set_polled_cmd(final String[] s) {
	for (final String value : s) {
	    ext.polled_cmd.add(value);
	}
    }

    // ==========================================================
    // ==========================================================
    Vector get_polled_attr() {
        return ext.polled_attr;
    }

    // ==========================================================
    // ==========================================================
    public void set_polled_attr(final String[] s) {
	for (final String value : s) {
	    ext.polled_attr.add(value);
	}
    }

    // ==========================================================
    // ==========================================================
    TangoMonitor get_dev_monitor() {
	return ext.only_one;
    }

    // ==========================================================
    /**
     * This method check return the polled object for input type and name.
     * 
     * @param obj_type
     *            the object type
     * @param obj_name
     *            the object name
     */
    // ==========================================================
    synchronized PollObj get_polled_obj_by_type_name(final int obj_type, final String obj_name)
	    throws DevFailed {
	// Get vector and search for type and name.
	final Vector po_list = get_poll_obj_list();
	for (int i = 0; i < po_list.size(); i++) {
	    final PollObj polled_obj = (PollObj) po_list.elementAt(i);
	    if (polled_obj.get_type_i() == obj_type) {
		if (polled_obj.get_name_i().equals(obj_name)) {
		    return polled_obj;
		}
	    }
	}

	// If not found throws exception
	Except.throw_exception("API_PollObjNotFound", obj_name
		+ " not found in list of polled object", "DeviceImpl.get_polled_obj_by_type_name");
	return null;
    }

    // ==========================================================
    // ==========================================================
    // +-------------------------------------------------------------------------
    //
    // method : DeviceImpl.get_command
    // 
    // description : This method returns a pointer to command object.
    // The method throws an exception if the
    // command is not defined
    //
    // in : cmd_name : The command name
    //
    // --------------------------------------------------------------------------
    Command get_command(final String cmd_name) throws DevFailed {
	Command ret_cmd = null;
	final Vector cmd_list = device_class.get_command_list();
	for (int i = 0; i < cmd_list.size(); i++) {
	    final Command cmd = (Command) cmd_list.elementAt(i);
	    if (cmd.get_name().toLowerCase().equals(cmd_name.toLowerCase())) {
		ret_cmd = cmd;
	    }
	}

	if (ret_cmd == null) {
	    Except.throw_exception("API_CommandNotFound", "Command " + cmd_name + " not found",
		    "DeviceImpl.get_command");
	}

	return ret_cmd;
    }

    // ==========================================================
    /**
	 *
	 */
    // ==========================================================
    class DeviceImplExt {
	boolean exported = false;
	boolean polled = false;
	int poll_ring_depth = 0;
	int poll_old_factor;

	Vector polled_cmd;
	Vector polled_attr;
	Vector non_auto_polled_cmd;
	Vector non_auto_polled_attr;
	Vector poll_obj_list;

	TangoMonitor only_one; // Polling monitor

	DeviceImplExt() {
	    polled_cmd = new Vector();
	    polled_attr = new Vector();
	    non_auto_polled_cmd = new Vector();
	    non_auto_polled_attr = new Vector();
	    poll_obj_list = new Vector();

	    only_one = new TangoMonitor();
	}
    }
}