GroupedAvpImpl.java

/*
 * Mobicents, Communications Middleware
 * 
 * Copyright (c) 2008, Red Hat Middleware LLC or third-party contributors as
 * indicated by the @author tags or express copyright attribution
 * statements applied by the authors.  All third-party contributions are
 * distributed under license by Red Hat Middleware LLC.
 *
 * This copyrighted material is made available to anyone wishing to use, modify, 
 * copy, or redistribute it subject to the terms and conditions of the GNU
 * Lesser General Public License, as published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful, but 
 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
 * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License
 * for more details.
 *
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this distribution; if not, write to:
 * Free Software Foundation, Inc.
 * 51 Franklin Street, Fifth Floor
 *
 * Boston, MA  02110-1301  USA
 */
package org.mobicents.slee.resource.diameter.base.events.avp;

import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.List;

import net.java.slee.resource.diameter.base.events.avp.Address;
import net.java.slee.resource.diameter.base.events.avp.AvpNotAllowedException;
import net.java.slee.resource.diameter.base.events.avp.AvpUtilities;
import net.java.slee.resource.diameter.base.events.avp.DiameterAvp;
import net.java.slee.resource.diameter.base.events.avp.DiameterAvpType;
import net.java.slee.resource.diameter.base.events.avp.DiameterIdentity;
import net.java.slee.resource.diameter.base.events.avp.DiameterURI;
import net.java.slee.resource.diameter.base.events.avp.GroupedAvp;

import org.jdiameter.api.Avp;
import org.jdiameter.api.AvpSet;
import org.mobicents.diameter.dictionary.AvpDictionary;
import org.mobicents.diameter.dictionary.AvpRepresentation;

/**
 * 
 * GroupedAvpImpl.java
 *
 * <br>Super project:  mobicents
 * <br>12:05:02 PM Jul 8, 2008 
 * <br>
 * @author <a href = "mailto:baranowb@gmail.com"> Bartosz Baranowski </a> 
 * @author <a href = "mailto:brainslog@gmail.com"> Alexandre Mendonca </a> 
 * @author Erick Svenson
 */
public class GroupedAvpImpl extends DiameterAvpImpl implements GroupedAvp {

  protected AvpSet avpSet;

  public GroupedAvpImpl(int code, long vendorId, int mnd, int prt, byte[] value)
  {
    super(code, vendorId, mnd, prt, value, DiameterAvpType.GROUPED);
    
    try {
      avpSet = parser.decodeAvpSet(value);
    }
    catch ( IOException e ) {
      log.error("Failure creating Grouped AVP.", e);
    }
  }

  public DiameterAvp[] getExtensionAvps()
  {
    DiameterAvp[] acc = new DiameterAvp[0];

    try {
      acc = getExtensionAvpsInternal(avpSet);
    }
    catch ( Exception e ) {
      log.error("Failure getting Extension AVPs.", e);
    }

    return acc;
  }

  public boolean hasExtensionAvps() {
    return getExtensionAvps().length > 0;
  }

  public void setExtensionAvps(DiameterAvp[] extensions) throws AvpNotAllowedException
  {
    if(extensions == null) {
      return;
    }
    
    try
    {
      for (DiameterAvp avp : extensions) {
        addAvp( avp, avpSet );
      }
    }
    catch (Exception e) {
      log.error("Failure setting Extension AVPs.", e);
    }
  }

  public double doubleValue() {
    throw new IllegalArgumentException();
  }

  public float floatValue() {
    throw new IllegalArgumentException();
  }

  public int intValue() {
    throw new IllegalArgumentException();
  }

  public long longValue() {
    throw new IllegalArgumentException();
  }

  public String stringValue() {
    throw new IllegalArgumentException();
  }

  public byte[] byteArrayValue() {
    return parser.encodeAvpSet(avpSet);
  }

  public Object clone() {
    return new GroupedAvpImpl(code, vendorId, mnd, prt, byteArrayValue());
  }

  private void addAvp(DiameterAvp avp, AvpSet set)
  {
    // FIXME: alexandre: Should we look at the types and add them with proper function?
    if(avp instanceof GroupedAvp)
    {
      AvpSet avpSet = set.addGroupedAvp(avp.getCode(), avp.getVendorId(), avp.getMandatoryRule() == 1, avp.getProtectedRule() == 1);

      DiameterAvp[] groupedAVPs = ((GroupedAvp)avp).getExtensionAvps();
      for(DiameterAvp avpFromGroup : groupedAVPs)
      {
        addAvp(avpFromGroup, avpSet);
      }
    }
    else if(avp  !=  null)
      set.addAvp(avp.getCode(), avp.byteArrayValue(), avp.getVendorId(), avp.getMandatoryRule() == 1, avp.getProtectedRule() == 1);
  }

  private DiameterAvp[] getExtensionAvpsInternal(AvpSet set) throws Exception
  {
    List<DiameterAvp> acc = new ArrayList<DiameterAvp>();

    for (Avp a : set) 
    {
      // FIXME: alexandre: This is how I can check if it's a Grouped AVP... 
      // should use dictionary (again). a.getGrouped() get's into deadlock.
      if(a.getRaw().length == 0)
      {
        GroupedAvpImpl gAVP = new GroupedAvpImpl(a.getCode(), a.getVendorId(), 
            a.isMandatory() ? 1 : 0, a.isEncrypted() ? 1: 0, a.getRaw());

        gAVP.setExtensionAvps( getExtensionAvpsInternal(a.getGrouped()) );

        // This is a grouped AVP... let's make it like that.
        acc.add( gAVP );
      }
      else
      {
        acc.add(new DiameterAvpImpl(a.getCode(), a.getVendorId(), 
            a.isMandatory() ? 1 : 0, a.isEncrypted() ? 1 : 0, a.getRaw(), null));
      }
    }

    return acc.toArray(new DiameterAvp[0]);
  }  

  // AVP Utilities Proxy Methods
  
  protected Date getAvpAsTime(int code)
  {
    return AvpUtilities.getAvpAsTime(code, avpSet);
  }

  protected Date getAvpAsTime(int code, long vendorId)
  {
    return AvpUtilities.getAvpAsTime(code, vendorId, avpSet);
  }

  protected Date[] getAvpsAsTime(int code)
  {
    return AvpUtilities.getAvpsAsTime(code, avpSet);
  }

  protected Date[] getAvpsAsTime(int code, long vendorId)
  {
    return AvpUtilities.getAvpsAsTime(code, vendorId, avpSet);
  }

  protected void setAvpAsTime(int code, long vendorId, Date value, boolean isMandatory, boolean isProtected)
  {
    AvpUtilities.setAvpAsTime(null, code, vendorId, avpSet, isMandatory, isProtected, value);
  }

  protected float getAvpAsFloat32(int code)
  {
    return AvpUtilities.getAvpAsFloat32(code, avpSet);
  }

  protected float getAvpAsFloat32(int code, long vendorId)
  {
    return AvpUtilities.getAvpAsFloat32(code, vendorId, avpSet);
  }

  protected float[] getAvpsAsFloat32(int code)
  {
    return AvpUtilities.getAvpsAsFloat32(code, avpSet);
  }

  protected float[] getAvpsAsFloat32(int code, long vendorId)
  {
    return AvpUtilities.getAvpsAsFloat32(code, vendorId, avpSet);
  }

  protected void setAvpAsFloat32(int code, long vendorId, float value, boolean isMandatory, boolean isProtected)
  {
    AvpUtilities.setAvpAsFloat32(null, code, vendorId, avpSet, isMandatory, isProtected, value);
  }

  protected double getAvpAsFloat64(int code)
  {
    return AvpUtilities.getAvpAsFloat64(code, avpSet);
  }

  protected double getAvpAsFloat64(int code, long vendorId)
  {
    return AvpUtilities.getAvpAsFloat64(code, vendorId, avpSet);
  }

  protected double[] getAvpsAsFloat64(int code)
  {
    return AvpUtilities.getAvpsAsFloat64(code, avpSet);
  }

  protected double[] getAvpsAsFloat64(int code, long vendorId)
  {
    return AvpUtilities.getAvpsAsFloat64(code, vendorId, avpSet);
  }

  protected void setAvpAsFloat64(int code, long vendorId, float value, boolean isMandatory, boolean isProtected)
  {
    AvpUtilities.setAvpAsFloat64(null, code, vendorId, avpSet, isMandatory, isProtected, value);
  }

  protected byte[] getAvpAsGrouped(int code)
  {
    return AvpUtilities.getAvpAsGrouped(code, avpSet);
  }

  protected byte[] getAvpAsGrouped(int code, long vendorId)
  {
    return AvpUtilities.getAvpAsGrouped(code, vendorId, avpSet);
  }

  protected byte[][] getAvpsAsGrouped(int code)
  {
    return AvpUtilities.getAvpsAsGrouped(code, avpSet);
  }

  protected byte[][] getAvpsAsGrouped(int code, long vendorId)
  {
    return AvpUtilities.getAvpsAsGrouped(code, vendorId, avpSet);
  }

  protected AvpSet setAvpAsGrouped(int code, long vendorId, DiameterAvp[] childs, boolean isMandatory, boolean isProtected)
  {
    return AvpUtilities.setAvpAsGrouped(null, code, vendorId, avpSet, isMandatory, isProtected, childs);
  }

  protected int getAvpAsInteger32(int code)
  {
    return AvpUtilities.getAvpAsInteger32(code, avpSet);
  }

  protected int getAvpAsInteger32(int code, long vendorId)
  {
    return AvpUtilities.getAvpAsInteger32(code, vendorId, avpSet);
  }

  protected int[] getAvpsAsInteger32(int code)
  {
    return AvpUtilities.getAvpsAsInteger32(code, avpSet);
  }

  protected int[] getAvpsAsInteger32(int code, long vendorId)
  {
    return AvpUtilities.getAvpsAsInteger32(code, vendorId, avpSet);
  }

  protected void setAvpAsInteger32(int code, long vendorId, int value, boolean isMandatory, boolean isProtected)
  {
    AvpUtilities.setAvpAsInteger32(null, code, vendorId, avpSet, isMandatory, isProtected, value);
  }

  protected long getAvpAsInteger64(int code)
  {
    return AvpUtilities.getAvpAsInteger64(code, avpSet);
  }

  protected long getAvpAsInteger64(int code, long vendorId)
  {
    return AvpUtilities.getAvpAsInteger64(code, vendorId, avpSet);
  }

  protected long[] getAvpsAsInteger64(int code)
  {
    return AvpUtilities.getAvpsAsInteger64(code, avpSet);
  }

  protected long[] getAvpsAsInteger64(int code, long vendorId)
  {
    return AvpUtilities.getAvpsAsInteger64(code, vendorId, avpSet);
  }

  protected void setAvpAsInteger64(int code, long vendorId, long value, boolean isMandatory, boolean isProtected)
  {
    AvpUtilities.setAvpAsInteger64(null, code, vendorId, avpSet, isMandatory, isProtected, value);
  }

  protected long getAvpAsUnsigned32(int code)
  {
    return AvpUtilities.getAvpAsUnsigned32(code, avpSet);
  }

  protected long getAvpAsUnsigned32(int code, long vendorId)
  {
    return AvpUtilities.getAvpAsUnsigned32(code, vendorId, avpSet);
  }

  protected long[] getAvpsAsUnsigned32(int code)
  {
    return AvpUtilities.getAvpsAsUnsigned32(code, avpSet);
  }

  protected long[] getAvpsAsUnsigned32(int code, long vendorId)
  {
    return AvpUtilities.getAvpsAsUnsigned32(code, vendorId, avpSet);
  }

  protected void setAvpAsUnsigned32(int code, long vendorId, long value, boolean isMandatory, boolean isProtected)
  {
    AvpUtilities.setAvpAsUnsigned32(null, code, vendorId, avpSet, isMandatory, isProtected, value);
  }

  protected long getAvpAsUnsigned64(int code)
  {
    return AvpUtilities.getAvpAsUnsigned64(code, avpSet);
  }

  protected long getAvpAsUnsigned64(int code, long vendorId)
  {
    return AvpUtilities.getAvpAsUnsigned64(code, vendorId, avpSet);
  }

  protected long[] getAvpsAsUnsigned64(int code)
  {
    return AvpUtilities.getAvpsAsUnsigned64(code, avpSet);
  }

  protected long[] getAvpsAsUnsigned64(int code, long vendorId)
  {
    return AvpUtilities.getAvpsAsUnsigned64(code, vendorId, avpSet);
  }

  protected void setAvpAsUnsigned64(int code, long vendorId, long value, boolean isMandatory, boolean isProtected)
  {
    AvpUtilities.setAvpAsUnsigned64(null, code, vendorId, avpSet, isMandatory, isProtected, value);
  }

  protected String getAvpAsUTF8String(int code)
  {
    return AvpUtilities.getAvpAsUTF8String(code, avpSet);
  }

  protected String getAvpAsUTF8String(int code, long vendorId)
  {
    return AvpUtilities.getAvpAsUTF8String(code, vendorId, avpSet);
  }

  protected String[] getAvpsAsUTF8String(int code)
  {
    return AvpUtilities.getAvpsAsUTF8String(code, avpSet);
  }

  protected String[] getAvpsAsUTF8String(int code, long vendorId)
  {
    return AvpUtilities.getAvpsAsUTF8String(code, vendorId, avpSet);
  }

  protected void setAvpAsUTF8String(int code, long vendorId, String value, boolean isMandatory, boolean isProtected)
  {
    AvpUtilities.setAvpAsUTF8String(null, code, vendorId, avpSet, isMandatory, isProtected, value);
  }

  protected String getAvpAsOctetString(int code)
  {
    return AvpUtilities.getAvpAsOctetString(code, avpSet);
  }

  protected String getAvpAsOctetString(int code, long vendorId)
  {
    return AvpUtilities.getAvpAsOctetString(code, vendorId, avpSet);
  }

  protected String[] getAvpsAsOctetString(int code)
  {
    return AvpUtilities.getAvpsAsOctetString(code, avpSet);
  }

  protected String[] getAvpsAsOctetString(int code, long vendorId)
  {
    return AvpUtilities.getAvpsAsOctetString(code, vendorId, avpSet);
  }

  protected void setAvpAsOctetString(int code, long vendorId, String value, boolean isMandatory, boolean isProtected)
  {
    AvpUtilities.setAvpAsOctetString(null, code, vendorId, avpSet, isMandatory, isProtected, value);
  }

  protected byte[] getAvpAsRaw(int code)
  {
    return AvpUtilities.getAvpAsRaw(code, avpSet);
  }

  protected byte[] getAvpAsRaw(int code, long vendorId)
  {
    return AvpUtilities.getAvpAsRaw(code, vendorId, avpSet);
  }

  protected byte[][] getAvpsAsRaw(int code)
  {
    return AvpUtilities.getAvpsAsRaw(code, avpSet);
  }

  protected byte[][] getAvpsAsRaw(int code, long vendorId)
  {
    return AvpUtilities.getAvpsAsRaw(code, vendorId, avpSet);
  }

  protected void setAvpAsRaw(int code, long vendorId, byte[] value, boolean isMandatory, boolean isProtected)
  {
    AvpUtilities.setAvpAsRaw(null, code, vendorId, avpSet, isMandatory, isProtected, value);
  }

  protected Object getAvpAsCustom(int code, Class clazz)
  {
    return AvpUtilities.getAvpAsCustom(code, avpSet, clazz);
  }

  protected Object getAvpAsCustom(int code, long vendorId, Class clazz)
  {
    return AvpUtilities.getAvpAsCustom(code, vendorId, avpSet, clazz);
  }

  protected Object[] getAvpsAsCustom(int code, Class clazz)
  {
    return AvpUtilities.getAvpsAsCustom(code, avpSet, clazz);
  }

  protected Object[] getAvpsAsCustom(int code, long vendorId, Class clazz)
  {
    return AvpUtilities.getAvpsAsCustom(code, vendorId, avpSet, clazz);
  }

  protected DiameterIdentity getAvpAsDiameterIdentity(int code)
  {
    return AvpUtilities.getAvpAsDiameterIdentity(code, avpSet);
  }

  protected DiameterIdentity getAvpAsDiameterIdentity(int code, long vendorId)
  {
    return AvpUtilities.getAvpAsDiameterIdentity(code, vendorId, avpSet);
  }

  protected DiameterIdentity[] getAvpsAsDiameterIdentity(int code)
  {
    return AvpUtilities.getAvpsAsDiameterIdentity(code, avpSet);
  }

  protected DiameterIdentity[] getAvpsAsDiameterIdentity(int code, long vendorId)
  {
    return AvpUtilities.getAvpsAsDiameterIdentity(code, vendorId, avpSet);
  }

  protected DiameterURI getAvpAsDiameterURI(int code)
  {
    return AvpUtilities.getAvpAsDiameterURI(code, avpSet);
  }

  protected DiameterURI getAvpAsDiameterURI(int code, long vendorId)
  {
    return AvpUtilities.getAvpAsDiameterURI(code, vendorId, avpSet);
  }

  protected DiameterURI[] getAvpsAsDiameterURI(int code)
  {
    return AvpUtilities.getAvpsAsDiameterURI(code, avpSet);
  }

  protected DiameterURI[] getAvpsAsDiameterURI(int code, long vendorId)
  {
    return AvpUtilities.getAvpsAsDiameterURI(code, vendorId, avpSet);
  }

  protected Address getAvpAsAddress(int code)
  {
    return AvpUtilities.getAvpAsAddress(code, avpSet);
  }

  protected Address getAvpAsAddress(int code, long vendorId)
  {
    return AvpUtilities.getAvpAsAddress(code, vendorId, avpSet);
  }

  protected Address[] getAvpsAsAddress(int code)
  {
    return AvpUtilities.getAvpsAsAddress(code, avpSet);
  }

  protected Address[] getAvpsAsAddress(int code, long vendorId)
  {
    return AvpUtilities.getAvpsAsAddress(code, vendorId, avpSet);
  }

  protected Object getAvpAsEnumerated(int code, Class clazz)
  {
    return AvpUtilities.getAvpAsEnumerated(code, avpSet, clazz);
  }

  protected Object getAvpAsEnumerated(int code, long vendorId, Class clazz)
  {
    return AvpUtilities.getAvpAsEnumerated(code, vendorId, avpSet, clazz);
  }

  protected Object[] getAvpsAsEnumerated(int code, Class clazz)
  {
    return AvpUtilities.getAvpsAsEnumerated(code, avpSet, clazz);
  }

  protected Object[] getAvpsAsEnumerated(int code, long vendorId, Class clazz)
  {
    return AvpUtilities.getAvpsAsEnumerated(code, vendorId, avpSet, clazz);
  }

  protected void addAvp(String avpName, Object avp)
  {
    AvpUtilities.addAvp(null, avpName, avpSet, avp);
  }

  protected void addAvp(int avpCode, Object avp)
  {
    AvpUtilities.addAvp(null, avpCode, 0L, avpSet, avp);
  }

  protected void addAvp(int avpCode, long vendorId, Object avp)
  {
    AvpUtilities.addAvp(null, avpCode, vendorId, avpSet, avp);
  }

  protected boolean hasAvp(int code)
  {
    return AvpUtilities.hasAvp(code, 0L, avpSet);
  }

  protected boolean hasAvp(int code, long vendorId)
  {
    return AvpUtilities.hasAvp(code, vendorId, avpSet);
  }

  protected Object getAvp(int avpCode)
  {
    return getAvp(avpCode, 0L);
  }

  protected Object getAvp(String avpName)
  {
    AvpRepresentation avpRep = AvpDictionary.INSTANCE.getAvp(avpName);

    if(avpRep != null) {
      return getAvp(avpRep.getCode(), avpRep.getVendorId());
    }

    return null;
  }

  protected Object getAvp(int avpCode, long vendorId)
  {
    AvpRepresentation avpRep = AvpDictionary.INSTANCE.getAvp(avpCode, vendorId);

    if(avpRep != null)
    {
      int avpType = AvpRepresentation.Type.valueOf(avpRep.getType()).ordinal();

      switch (avpType)
      {
      case DiameterAvpType._ADDRESS:
      case DiameterAvpType._DIAMETER_IDENTITY:
      case DiameterAvpType._DIAMETER_URI:
      case DiameterAvpType._IP_FILTER_RULE:
      case DiameterAvpType._OCTET_STRING:
      case DiameterAvpType._QOS_FILTER_RULE:
      {
        return getAvpAsOctetString(avpCode, vendorId);
      }
      case DiameterAvpType._ENUMERATED:
      case DiameterAvpType._INTEGER_32:
      {
        return getAvpAsInteger32(avpCode, vendorId);        
      }
      case DiameterAvpType._FLOAT_32:
      {
        return getAvpAsFloat32(avpCode, vendorId);        
      }
      case DiameterAvpType._FLOAT_64:
      {
        return getAvpAsFloat64(avpCode, vendorId);        
      }
      case DiameterAvpType._GROUPED:
      {
        return getAvpAsGrouped(avpCode, vendorId);
      }
      case DiameterAvpType._INTEGER_64:
      {
        return getAvpAsInteger64(avpCode, vendorId);
      }
      case DiameterAvpType._TIME:
      {
        return getAvpAsTime(avpCode, vendorId);
      }
      case DiameterAvpType._UNSIGNED_32:
      {
        return getAvpAsUnsigned32(avpCode, vendorId);
      }
      case DiameterAvpType._UNSIGNED_64:
      {
        return getAvpAsUnsigned64(avpCode, vendorId);
      }
      case DiameterAvpType._UTF8_STRING:
      {
        return getAvpAsUTF8String(avpCode, vendorId);
      }
      default:
      {
        return getAvpAsRaw(avpCode, vendorId);
      }
      }
    }

    return null;
  }

  public void addAvp(DiameterAvp avp) {
    AvpUtilities.addAvp(avp, avpSet);
  }

  @Override
  public boolean equals( Object other )
  {
    if(!(other instanceof GroupedAvpImpl))
      return false;
    GroupedAvpImpl that = (GroupedAvpImpl) other;
    
    if(this.code != that.getCode() || this.vendorId != that.getVendorId())
      return false;
      
    List<DiameterAvp> thisArray = Arrays.asList(this.getExtensionAvps());
    List<DiameterAvp> thatArray = Arrays.asList(that.getExtensionAvps());

    if(thisArray.size() != thatArray.size())
      return false;
    
    for(DiameterAvp avp : thisArray)
    {
      if(!thatArray.contains(avp))
        return false;
    }
    
    return true;
  }
}