gt:         if (groupD != o.groupD) {
context: /**
   * Copyright (c) 2010-2016 by the respective copyright holders.
   *
   * All rights reserved. This program and the accompanying materials
   * are made available under the terms of the Eclipse Public License v1.0
   * which accompanies this distribution, and is available at
   * http://www.eclipse.org/legal/epl-v10.html
   */
  package org.openhab.binding.dsmr.internal.messages;
  
  import java.text.ParseException;
  import java.util.regex.Matcher;
  import java.util.regex.Pattern;
  
  /**
   * Class representing an OBISIdentifier
   *
   * @author M. Volaart
   * @since 1.7.0
   */
  public class OBISIdentifier implements Comparable<OBISIdentifier> {
      /* String representing a.b.c.d.e.f OBIS ID */
      private static final String OBISID_REGEX = "((\\d+)\\-)?((\\d+):)?((\\d+)\\.)(\\d+)(\\.(\\d+))?(\\*(\\d+))?";
  
      /* OBIS ID pattern */
      private static final Pattern obisIdPattern = Pattern.compile(OBISID_REGEX);
  
      /* the six individual group values of the OBIS ID */
      private Integer groupA;
      private Integer groupB;
      private Integer groupC;
      private Integer groupD;
      private Integer groupE;
      private Integer groupF;
  
      /**
       * Constructs a new OBIS Identifier (A.B.C.D.E.F)
       * 
       * @param groupA
       *            A value
       * @param groupB
       *            B value
       * @param groupC
       *            C value
       * @param groupD
       *            D value
       * @param groupE
       *            E value
       * @param groupF
       *            F value
       */
      public OBISIdentifier(Integer groupA, Integer groupB, Integer groupC, Integer groupD, Integer groupE,
              Integer groupF) {
          this.groupA = groupA;
          this.groupB = groupB;
          this.groupC = groupC;
          this.groupD = groupD;
          this.groupE = groupE;
          this.groupF = groupF;
      }
  
      /**
       * Creates a new OBISIdentifier of the specified String
       * 
       * @param obisIDString
       *            the OBIS String ID
       * @throws ParseException
       *             if obisIDString is not a valid OBIS Identifier
       */
      public OBISIdentifier(String obisIDString) throws ParseException {
          Matcher m = obisIdPattern.matcher(obisIDString);
  
          if (m.matches()) {
              // Optional value A
              if (m.group(2) != null) {
                  this.groupA = Integer.parseInt(m.group(2));
              }
  
              // Optional value B
              if (m.group(4) != null) {
                  this.groupB = Integer.parseInt(m.group(4));
              }
  
              // Required value C & D
              this.groupC = Integer.parseInt(m.group(6));
              this.groupD = Integer.parseInt(m.group(7));
  
              // Optional value E
              if (m.group(9) != null) {
                  this.groupE = Integer.parseInt(m.group(9));
              }
  
              // Optional value F
              if (m.group(11) != null) {
                  this.groupF = Integer.parseInt(m.group(11));
              }
          } else {
              throw new ParseException("Invalis OBIS identifier:" + obisIDString, 0);
          }
      }
  
      /**
       * @return the groupA
       */
      public Integer getGroupA() {
          return groupA;
      }
  
      /**
       * @return the groupB
       */
      public Integer getGroupB() {
          return groupB;
      }
  
      /**
       * @return the groupC
       */
      public Integer getGroupC() {
          return groupC;
      }
  
      /**
       * @return the groupD
       */
      public Integer getGroupD() {
          return groupD;
      }
  
      /**
       * @return the groupE
       */
      public Integer getGroupE() {
          return groupE;
      }
  
      /**
       * @return the groupF
       */
      public Integer getGroupF() {
          return groupF;
      }
  
      @Override
      public String toString() {
          return (groupA != null ? (groupA + "-") : "") + (groupB != null ? (groupB + ":") : "") + groupC + "." + groupD
                  + (groupE != null ? ("." + groupE) : "") + (groupF != null ? ("*" + groupF) : "");
      }
  
      @Override
      public boolean equals(Object other) {
          OBISIdentifier o;
          if (other != null && other instanceof OBISIdentifier) {
              o = (OBISIdentifier) other;
          } else {
              return false;
          }
          boolean result = true;
  
          if (groupA != null && o.groupA != null) {
              result &= (groupA.equals(o.groupA));
          }
          if (groupB != null && o.groupB != null) {
              result &= (groupB.equals(o.groupB));
          }
          result &= (groupC.equals(o.groupC));
          result &= (groupD.equals(o.groupD));
          if (groupE != null && o.groupE != null) {
              result &= (groupE.equals(o.groupE));
          }
          if (groupF != null && o.groupF != null) {
              result &= (groupF.equals(o.groupF));
          }
  
          return result;
      }
  
      @Override
      public int compareTo(OBISIdentifier o) {
          if (o == null) {
              throw new NullPointerException("Compared OBISIdentifier is null");
          }
          if (groupA != o.groupA) {
              if (groupA == null) {
                  return 1;
              } else if (o.groupA == null) {
                  return -1;
              } else {
                  return groupA.compareTo(o.groupA);
              }
          }
          if (groupB != o.groupB) {
              if (groupB == null) {
                  return 1;
              } else if (o.groupB == null) {
                  return -1;
              } else {
                  return groupB.compareTo(o.groupB);
              }
          }
          if (groupC != o.groupC) {
              return groupC.compareTo(o.groupC);
          }
  