renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/policy/ResolvedRuleGroup.java

   1 /*
   2  * Copyright (c) 2016 Cisco Systems, Inc. and others. All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8
   9 package org.opendaylight.groupbasedpolicy.renderer.vpp.policy;
  10
  11 import java.util.Comparator;
  12 import java.util.List;
  13
  14 import javax.annotation.Nonnull;
  15 import javax.annotation.concurrent.Immutable;
  16
  17 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ContractId;
  18 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.SubjectName;
  19 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.TenantId;
  20 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.policy.contract.subject.Rule;
  21 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.rule.groups.RuleGroup;
  22 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.has.resolved.rules.ResolvedRule;
  23
  24 import com.google.common.collect.ComparisonChain;
  25 import com.google.common.collect.ImmutableSortedSet;
  26 import com.google.common.collect.Ordering;
  27
  28 /**
  29  * Represent a group of rules applied to a given pair of endpoints.
  30  * Includes references back to the normalized policy that resulted in the rule
  31  * group.
  32  */
  33 @Immutable
  34 public class ResolvedRuleGroup implements Comparable<ResolvedRuleGroup> {
  35
  36     private static final ResolvedRuleComparator RULE_COMPARATOR = new ResolvedRuleComparator();
  37     private ImmutableSortedSet<ResolvedRule> rules;
  38     private final Integer order;
  39     private final TenantId contractTenantId;
  40     private final ContractId contractId;
  41     private final SubjectName relatedSubject;
  42
  43     public static class ResolvedRuleComparator implements Comparator<ResolvedRule> {
  44
  45         @Override
  46         public int compare(ResolvedRule o1, ResolvedRule o2) {
  47             return ComparisonChain.start()
  48                 .compare(o1.getOrder(), o2.getOrder(), Ordering.natural().nullsLast())
  49                 .compare(o1.getName().getValue(), o2.getName().getValue(), Ordering.natural().nullsLast())
  50                 .result();
  51         }
  52
  53     }
  54
  55     public ResolvedRuleGroup(@Nonnull RuleGroup ruleGroup) {
  56         this.rules = ImmutableSortedSet.copyOf(RULE_COMPARATOR, ruleGroup.getResolvedRule());
  57         this.order = ruleGroup.getOrder();
  58         this.contractTenantId = ruleGroup.getTenantId();
  59         this.contractId = ruleGroup.getContractId();
  60         this.relatedSubject = ruleGroup.getSubjectName();
  61     }
  62
  63     public ResolvedRuleGroup(List<ResolvedRule> rules, Integer order, TenantId contractTenantId, ContractId contractId,
  64             SubjectName subject) {
  65         this.rules = ImmutableSortedSet.copyOf(RULE_COMPARATOR, rules);
  66         this.order = order;
  67         this.contractTenantId = contractTenantId;
  68         this.contractId = contractId;
  69         this.relatedSubject = subject;
  70     }
  71
  72     /**
  73      * @return sorted {@link Rule} list
  74      */
  75     public ImmutableSortedSet<ResolvedRule> getRules() {
  76         return rules;
  77     }
  78
  79     public Integer getOrder() {
  80         return order;
  81     }
  82
  83     public TenantId getContractTenantId() {
  84         return contractTenantId;
  85     }
  86
  87     public ContractId getContractId() {
  88         return contractId;
  89     }
  90
  91     public SubjectName getRelatedSubject() {
  92         return relatedSubject;
  93     }
  94
  95     @Override
  96     public int hashCode() {
  97         final int prime = 31;
  98         int result = 1;
  99         result = prime * result + ((order == null) ? 0 : order.hashCode());
 100         result = prime * result + ((rules == null) ? 0 : rules.hashCode());
 101         result = prime * result + ((relatedSubject == null) ? 0 : relatedSubject.hashCode());
 102         return result;
 103     }
 104
 105     @Override
 106     public boolean equals(Object obj) {
 107         if (this == obj)
 108             return true;
 109         if (obj == null)
 110             return false;
 111         if (getClass() != obj.getClass())
 112             return false;
 113         ResolvedRuleGroup other = (ResolvedRuleGroup) obj;
 114         if (order == null) {
 115             if (other.order != null)
 116                 return false;
 117         } else if (!order.equals(other.order))
 118             return false;
 119         if (rules == null) {
 120             if (other.rules != null)
 121                 return false;
 122         } else if (!rules.equals(other.rules))
 123             return false;
 124         if (relatedSubject == null) {
 125             if (other.relatedSubject != null)
 126                 return false;
 127         } else if (!relatedSubject.equals(other.relatedSubject))
 128             return false;
 129         return true;
 130     }
 131
 132     @Override
 133     public int compareTo(ResolvedRuleGroup o) {
 134         return ComparisonChain.start()
 135             .compare(order, o.order, Ordering.natural().nullsLast())
 136             .compare(relatedSubject.getValue(), o.relatedSubject.getValue(), Ordering.natural().nullsLast())
 137             .result();
 138     }
 139
 140 }