git.basschouten.com Git - openhab-addons.git/blob

   1 /**
   2  * Copyright (c) 2010-2020 Contributors to the openHAB project
   3  *
   4  * See the NOTICE file(s) distributed with this work for additional
   5  * information.
   6  *
   7  * This program and the accompanying materials are made available under the
   8  * terms of the Eclipse Public License 2.0 which is available at
   9  * http://www.eclipse.org/legal/epl-2.0
  10  *
  11  * SPDX-License-Identifier: EPL-2.0
  12  */
  13 package org.openhab.io.transport.modbus;
  14
  15 import java.util.Iterator;
  16 import java.util.stream.IntStream;
  17
  18 import org.eclipse.jdt.annotation.NonNullByDefault;
  19
  20 /**
  21  * Immutable {@link ModbusRegisterArray} implementation
  22  *
  23  * @author Sami Salonen - Initial contribution
  24  */
  25 @NonNullByDefault
  26 public class ModbusRegisterArray implements Iterable<ModbusRegister> {
  27
  28     private final ModbusRegister[] registers;
  29
  30     /**
  31      * Construct plain <code>ModbusRegister[]</code> array from register values
  32      *
  33      * @param registerValues register values, each <code>int</code> corresponding to one register
  34      * @return
  35      */
  36     public static ModbusRegister[] registersFromValues(int... registerValues) {
  37         ModbusRegister[] registers = new ModbusRegister[registerValues.length];
  38         for (int i = 0; i < registerValues.length; i++) {
  39             registers[i] = new ModbusRegister(registerValues[i]);
  40         }
  41         return registers;
  42     }
  43
  44     /**
  45      * Construct ModbusRegisterArrayImpl from array of {@link ModbusRegister}
  46      *
  47      * @param registers
  48      */
  49     public ModbusRegisterArray(ModbusRegister[] registers) {
  50         this.registers = registers;
  51     }
  52
  53     /**
  54      * Construct plain <code>ModbusRegisterArrayImpl</code> array from register values
  55      *
  56      * @param registerValues register values, each <code>int</code> corresponding to one register
  57      * @return
  58      */
  59     public ModbusRegisterArray(int... registerValues) {
  60         this(registersFromValues(registerValues));
  61     }
  62
  63     /**
  64      * Return register at the given index
  65      *
  66      * Index 0 matches first register (lowest register index).
  67      * <p>
  68      *
  69      * @param index the index of the register to be returned.
  70      * @throws IndexOutOfBoundsException if the index is out of bounds.
  71      */
  72     public ModbusRegister getRegister(int index) {
  73         return registers[index];
  74     }
  75
  76     /**
  77      * Get number of registers stored in this instance
  78      *
  79      * @return
  80      */
  81     public int size() {
  82         return registers.length;
  83     }
  84
  85     @Override
  86     public String toString() {
  87         if (registers.length == 0) {
  88             return "ModbusRegisterArrayImpl(<empty>)";
  89         }
  90         StringBuffer buffer = new StringBuffer(registers.length * 2).append("ModbusRegisterArrayImpl(");
  91         return appendHexString(buffer).append(')').toString();
  92     }
  93
  94     /**
  95      * Iterator over all the registers
  96      */
  97     @Override
  98     public Iterator<ModbusRegister> iterator() {
  99         return IntStream.range(0, size()).mapToObj(i -> getRegister(i)).iterator();
 100     }
 101
 102     /**
 103      * Get register data as a hex string
 104      *
 105      * For example, 04 45 00 00
 106      *
 107      * @return string representing the bytes of the register array
 108      */
 109     public String toHexString() {
 110         if (size() == 0) {
 111             return "";
 112         }
 113         // Initialize capacity to (n*2 + n-1), two chars per byte + spaces in between
 114         StringBuffer buffer = new StringBuffer(size() * 2 + (size() - 1));
 115         return appendHexString(buffer).toString();
 116     }
 117
 118     /**
 119      * Appends the register data as hex string to the given StringBuffer
 120      *
 121      */
 122     public StringBuffer appendHexString(StringBuffer buffer) {
 123         IntStream.range(0, size()).forEachOrdered(index -> {
 124             getRegister(index).appendHexString(buffer);
 125             if (index < size() - 1) {
 126                 buffer.append(' ');
 127             }
 128         });
 129         return buffer;
 130     }
 131 }