Page History

File : acme-system.yang
module acme-system {
    namespace "http://acme.example.com/system";
    prefix "acme";
    organization "ACME Inc.";
    contact "joe@acme.example.com";
    description
        "The module for entities implementing the ACME system.";
    revision 2007-06-09 {
        description "Initial revision.";
    }
    list login {
        key "name";
        list login {
   
 
File: SystemOpParam.java

package org.onosproject.yang.gen.v1.http.acme.example.com.system.rev20070609.acmesystem;
import org.onosproject.yang.gen.v1.http.acme.example.com.system.rev20070609.acmesystem.system.Login;
import org.onosproject.yangutils.datamodel.YangAugmentedInfo;
import org.onosproject.yangutils.datamodel.YangAugmentedOpParamInfo;
import java.util.BitSet;
public class SystemOpParam extends DefaultSystem  {
    public static enum OperationType {
        MERGE,
        REPLACE,
        CREATE,
        DELETE,
        REMOVE
    }
    private OperationType opParamType;

    public OperationType getOpertionType() {
        return key "name"opParamType;
    }
    public boolean   leaf nameisFilterContentMatch(Object obj) {
        DefaultSystem appInstance = (DefaultSystem)obj;
     type string;
  for (YangAugmentedInfo yangAugmentedInfo : this.getYangAugmentedInfoMap().values()) {
     }
       if (!(yangAugmentedInfo  instanceof  leaf full-name YangAugmentedOpParamInfo)) {
                typethrow string;
            }new IllegalArgumentException("provided augmented info is invalid for content match.");
            leaf class {}
            YangAugmentedInfo yangAugmentedOpParamInfo =  type string;appInstance
            }.getAugmentedInfo(((YangAugmentedOpParamInfo) yangAugmentedInfo).getBaseClass());
        }
    if(!((YangAugmentedOpParamInfo) yangAugmentedInfo).isFilterContentMatch(yangAugmentedOpParamInfo)) {
  leaf name {
            typereturn stringfalse;
        }
    }
    .
    .}
      .
}

File : Login.java

package org.onosproject.yang.gen.v1.http.acme.example.com.system.rev20070609.acmesystem;
import java.util.List;
public interface Login {

 return true;
    }
    Stringpublic nameSystemOpParam(SystemOpParamBuilder builderObject); {
     List<org.onosproject.yang.gen.v1.http.acme.example.com.system.rev20070609.acmesystem.login.Login> login(   super(builderObject);
    interface LoginBuilder {
}
    public class SystemOpParamBuilder extends String name();DefaultSystem.SystemBuilder {
        List<org.onosproject.yang.gen.v1.http.acme.example.com.system.rev20070609.acmesystem.login.Login> login()private OperationType opParamType;
        LoginBuilderpublic OperationType namegetOpertionType(String) name);
{
            LoginBuilder login(List<org.onosproject.yang.gen.v1.http.acme.example.com.system.rev20070609.acmesystemreturn opParamType;
        }
        .login
public void setOpertionType(OperationType operationType) {
            this.Login> login);
opParamType = operationType;
        Login build();}
    }
}

File : DefaultLogin.java


package org.onosproject.yang.gen.v1.http.acme.example.com.system.rev20070609.acmesystem;

import com.google.common.base.MoreObjects;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import org.onosproject.yangutils.datamodel.YangAugmentedInfo;

public class DefaultLogin implements Login {

    private Map<Class<?>, YangAugmentedInfo> yangAugmentedInfoMap = new HashMap<>();
    protected String name;
    protected List<org.onosproject.yang.gen.v1.http.acme.example.com.system.rev20070609.acmesystem.login.Login> login;

    @Override
    public String name() {
        return name;
    }

    @Override
    public List<org.onosproject.yang.gen.v1.http.acme.example.com.system.rev20070609.acmesystem.login.Login> login() 

module Test {
    namespace "http://test.example.com/"
    public DefaultLogin(LoginBuilder builderObject) {
        this.name = builderObject.name();
    prefix "test";
    organization "ACME Inc."this.login = builderObject.login();
    grouping endpoint { }

    public void addAugmentedInfo(YangAugmentedInfo value, leafClass addressclassObject) {
        yangAugmentedInfoMap.put(classObject, value);
   type int32; }

    public YangAugmentedInfo getAugmentedInfo(Class classObject) } {
        leaf port {return yangAugmentedInfoMap.get(classObject);
    }

    public Map<Class<?>, YangAugmentedInfo>  type int8; 
getYangAugmentedInfoMap() {
        return yangAugmentedInfoMap;
    }

    public class LoginBuilder  }
implements Login.LoginBuilder {

       container connectionprotected {String name;
        container source {protected List<org.onosproject.yang.gen.v1.http.acme.example.com.system.rev20070609.acmesystem.login
            uses.Login> endpointlogin;


        }@Override
        container destinationpublic String name() {
            usesreturn endpointname;
        }

    }
    .@Override
    .
    .
}

File : Connection.java
package org.public List<org.onosproject.yang.gen.v1.http.testacme.example.com.rev20160718.test;

import org.onosproject.yang.gen.v1.http.test.example.com.rev20160718.test.connection.Source;

public interface Connection {

system.rev20070609.acmesystem.login
       Source source();

    interface ConnectionBuilder.Login> login() {

            Sourcereturn source()login;

        }

 ConnectionBuilder source(Source source);

      @Override
        public ConnectionLoginBuilder buildname(String name) {
            this.name = name;
      }
      return this;
        }

File : Source.java

package org        @Override
        public LoginBuilder login(List<org.onosproject.yang.gen.v1.http.testacme.example.com.rev20160718.test.connection;

public interface Source {

system.rev20070609
          int address();

    byte port();

 .acmesystem
      interface SourceBuilder {

        int address();

.login.Login> login) {
            byte port();

this.login = login;
           SourceBuilder address(int address)return this;

        }
    SourceBuilder   port(byte port);

 @Override
        Sourcepublic Login build(); {
    }
}

File : link.yang
module link {
    yang-version 1;
    namespace http://huawei.com;
    prefix Ant;

    container link        return new DefaultLogin(this);
        }

        public LoginBuilder() {
        }
    }
}
 
File:LoginOpParam.java

package org.onosproject.yang.gen.v1.http.acme.example.com.system.rev20070609.acmesystem;
import java.util.List;
import org.onosproject.yangutils.datamodel.YangAugmentedInfo;
import org.onosproject.yangutils.datamodel.YangAugmentedOpParamInfo;
import java.util.BitSet;
public class LoginOpParam extends DefaultLogin  {
    public static enum  choice interfaceTypeOperationType {
        MERGE,
    case ethernerType {
  REPLACE,
        CREATE,
      leaf ethernet { type string; } DELETE,
        REMOVE
    }
    private OperationType opParamType;
    private BitSet filterLeafFlags case= p2pType {new BitSet();
    private BitSet selectLeafFlags = new BitSet();

    public BitSet leafgetFilterLeafFlags() p2p {
 type string; }
     return   filterLeafFlags;
    }
    public BitSet getSelectLeafFlags() {
 }
     }
}

File : InterfaceType.java
package org.onosproject.yang.gen.v1.http.huawei.com.rev20160509.choicecasetest.link1;

public interface InterfaceType {
}

File : EthernerType.java
package org.onosproject.yang.gen.v1.http.huawei.com.rev20160509.choicecasetest.link1.interfacetype;

import org.onosproject.yang.gen.v1.http.huawei.com.rev20160509.choicecasetest.link1.InterfaceType;

public interface EthernerType extends InterfaceType  {

    String ethernet();

    interface EthernerTypeBuilder {

return selectLeafFlags;
    }
    public OperationType getOpertionType() {
        return opParamType;
    }
    public boolean isFilterContentMatch(Object obj) {
        DefaultLogin StringappInstance = ethernet(DefaultLogin)obj;

        EthernerTypeBuilderfor ethernet(String ethernet);

YangAugmentedInfo yangAugmentedInfo : this.getYangAugmentedInfoMap().values()) {
          EthernerType build();
 if (!(yangAugmentedInfo  }
}

File : EthernerTypeBuilder.java
package org.onosproject.yang.gen.v1.http.huawei.com.rev20160509.choicecasetest.link1.interfacetype;

import com.google.common.base.MoreObjects;
import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
import org.onosproject.yangutils.translator.tojava.AugmentedInfo;

public class EthernerTypeBuilder implements EthernerType.EthernerTypeBuilder {

    private String ethernet;

    @Override
    public String ethernet() {instanceof  YangAugmentedOpParamInfo)) {
                throw new IllegalArgumentException("provided augmented info is invalid for content match.");
        return ethernet;
    }

    @Override
    public EthernerTypeBuilder ethernet(String ethernet) {
YangAugmentedInfo yangAugmentedOpParamInfo = appInstance
     this.ethernet = ethernet;
        return this.getAugmentedInfo(((YangAugmentedOpParamInfo) yangAugmentedInfo).getBaseClass());
    }

   @Override
   public EthernerType buildif(!((YangAugmentedOpParamInfo) {
yangAugmentedInfo).isFilterContentMatch(yangAugmentedOpParamInfo)) {
                return new EthernerTypeImpl(this)false;
   }

    public EthernerTypeBuilder() {
   }

   public final class EthernerTypeImpl implements EthernerType {}

        private String ethernet;
if (getFilterLeafFlags().get(1)) {
        @Override
    if (appInstance.name() == null public String ethernet(|| !(name().equals(appInstance.name()))) {
                return ethernetfalse;
            }
        }
        return true;
    }
    public EthernerTypeImplLoginOpParam(LoginOpParamBuilder builderObject) {
        }
super(builderObject);
        filterLeafFlags = builderObject.getFilterLeafFlags();
    }
    public EthernerTypeImpl(EthernerTypeBuilder builderObject)class LoginOpParamBuilder extends DefaultLogin.LoginBuilder {
        private OperationType opParamType;
         this.ethernetprivate BitSet filterLeafFlags = builderObject.ethernetnew BitSet();
        }
private BitSet selectLeafFlags = new }
}

File: sfc.yang
module Sfc {
    yang-version 1;BitSet();

        @Override
    namespace http://huawei.com;
   public prefix Ant;
    rpc SFP LoginBuilder name(String recvname) {
        input {
   name =  recvname;
      leaf port {
    getFilterLeafFlags().set(1);
            typereturn stringthis;
        }
      }
      public BitSet getFilterLeafFlags() {
            return filterLeafFlags;
        }
        public BitSet outputgetSelectLeafFlags() {
            return leafselectLeafFlags;
 path {
      }
        public OperationType type string;getOpertionType() {
            }return opParamType;
          }
    }
}

File : SfcService.java

package org.onosproject.yang.gen.v1.http.huawei.com.rev20160526;

import org.onosproject.yang.gen.v1.http.huawei.com.rev20160526.sfc.sfp.SfpInput;
import org.onosproject.yang.gen.v1.http.huawei.com.rev20160526.sfc.sfp.SfpOutput;

public interface SfcService public void setOpertionType(OperationType operationType) {
    SfpOutput sfp(SfpInput inputVar);
}
File : SfcManager.java
package org.onosproject.yang.gen.v1.http.huawei.com.rev20160526;

import org.apache.felix.scr.annotations.Activate;
import org.apache.felix.scr.annotations.Component;
import org.apache.felix.scr.annotations.Deactivate;
import org.apache.felix.scr.annotations.Service;
import org.onosproject.yang.gen.v1.http.huawei.com.rev20160526.sfc.sfp.SfpInput;
import org.onosproject.yang.gen.v1.http.huawei.com.rev20160526.sfc.sfp.SfpOutput;
import org.slf4j.Logger;
import static org.slf4j.LoggerFactory.getLogger;

@Component (immediate = true)
@Service
public class SfcManager implements SfcService {

    private final Logger log = getLogger(getClass());

    @Activate
    public void activate()         this.opParamType = operationType;
        }
    }
}
 

File : ospf.yang
module ospf {
    namespace "http://example.com/ospf";
    prefix "ospf";

    notification test for (YangAugmentedInfo yangAugmentedInfo : this.getYangAugmentedInfoMap().values()) {
            if (!(yangAugmentedInfo  instanceof  YangAugmentedOpParamInfo)) {
                throw new IllegalArgumentException("provided augmented info is invalid for content match.");
            }
            YangAugmentedInfo yangAugmentedOpParamInfo = appInstance
            .getAugmentedInfo(((YangAugmentedOpParamInfo) yangAugmentedInfo).getBaseClass());
            if(!((YangAugmentedOpParamInfo) yangAugmentedInfo).isFilterContentMatch(yangAugmentedOpParamInfo)) {
                return false;
            }
        }
        if (getFilterLeafFlags().get(1)) {
            if (appInstance.ethernet() == null leaf event-class|| !(ethernet().equals(appInstance.ethernet()))) {
               type return stringfalse;
            }
        }
   leaf severity {     return true;
    }
    public EthernerTypeOpParam(EthernerTypeOpParamBuilder builderObject) {
       type stringsuper(builderObject);
        filterLeafFlags = builderObject.getFilterLeafFlags();
    }
    }
}

File : OspfManager.java
package org.onosproject.yang.gen.v1.http.example.com.ospf.rev20160519;

import org.apache.felix.scr.annotations.Activate;
import org.apache.felix.scr.annotations.Component;
import org.apache.felix.scr.annotations.Deactivate;
import org.apache.felix.scr.annotations.Service;
import org.onosproject.event.ListenerRegistry;
import org.onosproject.yang.gen.v1.http.example.com.ospf.rev20160519.ospf.OspfEvent;
import org.onosproject.yang.gen.v1.http.example.com.ospf.rev20160519.ospf.OspfListener;
import org.slf4j.Logger;
import static org.slf4j.LoggerFactory.getLogger;

@Component (immediate = true)
@Service
public class OspfManager
public class EthernerTypeOpParamBuilder extends DefaultEthernerType.EthernerTypeBuilder {
        private OperationType opParamType;
        private BitSet filterLeafFlags = new BitSet();
        private BitSet selectLeafFlags = new BitSet();

        @Override
        public EthernerTypeBuilder ethernet(String recvethernet) {
            extendsethernet ListenerRegistry<OspfEvent,= OspfListener>recvethernet;
         implements  OspfService {

 getFilterLeafFlags().set(1);
        private final Logger log = getLogger(getClass());
return this;
        }
    @Activate
    public voidBitSet activategetFilterLeafFlags() {
         //TODO: YANG utils generatedreturn code
    filterLeafFlags;
    log.info("Started");
    }

    @Deactivate
    public voidBitSet deactivategetSelectLeafFlags() {
        //TODO:  YANG utils generatedreturn codeselectLeafFlags;
        }
   log.info("Stopped");
    }
}

File : OspfService.java
package org.onosproject.yang.gen.v1.http.example.com.ospf.rev20160519;

import org.onosproject.event.ListenerService;
import org.onosproject.yang.gen.v1.http.example.com.ospf.rev20160519.ospf.OspfEvent;
import org.onosproject.yang.gen.v1.http.example.com.ospf.rev20160519.ospf.OspfListener;

public interface OspfService
 public OperationType getOpertionType() {
            extends ListenerService<OspfEvent, OspfListener> {
}

File : OspfEvent.java
package org.onosproject.yang.gen.v1.http.example.com.ospf.rev20160527.ospf;

import org.onosproject.event.AbstractEvent;

public class OspfEvent extends AbstractEvent<OspfEvent.Type, OspfEventSubject> {

return opParamType;
        }
        public enum Typevoid setOpertionType(OperationType operationType) {

    TEST
    }

    public OspfEvent(Type type, OspfEventSubject subject) {this.opParamType = operationType;
        super(type, subject);}
    }
}

File : Test.yang
module Test {
     yang-version 1;
     namespace "http://huawei.com";
     prefix Ant;
     description "Interval before a route is declared invalid";

     container interface {    CREATE,
        DELETE,
        REMOVE
    }
    private OperationType opParamType;
    private BitSet filterLeafFlags = new BitSet();
    private BitSet selectLeafFlags = new BitSet();

    public BitSet getFilterLeafFlags() {
        return filterLeafFlags;
    }
    public BitSet getSelectLeafFlags() {
        return selectLeafFlags;
    }
    public OperationType getOpertionType() {
        return opParamType;
    }
    public boolean isFilterContentMatch(Object obj) {
        DefaultSfpInput appInstance = (DefaultSfpInput)obj;
        for (YangAugmentedInfo yangAugmentedInfo : this.getYangAugmentedInfoMap().values()) {
            if (!(yangAugmentedInfo  instanceof  YangAugmentedOpParamInfo)) {
                throw new IllegalArgumentException("provided augmented info is invalid for content match.");
            }
            YangAugmentedInfo yangAugmentedOpParamInfo = appInstance
            .getAugmentedInfo(((YangAugmentedOpParamInfo) yangAugmentedInfo).getBaseClass());
            if(!((YangAugmentedOpParamInfo) yangAugmentedInfo).isFilterContentMatch(yangAugmentedOpParamInfo)) {
                return false;
            }
        }
        if (getFilterLeafFlags().get(1)) {
            if (appInstance.port() == null || !(port().equals(appInstance.port()))) {
                return false;
          leaf ifType {}
        }
        typereturn stringtrue;
    }
    public SfpInputOpParam(SfpInputOpParamBuilder builderObject) }{
     }

   super(builderObject);
  augment "/Test/interface" {
      filterLeafFlags = builderObject.getFilterLeafFlags();
    }
 leaf ds0ChannelNumber {
 public class SfpInputOpParamBuilder extends DefaultSfpInput.SfpInputBuilder {
        private typeOperationType int16opParamType;
        private }
BitSet filterLeafFlags = new }
}

File : AugmentedInterface.java


package org.onosproject.yang.gen.v1.http.huawei.com.rev20160428.test;
import org.onosproject.yangutils.utils.AugmentedInfo;

public interface AugmentedInterface extends AugmentedInfo  {
   
    short getDs0ChannelNumber();
   
    interface AugmentedInterfaceBuilder {
 
BitSet();
        private BitSet selectLeafFlags = new BitSet();

        @Override
        public SfpInputBuilder port(String recvport) {
            port = recvport;
           short getDs0ChannelNumbergetFilterLeafFlags().set(1);

           AgmentedInterfaceBuilder setDs0ChannelNumber(short ds0ChannelNumber);

return this;
        }
        public AugmentedInterfaceBitSet buildgetFilterLeafFlags(); {
    }
}

File : AugmentedInterfaceBuilder.java
package org.onosproject.yang.gen.v1.http.huawei.com.rev20160428.test;
import java.util.Objects;
import com.google.common.base.MoreObjects;
import org.onosproject.yang.gen.v1.http.huawei.com.rev20160428.test.InterfaceBuilder.InterfaceImpl;

public class AugmentedInterfaceBuilder implements AugmentedInterface.AugmentedInterfaceBuilder        return filterLeafFlags;
        }
        public BitSet getSelectLeafFlags() {
   private short ds0ChannelNumber;

   @Override
   public short getDs0ChannelNumber() {return selectLeafFlags;
       return ds0ChannelNumber;}
   }

   @Override
   public AugmentedInterfaceBuilderOperationType setDs0ChannelNumbergetOpertionType(short ds0ChannelNumber)  {
          this.ds0ChannelNumber  =return ds0ChannelNumberopParamType;
       return this;}
   }

   @Override
   public AugmentedInterfacevoid buildsetOpertionType(OperationType operationType) {
          return new AugmentedInterfaceImpl(this)this.opParamType = operationType;
   }

   public AugmentedInterfaceBuilder() {}
    }
}
File : Sfpoutput.java

package org.onosproject.yang.gen.v1.http.huawei.com.rev20160721.sfc.sfp;
public finalinterface class AugmentedInterfaceImpl implements AugmentedInterface SfpOutput {

       private short ds0ChannelNumber;
String path();
    interface SfpOutputBuilder  @Override{
       public shortString getDs0ChannelNumberpath() {;
        SfpOutputBuilder path(String path);
 return ds0ChannelNumber;
      SfpOutput }build();

    }
}
File :  @Override
       Public int hashCode()DefaultSfpOutput.java

package org.onosproject.yang.gen.v1.http.huawei.com.rev20160721.sfc.sfp;
import com.google.common.base.MoreObjects;
import java.util.HashMap;
import java.util.Map;
import java.util.Objects;
import org.onosproject.yangutils.datamodel.YangAugmentedInfo;
public class DefaultSfpOutput implements SfpOutput {
    private Map<Class<?>, YangAugmentedInfo> yangAugmentedInfoMap =   return Objects.hash(ds0ChannelNumbernew HashMap<>();
    protected String  }path;

       @Override
       public booleanString equalspath(Object obj) {
        return path;
    if}
 (this == obj) {@Override
    public int hashCode() {
        return trueObjects.hash(path);
    }
    @Override
   }

 public boolean equals(Object obj) {
        if (objthis instanceof== AugmentedInterfaceImplobj) {
               AugmentedInterfaceImpl other = (AugmentedInterfaceImpl) obj;return true;
        }
        if (obj instanceof DefaultSfpOutput) {
            DefaultSfpOutput other  return
= (DefaultSfpOutput) obj;
            return
                 Objects.equals(ds0ChannelNumberpath, other.ds0ChannelNumberpath);
           }
           return false;
       }

       @Override
       public String toString() {
           return MoreObjects.toStringHelper(getClass())
               .add("ds0ChannelNumberpath", ds0ChannelNumberpath)
               .toString();
    }
    public DefaultSfpOutput(SfpOutputBuilder builderObject) }{

        Public AugmentedInterfaceImpl(AugmentedInterfaceBuilderthis.path = builderObject.path() {
;
    }
    public void addAugmentedInfo(YangAugmentedInfo value, Class classObject) {
      this.ds0ChannelNumber = builderObjectyangAugmentedInfoMap.getDs0ChannelNumberput(classObject, value);
    }
    public  InterfaceImpl interfaceImpl = new InterfaceBuilder().new InterfaceImpl(YangAugmentedInfo getAugmentedInfo(Class classObject) {
        return yangAugmentedInfoMap.get(classObject);
    }
    public  interfaceImpl.addAugmentation(this);Map<Class<?>, YangAugmentedInfo> getYangAugmentedInfoMap() {
       } return yangAugmentedInfoMap;
    }
}

leaf one {    public class SfpOutputBuilder implements SfpOutput.SfpOutputBuilder {
        protected String path;

        @Override
        public String path() {
            return path;
   
    type string;
}

leaf two {      @Override
        public SfpOutputBuilder path(String path) {
         
   this.path type= int32path;
}

leaf-list three {
    type boolean;
}

leaf-list four {   return this;
        }
     type int16;
}

private String one;@Override

private  int two;

private List<Boolean> three;

private List<Short> four;

File : test.yang

module test {

    yang-version 1;
    namespace "http://huawei.com";
    prefix "test";

    typedef percent { public SfpOutput build() {
            return new DefaultSfpOutput(this);
        type uint8;}
           description "Percentage";
    }

    leaf completedpublic SfpOutputBuilder() {
        type percent;}
    }
}

File 
 
File: PercentSfpOutputOpParam.java

package org.onosproject.yang.gen.v1.http.huawei.com.rev20160721.rev20160526sfc.testsfp;

import java.util.Objectsorg.onosproject.yangutils.datamodel.YangAugmentedInfo;
import comorg.googleonosproject.commonyangutils.basedatamodel.MoreObjectsYangAugmentedOpParamInfo;
import java.util.BitSet;
public final class Percentclass SfpOutputOpParam extends DefaultSfpOutput  {

    privatepublic short uint8;

  static enum OperationType {
  private Percent() {
    }MERGE,


     public Percent(short value) {REPLACE,
        CREATE,
  this.uint8 = value;
    }
DELETE,
    public static Percent of(short value) { REMOVE
    }
    returnprivate new Percent(value)OperationType opParamType;
    }

private BitSet filterLeafFlags = publicnew short uint8BitSet() {;
    private BitSet selectLeafFlags = returnnew uint8;
    }BitSet();

    @Override
    public intBitSet hashCodegetFilterLeafFlags() {
        return Objects.hash(uint8)filterLeafFlags;
    }

    @Override
    public booleanBitSet equalsgetSelectLeafFlags(Object obj) {
        if (this == obj) {return selectLeafFlags;
    }
    public OperationType getOpertionType() {
        return trueopParamType;
        }
    public boolean   if (obj instanceof PercentisFilterContentMatch(Object obj) {
        DefaultSfpOutput appInstance   Percent other = (PercentDefaultSfpOutput) obj;
        for (YangAugmentedInfo yangAugmentedInfo : return Objectsthis.equals(uint8, other.uint8);getYangAugmentedInfoMap().values()) {
        }
    if (!(yangAugmentedInfo  instanceof  return false;YangAugmentedOpParamInfo)) {
    }

     @Override
    public String toString() {
throw new IllegalArgumentException("provided augmented info is invalid for returncontent MoreObjects.toStringHelper(getClass())match.");
            .add("uint8", uint8)}
            .toString();
    }

YangAugmentedInfo yangAugmentedOpParamInfo = appInstance
            .getAugmentedInfo(((YangAugmentedOpParamInfo) yangAugmentedInfo).getBaseClass());
         public static Percent fromString(String valInString) {
if(!((YangAugmentedOpParamInfo) yangAugmentedInfo).isFilterContentMatch(yangAugmentedOpParamInfo)) {
                return false;
           try {}
        }
    short   tmpVal = Short.parseShort(valInString);if (getFilterLeafFlags().get(1)) {
            return of(tmpVal);
if (appInstance.path() == null || !(path().equals(appInstance.path()))) {
             } catch (Exception e)return {false;
            }
        }
        return nulltrue;
    }
}

File: test.yang
module Test {

    public SfpOutputOpParam(SfpOutputOpParamBuilder builderObject) {
        super(builderObject);
    yang-version 1;
   filterLeafFlags namespace "http://huawei.com"= builderObject.getFilterLeafFlags();
    prefix}
 Ant;
   public descriptionclass "IntervalSfpOutputOpParamBuilder beforeextends a route is declared invalid";

DefaultSfpOutput.SfpOutputBuilder {
       leaf private packetTypeOperationType {opParamType;
        private type enumeration {BitSet filterLeafFlags = new BitSet();
        private BitSet selectLeafFlags =  enum "unbounded"new BitSet();

        @Override
      enum ZERO;
 public SfpOutputBuilder path(String recvpath) {
      enum two;
     path = recvpath;
      enum four;
     getFilterLeafFlags().set(1);
    }        return this;
        }
}

File : PacketTypeEnum.java

package org.onosproject.yang.gen.v1.http.huawei.com.rev20160526.test;

public enum PacketTypeEnum {

  public BitSet UNBOUNDEDgetFilterLeafFlags(0), {

     ZERO(1),

    TWO(2),

   return FOUR(3)filterLeafFlags;
        }
    private int packetTypeEnum;

  public BitSet PacketTypeEnumgetSelectLeafFlags(int value) {
        packetTypeEnum = value;
  return  }selectLeafFlags;

    public static PacketTypeEnum of(int value) {
 }
        public switchOperationType getOpertionType(value) {
            casereturn 0:opParamType;
        }
        return PacketTypeEnum.UNBOUNDED;
    public void setOpertionType(OperationType operationType) {
        case 1:
                    return PacketTypeEnum.ZERO;
            case 2:
                    return PacketTypeEnum.TWO;
            case 3:
           this.opParamType = operationType;
         return PacketTypeEnum.FOUR;
            default :
                    return null;
            }
    }


    public int packetTypeEnum() {
            return packetTypeEnum;
    }

    public static PacketTypeEnum fromString(String valInString) {
            try {
                int tmpVal = Integer.parseInt(valInString);
                return of(tmpVal);
            } catch (Exception e) {
        }
        return null;
    }
}

File : IpAddressUnionOspfManager.java

package org.onosproject.yang.gen.v1.http.huaweiexample.com.rev20160526ospf.test.ipaddressrev20160721;

import java.util.Objectsorg.apache.felix.scr.annotations.Activate;
import comorg.apache.googlefelix.commonscr.baseannotations.MoreObjectsComponent;

public final class IpAddressUnion {

    private int int32;
    private long uint32;

    private IpAddressUnion() {
    }

    public IpAddressUnion(int value) {import org.apache.felix.scr.annotations.Deactivate;
import org.apache.felix.scr.annotations.Service;
import org.onosproject.event.ListenerRegistry;
import org.onosproject.yang.gen.v1.http.example.com.ospf.rev20160721.ospf.OspfEvent;
import org.onosproject.yang.gen.v1.http.example.com.ospf.rev20160721.ospf.OspfEventListener;
import org.slf4j.Logger;
import static org.slf4j.LoggerFactory.getLogger;

@Component(immediate = true)
@Service
public class OspfManager
        this.int32 = value;extends ListenerRegistry<OspfEvent, OspfEventListener>
    }

    publicimplements IpAddressUnion(long value) OspfService {
    private final Logger  this.uint32log = valuegetLogger(getClass());
    }@Activate

    public staticvoid IpAddressUnion of(int valueactivate() {
        return new IpAddressUnion(value);
    }

//TODO: YANG utils generated code
      public static IpAddressUnion of(long value) { log.info("Started");
        return new IpAddressUnion(value);}
    }
@Deactivate
    public intvoid int32deactivate() {
        return int32;
    }

//TODO: YANG utils generated code
      public long uint32() {log.info("Stopped");
    }
    return uint32;
    }

@Override
    public Ospf getOspf() {
     @Override
   //TODO: publicYANG intutils hashCode()generated {code
        return Objects.hash(int32, uint32)null;
    }

    @Override
    public booleanvoid equalssetOspf(ObjectOspf objospf) {
        if (this == obj) {//TODO: YANG utils generated code
    }
}
File : OspfService.java

package org.onosproject.yang.gen.v1.http.example.com.ospf.rev20160721;
import org.onosproject.event.ListenerService;
import    return true;
      }org.onosproject.yang.gen.v1.http.example.com.ospf.rev20160721.ospf.OspfEvent;
import org.onosproject.yang.gen.v1.http.example.com.ospf.rev20160721.ospf.OspfEventListener;
public interface OspfService
        ifextends (obj instanceof IpAddressUnion)ListenerService<OspfEvent, OspfEventListener> {
    Ospf getOspf();
    void setOspf(Ospf  IpAddressUnion other = (IpAddressUnion) obj;
     ospf);
}

File : OspfEvent.java
package org.onosproject.yang.gen.v1.http.example.com.ospf.rev20160527.ospf;

import org.onosproject.event.AbstractEvent;

public class OspfEvent extends AbstractEvent<OspfEvent.Type, OspfEventSubject> {

    public enum Type return{

    TEST
    }

    public OspfEvent(Type type,   Objects.equals(int32, other.int32) &&OspfEventSubject subject) {
        super(type, subject);
    }

    public Objects.equals(uint32, other.uint32);
    OspfEvent(Type type, OspfEventSubject subject, long time) {
    }
    super(type,    return falsesubject, time);
    }
}

File :   @Override
    public String toString() {OspfEventSubject.java
package org.onosproject.yang.gen.v1.http.example.com.ospf.rev20160519.ospf;

public class OspfEventSubject {

    private Test test;

  return MoreObjects.toStringHelper(getClass())  public Test test() {
            .omitNullValues()return test;
    }

    public void   .add("int32", int32)test(Test test) {
        this.test = test;
   .add("uint32", uint32)
            .toString();
    }

    public static IpAddressUnion fromString(String valInString) { }
}

File : OspfEventListener.java

package org.onosproject.yang.gen.v1.http.example.com.ospf.rev20160519.ospf;

import org.onosproject.event.EventListener;

public interface OspfEventListener extends EventListener<OspfEvent> {
}

File : Test.java

package org.onosproject.yang.gen.v1.http.example.com.ospf.rev20160721.ospf;

public interface Test {
    String eventClass();
    String severity();
    interface TestBuilder   try {
          int tmpVal = Integer.parseInt(valInStringString eventClass();
        String  return ofseverity(tmpVal);
        }TestBuilder catch eventClass(ExceptionString eeventClass) {;
        }
TestBuilder        try {
          long tmpVal = Long.parseLong(valInStringseverity(String severity);
        Test  return ofbuild(tmpVal);
        } catch (Exception e) {
        }
        return null;
   }
}

File : FlowClassifierServiceDefaultTest.java
package org.onosproject.yang.gen.v1.sfc.flowclassifier.rev20160524.http.example.com.ospf.rev20160721.ospf;

import orgcom.onosprojectgoogle.yangcommon.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev20100924.ietfyangtypes.Uuidbase.MoreObjects;
import java.util.HashMap;
import java.util.Map;
import java.util.Objects;
import org.onosproject.yangutils.datamodel.YangAugmentedInfo;

public interface FlowClassifierServiceclass DefaultTest implements Test {

    Uuid getIdprivate Map<Class<?>, YangAugmentedInfo> yangAugmentedInfoMap = new HashMap<>();

    voidprotected setId(Uuid id)String eventClass;
}

File : FlowClassifierManager.java
package org.onosproject.yang.gen.v1.sfc.flowclassifier.rev20160524;

import org.apache.felix.scr.annotations.Activate;
import org.apache.felix.scr.annotations.Component;
import org.apache.felix.scr.annotations.Deactivate;
import org.apache.felix.scr.annotations.Service;
import org.onosproject.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev20100924.ietfyangtypes.Uuid;
import org.slf4j.Logger;
import static org.slf4j.LoggerFactory.getLogger;

@Component (immediate = true)
@Service
public class FlowClassifierManager implements FlowClassifierService {

    private final Logger log = getLogger(getClass());

    @Activate protected String severity;

    @Override
    public String eventClass() {
        return eventClass;
    }

    @Override
    public voidString activateseverity() {
        //TODO: YANG utils generated codereturn severity;
    }

    @Override
     log.info("Started"public int hashCode() {
        return Objects.hash(eventClass, severity);
    }

    @Deactivate@Override
    public voidboolean deactivateequals(Object obj) {
        //TODO: YANG utils generated code
if (this == obj) {
          log.info("Stopped")  return true;
        }

     @Override
   if public(obj Uuidinstanceof getId(DefaultTest) {
        //TODO: YANG utils generated code
    DefaultTest other = (DefaultTest) obj;
            return
 null;
      }

    @Override
    public void setId(Uuid id) {Objects.equals(eventClass, other.eventClass) &&
        //TODO: YANG utils generated code
    }

}

File : IetfYangTypesService.java
package org.onosproject.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev20100924;

public interface IetfYangTypesService {
}

File : IetfYangTypesManager.java
package org.onosproject.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev20100924;

import org.apache.felix.scr.annotations.Activate;
import org.apache.felix.scr.annotations.Component;
import org.apache.felix.scr.annotations.Deactivate;
import org.apache.felix.scr.annotations.Service;
import org.slf4j.Logger;
import static org.slf4j.LoggerFactory.getLogger;

@Component (immediate = true)
@Service
public class IetfYangTypesManager implements IetfYangTypesService {

    private final Logger log = getLogger(getClass());

    @Activate
    public void activate() {
Objects.equals(severity, other.severity);
        }
        return false;
    }

    @Override
    public String toString() {
        return MoreObjects.toStringHelper(getClass())
            .add("eventClass", eventClass)
         //TODO: YANG utils generated code .add("severity", severity)
        log.info("Started"    .toString();
    }

    public DefaultTest(TestBuilder builderObject) @Deactivate{
    public void deactivate() {
 this.eventClass = builderObject.eventClass();
     //TODO: YANG utils generated code
        log.info("Stopped"this.severity = builderObject.severity();
    }
}

File  : Uuid.java
package org.onosproject.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev20100924.ietfyangtypes;
import java.util.Objects;
import com.google.common.base.MoreObjects;

public final class Uuid public void addAugmentedInfo(YangAugmentedInfo value, Class classObject) {
    private String string;

    private Uuid() {yangAugmentedInfoMap.put(classObject, value);
    }

    public YangAugmentedInfo UuidgetAugmentedInfo(StringClass valueclassObject) {
        return this.string = valueyangAugmentedInfoMap.get(classObject);
    }

    public static Uuid of(String valueMap<Class<?>, YangAugmentedInfo> getYangAugmentedInfoMap() {
        return new Uuid(value)yangAugmentedInfoMap;
    }

    public class String string()TestBuilder implements Test.TestBuilder {

        protected returnString stringeventClass;
    }

    protected String severity;


        @Override
        public intString hashCodeeventClass() {
            return Objects.hash(string)eventClass;
    }

    @Override}

    public boolean equals(Object obj) {@Override
        public ifString severity(this == obj) {
            return trueseverity;
        }

        if (obj instanceof Uuid) {@Override
        public TestBuilder   Uuid other = (Uuid) obj;eventClass(String eventClass) {
            return
this.eventClass = eventClass;
               Objects.equals(string, other.string)return this;
        }

        return false;@Override
    }

    @Override
public    public TestBuilder severity(String toString(severity) {
           return MoreObjects.toStringHelper(getClass())this.severity = severity;
            .add("string", string)
return this;
        }
     .toString();   @Override
    }

    public staticTest Uuid fromString(String valInStringbuild() {
        try {
   return new DefaultTest(this);
       String tmpVal = (valInString); }

        public TestBuilder() {
        }
    }
}
 
File:TestOpParam.java
package org.onosproject.yang.gen.v1.http.example.com.ospf.rev20160721.ospf;

import  return of(tmpVal);
        } catch (Exception e) {org.onosproject.yangutils.datamodel.YangAugmentedInfo;
import org.onosproject.yangutils.datamodel.YangAugmentedOpParamInfo;
import java.util.BitSet;

public class TestOpParam extends DefaultTest  {
    public static enum OperationType {
        MERGE,
        REPLACE,
        CREATE,
        DELETE,
        REMOVE
    }
    private OperationType opParamType;
    private BitSet filterLeafFlags = returnnew nullBitSet();
    }
}

File : ietf-network.yang
module ietf-networkprivate BitSet selectLeafFlags = new BitSet();


    public BitSet getFilterLeafFlags() {
    yang-version 1;
    namespace "urn:ietf:params:xml:ns:yang:ietf-network"return filterLeafFlags;
    prefix nd;}

    container networkspublic BitSet getSelectLeafFlags() {
        descriptionreturn selectLeafFlags;
    }

    public OperationType getOpertionType() {
  "Serves as top-level container for a listreturn ofopParamType;
    }

    public boolean isFilterContentMatch(Object  networks.";obj) {
        leaf network-id {DefaultTest appInstance = (DefaultTest)obj;
        for (YangAugmentedInfo yangAugmentedInfo  type uint8;: this.getYangAugmentedInfoMap().values()) {
            description
 if (!(yangAugmentedInfo  instanceof  YangAugmentedOpParamInfo)) {
      "Identifies a network.";
        }
throw new IllegalArgumentException("provided augmented }
info is invalid for container network-id {content match.");
        description
    }

        "Serves as top-level container forYangAugmentedInfo ayangAugmentedOpParamInfo list= ofappInstance
            networks.".getAugmentedInfo(((YangAugmentedOpParamInfo) yangAugmentedInfo).getBaseClass());
        leaf network-id {
  if(!((YangAugmentedOpParamInfo) yangAugmentedInfo).isFilterContentMatch(yangAugmentedOpParamInfo)) {
        type leafref {
      return false;
         path "/nd:networks/nd:network-id";
    }
        }
        }
    }
}

File : Networks.java
public interface Networks { 
    short networkId(); if (getFilterLeafFlags().get(1)) {
            if (appInstance.eventClass() == null || !(eventClass().equals(appInstance.eventClass()))) {
    interface  NetworksBuilder { 
        shortreturn networkId()false;
            }
     NetworksBuilder networkId(short networkId); }
        Networks build();
if (getFilterLeafFlags().get(2)) {
      }
}

File : NetworkId.java
public interface NetworkId { 
    short networkRef(); if (appInstance.severity() == null || !(severity().equals(appInstance.severity()))) {
    interface  NetworkIdBuilder { 
        shortreturn networkRef()false;
        NetworkIdBuilder networkRef(short networkRef);     }
        }
        NetworkIdreturn build()true;
    }
} 

File : ietf-network.yang
module ietf-network {
    yang-version 1

    public TestOpParam(TestOpParamBuilder builderObject) {
        super(builderObject);
    namespace "urn:ietf:params:xml:ns:yang:ietf-network"    filterLeafFlags = builderObject.getFilterLeafFlags();
    prefix nd;}

    public identity tunnel-typeclass TestOpParamBuilder extends DefaultTest.TestBuilder {
      description  "Baseprivate identityOperationType fromopParamType;
 which specific tunnel types are derived.";
  private  }

}

File : TunnelType.java
public abstract class TunnelType {
}

File : ietf-network.yang
module ietf-network {
    yang-version 1;BitSet filterLeafFlags = new BitSet();
        private BitSet selectLeafFlags = new BitSet();


    namespace "urn:ietf:params:xml:ns:yang:ietf-network";
    prefix nd;
@Override
    identity tunnel-type {
  public TestBuilder eventClass(String recveventClass) description{
  "Base identity from which specific tunnel types are derived.";
  eventClass = }recveventClass;

      container network-id {
    getFilterLeafFlags().set(1);
    description "Serves as top-level container for a list ofreturn networks."this;
        }
 leaf leaf-network-id {
     @Override
       type identityrefpublic {
TestBuilder severity(String recvseverity) {
            severity base= tunnel-typerecvseverity;
            }getFilterLeafFlags().set(2);
        }
    }

}

File : TunnelType.java
public abstract class TunnelType {
}
 
File : NetworkId.java
public interface NetworkId { 
    TunnelType leafNetworkId(); 
    interface NetworkIdBuilder { 
  return this;
        }

        public BitSet getFilterLeafFlags() {
            return filterLeafFlags;
      TunnelType leafNetworkId(); }

        NetworkIdBuilderpublic BitSet leafNetworkIdgetSelectLeafFlags(TunnelType leafNetworkId); {
        NetworkId build();
    return selectLeafFlags;
        }
} 

File : test.yang
module Test {
    yang-version 1;

        public OperationType getOpertionType() {
    namespace http://huawei.com;
    prefix Ant;
  return opParamType;
 typedef MyBits {
        type bits {
             bit disable-nagle {
                 position 0;
             }
             bit auto-sense-speed {
        public void setOpertionType(OperationType       position 1;
             }
             bit Mb-only operationType) {
            this.opParamType     position 2= operationType;
             }
         }
    }
}

File : test.yang
module Testpublic boolean equals(Object obj) {
   yang-version 1;
   namespace http://huawei.com;
   prefix Ant;
 if (this == obj) {
   typedef MyBinary {
      type binaryreturn {true;
         length "4";}
      }
   }
}

File: MyBinary.java
package org.onosproject.yang.gen.v1.http.huawei.com.rev20160718.test;
import java.util.Objects;
import com.google.common.base.MoreObjects;
import java.util.Base64;
/**
 * Represents the implementation of myBinary.
 */
public final class MyBinary {
   private byte[] binary;

   /**
   * Creates an instance of myBinary.
   */
   private MyBinary() {
   }

   /**
   * Creates an instance of myBinaryForTypeBinary.
   *
   * @param value value of myBinaryForTypeBinary
   */
   public MyBinary(byte[] valueif (obj instanceof DefaultAugmentedYangAutoPrefixInterface) {
            DefaultAugmentedYangAutoPrefixInterface other = (DefaultAugmentedYangAutoPrefixInterface) obj;
            return
                 Objects.equals(ds0ChannelNumber, other.ds0ChannelNumber);
        }
        return false;
    }

    @Override
    public String toString() {
      this.binary  = value;return MoreObjects.toStringHelper(getClass())
   }         .add("ds0ChannelNumber", ds0ChannelNumber)
 
   /**
   * Returns the object of myBinaryForTypeBinary.toString();
   * }

    public * @param value value of myBinaryForTypeBinary
DefaultAugmentedYangAutoPrefixInterface(AugmentedYangAutoPrefixInterfaceBuilder builderObject) {
      * @return Objectthis.ds0ChannelNumber of myBinaryForTypeBinary= builderObject.ds0ChannelNumber();
   */ }

    public static MyBinary of(byte[] value) class AugmentedYangAutoPrefixInterfaceBuilder implements AugmentedYangAutoPrefixInterface
                .AugmentedYangAutoPrefixInterfaceBuilder {

      return  protected new MyBinary(value)short ds0ChannelNumber;


   }
 
   /**
     @Override
        public short ds0ChannelNumber() {
         * Returns the attributereturn binary.ds0ChannelNumber;
   *
     }

    * @return value of binary@Override
   */
     public byte[]AugmentedYangAutoPrefixInterfaceBuilder binaryds0ChannelNumber(short ds0ChannelNumber) {
         return binary;
  this.ds0ChannelNumber }
= ds0ChannelNumber;
   @Override
   public int hashCode() {
      return Objects.hash(binary);
   }
 
   @Override
   public boolean equals(Object obj) {
      if (this == obj) {
         return true;
      }
      if (obj instanceof MyBinary) {
         MyBinary other = (MyBinary) obj;
         return Objects.equals(binary, other.binary);
      }
      return false;
   }
 
   @Override
   public String toString() {
      return Base64.getEncoder().encodeToString(binary);
   }
 
   /**
   * Returns the object of myBinary fromString input String.
   *
   * @param valInString input String
   * @return Object of myBinary
   */
   public static MyBinary fromString(String valInString) {
      try {
         byte[] tmpVal = Base64.getDecoder().decode(valInString);
         return of(tmpVal);
      } catch (Exception e) {
      }
      return null;
   }
}