public EntityGroundVehicle(INETWISEDriverSink2 WISE, DatabaseHandle databaseHandle, ObjectHandle objectHandle, TransactionHandle transactionHandle)
 {
     this.WISE = WISE;
     this.Database = databaseHandle;
     this.Object = objectHandle;
     this.Transaction = transactionHandle;
 }

 public EntityEquipmentSensorCBRNAP2Ce(INETWISEDriverSink2 WISE, DatabaseHandle databaseHandle, ObjectHandle objectHandle, TransactionHandle transactionHandle)
 {
     this.WISE = WISE;
     this.Database = databaseHandle;
     this.Object = objectHandle;
     this.Transaction = transactionHandle;
 }

 public EntityEquipment(INETWISEDriverSink2 WISE, DatabaseHandle databaseHandle, ObjectHandle objectHandle)
 {
     this.WISE = WISE;
     this.Database = databaseHandle;
     this.Object = objectHandle;
     this.Transaction = TransactionHandle.None;
 }

 public WISEObject(INETWISEDriverSink2 WISE, DatabaseHandle databaseHandle, ObjectHandle objectHandle, TransactionHandle transactionHandle)
 {
     this.WISE = WISE;
     this.Database = databaseHandle;
     this.Object = objectHandle;
     this.Transaction = transactionHandle;
 }

        protected override WISE_RESULT OnCloseDatabase(DatabaseHandle hDatabase)
        {
            WISE_RESULT result = WISEError.WISE_OK;

            // Call base class implementation
            result = base.OnCloseDatabase(hDatabase);
            WISEError.CheckCallFailedEx(result);

            //
            // TODO: Close driver communication for the specified database.
            //

            _serviceHost.Close();

            return WISEError.WISE_OK;
        }

        public uint CreateInstance(INETWISEDriverSink2 WISE, DatabaseHandle hDatabase, string objectName)
        {
            uint result = WISEError.WISE_ERROR;
            ObjectHandle objectHandle = this.Object;

            if (WISE == null)
            {
                result = WISEError.WISE_E_INVALID_ARG;
                return result;
            }

            if (objectHandle == WISEConstants.WISE_INVALID_HANDLE)
            {
                // Create object from template, if none exist.
                Dictionary<string, AttributeHandle> attributes = new Dictionary<string, AttributeHandle>(); // it's set from Template
                result = WISE.CreateObjectFromTemplate(hDatabase, objectName, EntityGroundVehicle.ClassName, ref objectHandle, ref attributes);
            }

            if (WISEError.CheckCallSucceeded(result))
            {
                this.WISE = WISE;
                this.Database = WISEConstants.WISE_INVALID_HANDLE;
                this.Object = objectHandle;
            }

            return result;
        }

 public EntityEquipmentSensorCBRNI28(INETWISEDriverSink2 WISE, DatabaseHandle databaseHandle, ObjectHandle objectHandle)
     : base(WISE, databaseHandle, objectHandle)
 {
 }

 public WISE_RESULT CreateInstance(INETWISEDriverSink sink, DatabaseHandle hDatabase)
 {
     return CreateInstance(sink, hDatabase, "");
 }

 public EntityEquipmentSensorCBRNLCD(INETWISEDriverSink2 WISE, DatabaseHandle databaseHandle, ObjectHandle objectHandle, TransactionHandle transactionHandle)
     : base(WISE, databaseHandle, objectHandle, transactionHandle)
 {
 }

        protected override WISE_RESULT OnSendEvent(DateTime timeStamp, DatabaseHandle hDatabase, EventHandle hEvent,
            ClassHandle hClass, TransactionHandle hTransaction)
        {
            WISE_RESULT result = WISEError.WISE_OK;

            // Call base class implementation
            result = base.OnSendEvent(timeStamp, hDatabase, hEvent, hClass, hTransaction);
            WISEError.CheckCallFailedEx(result);

            try
            {
                //
                // TODO: Send event on driver communication interface.
                //
                // This method typically needs to perform the following steps;
                //   1. Identify the type of event.
                //   2. Based on the event type, extract event attributes.
                //   3. Fill event attribute values into the protocol container associated with the event.
                //   4. Send the event on the underlying protocol.
                //

                #region Sample code: Check event type
                //ClassHandle hTestEventClass = ClassHandle.Invalid;

                //// Get handle corresponding to class "TEST_EVENT" (this can be done once and then cached)
                //result = this.WISETypeInfo.GetWISEClassHandle(hDatabase, "TEST_EVENT", ref hTestEventClass);
                //WISEError.CheckCallFailedEx(result);

                //if (hClass == hTestEventClass)
                //{
                //    #region Sample code: Access TEST_EVENT attributes
                //    string stringAttributeValue = "";
                //    AttributeHandle hAttr = AttributeHandle.Invalid;

                //    result = this.Sink.GetEventAttributeHandle(hDatabase, hEvent, "TEST_STRING", ref hAttr);
                //    WISEError.CheckCallFailedEx(result);

                //    result = this.Sink.GetEventAttributeValue(hDatabase, hEvent, hAttr, ref stringAttributeValue);
                //    WISEError.CheckCallFailedEx(result);
                //    #endregion
                //}
                #endregion
            }
            catch (WISEException ex)
            {
                result = ex.Error.ErrorCode;
            }
            return result;
        }

        protected override WISE_RESULT OnCreateDatabase(string strDatabaseName, DatabaseHandle hDatabase,
            DatabaseHandle hTemplateDatabase, DatabaseDistType eDatabaseDistType, DatabaseType eDatabaseType,
            OwnershipMode eModeOwnership, AttributeQualityMode eModeAttributeQuality,
            AttributeTimeMode eModeAttributeTime)
        {
            WISE_RESULT result = WISEError.WISE_OK;

            // Call base class implementation
            result = base.OnCreateDatabase(strDatabaseName, hDatabase, hTemplateDatabase, eDatabaseDistType,
                                eDatabaseType, eModeOwnership, eModeAttributeQuality, eModeAttributeTime);
            WISEError.CheckCallFailedEx(result);

            if (eDatabaseType == DatabaseType.Application)
            {
                //
                // TODO: Open driver communication for the specified database.
                //

                Uri baseAddress = new Uri(string.Format("{0}:{1}", _baseAddress, _port));

                IService service = new Service(this.WISE, hDatabase);
                _serviceHost = new WebServiceHost(service, baseAddress);

                ServiceEndpoint serviceEndpoint = _serviceHost.AddServiceEndpoint(typeof(IService), new WebHttpBinding(), "");

                WebHttpBehavior webHttpBehavior = _serviceHost.Description.Behaviors.Find<WebHttpBehavior>();

                if (webHttpBehavior != null)
                {
                    webHttpBehavior.AutomaticFormatSelectionEnabled = true;
                }
                else
                {
                    WebHttpBehavior webBehavior = new WebHttpBehavior();
                    webBehavior.AutomaticFormatSelectionEnabled = true;
                    serviceEndpoint.Behaviors.Add(webBehavior);
                }

                //
                // Enable metadata
                //

                //ServiceMetadataBehavior metadataBehavior = new ServiceMetadataBehavior();
                //metadataBehavior.MetadataExporter.PolicyVersion = PolicyVersion.Policy15;
                //metadataBehavior.HttpGetEnabled = true;
                //_serviceHost.Description.Behaviors.Add(metadataBehavior);

                //_serviceHost.AddServiceEndpoint(typeof(IMetadataExchange),
                //MetadataExchangeBindings.CreateMexHttpBinding(), "mex");

                //WebHttpBinding webHttpBinding = new WebHttpBinding();
                //webHttpBinding.

                //_serviceHost.AddServiceEndpoint(typeof(IService), webHttpBinding, "");

                // Initialize generated code.
                // TODO: handle error code
                Model.InitializeModel(this.WISE);

                _serviceHost.Open();
            }

            return WISEError.WISE_OK;
        }

 public CBRNLCDControl(INETWISEDriverSink2 WISE, DatabaseHandle databaseHandle, EventHandle eventHandle)
 {
     this.WISE = WISE;
     this.Database = databaseHandle;
     this.Handle = eventHandle;
 }

        public uint CreateInstance(INETWISEDriverSink2 WISE, DatabaseHandle hDatabase)
        {
            uint result = WISEError.WISE_ERROR;
            EventHandle eventHandle = this.Handle;

            if (WISE == null)
            {
                result = WISEError.WISE_E_INVALID_ARG;
                return result;
            }

            if (eventHandle == WISEConstants.WISE_INVALID_HANDLE)
            {
                // Create event from template, if none exist.
                Dictionary<string, AttributeHandle> attributes = new Dictionary<string, AttributeHandle>();
                result = WISE.CreateEventFromTemplate(hDatabase, CBRNLCDControl.ClassName, ref eventHandle, ref attributes);
            }

            if (WISEError.CheckCallSucceeded(result))
            {
                this.WISE = WISE;
                this.Database = WISEConstants.WISE_INVALID_HANDLE;
                this.Handle = eventHandle;
            }

            return result;
        }

 public EntityEquipmentSensor(INETWISEDriverSink sink, DatabaseHandle databaseHandle, ObjectHandle objectHandle)
 {
     this.WISESink = sink;
     this.Database = databaseHandle;
     this.Handle = objectHandle;
 }

		public abstract WISE_RESULT AddToDatabase(DatabaseHandle databaseHandle);

		public abstract WISE_RESULT CreateInstance(INETWISEDriverSink2 WISE, DatabaseHandle hDatabase, string objectName);

        protected override WISE_RESULT OnCommitTransaction(System.DateTime timeStamp, DatabaseHandle hDatabase, TransactionHandle hTransaction,
                ObjectHandleList newObjects, ObjectHandleList removedObjects, Dictionary<ObjectHandle, List<AttributeHandle>> dictNewAttributes,
                Dictionary<ObjectHandle, List<AttributeHandle>> dictRemovedAttributes,
                Dictionary<ObjectHandle, List<AttributeHandle>> dictUpdatedAttributes, List<EventHandle> newEvents)
        {
            //
            // TODO:
            //      If your protocol handles transactions, process the transaction data here.
            //      Returning WISE_E_NOT_IMPL from this method will trigger the driver base class to use the
            //      fallback behaviour where each change in the transaction is processed individually
            //      through calls to OnAddObject, OnRemoveObject, OnNewAttribute, OnRemoveAttribute,
            //      OnUpdateAttribute and OnSendEvent respectively.
            //

            return WISEError.WISE_E_NOT_IMPL;
        }

        public uint SendEventToDatabase(DatabaseHandle databaseHandle)
        {
            uint result = WISEError.WISE_ERROR;

            if (this.WISE == null)
            {
                result = WISEError.WISE_E_INVALID_ARG;
                return result;
            }

            result = this.WISE.SendEvent(databaseHandle, this.Handle);

            if (WISEError.CheckCallSucceeded(result))
            {
                this.Database = databaseHandle;
            }
            return result;
        }

        protected override WISE_RESULT OnConnectDatabase(string strDatabaseName, DatabaseHandle hDatabase,
            DatabaseDistType eDatabaseDistType, DatabaseType eDatabaseType, OwnershipMode eModeOwnership,
            AttributeQualityMode eModeAttributeQuality, AttributeTimeMode eModeAttributeTime)
        {
            WISE_RESULT result = WISEError.WISE_OK;

            // Implementation of this method is optional.

            // Call base class implementation
            result = base.OnConnectDatabase(strDatabaseName, hDatabase, eDatabaseDistType, eDatabaseType,
                                eModeOwnership, eModeAttributeQuality, eModeAttributeTime);
            WISEError.CheckCallFailedEx(result);

            if (eDatabaseType == DatabaseType.Application)
            {
                //
                // TODO: Open driver communication for the specified database.
                //
            }

            return WISEError.WISE_OK;
        }

        protected override WISE_RESULT OnUpdateAttribute(DateTime timeStamp, DatabaseHandle hDatabase, ObjectHandle hObject,
            ClassHandle hClass, AttributeHandle hAttribute, object value, AttributeQualityCode quality,
            TransactionHandle hTransaction)
        {
            WISE_RESULT result = WISEError.WISE_OK;

            // Call base class implementation
            result = base.OnUpdateAttribute(timeStamp, hDatabase, hObject, hClass, hAttribute, value, quality, hTransaction);
            WISEError.CheckCallFailedEx(result);

            //string myValue = string.Empty;
            //AttributeHandle myAttributeHandle = AttributeHandle.Invalid;
            //this.WISE.GetAttributeHandle(hDatabase, hObject, "SomeAttribute", ref myAttributeHandle);
            //this.WISE.GetAttributeValue(hDatabase, hObject, myAttributeHandle, ref myValue);

            //global::CBRNSensors.EntityEquipmentSensorCBRNLCD stateObject = new global::CBRNSensors.EntityEquipmentSensorCBRNLCD();
            //stateObject.CreateInstance(this.WISE, hDatabase);
            //stateObject.SensorState =
            //stateObject.AddToDatabase(hDatabase);

            return result;
        }