baci.idl

Go to the documentation of this file.

#ifndef _BACI_IDL_
#define _BACI_IDL_

/*******************************************************************************
*    ALMA - Atacama Large Millimiter Array
*    (c) European Southern Observatory, 2002
*    Copyright by ESO (in the framework of the ALMA collaboration)
*    and Cosylab 2002, All rights reserved
*
*    This library 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 2.1 of the License, or (at your option) any later version.
*
*    This library 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 this library; if not, write to the Free Software
*    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA
*
*
* "@(#) $Id: baci.idl,v 1.15 2012/11/20 15:12:33 acaproni Exp $"
*
* who       when      what
* --------  --------  ----------------------------------------------
* gchiozzi 2003-09-10 created
*/

#include <CosProperty.idl>
#include <acscomponent.idl>
#include <acscommon.idl>
#include <acserr.idl>
#include <baciErrTypeProperty.idl>

#pragma prefix "alma"


module ACS {
    //need a forward declaration for this interface
    interface CharacteristicComponent;
        
    exception NoSuchCharacteristic {
    string characteristic_name;
    string component_name;
    };
    
    interface CharacteristicModel {
    
    any get_characteristic_by_name (in string name)                     
        raises (NoSuchCharacteristic);
    
    stringSeq find_characteristic (in string reg_exp);
    
    CosPropertyService::PropertySet get_all_characteristics ();
    };
    
    interface Property : CharacteristicModel, OffShoot {

    readonly attribute string name;
    
    readonly attribute string characteristic_component_name;
    };
    
    struct PropertyDesc {
        
        Property property_ref;
        
        string name;
        
        CosPropertyService::PropertySet characteristics;
    };
    
    typedef sequence <PropertyDesc> PropertyDescSeq;
    
        
    interface Subscription : OffShoot {
    
    void suspend ();
                        
    void resume ();
    
    void destroy ();
    };

    //Monitors////////////////////////////////////////////////////////////////////////////
    
    interface Monitor : Subscription {
    readonly attribute Time start_time;
                
    void set_timer_trigger (in TimeInterval timer);
                        
    void get_timer_trigger (out TimeInterval timer);
    };
        
    interface Monitordouble : ACS::Monitor {
    
    void set_value_trigger (in double delta, 
                            in boolean enable);
                        
    void get_value_trigger (out double delta,
                            out boolean enable);

    void set_value_percent_trigger (in double delta, 
                            in boolean enable);
                        
    void get_value_percent_trigger (out double delta,
                            out boolean enable);
    };
    
    interface Monitorfloat : ACS::Monitor {
    
    void set_value_trigger (in float delta, 
                            in boolean enable);
                        
    void get_value_trigger (out float delta,
                            out boolean enable);

    void set_value_percent_trigger (in double delta, 
                            in boolean enable);
                        
    void get_value_percent_trigger (out double delta,
                            out boolean enable);
    };

    interface Monitorpattern : ACS::Monitor {
    
    void set_value_trigger (in pattern delta,
                            in boolean enable);
    
    void get_value_trigger (out pattern delta,
                            out boolean enable);

    void set_value_percent_trigger (in double delta, 
                            in boolean enable);
                        
    void get_value_percent_trigger (out double delta,
                            out boolean enable);
    };

    interface Monitorstring : ACS::Monitor {
        
    void set_value_trigger (in string delta,
                            in boolean enable);
                        
    void get_value_trigger (out string delta,
                            out boolean enable);

    void set_value_percent_trigger (in double delta, 
                            in boolean enable);
                        
    void get_value_percent_trigger (out double delta,
                            out boolean enable);
    };

    interface MonitorstringSeq : ACS::Monitor {
    
    void set_value_trigger (in stringSeq delta,
                            in boolean enable);
    
    void get_value_trigger (out stringSeq delta,
                            out boolean enable);

    void set_value_percent_trigger (in double delta, 
                            in boolean enable);
                        
    void get_value_percent_trigger (out double delta,
                            out boolean enable);
    };

    interface Monitorlong : ACS::Monitor {
    
    void set_value_trigger (in long delta,
                            in boolean enable);
    
    void get_value_trigger (out long delta,
                            out boolean enable);

    void set_value_percent_trigger (in double delta, 
                            in boolean enable);
                        
    void get_value_percent_trigger (out double delta,
                            out boolean enable);
    };
        
    interface MonitoruLong : ACS::Monitor {
        
    void set_value_trigger (in uLong delta,
                            in boolean enable);
    
    void get_value_trigger (out uLong delta,
                            out boolean enable);

    void set_value_percent_trigger (in double delta, 
                            in boolean enable);
                        
    void get_value_percent_trigger (out double delta,
                            out boolean enable);
    };

    interface MonitorlongLong : ACS::Monitor {
    
    void set_value_trigger (in longLong delta,
                            in boolean enable);
    
    void get_value_trigger (out longLong delta,
                            out boolean enable);

    void set_value_percent_trigger (in double delta, 
                            in boolean enable);
                        
    void get_value_percent_trigger (out double delta,
                            out boolean enable);
    };

    interface MonitoruLongLong : ACS::Monitor {
        
    void set_value_trigger (in uLongLong delta,
                            in boolean enable);
    
    void get_value_trigger (out uLongLong delta,
                            out boolean enable);

    void set_value_percent_trigger (in double delta, 
                            in boolean enable);
                        
    void get_value_percent_trigger (out double delta,
                            out boolean enable);
    };

    interface Monitorboolean : ACS::Monitor {
        
    void set_value_trigger (in boolean delta,
                            in boolean enable);
    
    void get_value_trigger (out boolean delta,
                            out boolean enable);

    void set_value_percent_trigger (in double delta, 
                            in boolean enable);
                        
    void get_value_percent_trigger (out double delta,
                            out boolean enable);
    };

    //Property interfaces///////////////////////////////////////////////////////////////////////////

    interface TypelessProperty : Property {
    
    readonly attribute string description;
    
    readonly attribute string format;
    
    readonly attribute string units;
    
    readonly attribute pattern resolution;

        oneway void publish_now();

    };
        
    struct CharacteristicComponentDesc {
        
        ACS::CharacteristicComponent characteristic_component_ref;
        
        string name;
        
        PropertyDescSeq properties;
        
        CosPropertyService::PropertySet characteristics;
    };
    
    interface CharacteristicComponent : ACSComponent, CharacteristicModel {
    
    CharacteristicComponentDesc descriptor ();
    };
        

    interface PropertyActionExecutor : ACSComponent {
        struct PropertyAlarm {
            string FF;
            string FM;
            long FC;
            // (needed?) ACS::Time sourceTimestamp,
            CosPropertyService::Properties alarmProperties;
        };
        oneway void dispatchPropertyAction(
                in string propertyName, in string propertyValue, in string propertyType, 
                in PropertyAlarm alarm, in CosPropertyService::Properties extra );
    };


        
    interface CBpattern : Callback {
    
    oneway void working (in pattern value,
                         in ACSErr::Completion c,
                         in CBDescOut desc);
    
    oneway void done (in pattern value,
                      in ACSErr::Completion c,
                      in CBDescOut desc);
    };


    //Alarms//////////////////////////////////////////////////////////////////////////////////////////
        
        interface Alarmpattern : Callback {

        oneway void alarm_raised (in pattern value,
                                  in ACSErr::Completion c,
                                  in CBDescOut desc);
        
        oneway void alarm_cleared (in pattern value,
                                   in ACSErr::Completion c,
                                   in CBDescOut desc);  
        };
        
        interface Alarmdouble : Callback {

        oneway void alarm_raised (in double value,
                                  in ACSErr::Completion c,
                                  in CBDescOut desc);
                        
        oneway void alarm_cleared (in double value,
                                   in ACSErr::Completion c,
                                   in CBDescOut desc);
        };
        
        interface Alarmfloat : Callback {

        oneway void alarm_raised (in float value,
                                  in ACSErr::Completion c,
                                  in CBDescOut desc);
                        
        oneway void alarm_cleared (in float value,
                                   in ACSErr::Completion c,
                                   in CBDescOut desc);
        };
        
        interface Alarmlong : Callback {
        
        oneway void alarm_raised (in long value,
                                  in ACSErr::Completion c,
                                  in CBDescOut desc);
                        
        oneway void alarm_cleared (in long value,
                                   in ACSErr::Completion c,
                                   in CBDescOut desc);
                        
        };

        interface AlarmuLong : Callback {

        oneway void alarm_raised (in uLong value,
                                  in ACSErr::Completion c,
                                  in CBDescOut desc);
                        
        oneway void alarm_cleared (in uLong value,
                                   in ACSErr::Completion c,
                                   in CBDescOut desc);
                        
        };
        
        interface Alarmstring : Callback {
        
        oneway void alarm_raised (in string value,
                                  in ACSErr::Completion c,
                                  in CBDescOut desc);
        
        oneway void alarm_cleared (in string value,
                                   in ACSErr::Completion c,
                                   in CBDescOut desc);
        };
        
        interface Alarmboolean : Callback {

        oneway void alarm_raised (in boolean value,
                                  in ACSErr::Completion c,
                                  in CBDescOut desc);
                        
        oneway void alarm_cleared (in boolean value,
                                   in ACSErr::Completion c,
                                   in CBDescOut desc);
                        
        };
        
        interface AlarmstringSeq : Callback {

        oneway void alarm_raised (in stringSeq value,
                                  in ACSErr::Completion c,
                                  in CBDescOut desc);
                        
        oneway void alarm_cleared (in stringSeq value,
                                   in ACSErr::Completion c,
                                   in CBDescOut desc);
        };

        interface Pdouble : TypelessProperty {
                
        readonly attribute TimeInterval default_timer_trigger;
        
        readonly attribute TimeInterval min_timer_trigger;
        
        readonly attribute double min_delta_trigger;
        
        readonly attribute double default_value;
        
        readonly attribute double graph_min;
        
        readonly attribute double graph_max;
        
        readonly attribute double min_step;
                
        double get_sync (out ACSErr::Completion c       //The Completion structure of the request is returned as out parameter
            );
                        
        void get_async (in CBdouble cb,
                        in CBDescIn desc);
                        
        long get_history (in long n_last_values,        //The number of last monitored values to return
                          out doubleSeq vs,     //a sequence returning the requested values in ascending temporal order
                          out TimeSeq ts        //a sequence returning the timestamps corresponding to the returned values
            );
                        
        Monitordouble create_monitor (in CBdouble cb,
                                      in CBDescIn desc);
        
        Monitordouble create_postponed_monitor (in Time start_time,
                                                in CBdouble cb,
                                                in CBDescIn desc);
                        
        };
        
        interface Pfloat : TypelessProperty {
                
        readonly attribute TimeInterval default_timer_trigger;
        
        readonly attribute TimeInterval min_timer_trigger;
        
        readonly attribute float min_delta_trigger;
        
        readonly attribute float default_value;
        
        readonly attribute float graph_min;
        
        readonly attribute float graph_max;
        
        readonly attribute float min_step;
                
        float get_sync (out ACSErr::Completion c        //The Completion structure of the request is returned as out parameter
            );
                        
        void get_async (in CBfloat cb,
                        in CBDescIn desc);
                        
        long get_history (in long n_last_values,        //The number of last monitored values to return
                          out floatSeq vs,      //a sequence returning the requested values in ascending temporal order
                          out TimeSeq ts        //a sequence returning the timestamps corresponding to the returned values
            );
                        
        Monitorfloat create_monitor (in CBfloat cb,
                                      in CBDescIn desc);
        
        Monitorfloat create_postponed_monitor (in Time start_time,
                                                in CBfloat cb,
                                                in CBDescIn desc);
                        
        };
        
        interface Plong : TypelessProperty {
                readonly attribute TimeInterval default_timer_trigger;
                readonly attribute TimeInterval min_timer_trigger;
                readonly attribute long min_delta_trigger;
                readonly attribute long default_value;
                readonly attribute long graph_min;
                readonly attribute long graph_max;
                readonly attribute long min_step;
                
                long get_sync (out ACSErr::Completion c);
                        
                void get_async (in CBlong cb,
                                in CBDescIn desc);
                        
                long get_history (in long n_last_values,
                                  out longSeq vs,
                                  out TimeSeq ts);
                        
                Monitorlong create_monitor (in CBlong cb,
                                            in CBDescIn desc);
                        
                Monitorlong create_postponed_monitor (in Time start_time,
                                                      in CBlong cb,
                                                      in CBDescIn desc);
                        
        };
        
        interface PuLong : TypelessProperty {
                readonly attribute TimeInterval default_timer_trigger;
                readonly attribute TimeInterval min_timer_trigger;
                readonly attribute uLong min_delta_trigger;
                readonly attribute uLong default_value;
                readonly attribute uLong graph_min;
                readonly attribute uLong graph_max;
                readonly attribute uLong min_step;
                
                uLong get_sync (out ACSErr::Completion c);
                                
                void get_async (in CBuLong cb,
                                in CBDescIn desc);
                                
                long get_history (in long n_last_values,
                                  out uLongSeq vs,
                                  out TimeSeq ts);
                                
                MonitoruLong create_monitor (in CBuLong cb,
                                             in CBDescIn desc);
                                
                MonitoruLong create_postponed_monitor (in Time start_time,
                                                       in CBuLong cb,
                                                       in CBDescIn desc);
                                
        };

        interface Ppattern : TypelessProperty {
        readonly attribute TimeInterval default_timer_trigger;
        readonly attribute TimeInterval min_timer_trigger;
        readonly attribute pattern default_value;
        
        readonly attribute stringSeq bitDescription;
        
        readonly attribute ConditionSeq whenSet;
        
        readonly attribute ConditionSeq whenCleared;
                
        pattern get_sync (out ACSErr::Completion c);
                        
        void get_async (in CBpattern cb,
                        in CBDescIn desc);
        
        long get_history (in long n_last_values,
                          out patternSeq vs,
                          out TimeSeq ts);
                        
        Monitorpattern create_monitor ( in CBpattern cb,
                                        in CBDescIn desc);
        
        Monitorpattern create_postponed_monitor (in Time start_time,
                                                 in CBpattern cb,
                                                 in CBDescIn desc);
                        
        };
        
        interface Pstring : TypelessProperty {
        readonly attribute TimeInterval default_timer_trigger;
        readonly attribute TimeInterval min_timer_trigger;
        readonly attribute string default_value;
        
        string get_sync (out ACSErr::Completion c);
                        
        void get_async (in CBstring cb,
                        in CBDescIn desc);
                        
        long get_history (in long n_last_values,
                          out stringSeq vs,
                          out TimeSeq ts);
                        
        Monitor create_monitor (in CBstring cb,
                                in CBDescIn desc);
                        
        Monitor create_postponed_monitor (in Time start_time,
                                          in CBstring cb,
                                          in CBDescIn desc);
                        
        };

        interface Pboolean : TypelessProperty {
        readonly attribute TimeInterval default_timer_trigger;
        readonly attribute TimeInterval min_timer_trigger;
        readonly attribute boolean default_value;
        
        boolean get_sync (out ACSErr::Completion c);
                        
        void get_async (in CBboolean cb,
                        in CBDescIn desc);
                        
        long get_history (in long n_last_values,
                          out booleanSeq vs,
                          out TimeSeq ts);
                        
        Monitor create_monitor (in CBboolean cb,
                                in CBDescIn desc);
                        
        Monitor create_postponed_monitor (in Time start_time,
                                          in CBboolean cb,
                                          in CBDescIn desc);
                        
        };
        
        interface PstringSeq : TypelessProperty {
        readonly attribute TimeInterval default_timer_trigger;
        readonly attribute TimeInterval min_timer_trigger;
        readonly attribute stringSeq default_value;
        
        stringSeq get_sync (out ACSErr::Completion c);
        
        void get_async (in CBstringSeq cb,
                        in CBDescIn desc);
                        
        long get_history (in long n_last_values,
                          out stringSeqSeq vs,
                          out TimeSeq ts);
        
        MonitorstringSeq create_monitor (in CBstringSeq cb,
                                         in CBDescIn desc);
                        
        MonitorstringSeq create_postponed_monitor (in Time start_time,
                                                   in CBstringSeq cb,
                                                   in CBDescIn desc);
                        
        };

        interface PbooleanSeq : TypelessProperty {
        readonly attribute TimeInterval default_timer_trigger;
        readonly attribute TimeInterval min_timer_trigger;
        readonly attribute boolean default_value;
        
        booleanSeq get_sync (out ACSErr::Completion c);
        
        void get_async (in CBbooleanSeq cb,
                        in CBDescIn desc);
                        
        long get_history (in long n_last_values,
                          out booleanSeqSeq vs,
                          out TimeSeq ts);
        
        Monitorboolean create_monitor (in CBbooleanSeq cb,
                                         in CBDescIn desc);
                        
        Monitorboolean create_postponed_monitor (in Time start_time,
                                                   in CBbooleanSeq cb,
                                                   in CBDescIn desc);
                        
        };

        interface PdoubleSeq : TypelessProperty {
        readonly attribute TimeInterval default_timer_trigger;
        readonly attribute TimeInterval min_timer_trigger;
        readonly attribute double min_delta_trigger;
        readonly attribute double default_value;
        readonly attribute double graph_min;
        readonly attribute double graph_max;
        readonly attribute double min_step;
        
        doubleSeq get_sync (out ACSErr::Completion c);
        
        void get_async (in CBdoubleSeq cb,
                        in CBDescIn desc);
                        
        long get_history (in long n_last_values,
                          out doubleSeqSeq vs,
                          out TimeSeq ts);
                        
        Monitordouble create_monitor (in CBdoubleSeq cb,
                                      in CBDescIn desc);
                        
        Monitordouble create_postponed_monitor (in Time start_time,
                                                in CBdoubleSeq cb,
                                                in CBDescIn desc);
                        
        };
        

        interface PfloatSeq : TypelessProperty {
        readonly attribute TimeInterval default_timer_trigger;
        readonly attribute TimeInterval min_timer_trigger;
        readonly attribute float min_delta_trigger;
        readonly attribute float default_value;
        readonly attribute float graph_min;
        readonly attribute float graph_max;
        readonly attribute float min_step;
        
        floatSeq get_sync (out ACSErr::Completion c);
        
        void get_async (in CBfloatSeq cb,
                        in CBDescIn desc);
                        
        long get_history (in long n_last_values,
                          out floatSeqSeq vs,
                          out TimeSeq ts);
                        
        Monitorfloat create_monitor (in CBfloatSeq cb,
                                      in CBDescIn desc);
                        
        Monitorfloat create_postponed_monitor (in Time start_time,
                                                in CBfloatSeq cb,
                                                in CBDescIn desc);
                        
        };
        
        interface PlongSeq : TypelessProperty {
        readonly attribute TimeInterval default_timer_trigger;
        readonly attribute TimeInterval min_timer_trigger;
        readonly attribute long min_delta_trigger;
        readonly attribute long default_value;
        readonly attribute long graph_min;
        readonly attribute long graph_max;
        readonly attribute long min_step;
        
        longSeq get_sync (out ACSErr::Completion c);
                        
        void get_async (in CBlongSeq cb,
                        in CBDescIn desc);
        
        long get_history (in long n_last_values,
                          out longSeqSeq vs,
                          out TimeSeq ts);
                        
        Monitorlong create_monitor (in CBlongSeq cb,
                                    in CBDescIn desc);
                        
        Monitorlong create_postponed_monitor (in Time start_time,
                                              in CBlongSeq cb,
                                              in CBDescIn desc);
        
        };
        
        interface PuLongSeq : TypelessProperty {
        readonly attribute TimeInterval default_timer_trigger;
        readonly attribute TimeInterval min_timer_trigger;
        readonly attribute uLong min_delta_trigger;
        readonly attribute uLong default_value;
        readonly attribute uLong graph_min;
        readonly attribute uLong graph_max;
        readonly attribute uLong min_step;
        
        uLongSeq get_sync (out ACSErr::Completion c);
                        
        void get_async (in CBuLongSeq cb,
                        in CBDescIn desc);
        
        long get_history (in long n_last_values,
                          out uLongSeqSeq vs,
                          out TimeSeq ts);
                        
        MonitoruLong create_monitor (in CBuLongSeq cb,
                                    in CBDescIn desc);
                        
        MonitoruLong create_postponed_monitor (in Time start_time,
                                              in CBuLongSeq cb,
                                              in CBDescIn desc);
        
        };

        interface ROdouble : Pdouble {

        readonly attribute double alarm_low_on;
        
        readonly attribute double alarm_low_off;
        
        readonly attribute double alarm_high_on;
        
        readonly attribute double alarm_high_off;
        
        Subscription new_subscription_Alarm (in Alarmdouble cb,
                                             in CBDescIn desc);

        //** Enables the propagation of Property Alarms to the ACS Alarm System **/
        void enable_alarm_system();

        //** Disables the propagation of Property Alarms to the ACS Alarm System **/
        void disable_alarm_system() raises (baciErrTypeProperty::DisableAlarmsErrorEx);

        //** Returns the current status of the propagation of Property Alarms to the ACS Alarm System **/
        boolean alarm_system_enabled();

        };
        
        interface RWdouble : Pdouble {
        
        readonly attribute double min_value;
        readonly attribute double max_value;
                
        ACSErr::Completion set_sync (in double value);
                        
        void set_async (in double value,
                        in CBvoid cb,
                        in CBDescIn desc);
                        
        void set_nonblocking (in double value);
                        
        void increment (in CBvoid cb,
                        in CBDescIn desc);
                        
        void decrement (in CBvoid cb,
                        in CBDescIn desc);
                        
        };
        
        interface ROfloat : Pfloat {

        readonly attribute float alarm_low_on;
        
        readonly attribute float alarm_low_off;
        
        readonly attribute float alarm_high_on;
        
        readonly attribute float alarm_high_off;
        
        Subscription new_subscription_Alarm (in Alarmfloat cb,
                                             in CBDescIn desc);

        //** Enables the propagation of Property Alarms to the ACS Alarm System **/
        void enable_alarm_system();

        //** Disables the propagation of Property Alarms to the ACS Alarm System **/
        void disable_alarm_system() raises (baciErrTypeProperty::DisableAlarmsErrorEx);

        //** Returns the current status of the propagation of Property Alarms to the ACS Alarm System **/
        boolean alarm_system_enabled();

        };
        
        interface RWfloat : Pfloat {
        
        readonly attribute float min_value;
        readonly attribute float max_value;
                
        ACSErr::Completion set_sync (in float value);
                        
        void set_async (in float value,
                        in CBvoid cb,
                        in CBDescIn desc);
                        
        void set_nonblocking (in float value);
                        
        void increment (in CBvoid cb,
                        in CBDescIn desc);
                        
        void decrement (in CBvoid cb,
                        in CBDescIn desc);
                        
        };
        
        interface ROpattern : Ppattern {
                
        readonly attribute pattern alarm_mask;
        
        readonly attribute pattern alarm_trigger;
        
        Subscription new_subscription_Alarm (in Alarmpattern cb,
                                             in CBDescIn desc);
                        
        //** Enables the propagation of Property Alarms to the ACS Alarm System **/
        void enable_alarm_system();

        //** Disables the propagation of Property Alarms to the ACS Alarm System **/
        void disable_alarm_system() raises (baciErrTypeProperty::DisableAlarmsErrorEx);

        //** Returns the current status of the propagation of Property Alarms to the ACS Alarm System **/
        boolean alarm_system_enabled();

        };

        interface RWpattern : Ppattern {
        ACSErr::Completion set_sync (in pattern value);
                        
        void set_async (in pattern value,
                        in CBvoid cb,
                        in CBDescIn desc);
                        
        void set_nonblocking (in pattern value);
                        
        };
        
        interface RWstring : Pstring {
        ACSErr::Completion set_sync (in string value);
                        
        void set_async (in string value,
                        in CBvoid cb,
                        in CBDescIn desc);
        
        void set_nonblocking (in string value);
                        
        };
        
        interface ROstring : Pstring {
        
        Subscription new_subscription_Alarm (in Alarmstring cb,
                                             in CBDescIn desc);

        //** Enables the propagation of Property Alarms to the ACS Alarm System **/
        void enable_alarm_system();

        //** Disables the propagation of Property Alarms to the ACS Alarm System **/
        void disable_alarm_system() raises (baciErrTypeProperty::DisableAlarmsErrorEx);

        //** Returns the current status of the propagation of Property Alarms to the ACS Alarm System **/
        boolean alarm_system_enabled();

        };
        
        interface ROstringSeq : PstringSeq {
        Subscription new_subscription_Alarm (in AlarmstringSeq cb,
                                             in CBDescIn desc);

        //** Enables the propagation of Property Alarms to the ACS Alarm System **/
        void enable_alarm_system();

        //** Disables the propagation of Property Alarms to the ACS Alarm System **/
        void disable_alarm_system() raises (baciErrTypeProperty::DisableAlarmsErrorEx);

        //** Returns the current status of the propagation of Property Alarms to the ACS Alarm System **/
        boolean alarm_system_enabled();
        };
        
        
        interface RWboolean : Pboolean {
        readonly attribute boolean min_value;
        
        readonly attribute boolean max_value;
        
        ACSErr::Completion set_sync (in boolean value);
                        
        void set_async (in boolean value,
                        in CBvoid cb,
                        in CBDescIn desc);
        
        void set_nonblocking (in boolean value);
                        
        };
        
        interface ROboolean : Pboolean {
        
        Subscription new_subscription_Alarm (in Alarmboolean cb,
                                             in CBDescIn desc);
                                             
    //** Enables the propagation of Property Alarms to the ACS Alarm System **/
        void enable_alarm_system();

        //** Disables the propagation of Property Alarms to the ACS Alarm System **/
        void disable_alarm_system() raises (baciErrTypeProperty::DisableAlarmsErrorEx);

        //** Returns the current status of the propagation of Property Alarms to the ACS Alarm System **/
        boolean alarm_system_enabled();
                                             
        };
        
        interface RObooleanSeq : PbooleanSeq {
        Subscription new_subscription_Alarm (in Alarmboolean cb,
                                             in CBDescIn desc);
    
    //** Enables the propagation of Property Alarms to the ACS Alarm System **/
        void enable_alarm_system();

        //** Disables the propagation of Property Alarms to the ACS Alarm System **/
        void disable_alarm_system() raises (baciErrTypeProperty::DisableAlarmsErrorEx);

        //** Returns the current status of the propagation of Property Alarms to the ACS Alarm System **/
        boolean alarm_system_enabled();                                      
        };

        interface RWbooleanSeq : PbooleanSeq {
        readonly attribute boolean min_value;
        
        readonly attribute boolean max_value;
        
        ACSErr::Completion set_sync (in booleanSeq value);
                        
        void set_async (in booleanSeq value,
                        in CBvoid cb,
                        in CBDescIn desc);
                        
        void set_nonblocking (in booleanSeq value);
                        
        void increment (in CBvoid cb,
                        in CBDescIn desc);
                        
        void decrement (in CBvoid cb,
                        in CBDescIn desc);
                        
        };


        interface ROdoubleSeq : PdoubleSeq {
        readonly attribute double alarm_low_on;
        readonly attribute double alarm_low_off;
        readonly attribute double alarm_high_on;
        readonly attribute double alarm_high_off;
                
        Subscription new_subscription_Alarm (in Alarmdouble cb,
                                             in CBDescIn desc);
        
        //** Enables the propagation of Property Alarms to the ACS Alarm System **/
        void enable_alarm_system();

        //** Disables the propagation of Property Alarms to the ACS Alarm System **/
        void disable_alarm_system() raises (baciErrTypeProperty::DisableAlarmsErrorEx);

        //** Returns the current status of the propagation of Property Alarms to the ACS Alarm System **/
        boolean alarm_system_enabled();

        };
        
        interface RWdoubleSeq : PdoubleSeq {
        readonly attribute double min_value;
        
        readonly attribute double max_value;
        
        ACSErr::Completion set_sync (in doubleSeq value);
                        
        void set_async (in doubleSeq value,
                        in CBvoid cb,
                        in CBDescIn desc);
                        
        void set_nonblocking (in doubleSeq value);
                        
        void increment (in CBvoid cb,
                        in CBDescIn desc);
                        
        void decrement (in CBvoid cb,
                        in CBDescIn desc);
                        
        };
        
        interface ROfloatSeq : PfloatSeq {
        readonly attribute float alarm_low_on;
        readonly attribute float alarm_low_off;
        readonly attribute float alarm_high_on;
        readonly attribute float alarm_high_off;
                
        Subscription new_subscription_Alarm (in Alarmfloat cb,
                                             in CBDescIn desc);
        
        //** Enables the propagation of Property Alarms to the ACS Alarm System **/
        void enable_alarm_system();

        //** Disables the propagation of Property Alarms to the ACS Alarm System **/
        void disable_alarm_system() raises (baciErrTypeProperty::DisableAlarmsErrorEx);

        //** Returns the current status of the propagation of Property Alarms to the ACS Alarm System **/
        boolean alarm_system_enabled();

        };
        
        interface RWfloatSeq : PfloatSeq {
        readonly attribute float min_value;
        
        readonly attribute float max_value;
        
        ACSErr::Completion set_sync (in floatSeq value);
                        
        void set_async (in floatSeq value,
                        in CBvoid cb,
                        in CBDescIn desc);
                        
        void set_nonblocking (in floatSeq value);
                        
        void increment (in CBvoid cb,
                        in CBDescIn desc);
                        
        void decrement (in CBvoid cb,
                        in CBDescIn desc);
                        
        };
        
        interface ROlongSeq : PlongSeq {
        readonly attribute long alarm_low_on;
        readonly attribute long alarm_low_off;
        readonly attribute long alarm_high_on;
        readonly attribute long alarm_high_off;
        
        Subscription new_subscription_Alarm (in Alarmlong cb,
                                             in CBDescIn desc);
                        
        //** Enables the propagation of Property Alarms to the ACS Alarm System **/
        void enable_alarm_system();

        //** Disables the propagation of Property Alarms to the ACS Alarm System **/
        void disable_alarm_system() raises (baciErrTypeProperty::DisableAlarmsErrorEx);

        //** Returns the current status of the propagation of Property Alarms to the ACS Alarm System **/
        boolean alarm_system_enabled();

        };
        
        interface RWlongSeq : PlongSeq {
        readonly attribute long min_value;
        
        readonly attribute long max_value;
                
        ACSErr::Completion set_sync (in longSeq value);
                        
        void set_async (in longSeq value,
                        in CBvoid cb,
                        in CBDescIn desc);
                        
        void set_nonblocking (in longSeq value);
                        
        void increment (in CBvoid cb,
                        in CBDescIn desc);
                        
        void decrement (in CBvoid cb,
                        in CBDescIn desc);
                        
        };
        
        interface ROuLongSeq : PuLongSeq {
        readonly attribute uLong alarm_low_on;
        readonly attribute uLong alarm_low_off;
        readonly attribute uLong alarm_high_on;
        readonly attribute uLong alarm_high_off;
        
        Subscription new_subscription_Alarm (in AlarmuLong cb,
                                             in CBDescIn desc);
                                             
        //** Enables the propagation of Property Alarms to the ACS Alarm System **/
        void enable_alarm_system();

        //** Disables the propagation of Property Alarms to the ACS Alarm System **/
        void disable_alarm_system() raises (baciErrTypeProperty::DisableAlarmsErrorEx);

        //** Returns the current status of the propagation of Property Alarms to the ACS Alarm System **/
        boolean alarm_system_enabled();
                        
        };
        
        interface RWuLongSeq : PuLongSeq {
        readonly attribute uLong min_value;
        
        readonly attribute uLong max_value;
                
        ACSErr::Completion set_sync (in uLongSeq value);
                        
        void set_async (in uLongSeq value,
                        in CBvoid cb,
                        in CBDescIn desc);
                        
        void set_nonblocking (in uLongSeq value);
                        
        void increment (in CBvoid cb,
                        in CBDescIn desc);
                        
        void decrement (in CBvoid cb,
                        in CBDescIn desc);
                        
        };
        
        interface ROlong : Plong {
                readonly attribute long alarm_low_on;
                readonly attribute long alarm_low_off;
                readonly attribute long alarm_high_on;
                readonly attribute long alarm_high_off;
                
                Subscription new_subscription_Alarm (in Alarmlong cb,
                                                     in CBDescIn desc);
                        
        //** Enables the propagation of Property Alarms to the ACS Alarm System **/
        void enable_alarm_system();

        //** Disables the propagation of Property Alarms to the ACS Alarm System **/
        void disable_alarm_system() raises (baciErrTypeProperty::DisableAlarmsErrorEx);

        //** Returns the current status of the propagation of Property Alarms to the ACS Alarm System **/
        boolean alarm_system_enabled();

        };
        
        interface RWlong : Plong {
        ACSErr::Completion set_sync (in long value);
                        
        void set_async (in long value,
                        in CBvoid cb,
                        in CBDescIn desc);
                        
        void set_nonblocking (in long value);
                        
        void increment (in CBvoid cb,
                        in CBDescIn desc);
                        
        void decrement (in CBvoid cb,
                        in CBDescIn desc);
                        
        readonly attribute long max_value;
        readonly attribute long min_value;
        };
        
        interface ROuLong : PuLong {
        readonly attribute uLong alarm_low_on;
        readonly attribute uLong alarm_low_off;
        readonly attribute uLong alarm_high_on;
        readonly attribute uLong alarm_high_off;
        
        Subscription new_subscription_Alarm (in AlarmuLong cb,
                                             in CBDescIn desc);
    
    //** Enables the propagation of Property Alarms to the ACS Alarm System **/
        void enable_alarm_system();

        //** Disables the propagation of Property Alarms to the ACS Alarm System **/
        void disable_alarm_system() raises (baciErrTypeProperty::DisableAlarmsErrorEx);

        //** Returns the current status of the propagation of Property Alarms to the ACS Alarm System **/
        boolean alarm_system_enabled();                                      
        
        };

        interface RWuLong : PuLong {

        ACSErr::Completion set_sync (in uLong value);
                        
        void set_async (in uLong value,
                        in CBvoid cb,
                        in CBDescIn desc);
                        
        void set_nonblocking (in uLong value);
                        
        void increment (in CBvoid cb,
                        in CBDescIn desc);
                        
        void decrement (in CBvoid cb,
                        in CBDescIn desc);
                        
        readonly attribute uLong max_value;
        readonly attribute uLong min_value;
        };

/***********************  LONG LONG */

        interface PlongLong : TypelessProperty {
        readonly attribute TimeInterval default_timer_trigger;
        readonly attribute TimeInterval min_timer_trigger;
        readonly attribute longLong min_delta_trigger;
        readonly attribute longLong default_value;
        readonly attribute longLong graph_min;
        readonly attribute longLong graph_max;
        readonly attribute longLong min_step;
        
        longLong get_sync (out ACSErr::Completion c);
        
        void get_async (in CBlongLong cb,
                        in CBDescIn desc);
                        
        long get_history (in long n_last_values,
                          out longLongSeq vs,
                          out TimeSeq ts);
                        
        MonitorlongLong create_monitor (in CBlongLong cb,
                                        in CBDescIn desc);
        
        MonitorlongLong create_postponed_monitor (in Time start_time,
                                                  in CBlongLong cb,
                                                  in CBDescIn desc);
                        
        };

        interface AlarmlongLong : Callback {
        oneway void alarm_raised (in longLong value,
                                  in ACSErr::Completion c,
                                  in CBDescOut desc);
                        
        oneway void alarm_cleared (in longLong value,
                                   in ACSErr::Completion c,
                                   in CBDescOut desc);
        };

        interface ROlongLong : PlongLong {
        readonly attribute longLong alarm_low_on;
        readonly attribute longLong alarm_low_off;
        readonly attribute longLong alarm_high_on;
        readonly attribute longLong alarm_high_off;
                
        Subscription new_subscription_Alarm (in AlarmlongLong cb,
                                             in CBDescIn desc);
                        
        //** Enables the propagation of Property Alarms to the ACS Alarm System **/
        void enable_alarm_system();

        //** Disables the propagation of Property Alarms to the ACS Alarm System **/
        void disable_alarm_system() raises (baciErrTypeProperty::DisableAlarmsErrorEx);

        //** Returns the current status of the propagation of Property Alarms to the ACS Alarm System **/
        boolean alarm_system_enabled();

        };

        interface RWlongLong : PlongLong {
        ACSErr::Completion set_sync (in longLong value);
                        
        void set_async (in longLong value,
                        in CBvoid cb,
                        in CBDescIn desc);
                        
        void set_nonblocking (in longLong value);
                        
        void increment (in CBvoid cb,
                        in CBDescIn desc);
                        
        void decrement (in CBvoid cb,
                        in CBDescIn desc);
                        
        readonly attribute longLong max_value;
        readonly attribute longLong min_value;
        };

        /****** unsigned long long ***/



        interface PuLongLong : TypelessProperty {
        readonly attribute TimeInterval default_timer_trigger;
        readonly attribute TimeInterval min_timer_trigger;
        readonly attribute uLongLong min_delta_trigger;
        readonly attribute uLongLong default_value;
        readonly attribute uLongLong graph_min;
        readonly attribute uLongLong graph_max;
        readonly attribute uLongLong min_step;
        
        uLongLong get_sync (out ACSErr::Completion c);
                        
        void get_async (in CBuLongLong cb,
                        in CBDescIn desc);
                        
        long get_history (in  long n_last_values,
                          out uLongLongSeq vs,
                          out TimeSeq ts);
                        
        MonitoruLongLong create_monitor (in CBuLongLong cb,
                                         in CBDescIn desc);
                        
        MonitoruLongLong create_postponed_monitor (in Time start_time,
                                                   in CBuLongLong cb,
                                                   in CBDescIn desc);
                        
        };

        interface AlarmuLongLong : Callback {

        oneway void alarm_raised (in uLongLong value,
                                  in ACSErr::Completion c,
                                  in CBDescOut desc);
                        
        oneway void alarm_cleared (in uLongLong value,
                                   in ACSErr::Completion c,
                                   in CBDescOut desc);
                        
        };

        interface ROuLongLong : PuLongLong {
        readonly attribute uLongLong alarm_low_on;
        readonly attribute uLongLong alarm_low_off;
        readonly attribute uLongLong alarm_high_on;
        readonly attribute uLongLong alarm_high_off;
        
        Subscription new_subscription_Alarm (in AlarmuLongLong cb,
                                             in CBDescIn desc);
        
        //** Enables the propagation of Property Alarms to the ACS Alarm System **/
        void enable_alarm_system();

        //** Disables the propagation of Property Alarms to the ACS Alarm System **/
        void disable_alarm_system() raises (baciErrTypeProperty::DisableAlarmsErrorEx);

        //** Returns the current status of the propagation of Property Alarms to the ACS Alarm System **/
        boolean alarm_system_enabled();

        };

        interface RWuLongLong : PuLongLong {

        ACSErr::Completion set_sync (in uLongLong value);
                        
        void set_async (in uLongLong value,
                        in CBvoid cb,
                        in CBDescIn desc);
                        
        void set_nonblocking (in uLongLong value);
                        
        void increment (in CBvoid cb,
                        in CBDescIn desc);
                        
        void decrement (in CBvoid cb,
                        in CBDescIn desc);
                        
        readonly attribute uLongLong max_value;
        readonly attribute uLongLong min_value;
        };
};

#endif /* _BACI_IDL_ */