public MappingEntry(PlcObject plcObject)
 {
     PlcObject   = plcObject ?? ExceptionThrowHelper.ThrowArgumentNullException <PlcObject>(nameof(plcObject));
     BaseBinding = new PlcObjectBinding(new PlcRawData(plcObject.ByteSize), plcObject, 0, 0, true);
     Variables   = new Dictionary <string, Tuple <int, PlcObject> >();
     Bindings    = new Dictionary <string, PlcObjectBinding>();
 }
Beispiel #2
0
        public object Deserialize(Type t, byte[] data)
        {
            var binding = _mappingEntryProvider.GetMappingEntryForType(t).BaseBinding;

            if (data.Length < binding.Size)
            {
                ExceptionThrowHelper.ThrowArgumentOutOfRangeException(nameof(data));
            }
            return(binding.ConvertFromRaw(data));
        }
Beispiel #3
0
        /// <summary>
        /// Return all variable names of an mapping
        /// </summary>
        /// <param name="mapping"></param>
        /// <returns></returns>
        public IEnumerable <string> GetVariablesOf(string mapping)
        {
            var result = new List <string>();

            if (EntriesByName.TryGetValue(mapping, out IEntry entry))
            {
                return(PlcObjectResolver.GetLeafs(entry.PlcObject, result));
            }
            ExceptionThrowHelper.ThrowMappingNotFoundException(mapping);
            return(null);
        }
Beispiel #4
0
 /// <summary>
 /// Sequential Equal with offset and length specification
 /// </summary>
 /// <typeparam name="TSource"></typeparam>
 /// <param name="first"></param>
 /// <param name="firstStartIndex"></param>
 /// <param name="second"></param>
 /// <param name="secondStartIndex"></param>
 /// <param name="length"></param>
 /// <param name="comparer"></param>
 /// <returns></returns>
 public static bool SequenceEqual <TSource>(this IEnumerable <TSource> first, int firstStartIndex, IEnumerable <TSource> second, int secondStartIndex, int length = -1, IEqualityComparer <TSource> comparer = null)
 {
     if (comparer == null)
     {
         comparer = EqualityComparer <TSource> .Default;
     }
     ;
     if (first == null)
     {
         ExceptionThrowHelper.ThrowArgumentNullException(nameof(first));
     }
     if (second == null)
     {
         ExceptionThrowHelper.ThrowArgumentNullException(nameof(second));
     }
     using (var e1 = first.GetEnumerator())
         using (var e2 = second.GetEnumerator())
         {
             var skip = Math.Max(firstStartIndex, secondStartIndex);
             for (int i = 0; i < skip; i++)
             {
                 if (i < firstStartIndex)
                 {
                     e1.MoveNext();
                 }
                 if (i < secondStartIndex)
                 {
                     e2.MoveNext();
                 }
             }
             var index = 0;
             while (e1.MoveNext())
             {
                 if (!(e2.MoveNext() && comparer.Equals(e1.Current, e2.Current)))
                 {
                     return(false);
                 }
                 index++;
                 if (length > 0 && index >= length)
                 {
                     return(true);
                 }
             }
             if (e2.MoveNext())
             {
                 return(false);
             }
         }
     return(true);
 }
Beispiel #5
0
        /// <summary>
        /// Add a type with and a list og MappingAttributes to register this type as an mapping for read and write operations
        /// </summary>
        /// <param name="type">Could be any type</param>
        /// <param name="mappingAttributes">mappings to add</param>
        /// <returns></returns>
        public bool AddMapping(Type type, params MappingAttribute[] mappingAttributes)
        {
            if (type == null)
            {
                ExceptionThrowHelper.ThrowArgumentNullException <Type>(nameof(type));
            }

            if (!mappingAttributes.Any())
            {
                ExceptionThrowHelper.ThrowMappingAttributeNotFoundForTypeException(type);
            }

            return(AddMappingsInternal(type, mappingAttributes));
        }
Beispiel #6
0
        /// <summary>
        /// Add a type with an MappingAttribute to register this type as an mapping for read and write operations
        /// </summary>
        /// <param name="type">Has to be a type with at least one MappingAttribute</param>
        /// <returns></returns>
        public bool AddMapping(Type type)
        {
            if (type == null)
            {
                ExceptionThrowHelper.ThrowArgumentNullException <Type>(nameof(type));
            }

            var mappingAttributes = type.GetTypeInfo().GetCustomAttributes <MappingAttribute>().ToList();

            if (!mappingAttributes.Any())
            {
                ExceptionThrowHelper.ThrowMappingAttributeNotFoundForTypeException(type);
            }
            return(AddMappingsInternal(type, mappingAttributes));
        }
Beispiel #7
0
 public PlcDataMapper(int pduSize,
                      ReadOperation readEventHandler,
                      WriteOperation writeEventHandler,
                      UpdateMonitoring updateHandler,
                      ReadBlockInfo blockInfoHandler,
                      OptimizerType optimizer = OptimizerType.Block)
 {
     PduSize            = pduSize;
     _readEventHandler  = readEventHandler;
     _writeEventHandler = writeEventHandler;
     _updateHandler     = updateHandler;
     _blockInfoHandler  = blockInfoHandler;
     Optimizer          = OptimizerFactory.CreateOptimizer(optimizer);
     ReadDataBlockSize  = pduSize - _readDataHeaderLength;
     if (ReadDataBlockSize <= 0)
     {
         ExceptionThrowHelper.ThrowInvalidPduSizeException(_readDataHeaderLength);
     }
     PlcMetaDataTreePath.CreateAbsolutePath(PlcObjectResolver.RootNodeName);
 }