drivers/lisp/src/main/java/org/onosproject/drivers/lisp/extensions/LispExtensionMappingAddressInterpreter.java

/*
 * Copyright 2017-present Open Networking Laboratory
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.onosproject.drivers.lisp.extensions;

import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.node.ObjectNode;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.Lists;
import org.onlab.packet.IpAddress;
import org.onlab.packet.IpPrefix;
import org.onlab.packet.MacAddress;
import org.onosproject.codec.CodecContext;
import org.onosproject.lisp.ctl.ExtensionMappingAddressInterpreter;
import org.onosproject.lisp.msg.types.LispAfiAddress;
import org.onosproject.lisp.msg.types.LispDistinguishedNameAddress;
import org.onosproject.lisp.msg.types.LispIpv4Address;
import org.onosproject.lisp.msg.types.LispIpv6Address;
import org.onosproject.lisp.msg.types.LispMacAddress;
import org.onosproject.lisp.msg.types.lcaf.LispAppDataLcafAddress;
import org.onosproject.lisp.msg.types.lcaf.LispAsLcafAddress;
import org.onosproject.lisp.msg.types.lcaf.LispGeoCoordinateLcafAddress;
import org.onosproject.lisp.msg.types.lcaf.LispLcafAddress;
import org.onosproject.lisp.msg.types.lcaf.LispListLcafAddress;
import org.onosproject.lisp.msg.types.lcaf.LispMulticastLcafAddress;
import org.onosproject.lisp.msg.types.lcaf.LispNatLcafAddress;
import org.onosproject.lisp.msg.types.lcaf.LispNonceLcafAddress;
import org.onosproject.lisp.msg.types.lcaf.LispSegmentLcafAddress;
import org.onosproject.lisp.msg.types.lcaf.LispSourceDestLcafAddress;
import org.onosproject.lisp.msg.types.lcaf.LispTeLcafAddress;
import org.onosproject.lisp.msg.types.lcaf.LispTeRecord;
import org.onosproject.mapping.addresses.ExtensionMappingAddress;
import org.onosproject.mapping.addresses.ExtensionMappingAddressResolver;
import org.onosproject.mapping.addresses.ExtensionMappingAddressType;
import org.onosproject.mapping.addresses.IPMappingAddress;
import org.onosproject.mapping.addresses.MappingAddress;
import org.onosproject.mapping.addresses.MappingAddresses;
import org.onosproject.net.driver.AbstractHandlerBehaviour;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.List;

import static com.google.common.base.Preconditions.checkNotNull;
import static org.onlab.util.Tools.nullIsIllegal;
import static org.onosproject.mapping.addresses.ExtensionMappingAddressType.ExtensionMappingAddressTypes.*;
/**
 * Interpreter for mapping address extension.
 */
public class LispExtensionMappingAddressInterpreter extends AbstractHandlerBehaviour
        implements ExtensionMappingAddressInterpreter, ExtensionMappingAddressResolver {

    private static final Logger log = LoggerFactory.getLogger(
            LispExtensionMappingAddressInterpreter.class);

    private static final int IPV4_PREFIX_LENGTH = 32;
    private static final int IPV6_PREFIX_LENGTH = 128;

    protected static final String LISP_LIST_ADDRESS = "listAddress";
    protected static final String LISP_SEGMENT_ADDRESS = "segmentAddress";
    protected static final String LISP_AS_ADDRESS = "asAddress";
    protected static final String LISP_APPLICATION_DATA_ADDRESS = "applicationDataAddress";
    protected static final String LISP_GEO_COORDINATE_ADDRESS = "geoCoordinateAddress";
    protected static final String LISP_NAT_ADDRESS = "natAddress";
    protected static final String LISP_NONCE_ADDRESS = "nonceAddress";
    protected static final String LISP_MULTICAST_ADDRESS = "multicastAddress";
    protected static final String LISP_TRAFFIC_ENGINEERING_ADDRESS = "trafficEngineeringAddress";
    protected static final String LISP_SOURCE_DEST_ADDRESS = "sourceDestAddress";

    private static final String TYPE = "type";

    private static final String MISSING_MEMBER_MESSAGE =
            " member is required in LispExtensionMappingAddressInterpreter";

    @Override
    public boolean supported(ExtensionMappingAddressType type) {

        if (type.equals(LIST_ADDRESS.type())) {
            return true;
        }
        if (type.equals(SEGMENT_ADDRESS.type())) {
            return true;
        }
        if (type.equals(AS_ADDRESS.type())) {
            return true;
        }
        if (type.equals(APPLICATION_DATA_ADDRESS.type())) {
            return true;
        }
        if (type.equals(GEO_COORDINATE_ADDRESS.type())) {
            return true;
        }
        if (type.equals(NAT_ADDRESS.type())) {
            return true;
        }
        if (type.equals(NONCE_ADDRESS.type())) {
            return true;
        }
        if (type.equals(MULTICAST_ADDRESS.type())) {
            return true;
        }
        if (type.equals(TRAFFIC_ENGINEERING_ADDRESS.type())) {
            return true;
        }
        if (type.equals(SOURCE_DEST_ADDRESS.type())) {
            return true;
        }

        return false;
    }

    @Override
    public LispLcafAddress mapMappingAddress(ExtensionMappingAddress mappingAddress) {
        ExtensionMappingAddressType type = mappingAddress.type();

        if (type.equals(LIST_ADDRESS.type())) {

            LispListAddress listAddress = (LispListAddress) mappingAddress;
            LispAfiAddress ipv4 = mapping2afi(listAddress.getIpv4());
            LispAfiAddress ipv6 = mapping2afi(listAddress.getIpv6());

            if (ipv4 != null && ipv6 != null) {
                return new LispListLcafAddress(ImmutableList.of(ipv4, ipv6));
            } else {
                return new LispListLcafAddress(ImmutableList.of());
            }
        }

        if (type.equals(SEGMENT_ADDRESS.type())) {

            LispSegmentAddress segmentAddress = (LispSegmentAddress) mappingAddress;

            return new LispSegmentLcafAddress.SegmentAddressBuilder()
                    .withInstanceId(segmentAddress.getInstanceId())
                    .withAddress(getAfiAddress(segmentAddress.getAddress()))
                    .build();
        }

        if (type.equals(AS_ADDRESS.type())) {

            LispAsAddress asAddress = (LispAsAddress) mappingAddress;

            return new LispAsLcafAddress.AsAddressBuilder()
                            .withAsNumber(asAddress.getAsNumber())
                            .withAddress(getAfiAddress(asAddress.getAddress()))
                            .build();
        }

        if (type.equals(APPLICATION_DATA_ADDRESS.type())) {

            LispAppDataAddress appDataAddress = (LispAppDataAddress) mappingAddress;

            return new LispAppDataLcafAddress.AppDataAddressBuilder()
                            .withProtocol(appDataAddress.getProtocol())
                            .withIpTos(appDataAddress.getIpTos())
                            .withLocalPortLow(appDataAddress.getLocalPortLow())
                            .withLocalPortHigh(appDataAddress.getLocalPortHigh())
                            .withRemotePortLow(appDataAddress.getRemotePortLow())
                            .withRemotePortHigh(appDataAddress.getRemotePortHigh())
                            .withAddress(getAfiAddress(appDataAddress.getAddress()))
                            .build();
        }

        if (type.equals(GEO_COORDINATE_ADDRESS.type())) {

            LispGcAddress gcAddress = (LispGcAddress) mappingAddress;

            return new LispGeoCoordinateLcafAddress.GeoCoordinateAddressBuilder()
                            .withIsNorth(gcAddress.isNorth())
                            .withLatitudeDegree(gcAddress.getLatitudeDegree())
                            .withLatitudeMinute(gcAddress.getLatitudeMinute())
                            .withLatitudeSecond(gcAddress.getLatitudeSecond())
                            .withIsEast(gcAddress.isEast())
                            .withLongitudeDegree(gcAddress.getLongitudeDegree())
                            .withLongitudeMinute(gcAddress.getLongitudeMinute())
                            .withLongitudeSecond(gcAddress.getLongitudeSecond())
                            .withAltitude(gcAddress.getAltitude())
                            .withAddress(getAfiAddress(gcAddress.getAddress()))
                            .build();
        }

        if (type.equals(NAT_ADDRESS.type())) {

            LispNatAddress natAddress = (LispNatAddress) mappingAddress;

            List<LispAfiAddress> aas = Lists.newArrayList();

            natAddress.getRtrRlocAddresses()
                    .forEach(rtr -> aas.add(getAfiAddress(rtr)));

            return new LispNatLcafAddress.NatAddressBuilder()
                            .withMsUdpPortNumber(natAddress.getMsUdpPortNumber())
                            .withEtrUdpPortNumber(natAddress.getEtrUdpPortNumber())
                            .withMsRlocAddress(getAfiAddress(natAddress.getMsRlocAddress()))
                            .withGlobalEtrRlocAddress(
                                    getAfiAddress(natAddress.getGlobalEtrRlocAddress()))
                            .withPrivateEtrRlocAddress(
                                    getAfiAddress(natAddress.getPrivateEtrRlocAddress()))
                            .withRtrRlocAddresses(aas)
                            .build();
        }

        if (type.equals(NONCE_ADDRESS.type())) {

            LispNonceAddress nonceAddress = (LispNonceAddress) mappingAddress;

            return new LispNonceLcafAddress.NonceAddressBuilder()
                            .withNonce(nonceAddress.getNonce())
                            .withAddress(getAfiAddress(nonceAddress.getAddress()))
                            .build();
        }

        if (type.equals(MULTICAST_ADDRESS.type())) {

            LispMulticastAddress multicastAddress = (LispMulticastAddress) mappingAddress;

            return new LispMulticastLcafAddress.MulticastAddressBuilder()
                            .withInstanceId(multicastAddress.getInstanceId())
                            .withSrcAddress(getAfiAddress(multicastAddress.getSrcAddress()))
                            .withSrcMaskLength(multicastAddress.getSrcMaskLength())
                            .withGrpAddress(getAfiAddress(multicastAddress.getGrpAddress()))
                            .withGrpMaskLength(multicastAddress.getGrpMaskLength())
                            .build();
        }

        if (type.equals(TRAFFIC_ENGINEERING_ADDRESS.type())) {

            LispTeAddress teAddress = (LispTeAddress) mappingAddress;

            List<LispTeRecord> records = Lists.newArrayList();

            teAddress.getTeRecords().forEach(record -> {
                LispTeRecord teRecord =
                        new LispTeRecord.TeRecordBuilder()
                                .withIsLookup(record.isLookup())
                                .withIsRlocProbe(record.isRlocProbe())
                                .withIsStrict(record.isStrict())
                                .withRtrRlocAddress(getAfiAddress(
                                        record.getAddress()))
                                .build();
                records.add(teRecord);
            });

            return new LispTeLcafAddress.TeAddressBuilder()
                            .withTeRecords(records)
                            .build();
        }

        if (type.equals(SOURCE_DEST_ADDRESS.type())) {

            LispSrcDstAddress srcDstAddress = (LispSrcDstAddress) mappingAddress;

            return new LispSourceDestLcafAddress.SourceDestAddressBuilder()
                            .withSrcPrefix(getAfiAddress(srcDstAddress.getSrcPrefix()))
                            .withSrcMaskLength(srcDstAddress.getSrcMaskLength())
                            .withDstPrefix(getAfiAddress(srcDstAddress.getDstPrefix()))
                            .withDstMaskLength(srcDstAddress.getDstMaskLength())
                            .build();
        }

        log.error("Unsupported extension mapping address type {}", mappingAddress.type());

        return null;
    }

    @Override
    public ExtensionMappingAddress mapLcafAddress(LispLcafAddress lcafAddress) {

        switch (lcafAddress.getType()) {
            case LIST:
                LispListLcafAddress lcafListAddress = (LispListLcafAddress) lcafAddress;
                MappingAddress ipv4Ma =
                        afi2mapping(lcafListAddress.getAddresses().get(0));
                MappingAddress ipv6Ma =
                        afi2mapping(lcafListAddress.getAddresses().get(1));

                return new LispListAddress.Builder()
                        .withIpv4(ipv4Ma)
                        .withIpv6(ipv6Ma)
                        .build();

            case SEGMENT:
                LispSegmentLcafAddress segmentLcafAddress =
                        (LispSegmentLcafAddress) lcafAddress;

                return new LispSegmentAddress.Builder()
                        .withInstanceId(segmentLcafAddress.getInstanceId())
                        .withAddress(getMappingAddress(segmentLcafAddress.getAddress()))
                        .build();

            case AS:
                LispAsLcafAddress asLcafAddress = (LispAsLcafAddress) lcafAddress;

                return new org.onosproject.drivers.lisp.extensions.LispAsAddress.Builder()
                        .withAsNumber(asLcafAddress.getAsNumber())
                        .withAddress(getMappingAddress(asLcafAddress.getAddress()))
                        .build();

            case APPLICATION_DATA:

                LispAppDataLcafAddress appLcafAddress = (LispAppDataLcafAddress) lcafAddress;

                return new LispAppDataAddress.Builder()
                        .withProtocol(appLcafAddress.getProtocol())
                        .withIpTos(appLcafAddress.getIpTos())
                        .withLocalPortLow(appLcafAddress.getLocalPortLow())
                        .withLocalPortHigh(appLcafAddress.getLocalPortHigh())
                        .withRemotePortLow(appLcafAddress.getRemotePortLow())
                        .withRemotePortHigh(appLcafAddress.getRemotePortHigh())
                        .withAddress(getMappingAddress(appLcafAddress.getAddress()))
                        .build();

            case GEO_COORDINATE:

                LispGeoCoordinateLcafAddress gcLcafAddress =
                        (LispGeoCoordinateLcafAddress) lcafAddress;

                return new LispGcAddress.Builder()
                        .withIsNorth(gcLcafAddress.isNorth())
                        .withLatitudeDegree(gcLcafAddress.getLatitudeDegree())
                        .withLatitudeMinute(gcLcafAddress.getLatitudeMinute())
                        .withLatitudeSecond(gcLcafAddress.getLatitudeSecond())
                        .withIsEast(gcLcafAddress.isEast())
                        .withLongitudeDegree(gcLcafAddress.getLongitudeDegree())
                        .withLongitudeMinute(gcLcafAddress.getLongitudeMinute())
                        .withLongitudeSecond(gcLcafAddress.getLongitudeSecond())
                        .withAltitude(gcLcafAddress.getAltitude())
                        .withAddress(getMappingAddress(gcLcafAddress.getAddress()))
                        .build();

            case NAT:

                LispNatLcafAddress natLcafAddress = (LispNatLcafAddress) lcafAddress;

                List<MappingAddress> mas = Lists.newArrayList();

                natLcafAddress.getRtrRlocAddresses()
                        .forEach(rtr -> mas.add(getMappingAddress(rtr)));

                return new LispNatAddress.Builder()
                        .withMsUdpPortNumber(natLcafAddress.getMsUdpPortNumber())
                        .withEtrUdpPortNumber(natLcafAddress.getEtrUdpPortNumber())
                        .withMsRlocAddress(getMappingAddress(natLcafAddress.getMsRlocAddress()))
                        .withGlobalEtrRlocAddress(
                                getMappingAddress(natLcafAddress.getGlobalEtrRlocAddress()))
                        .withPrivateEtrRlocAddress(
                                getMappingAddress(natLcafAddress.getPrivateEtrRlocAddress()))
                        .withRtrRlocAddresses(mas)
                        .build();

            case NONCE:

                LispNonceLcafAddress nonceLcafAddress = (LispNonceLcafAddress) lcafAddress;

                return new LispNonceAddress.Builder()
                        .withNonce(nonceLcafAddress.getNonce())
                        .withAddress(getMappingAddress(nonceLcafAddress.getAddress()))
                        .build();

            case MULTICAST:

                LispMulticastLcafAddress multiLcafAddress =
                        (LispMulticastLcafAddress) lcafAddress;

                return new LispMulticastAddress.Builder()
                        .withInstanceId(multiLcafAddress.getInstanceId())
                        .withSrcAddress(getMappingAddress(multiLcafAddress.getSrcAddress()))
                        .withSrcMaskLength(multiLcafAddress.getSrcMaskLength())
                        .withGrpAddress(getMappingAddress(multiLcafAddress.getGrpAddress()))
                        .withGrpMaskLength(multiLcafAddress.getGrpMaskLength())
                        .build();

            case TRAFFIC_ENGINEERING:

                LispTeLcafAddress teLcafAddress = (LispTeLcafAddress) lcafAddress;

                List<LispTeAddress.TeRecord> records = Lists.newArrayList();

                teLcafAddress.getTeRecords().forEach(record -> {
                    LispTeAddress.TeRecord teRecord =
                            new LispTeAddress.TeRecord.Builder()
                                    .withIsLookup(record.isLookup())
                                    .withIsRlocProbe(record.isRlocProbe())
                                    .withIsStrict(record.isStrict())
                                    .withRtrRlocAddress(getMappingAddress(
                                            record.getRtrRlocAddress()))
                                    .build();
                    records.add(teRecord);
                });

                return new LispTeAddress.Builder()
                        .withTeRecords(records)
                        .build();

            case SECURITY:

                // TODO: need to implement security type later
                log.warn("security type will be implemented later");

                return null;

            case SOURCE_DEST:

                LispSourceDestLcafAddress srcDstLcafAddress =
                        (LispSourceDestLcafAddress) lcafAddress;


                return new LispSrcDstAddress.Builder()
                        .withSrcPrefix(getMappingAddress(srcDstLcafAddress.getSrcPrefix()))
                        .withSrcMaskLength(srcDstLcafAddress.getSrcMaskLength())
                        .withDstPrefix(getMappingAddress(srcDstLcafAddress.getDstPrefix()))
                        .withDstMaskLength(srcDstLcafAddress.getDstMaskLength())
                        .build();

            case UNSPECIFIED:
            case UNKNOWN:
            default:
                log.error("Unsupported LCAF type {}", lcafAddress.getType());
                return null;
        }
    }

    @Override
    public ExtensionMappingAddress getExtensionMappingAddress(
                                            ExtensionMappingAddressType type) {

        if (type.equals(LIST_ADDRESS.type())) {
            return new LispListAddress();
        }
        if (type.equals(SEGMENT_ADDRESS.type())) {
            return new LispSegmentAddress();
        }
        if (type.equals(AS_ADDRESS.type())) {
            return new LispAsAddress();
        }
        if (type.equals(APPLICATION_DATA_ADDRESS.type())) {
            return new LispAppDataAddress();
        }
        if (type.equals(GEO_COORDINATE_ADDRESS.type())) {
            return new LispGcAddress();
        }
        if (type.equals(NAT_ADDRESS.type())) {
            return new LispNatAddress();
        }
        if (type.equals(NONCE_ADDRESS.type())) {
            return new LispNonceAddress();
        }
        if (type.equals(MULTICAST_ADDRESS.type())) {
            return new LispMulticastAddress();
        }
        if (type.equals(TRAFFIC_ENGINEERING_ADDRESS.type())) {
            return new LispTeAddress();
        }
        if (type.equals(SOURCE_DEST_ADDRESS.type())) {
            return new LispSrcDstAddress();
        }

        return null;
    }

    /**
     * Converts AFI address to generalized mapping address.
     *
     * @param afi IP typed AFI address
     * @return generalized mapping address
     */
    private MappingAddress afi2mapping(LispAfiAddress afi) {
        switch (afi.getAfi()) {
            case IP4:
                IpAddress ipv4Address = ((LispIpv4Address) afi).getAddress();
                IpPrefix ipv4Prefix = IpPrefix.valueOf(ipv4Address, IPV4_PREFIX_LENGTH);
                return MappingAddresses.ipv4MappingAddress(ipv4Prefix);
            case IP6:
                IpAddress ipv6Address = ((LispIpv6Address) afi).getAddress();
                IpPrefix ipv6Prefix = IpPrefix.valueOf(ipv6Address, IPV6_PREFIX_LENGTH);
                return MappingAddresses.ipv6MappingAddress(ipv6Prefix);
            default:
                log.warn("Only support to convert IP address type");
                break;
        }
        return null;
    }

    /**
     * Converts mapping address to AFI address.
     *
     * @param address generalized mapping address
     * @return IP typed AFI address
     */
    private LispAfiAddress mapping2afi(MappingAddress address) {
        switch (address.type()) {
            case IPV4:
                IpPrefix ipv4Prefix = ((IPMappingAddress) address).ip();
                return new LispIpv4Address(ipv4Prefix.address());
            case IPV6:
                IpPrefix ipv6Prefix = ((IPMappingAddress) address).ip();
                return new LispIpv6Address(ipv6Prefix.address());
            default:
                log.warn("Only support to convert IP address type");
                break;
        }
        return null;
    }

    /**
     * Converts LispAfiAddress into abstracted mapping address.
     *
     * @param address LispAfiAddress
     * @return abstracted mapping address
     */
    private MappingAddress getMappingAddress(LispAfiAddress address) {

        if (address == null) {
            log.warn("Address is not specified.");
            return null;
        }

        switch (address.getAfi()) {
            case IP4:
                return afi2mapping(address);
            case IP6:
                return afi2mapping(address);
            case AS:
                int asNum = ((org.onosproject.lisp.msg.types.LispAsAddress) address).getASNum();
                return MappingAddresses.asMappingAddress(String.valueOf(asNum));
            case DISTINGUISHED_NAME:
                String dn = ((LispDistinguishedNameAddress)
                        address).getDistinguishedName();
                return MappingAddresses.dnMappingAddress(dn);
            case MAC:
                MacAddress macAddress = ((LispMacAddress) address).getAddress();
                return MappingAddresses.ethMappingAddress(macAddress);
            case LCAF:
                LispLcafAddress lcafAddress = (LispLcafAddress) address;
                return MappingAddresses.extensionMappingAddressWrapper(mapLcafAddress(lcafAddress));
            default:
                log.warn("Unsupported address AFI type {}", address.getAfi());
                break;
        }

        return null;
    }

    /**
     * Converts mapping address into afi address.
     *
     * @param address mapping address
     * @return afi address
     */
    private LispAfiAddress getAfiAddress(MappingAddress address) {

        if (address == null) {
            log.warn("Address is not specified.");
            return null;
        }

        switch (address.type()) {
            case IPV4:
                return mapping2afi(address);
            case IPV6:
                return mapping2afi(address);
            case AS:
                int asNum = ((org.onosproject.lisp.msg.types.LispAsAddress) address).getASNum();
                return new org.onosproject.lisp.msg.types.LispAsAddress(asNum);
            case DN:
                String dn = ((LispDistinguishedNameAddress) address).getDistinguishedName();
                return new LispDistinguishedNameAddress(dn);
            case ETH:
                MacAddress macAddress = ((LispMacAddress) address).getAddress();
                return new LispMacAddress(macAddress);
            case EXTENSION:
                ExtensionMappingAddress extAddress = (ExtensionMappingAddress) address;
                return mapMappingAddress(extAddress);
            default:
                log.warn("Unsupported address type {}", address.type());
                break;
        }

        return null;
    }

    @Override
    public ObjectNode encode(ExtensionMappingAddress mappingAddress, CodecContext context) {
        checkNotNull(mappingAddress, "Extension mapping address cannot be null");
        ExtensionMappingAddressType type = mappingAddress.type();
        ObjectNode root = context.mapper().createObjectNode();

        if (type.equals(LIST_ADDRESS.type())) {
            LispListAddress listAddress = (LispListAddress) mappingAddress;
            root.set(LISP_LIST_ADDRESS,
                    context.codec(LispListAddress.class).encode(listAddress, context));
        }
        if (type.equals(SEGMENT_ADDRESS.type())) {
            LispSegmentAddress segmentAddress = (LispSegmentAddress) mappingAddress;
            root.set(LISP_SEGMENT_ADDRESS,
                    context.codec(LispSegmentAddress.class).encode(segmentAddress, context));
        }
        if (type.equals(AS_ADDRESS.type())) {
            LispAsAddress asAddress = (LispAsAddress) mappingAddress;
            root.set(LISP_AS_ADDRESS,
                    context.codec(LispAsAddress.class).encode(asAddress, context));
        }
        if (type.equals(APPLICATION_DATA_ADDRESS.type())) {
            LispAppDataAddress appDataAddress = (LispAppDataAddress) mappingAddress;
            root.set(LISP_APPLICATION_DATA_ADDRESS,
                    context.codec(LispAppDataAddress.class).encode(appDataAddress, context));
        }
        if (type.equals(GEO_COORDINATE_ADDRESS.type())) {
            LispGcAddress gcAddress = (LispGcAddress) mappingAddress;
            root.set(LISP_GEO_COORDINATE_ADDRESS,
                    context.codec(LispGcAddress.class).encode(gcAddress, context));
        }
        if (type.equals(NAT_ADDRESS.type())) {
            LispNatAddress natAddress = (LispNatAddress) mappingAddress;
            root.set(LISP_NAT_ADDRESS,
                    context.codec(LispNatAddress.class).encode(natAddress, context));
        }
        if (type.equals(NONCE_ADDRESS.type())) {
            LispNonceAddress nonceAddress = (LispNonceAddress) mappingAddress;
            root.set(LISP_NONCE_ADDRESS, context.codec(LispNonceAddress.class).encode(nonceAddress, context));
        }
        if (type.equals(MULTICAST_ADDRESS.type())) {
            LispMulticastAddress multicastAddress = (LispMulticastAddress) mappingAddress;
            root.set(LISP_MULTICAST_ADDRESS,
                    context.codec(LispMulticastAddress.class).encode(multicastAddress, context));
        }
        if (type.equals(TRAFFIC_ENGINEERING_ADDRESS.type())) {
            LispTeAddress teAddress = (LispTeAddress) mappingAddress;
            root.set(LISP_TRAFFIC_ENGINEERING_ADDRESS,
                    context.codec(LispTeAddress.class).encode(teAddress, context));
        }
        if (type.equals(SOURCE_DEST_ADDRESS.type())) {
            LispSrcDstAddress srcDstAddress = (LispSrcDstAddress) mappingAddress;
            root.set(LISP_SOURCE_DEST_ADDRESS,
                    context.codec(LispSrcDstAddress.class).encode(srcDstAddress, context));
        }

        return root;
    }

    @Override
    public ExtensionMappingAddress decode(ObjectNode json, CodecContext context) {
        if (json == null || !json.isObject()) {
            return null;
        }

        // parse extension type
        String typeString = nullIsIllegal(json.get(TYPE),
                TYPE + MISSING_MEMBER_MESSAGE).asText();

        if (typeString.equals(LIST_ADDRESS.name())) {
            return context.codec(LispListAddress.class)
                    .decode(get(json, LISP_LIST_ADDRESS), context);
        }
        if (typeString.equals(SEGMENT_ADDRESS.name())) {
            return context.codec(LispSegmentAddress.class)
                    .decode(get(json, LISP_SEGMENT_ADDRESS), context);
        }
        if (typeString.equals(AS_ADDRESS.name())) {
            return context.codec(LispAsAddress.class)
                    .decode(get(json, LISP_AS_ADDRESS), context);
        }
        if (typeString.equals(APPLICATION_DATA_ADDRESS.name())) {
            return context.codec(LispAppDataAddress.class)
                    .decode(get(json, LISP_APPLICATION_DATA_ADDRESS), context);
        }
        if (typeString.equals(GEO_COORDINATE_ADDRESS.name())) {
            return context.codec(LispGcAddress.class)
                    .decode(get(json, LISP_GEO_COORDINATE_ADDRESS), context);
        }
        if (typeString.equals(NAT_ADDRESS.name())) {
            return context.codec(LispNatAddress.class)
                    .decode(get(json, LISP_NAT_ADDRESS), context);
        }
        if (typeString.equals(NONCE_ADDRESS.name())) {
            return context.codec(LispNonceAddress.class)
                    .decode(get(json, LISP_NONCE_ADDRESS), context);
        }
        if (typeString.equals(MULTICAST_ADDRESS.name())) {
            return context.codec(LispMulticastAddress.class)
                    .decode(get(json, LISP_MULTICAST_ADDRESS), context);
        }
        if (typeString.equals(TRAFFIC_ENGINEERING_ADDRESS.name())) {
            return context.codec(LispTeAddress.class)
                    .decode(get(json, LISP_TRAFFIC_ENGINEERING_ADDRESS), context);
        }
        if (typeString.equals(SOURCE_DEST_ADDRESS.name())) {
            return context.codec(LispSrcDstAddress.class)
                    .decode(get(json, LISP_SOURCE_DEST_ADDRESS), context);
        }

        throw new UnsupportedOperationException(
                "Driver does not support extension type " + typeString);
    }

    /**
     * Gets a child Object Node from a parent by name. If the child is not found
     * or does nor represent an object, null is returned.
     *
     * @param parent parent object
     * @param childName name of child to query
     * @return child object if found, null if not found or if not an object
     */
    private static ObjectNode get(ObjectNode parent, String childName) {
        JsonNode node = parent.path(childName);
        return node.isObject() && !node.isNull() ? (ObjectNode) node : null;
    }
}