FaultState.h

Go to the documentation of this file.

#ifndef FAULTSTATE_H_
#define FAULTSTATE_H_

#include <iostream>     
#include <memory>
#include "Properties.h"
#include "Timestamp.h"

namespace acsalarm 
{
        /*
         * Class representing a single fault state for use by cpp alarm source clients 
         * which wish to send an alarm to the laser alarm server.
         */
        class FaultState
        {       
                public:

                        FaultState();

                        FaultState(const FaultState &);

                        FaultState(std::string family, std::string member, int code);

                        /*
                         * Destructor
                         */
                        virtual ~FaultState();

                        FaultState & operator=(const FaultState & rhs);
 
                        void setCode(const int faultCode) {
                                code=faultCode;
                        }

                        int getCode() const {
                                return code;
                        }

                        void setDescriptor(const std::string & newDescriptor) {
                                descriptor=newDescriptor;
                        }

                        std::string getDescriptor() const {
                                return descriptor;
                        }

                        std::string getFamily() const {
                                return family;
                        }
         
                        std::string getMember() const {
                                return member;
                        }


                        void  setFamily(const std::string & faultFamily);

                        void  setMember(const std::string & newFaultMember);

                        virtual std::string toXML(int amountToIndent = 3);

                        virtual void setUserProperties(std::auto_ptr<acsalarm::Properties> theProperties) { userProperties = theProperties; }

                        const virtual acsalarm::Properties & getUserProperties() const { return *userProperties; }

                        virtual void setUserTimestamp(std::auto_ptr<acsalarm::Timestamp> theTimestamp) { userTimestamp = theTimestamp; }

                        const virtual acsalarm::Timestamp & getUserTimestamp() const { return *userTimestamp; }

                        virtual bool getActivatedByBackup() const { return activatedByBackup; }
                        virtual void setActivatedByBackup(bool newActivatedByBackup) { activatedByBackup = newActivatedByBackup; }

                        virtual bool getTerminatedByBackup() const { return terminatedByBackup; }
                        virtual void setTerminatedByBackup(bool newTerminatedByBackup) { terminatedByBackup = newTerminatedByBackup; }

                private:

                        std::string member;
                        std::string family;
                        std::string descriptor;
                        int code;
                        bool activatedByBackup; 
                        bool terminatedByBackup;
                        std::auto_ptr<acsalarm::Properties> userProperties;
                        std::auto_ptr<acsalarm::Timestamp> userTimestamp;
        };
};
#endif /*FAULTSTATE_H_*/