aboutsummaryrefslogtreecommitdiffstats
path: root/Software/Embedded_SW/Embedded/Communication/PMR/IO/FileInfo.pb-c.h
blob: 393b8276b72b06b426de522b90c764463cc15b74 (plain) 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81

/* Generated by the protocol buffer compiler.  DO NOT EDIT! */
/* Generated from: FileInfo.proto */

#ifndef PROTOBUF_C_FileInfo_2eproto__INCLUDED
#define PROTOBUF_C_FileInfo_2eproto__INCLUDED

#include <protobuf-c/protobuf-c.h>

PROTOBUF_C__BEGIN_DECLS

#if PROTOBUF_C_VERSION_NUMBER < 1003000
# error This file was generated by a newer version of protoc-c which is incompatible with your libprotobuf-c headers. Please update your headers.
#elif 1003000 < PROTOBUF_C_MIN_COMPILER_VERSION
# error This file was generated by an older version of protoc-c which is incompatible with your libprotobuf-c headers. Please regenerate this file with a newer version of protoc-c.
#endif

#include "FileAttribute.pb-c.h"

typedef struct _FileInfo FileInfo;


/* --- enums --- */


/* --- messages --- */

struct  _FileInfo
{
  ProtobufCMessage base;
  char *name;
  char *fullpath;
  protobuf_c_boolean has_length;
  int64_t length;
  protobuf_c_boolean has_lastmodifieddate;
  int32_t lastmodifieddate;
  protobuf_c_boolean has_lastmodifiedtime;
  int32_t lastmodifiedtime;
  protobuf_c_boolean has_attribute;
  FileAttribute attribute;
};
#define FILE_INFO__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&file_info__descriptor) \
    , NULL, NULL, 0, 0, 0, 0, 0, 0, 0, FILE_ATTRIBUTE__Unspecified }


/* FileInfo methods */
void   file_info__init
                     (FileInfo         *message);
size_t file_info__get_packed_size
                     (const FileInfo   *message);
size_t file_info__pack
                     (const FileInfo   *message,
                      uint8_t             *out);
size_t file_info__pack_to_buffer
                     (const FileInfo   *message,
                      ProtobufCBuffer     *buffer);
FileInfo *
       file_info__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   file_info__free_unpacked
                     (FileInfo *message,
                      ProtobufCAllocator *allocator);
/* --- per-message closures --- */

typedef void (*FileInfo_Closure)
                 (const FileInfo *message,
                  void *closure_data);

/* --- services --- */


/* --- descriptors --- */

extern const ProtobufCMessageDescriptor file_info__descriptor;

PROTOBUF_C__END_DECLS


#endif  /* PROTOBUF_C_FileInfo_2eproto__INCLUDED */
generated by cgit v1.3.1 (git 2.54.0) at 2026-08-01 00:55:02 +0000
//------------------------------------------------------------------------------
// <auto-generated>
// This code was generated by a tool.
// Tango Observables Generator
// 
// Changes to this file may cause incorrect behavior and will be lost if
// the code is regenerated. Do not modify!
// </auto-generated>
//------------------------------------------------------------------------------

using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel.DataAnnotations;
using System.ComponentModel.DataAnnotations.Schema;
using System.Xml.Serialization;
using Newtonsoft.Json;
using System.Linq;
using Tango.DAL.Remote.DB;
using Tango.Core;
using System.ComponentModel;
using Tango.Core.CustomAttributes;

namespace Tango.BL.Entities
{
    [Table("HARDWARE_DANCERS")]
    public abstract class HardwareDancerBase : ObservableEntity<HardwareDancer>
    {

        public event EventHandler<Boolean> GradualChanged;

        public event EventHandler<Double> KChanged;

        public event EventHandler<Double> XChanged;

        public event EventHandler<Int32> PulsePerMmSpringChanged;

        public event EventHandler<Int32> MaximalMovementMmChanged;

        public event EventHandler<Int32> ZeroPointChanged;

        public event EventHandler<Int32> ResolutionBitsChanged;

        public event EventHandler<Int32> ArmLengthChanged;

        public event EventHandler<Boolean> AssemblyDirectionRightChanged;

        public event EventHandler<Boolean> AccelerateOnTensionRaiseChanged;

        public event EventHandler<Boolean> ActiveChanged;

        public event EventHandler<HardwareDancerType> HardwareDancerTypeChanged;

        public event EventHandler<HardwareVersion> HardwareVersionChanged;

        protected String _hardwaredancertypeguid;

        /// <summary>
        /// Gets or sets the hardwaredancerbase hardware dancer type guid.
        /// </summary>

        [Column("HARDWARE_DANCER_TYPE_GUID")]
        [ForeignKey("HardwareDancerType")]

        public  String HardwareDancerTypeGuid
        {
            get 
            {
                return _hardwaredancertypeguid; 
            }

            set 
            {
                if (_hardwaredancertypeguid != value)
                {
                    _hardwaredancertypeguid = value;

                }
            }
        }

        protected String _hardwareversionguid;

        /// <summary>
        /// Gets or sets the hardwaredancerbase hardware version guid.
        /// </summary>

        [Column("HARDWARE_VERSION_GUID")]
        [ForeignKey("HardwareVersion")]

        public  String HardwareVersionGuid
        {
            get 
            {
                return _hardwareversionguid; 
            }

            set 
            {
                if (_hardwareversionguid != value)
                {
                    _hardwareversionguid = value;

                }
            }
        }

        protected Boolean _gradual;

        /// <summary>
        /// Gets or sets the hardwaredancerbase gradual.
        /// </summary>

        [Column("GRADUAL")]

        public  Boolean Gradual
        {
            get 
            {
                return _gradual; 
            }

            set 
            {
                if (_gradual != value)
                {
                    _gradual = value;

                    OnGradualChanged(value);

                }
            }
        }

        protected Double _k;

        /// <summary>
        /// Gets or sets the hardwaredancerbase k.
        /// </summary>

        [Column("K")]

        public  Double K
        {
            get 
            {
                return _k; 
            }

            set 
            {
                if (_k != value)
                {
                    _k = value;

                    OnKChanged(value);

                }
            }
        }

        protected Double _x;

        /// <summary>
        /// Gets or sets the hardwaredancerbase x.
        /// </summary>

        [Column("X")]

        public  Double X
        {
            get 
            {
                return _x; 
            }

            set 
            {
                if (_x != value)
                {
                    _x = value;

                    OnXChanged(value);

                }
            }
        }

        protected Int32 _pulsepermmspring;

        /// <summary>
        /// Gets or sets the hardwaredancerbase pulse per mm spring.
        /// </summary>

        [Column("PULSE_PER_MM_SPRING")]

        public  Int32 PulsePerMmSpring
        {
            get 
            {
                return _pulsepermmspring; 
            }

            set 
            {
                if (_pulsepermmspring != value)
                {
                    _pulsepermmspring = value;

                    OnPulsePerMmSpringChanged(value);

                }
            }
        }

        protected Int32 _maximalmovementmm;

        /// <summary>
        /// Gets or sets the hardwaredancerbase maximal movement mm.
        /// </summary>

        [Column("MAXIMAL_MOVEMENT_MM")]

        public  Int32 MaximalMovementMm
        {
            get 
            {
                return _maximalmovementmm; 
            }

            set 
            {
                if (_maximalmovementmm != value)
                {
                    _maximalmovementmm = value;

                    OnMaximalMovementMmChanged(value);

                }
            }
        }

        protected Int32 _zeropoint;

        /// <summary>
        /// Gets or sets the hardwaredancerbase zero point.
        /// </summary>

        [Column("ZERO_POINT")]

        public  Int32 ZeroPoint
        {
            get 
            {
                return _zeropoint; 
            }

            set 
            {
                if (_zeropoint != value)
                {
                    _zeropoint = value;

                    OnZeroPointChanged(value);

                }
            }
        }

        protected Int32 _resolutionbits;

        /// <summary>
        /// Gets or sets the hardwaredancerbase resolution bits.
        /// </summary>

        [Column("RESOLUTION_BITS")]

        public  Int32 ResolutionBits
        {
            get 
            {
                return _resolutionbits; 
            }

            set 
            {
                if (_resolutionbits != value)
                {
                    _resolutionbits = value;

                    OnResolutionBitsChanged(value);

                }
            }
        }

        protected Int32 _armlength;

        /// <summary>
        /// Gets or sets the hardwaredancerbase arm length.
        /// </summary>

        [Column("ARM_LENGTH")]

        public  Int32 ArmLength
        {
            get 
            {
                return _armlength; 
            }

            set 
            {
                if (_armlength != value)
                {
                    _armlength = value;

                    OnArmLengthChanged(value);

                }
            }
        }

        protected Boolean _assemblydirectionright;

        /// <summary>
        /// Gets or sets the hardwaredancerbase assembly direction right.
        /// </summary>

        [Column("ASSEMBLY_DIRECTION_RIGHT")]

        public  Boolean AssemblyDirectionRight
        {
            get 
            {
                return _assemblydirectionright; 
            }

            set 
            {
                if (_assemblydirectionright != value)
                {
                    _assemblydirectionright = value;

                    OnAssemblyDirectionRightChanged(value);

                }
            }
        }

        protected Boolean _accelerateontensionraise;

        /// <summary>
        /// Gets or sets the hardwaredancerbase accelerate on tension raise.
        /// </summary>

        [Column("ACCELERATE_ON_TENSION_RAISE")]

        public  Boolean AccelerateOnTensionRaise
        {
            get 
            {
                return _accelerateontensionraise; 
            }

            set 
            {
                if (_accelerateontensionraise != value)
                {
                    _accelerateontensionraise = value;

                    OnAccelerateOnTensionRaiseChanged(value);

                }
            }
        }

        protected Boolean _active;

        /// <summary>
        /// Gets or sets the hardwaredancerbase active.
        /// </summary>

        [Column("ACTIVE")]

        public  Boolean Active
        {
            get 
            {
                return _active; 
            }

            set 
            {
                if (_active != value)
                {
                    _active = value;

                    OnActiveChanged(value);

                }
            }
        }

        protected HardwareDancerType _hardwaredancertype;

        /// <summary>
        /// Gets or sets the hardwaredancerbase hardware dancer types.
        /// </summary>

        [XmlIgnore]
        [JsonIgnore]
        public virtual HardwareDancerType HardwareDancerType
        {
            get 
            {
                return _hardwaredancertype; 
            }

            set 
            {
                if (_hardwaredancertype != value)
                {
                    _hardwaredancertype = value;

                    if (HardwareDancerType != null)
                    {
                        HardwareDancerTypeGuid = HardwareDancerType.Guid;
                    }

                    OnHardwareDancerTypeChanged(value);

                }
            }
        }

        protected HardwareVersion _hardwareversion;

        /// <summary>
        /// Gets or sets the hardwaredancerbase hardware versions.
        /// </summary>

        [XmlIgnore]
        [JsonIgnore]
        public virtual HardwareVersion HardwareVersion
        {
            get 
            {
                return _hardwareversion; 
            }

            set 
            {
                if (_hardwareversion != value)
                {
                    _hardwareversion = value;

                    if (HardwareVersion != null)
                    {
                        HardwareVersionGuid = HardwareVersion.Guid;
                    }

                    OnHardwareVersionChanged(value);

                }
            }
        }

        /// <summary>
        /// Called when the Gradual has changed.
        /// </summary>
        protected virtual void OnGradualChanged(Boolean gradual)
        {
            GradualChanged?.Invoke(this, gradual);
            RaisePropertyChanged(nameof(Gradual));
        }

        /// <summary>
        /// Called when the K has changed.
        /// </summary>
        protected virtual void OnKChanged(Double k)
        {
            KChanged?.Invoke(this, k);
            RaisePropertyChanged(nameof(K));
        }

        /// <summary>
        /// Called when the X has changed.
        /// </summary>
        protected virtual void OnXChanged(Double x)
        {
            XChanged?.Invoke(this, x);
            RaisePropertyChanged(nameof(X));
        }

        /// <summary>
        /// Called when the PulsePerMmSpring has changed.
        /// </summary>
        protected virtual void OnPulsePerMmSpringChanged(Int32 pulsepermmspring)
        {
            PulsePerMmSpringChanged?.Invoke(this, pulsepermmspring);
            RaisePropertyChanged(nameof(PulsePerMmSpring));
        }

        /// <summary>
        /// Called when the MaximalMovementMm has changed.
        /// </summary>
        protected virtual void OnMaximalMovementMmChanged(Int32 maximalmovementmm)
        {
            MaximalMovementMmChanged?.Invoke(this, maximalmovementmm);
            RaisePropertyChanged(nameof(MaximalMovementMm));
        }

        /// <summary>
        /// Called when the ZeroPoint has changed.
        /// </summary>
        protected virtual void OnZeroPointChanged(Int32 zeropoint)
        {
            ZeroPointChanged?.Invoke(this, zeropoint);
            RaisePropertyChanged(nameof(ZeroPoint));
        }

        /// <summary>
        /// Called when the ResolutionBits has changed.
        /// </summary>
        protected virtual void OnResolutionBitsChanged(Int32 resolutionbits)
        {
            ResolutionBitsChanged?.Invoke(this, resolutionbits);
            RaisePropertyChanged(nameof(ResolutionBits));
        }

        /// <summary>
        /// Called when the ArmLength has changed.
        /// </summary>
        protected virtual void OnArmLengthChanged(Int32 armlength)
        {
            ArmLengthChanged?.Invoke(this, armlength);
            RaisePropertyChanged(nameof(ArmLength));
        }

        /// <summary>
        /// Called when the AssemblyDirectionRight has changed.
        /// </summary>
        protected virtual void OnAssemblyDirectionRightChanged(Boolean assemblydirectionright)
        {
            AssemblyDirectionRightChanged?.Invoke(this, assemblydirectionright);
            RaisePropertyChanged(nameof(AssemblyDirectionRight));
        }

        /// <summary>
        /// Called when the AccelerateOnTensionRaise has changed.
        /// </summary>
        protected virtual void OnAccelerateOnTensionRaiseChanged(Boolean accelerateontensionraise)
        {
            AccelerateOnTensionRaiseChanged?.Invoke(this, accelerateontensionraise);
            RaisePropertyChanged(nameof(AccelerateOnTensionRaise));
        }

        /// <summary>
        /// Called when the Active has changed.
        /// </summary>
        protected virtual void OnActiveChanged(Boolean active)
        {
            ActiveChanged?.Invoke(this, active);
            RaisePropertyChanged(nameof(Active));
        }

        /// <summary>
        /// Called when the HardwareDancerType has changed.
        /// </summary>
        protected virtual void OnHardwareDancerTypeChanged(HardwareDancerType hardwaredancertype)
        {
            HardwareDancerTypeChanged?.Invoke(this, hardwaredancertype);
            RaisePropertyChanged(nameof(HardwareDancerType));
        }

        /// <summary>
        /// Called when the HardwareVersion has changed.
        /// </summary>
        protected virtual void OnHardwareVersionChanged(HardwareVersion hardwareversion)
        {
            HardwareVersionChanged?.Invoke(this, hardwareversion);
            RaisePropertyChanged(nameof(HardwareVersion));
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="HardwareDancerBase" /> class.
        /// </summary>
        public HardwareDancerBase() : base()
        {
        }
    }
}
generated by cgit v1.3.1 (git 2.54.0) at 2026-08-01 00:55:02 +0000