selenium-server-standalone-2.42.2 Java Tiger

   onChanged();
      }
      mergeUnknownFields(other.getUnknownFields());
      return this;
    }
    
    public final boolean isInitialized()
    {
      return true;
    }
    
    public Builder mergeFrom(CodedInputStream input, ExtensionRegistryLite extensionRegistry)
      throws IOException
    {
      UnknownFieldSet.Builder unknownFields = UnknownFieldSet.newBuilder(getUnknownFields());
      for (;;)
      {
        int tag = input.readTag();
        switch (tag)
        {
        case 0: 
          setUnknownFields(unknownFields.build());
          onChanged();
          return this;
        default: 
          if (!parseUnknownField(input, unknownFields, extensionRegistry, tag))
          {
            setUnknownFields(unknownFields.build());
            onChanged();
            return this;
          }
          break;
        case 10: 
          ensureNameListIsMutable();
          nameList_.add(input.readBytes());
        }
      }
    }
    
    private LazyStringList nameList_ = LazyStringArrayList.EMPTY;
    
    private void ensureNameListIsMutable()
    {
      if ((bitField0_ & 0x1) != 1)
      {
        nameList_ = new LazyStringArrayList(nameList_);
        bitField0_ |= 0x1;
      }
    }
    
    public List<String> getNameListList()
    {
      return Collections.unmodifiableList(nameList_);
    }
    
    public int getNameListCount()
    {
      return nameList_.size();
    }
    
    public String getNameList(int index)
    {
      return (String)nameList_.get(index);
    }
    
    public Builder setNameList(int index, String value)
    {
      if (value == null) {
        throw new NullPointerException();
      }
      ensureNameListIsMutable();
      nameList_.set(index, value);
      onChanged();
      return this;
    }
    
    public Builder addNameList(String value)
    {
      if (value == null) {
        throw new NullPointerException();
      }
      ensureNameListIsMutable();
      nameList_.add(value);
      onChanged();
      return this;
    }
    
    public Builder addAllNameList(Iterable<String> values)
    {
      ensureNameListIsMutable();
      GeneratedMessage.Builder.addAll(values, nameList_);
      onChanged();
      return this;
    }
    
    public Builder clearNameList()
    {
      nameList_ = LazyStringArrayList.EMPTY;
      bitField0_ &= 0xFFFFFFFE;
      onChanged();
      return this;
    }
    
    void addNameList(ByteString value)
    {
      ensureNameListIsMutable();
      nameList_.add(value);
      onChanged();
    }
  }
  
  private static final CssIndexMap defaultInstance = new CssIndexMap(true);
  public static final int NAMELIST_FIELD_NUMBER = 1;
  private LazyStringList nameList_;
  private static final long serialVersionUID = 0L;
  
  static
  {
    defaultInstance.initFields();
  }
}

/* Location:
 * Qualified Name:     com.opera.core.systems.scope.protos.EsdbgProtos.CssIndexMap
 * Java Class Version: 6 (50.0)
 * JD-Core Version:    0.7.1
 */
package com.opera.core.systems.scope.protos;

import com.google.protobuf.MessageOrBuilder;
import java.util.List;

public abstract interface EsdbgProtos$CssIndexMapOrBuilder
  extends MessageOrBuilder
{
  public abstract List<String> getNameListList();
  
  public abstract int getNameListCount();
  
  public abstract String getNameList(int paramInt);
}

/* Location:
 * Qualified Name:     com.opera.core.systems.scope.protos.EsdbgProtos.CssIndexMapOrBuilder
 * Java Class Version: 6 (50.0)
 * JD-Core Version:    0.7.1
 */
package com.opera.core.systems.scope.protos;

import com.google.protobuf.ByteString;
import com.google.protobuf.CodedInputStream;
import com.google.protobuf.Descriptors.Descriptor;
import com.google.protobuf.ExtensionRegistryLite;
import com.google.protobuf.GeneratedMessage.Builder;
import com.google.protobuf.GeneratedMessage.BuilderParent;
import com.google.protobuf.GeneratedMessage.FieldAccessorTable;
import com.google.protobuf.InvalidProtocolBufferException;
import com.google.protobuf.LazyStringArrayList;
import com.google.protobuf.LazyStringList;
import com.google.protobuf.Message;
import com.google.protobuf.RepeatedFieldBuilder;
import com.google.protobuf.UninitializedMessageException;
import com.google.protobuf.UnknownFieldSet;
import com.google.protobuf.UnknownFieldSet.Builder;
import com.google.protobuf.UnmodifiableLazyStringList;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public final class EsdbgProtos$CssStyleDeclarations$Builder
  extends GeneratedMessage.Builder<Builder>
  implements EsdbgProtos.CssStyleDeclarationsOrBuilder
{
  private int bitField0_;
  
  public static final Descriptors.Descriptor getDescriptor()
  {
    return EsdbgProtos.access$30500();
  }
  
  protected GeneratedMessage.FieldAccessorTable internalGetFieldAccessorTable()
  {
    return EsdbgProtos.access$30600();
  }
  
  private EsdbgProtos$CssStyleDeclarations$Builder()
  {
    maybeForceBuilderInitialization();
  }
  
  private EsdbgProtos$CssStyleDeclarations$Builder(GeneratedMessage.BuilderParent parent)
  {
    super(parent);
    maybeForceBuilderInitialization();
  }
  
  private void maybeForceBuilderInitialization()
  {
    if (EsdbgProtos.CssStyleDeclarations.access$34000()) {
      getNodeStyleListFieldBuilder();
    }
  }
  
  private static Builder create()
  {
    return new Builder();
  }
  
  public Builder clear()
  {
    super.clear();
    computedStyleList_ = LazyStringArrayList.EMPTY;
    bitField0_ &= 0xFFFFFFFE;
    if (nodeStyleListBuilder_ == null)
    {
      nodeStyleList_ = Collections.emptyList();
      bitField0_ &= 0xFFFFFFFD;
    }
    else
    {
      nodeStyleListBuilder_.clear();
    }
    return this;
  }
  
  public Builder clone()
  {
    return create().mergeFrom(buildPartial());
  }
  
  public Descriptors.Descriptor getDescriptorForType()
  {
    return EsdbgProtos.CssStyleDeclarations.getDescriptor();
  }
  
  public EsdbgProtos.CssStyleDeclarations getDefaultInstanceForType()
  {
    return EsdbgProtos.CssStyleDeclarations.getDefaultInstance();
  }
  
  public EsdbgProtos.CssStyleDeclarations build()
  {
    EsdbgProtos.CssStyleDeclarations result = buildPartial();
    if (!result.isInitialized()) {
      throw newUninitializedMessageException(result);
    }
    return result;
  }
  
  private EsdbgProtos.CssStyleDeclarations buildParsed()
    throws InvalidProtocolBufferException
  {
    EsdbgProtos.CssStyleDeclarations result = buildPartial();
    if (!result.isInitialized()) {
      throw newUninitializedMessageException(result).asInvalidProtocolBufferException();
    }
    return result;
  }
  
  public EsdbgProtos.CssStyleDeclarations buildPartial()
  {
    EsdbgProtos.CssStyleDeclarations result = new EsdbgProtos.CssStyleDeclarations(this, null);
    int from_bitField0_ = bitField0_;
    if ((bitField0_ & 0x1) == 1)
    {
      computedStyleList_ = new UnmodifiableLazyStringList(computedStyleList_);
      
      bitField0_ &= 0xFFFFFFFE;
    }
    EsdbgProtos.CssStyleDeclarations.access$34202(result, computedStyleList_);
    if (nodeStyleListBuilder_ == null)
    {
      if ((bitField0_ & 0x2) == 2)
      {
        nodeStyleList_ = Collections.unmodifiableList(nodeStyleList_);
        bitField0_ &= 0xFFFFFFFD;
      }
      EsdbgProtos.CssStyleDeclarations.access$34302(result, nodeStyleList_);
    }
    else
    {
      EsdbgProtos.CssStyleDeclarations.access$34302(result, nodeStyleListBuilder_.build());
    }
    onBuilt();
    return result;
  }
  
  public Builder mergeFrom(Message other)
  {
    if ((other instanceof EsdbgProtos.CssStyleDeclarations)) {
      return mergeFrom((EsdbgProtos.CssStyleDeclarations)other);
    }
    super.mergeFrom(other);
    return this;
  }
  
  public Builder mergeFrom(EsdbgProtos.CssStyleDeclarations other)
  {
    if (other == EsdbgProtos.CssStyleDeclarations.getDefaultInstance()) {
      return this;
    }
    if (!EsdbgProtos.CssStyleDeclarations.access$34200(other).isEmpty())
    {
      if (computedStyleList_.isEmpty())
      {
        computedStyleList_ = EsdbgProtos.CssStyleDeclarations.access$34200(other);
        bitField0_ &= 0xFFFFFFFE;
      }
      else
      {
        ensureComputedStyleListIsMutable();
        computedStyleList_.addAll(EsdbgProtos.CssStyleDeclarations.access$34200(other));
      }
      onChanged();
    }
    if (nodeStyleListBuilder_ == null)
    {
      if (!EsdbgProtos.CssStyleDeclarations.access$34300(other).isEmpty())
      {
        if (nodeStyleList_.isEmpty())
        {
          nodeStyleList_ = EsdbgProtos.CssStyleDeclarations.access$34300(other);
          bitField0_ &= 0xFFFFFFFD;
        }
        else
        {
          ensureNodeStyleListIsMutable();
          nodeStyleList_.addAll(EsdbgProtos.CssStyleDeclarations.access$34300(other));
        }
        onChanged();
      }
    }
    else if (!EsdbgProtos.CssStyleDeclarations.access$34300(other).isEmpty()) {
      if (nodeStyleListBuilder_.isEmpty())
      {
        nodeStyleListBuilder_.dispose();
        nodeStyleListBuilder_ = null;
        nodeStyleList_ = EsdbgProtos.CssStyleDeclarations.access$34300(other);
        bitField0_ &= 0xFFFFFFFD;
        nodeStyleListBuilder_ = (EsdbgProtos.CssStyleDeclarations.access$34400() ? getNodeStyleListFieldBuilder() : null);
      }
      else
      {
        nodeStyleListBuilder_.addAllMessages(EsdbgProtos.CssStyleDeclarations.access$34300(other));
      }
    }
    mergeUnknownFields(other.getUnknownFields());
    return this;
  }
  
  public final boolean isInitialized()
  {
    for (int i = 0; i < getNodeStyleListCount(); i++) {
      if (!getNodeStyleList(i).isInitialized()) {
        return false;
      }
    }
    return true;
  }
  
  public Builder mergeFrom(CodedInputStream input, ExtensionRegistryLite extensionRegistry)
    throws IOException
  {
    UnknownFieldSet.Builder unknownFields = UnknownFieldSet.newBuilder(getUnknownFields());
    for (;;)
    {
      int tag = input.readTag();
      switch (tag)
      {
      case 0: 
        setUnknownFields(unknownFields.build());
        onChanged();
        return this;
      default: 
        if (!parseUnknownField(input, unknownFields, extensionRegistry, tag))
        {
          setUnknownFields(unknownFields.build());
          onChanged();
          return this;
        }
        break;
      case 10: 
        ensureComputedStyleListIsMutable();
        computedStyleList_.add(input.readBytes());
        break;
      case 18: 
        EsdbgProtos.CssStyleDeclarations.NodeStyle.Builder subBuilder = EsdbgProtos.CssStyleDeclarations.NodeStyle.newBuilder();
        input.readMessage(subBuilder, extensionRegistry);
        addNodeStyleList(subBuilder.buildPartial());
      }
    }
  }
  
  private LazyStringList computedStyleList_ = LazyStringArrayList.EMPTY;
  
  private void ensureComputedStyleListIsMutable()
  {
    if ((bitField0_ & 0x1) != 1)
    {
      computedStyleList_ = new LazyStringArrayList(computedStyleList_);
      bitField0_ |= 0x1;
    }
  }
  
  public List<String> getComputedStyleListList()
  {
    return Collections.unmodifiableList(computedStyleList_);
  }
  
  public int getComputedStyleListCount()
  {
    return computedStyleList_.size();
  }
  
  public String getComputedStyleList(int index)
  {
    return (String)computedStyleList_.get(index);
  }
  
  public Builder setComputedStyleList(int index, String value)
  {
    if (value == null) {
      throw new NullPointerException();
    }
    ensureComputedStyleListIsMutable();
    computedStyleList_.set(index, value);
    onChanged();
    return this;
  }
  
  public Builder addComputedStyleList(String value)
  {
    if (value == null) {
      throw new NullPointerException();
    }
    ensureComputedStyleListIsMutable();
    computedStyleList_.add(value);
    onChanged();
    return this;
  }
  
  public Builder addAllComputedStyleList(Iterable<String> values)
  {
    ensureComputedStyleListIsMutable();
    GeneratedMessage.Builder.addAll(values, computedStyleList_);
    onChanged();
    return this;
  }
  
  public Builder clearComputedStyleList()
  {
    computedStyleList_ = LazyStringArrayList.EMPTY;
    bitField0_ &= 0xFFFFFFFE;
    onChanged();
    return this;
  }
  
  void addComputedStyleList(ByteString value)
  {
    ensureComputedStyleListIsMutable();
    computedStyleList_.add(value);
    onChanged();
  }
  
  private List<EsdbgProtos.CssStyleDeclarations.NodeStyle> nodeStyleList_ = Collections.emptyList();
  private RepeatedFieldBuilder<EsdbgProtos.CssStyleDeclarations.NodeStyle, EsdbgProtos.CssStyleDeclarations.NodeStyle.Builder, EsdbgProtos.CssStyleDeclarations.NodeStyleOrBuilder> nodeStyleListBuilder_;
  
  private void ensureNodeStyleListIsMutable()
  {
    if ((bitField0_ & 0x2) != 2)
    {
      nodeStyleList_ = new ArrayList(nodeStyleList_);
      bitField0_ |= 0x2;
    }
  }
  
  public List<EsdbgProtos.CssStyleDeclarations.NodeStyle> getNodeStyleListList()
  {
    if (nodeStyleListBuilder_ == null) {
      return Collections.unmodifiableList(nodeStyleList_);
    }
    return nodeStyleListBuilder_.getMessageList();
  }
  
  public int getNodeStyleListCount()
  {
    if (nodeStyleListBuilder_ == null) {
      return nodeStyleList_.size();
    }
    return nodeStyleListBuilder_.getCount();
  }
  
  public EsdbgProtos.CssStyleDeclarations.NodeStyle getNodeStyleList(int index)
  {
    if (nodeStyleListBuilder_ == null) {
      return (EsdbgProtos.CssStyleDeclarations.NodeStyle)nodeStyleList_.get(index);
    }
    return (EsdbgProtos.CssStyleDeclarations.NodeStyle)nodeStyleListBuilder_.getMessage(index);
  }
  
  public Builder setNodeStyleList(int index, EsdbgProtos.CssStyleDeclarations.NodeStyle value)
  {
    if (nodeStyleListBuilder_ == null)
    {
      if (value == null) {
        throw new NullPointerException();
      }
      ensureNodeStyleListIsMutable();
      nodeStyleList_.set(index, value);
      onChanged();
    }
    else
    {
      nodeStyleListBuilder_.setMessage(index, value);
    }
    return this;
  }
  
  public Builder setNodeStyleList(int index, EsdbgProtos.CssStyleDeclarations.NodeStyle.Builder builderForValue)
  {
    if (nodeStyleListBuilder_ == null)
    {
      ensureNodeStyleListIsMutable();
      nodeStyleList_.set(index, builderForValue.build());
      onChanged();
    }
    else
    {
      nodeStyleListBuilder_.setMessage(index, builderForValue.build());
    }
    return this;
  }
  
  public Builder addNodeStyleList(EsdbgProtos.CssStyleDeclarations.NodeStyle value)
  {
    if (nodeStyleListBuilder_ == null)
    {
      if (value == null) {
        throw new NullPointerException();
      }
      ensureNodeStyleListIsMutable();
      nodeStyleList_.add(value);
      onChanged();
    }
    else
    {
      nodeStyleListBuilder_.addMessage(value);
    }
    return this;
  }
  
  public Builder addNodeStyleList(int index, EsdbgProtos.CssStyleDeclarations.NodeStyle value)
  {
    if (nodeStyleListBuilder_ == null)
    {
      if (value == null) {
        throw new NullPointerException();
      }
      ensureNodeStyleListIsMutable();
      nodeStyleList_.add(index, value);
      onChanged();
    }
    else
    {
      nodeStyleListBuilder_.addMessage(index, value);
    }
    return this;
  }
  
  public Builder addNodeStyleList(EsdbgProtos.CssStyleDeclarations.NodeStyle.Builder builderForValue)
  {
    if (nodeStyleListBuilder_ == null)
    {
      ensureNodeStyleListIsMutable();
      nodeStyleList_.add(builderForValue.build());
      onChanged();
    }
    else
    {
      nodeStyleListBuilder_.addMessage(builderForValue.build());
    }
    return this;
  }
  
  public Builder addNodeStyleList(int index, EsdbgProtos.CssStyleDeclarations.NodeStyle.Builder builderForValue)
  {
    if (nodeStyleListBuilder_ == null)
    {
      ensureNodeStyleListIsMutable();
      nodeStyleList_.add(index, builderForValue.build());
      onChanged();
    }
    else
    {
      nodeStyleListBuilder_.addMessage(index, builderForValue.build());
    }
    return this;
  }
  
  public Builder addAllNodeStyleList(Iterable<? extends EsdbgProtos.CssStyleDeclarations.NodeStyle> values)
  {
    if (nodeStyleListBuilder_ == null)
    {
      ensureNodeStyleListIsMutable();
      GeneratedMessage.Builder.addAll(values, nodeStyleList_);
      onChanged();
    }
    else
    {
      nodeStyleListBuilder_.addAllMessages(values);
    }
    return this;
  }
  
  public Builder clearNodeStyleList()
  {
    if (nodeStyleListBuilder_ == null)
    {
      nodeStyleList_ = Collections.emptyList();
      bitField0_ &= 0xFFFFFFFD;
      onChanged();
    }
    else
    {
      nodeStyleListBuilder_.clear();
    }
    return this;
  }
  
  public Builder removeNodeStyleList(int index)
  {
    if (nodeStyleListBuilder_ == null)
    {
      ensureNodeStyleListIsMutable();
      nodeStyleList_.remove(index);
      onChanged();
    }
    else
    {
      nodeStyleListBuilder_.remove(index);
    }
    return this;
  }
  
  public EsdbgProtos.CssStyleDeclarations.NodeStyle.Builder getNodeStyleListBuilder(int index)
  {
    return (EsdbgProtos.CssStyleDeclarations.NodeStyle.Builder)getNodeStyleListFieldBuilder().getBuilder(index);
  }
  
  public EsdbgProtos.CssStyleDeclarations.NodeStyleOrBuilder getNodeStyleListOrBuilder(int index)
  {
    if (nodeStyleListBuilder_ == null) {
      return (EsdbgProtos.CssStyleDeclarations.NodeStyleOrBuilder)nodeStyleList_.get(index);
    }
    return (EsdbgProtos.CssStyleDeclarations.NodeStyleOrBuilder)nodeStyleListBuilder_.getMessageOrBuilder(index);
  }
  
  public List<? extends EsdbgProtos.CssStyleDeclarations.NodeStyleOrBuilder> getNodeStyleListOrBuilderList()
  {
    if (nodeStyleListBuilder_ != null) {
      return nodeStyleListBuilder_.getMessageOrBuilderList();
    }
    return Collections.unmodifiableList(nodeStyleList_);
  }
  
  public EsdbgProtos.CssStyleDeclarations.NodeStyle.Builder addNodeStyleListBuilder()
  {
    return (EsdbgProtos.CssStyleDeclarations.NodeStyle.Builder)getNodeStyleListFieldBuilder().addBuilder(EsdbgProtos.CssStyleDeclarations.NodeStyle.getDefaultInstance());
  }
  
  public EsdbgProtos.CssStyleDeclarations.NodeStyle.Builder addNodeStyleListBuilder(int index)
  {
    return (EsdbgProtos.CssStyleDeclarations.NodeStyle.Builder)getNodeStyleListFieldBuilder().addBuilder(index, EsdbgProtos.CssStyleDeclarations.NodeStyle.getDefaultInstance());
  }
  
  public List<EsdbgProtos.CssStyleDeclarations.NodeStyle.Builder> getNodeStyleListBuilderList()
  {
    return getNodeStyleListFieldBuilder().getBuilderList();
  }
  
  private RepeatedFieldBuilder<EsdbgProtos.CssStyleDeclarations.NodeStyle, EsdbgProtos.CssStyleDeclarations.NodeStyle.Builder, EsdbgProtos.CssStyleDeclarations.NodeStyleOrBuilder> getNodeStyleListFieldBuilder()
  {
    if (nodeStyleListBuilder_ == null)
    {
      nodeStyleListBuilder_ = new RepeatedFieldBuilder(nodeStyleList_, (bitField0_ & 0x2) == 2, getParentForChildren(), isClean());
      
      nodeStyleList_ = null;
    }
    return nodeStyleListBuilder_;
  }
}

/* Location:
 * Qualified Name:     com.opera.core.systems.scope.protos.EsdbgProtos.CssStyleDeclarations.Builder
 * Java Class Version: 6 (50.0)
 * JD-Core Version:    0.7.1
 */
package com.opera.core.systems.scope.protos;

import com.google.protobuf.ByteString;
import com.google.protobuf.CodedInputStream;
import com.google.protobuf.Descriptors.Descriptor;
import com.google.protobuf.ExtensionRegistryLite;
import com.google.protobuf.GeneratedMessage.Builder;
import com.google.protobuf.GeneratedMessage.BuilderParent;
import com.google.protobuf.GeneratedMessage.FieldAccessorTable;
import com.google.protobuf.InvalidProtocolBufferException;
import com.google.protobuf.Message;
import com.google.protobuf.RepeatedFieldBuilder;
import com.google.protobuf.UninitializedMessageException;
import com.google.protobuf.UnknownFieldSet;
import com.google.protobuf.UnknownFieldSet.Builder;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public final class EsdbgProtos$CssStyleDeclarations$NodeStyle$Builder
  extends GeneratedMessage.Builder<Builder>
  implements EsdbgProtos.CssStyleDeclarations.NodeStyleOrBuilder
{
  private int bitField0_;
  private int objectID_;
  
  public static final Descriptors.Descriptor getDescriptor()
  {
    return EsdbgProtos.access$30700();
  }
  
  protected GeneratedMessage.FieldAccessorTable internalGetFieldAccessorTable()
  {
    return EsdbgProtos.access$30800();
  }
  
  private EsdbgProtos$CssStyleDeclarations$NodeStyle$Builder()
  {
    maybeForceBuilderInitialization();
  }
  
  private EsdbgProtos$CssStyleDeclarations$NodeStyle$Builder(GeneratedMessage.BuilderParent parent)
  {
    super(parent);
    maybeForceBuilderInitialization();
  }
  
  private void maybeForceBuilderInitialization()
  {
    if (EsdbgProtos.CssStyleDeclarations.NodeStyle.access$33000()) {
      getStyleListFieldBuilder();
    }
  }
  
  private static Builder create()
  {
    return new Builder();
  }
  
  public Builder clear()
  {
    super.clear();
    objectID_ = 0;
    bitField0_ &= 0xFFFFFFFE;
    elementName_ = "";
    bitField0_ &= 0xFFFFFFFD;
    if (styleListBuilder_ == null)
    {
      styleList_ = Collections.emptyList();
      bitField0_ &= 0xFFFFFFFB;
    }
    else
    {
      styleListBuilder_.clear();
    }
    return this;
  }
  
  public Builder clone()
  {
    return create().mergeFrom(buildPartial());
  }
  
  public Descriptors.Descriptor getDescriptorForType()
  {
    return EsdbgProtos.CssStyleDeclarations.NodeStyle.getDescriptor();
  }
  
  public EsdbgProtos.CssStyleDeclarations.NodeStyle getDefaultInstanceForType()
  {
    return EsdbgProtos.CssStyleDeclarations.NodeStyle.getDefaultInstance();
  }
  
  public EsdbgProtos.CssStyleDeclarations.NodeStyle build()
  {
    EsdbgProtos.CssStyleDeclarations.NodeStyle result = buildPartial();
    if (!result.isInitialized()) {
      throw newUninitializedMessageException(result);
    }
    return result;
  }
  
  private EsdbgProtos.CssStyleDeclarations.NodeStyle buildParsed()
    throws InvalidProtocolBufferException
  {
    EsdbgProtos.CssStyleDeclarations.NodeStyle result = buildPartial();
    if (!result.isInitialized()) {
      throw newUninitializedMessageException(result).asInvalidProtocolBufferException();
    }
    return result;
  }
  
  public EsdbgProtos.CssStyleDeclarations.NodeStyle buildPartial()
  {
    EsdbgProtos.CssStyleDeclarations.NodeStyle result = new EsdbgProtos.CssStyleDeclarations.NodeStyle(this, null);
    int from_bitField0_ = bitField0_;
    int to_bitField0_ = 0;
    if ((from_bitField0_ & 0x1) == 1) {
      to_bitField0_ |= 0x1;
    }
    EsdbgProtos.CssStyleDeclarations.NodeStyle.access$33202(result, objectID_);
    if ((from_bitField0_ & 0x2) == 2) {
      to_bitField0_ |= 0x2;
    }
    EsdbgProtos.CssStyleDeclarations.NodeStyle.access$33302(result, elementName_);
    if (styleListBuilder_ == null)
    {
      if ((bitField0_ & 0x4) == 4)
      {
        styleList_ = Collections.unmodifiableList(styleList_);
        bitField0_ &= 0xFFFFFFFB;
      }
      EsdbgProtos.CssStyleDeclarations.NodeStyle.access$33402(result, styleList_);
    }
    else
    {
      EsdbgProtos.CssStyleDeclarations.NodeStyle.access$33402(result, styleListBuilder_.build());
    }
    EsdbgProtos.CssStyleDeclarations.NodeStyle.access$33502(result, to_bitField0_);
    onBuilt();
    return result;
  }
  
  public Builder mergeFrom(Message other)
  {
    if ((other instanceof EsdbgProtos.CssStyleDeclarations.NodeStyle)) {
      return mergeFrom((EsdbgProtos.CssStyleDeclarations.NodeStyle)other);
    }
    super.mergeFrom(other);
    return this;
  }
  
  public Builder mergeFrom(EsdbgProtos.CssStyleDeclarations.NodeStyle other)
  {
    if (other == EsdbgProtos.CssStyleDeclarations.NodeStyle.getDefaultInstance()) {
      return this;
    }
    if (other.hasObjectID()) {
      setObjectID(other.getObjectID());
    }
    if (other.hasElementName()) {
      setElementName(other.getElementName());
    }
    if (styleListBuilder_ == null)
    {
      if (!EsdbgProtos.CssStyleDeclarations.NodeStyle.access$33400(other).isEmpty())
      {
        if (styleList_.isEmpty())
        {
          styleList_ = EsdbgProtos.CssStyleDeclarations.NodeStyle.access$33400(other);
          bitField0_ &= 0xFFFFFFFB;
        }
        else
        {
          ensureStyleListIsMutable();
          styleList_.addAll(EsdbgProtos.CssStyleDeclarations.NodeStyle.access$33400(other));
        }
        onChanged();
      }
    }
    else if (!EsdbgProtos.CssStyleDeclarations.NodeStyle.access$33400(other).isEmpty()) {
      if (styleListBuilder_.isEmpty())
      {
        styleListBuilder_.dispose();
        styleListBuilder_ = null;
        styleList_ = EsdbgProtos.CssStyleDeclarations.NodeStyle.access$33400(other);
        bitField0_ &= 0xFFFFFFFB;
        styleListBuilder_ = (EsdbgProtos.CssStyleDeclarations.NodeStyle.access$33600() ? getStyleListFieldBuilder() : null);
      }
      else
      {
        styleListBuilder_.addAllMessages(EsdbgProtos.CssStyleDeclarations.NodeStyle.access$33400(other));
      }
    }
    mergeUnknownFields(other.getUnknownFields());
    return this;
  }
  
  public final boolean isInitialized()
  {
    if (!hasObjectID()) {
      return false;
    }
    if (!hasElementName()) {
      return false;
    }
    for (int i = 0; i < getStyleListCount(); i++) {
      if (!getStyleList(i).isInitialized()) {
        return false;
      }
    }
    return true;
  }
  
  public Builder mergeFrom(CodedInputStream input, ExtensionRegistryLite extensionRegistry)
    throws IOException
  {
    UnknownFieldSet.Builder unknownFields = UnknownFieldSet.newBuilder(getUnknownFields());
    for (;;)
    {
      int tag = input.readTag();
      switch (tag)
      {
      case 0: 
        setUnknownFields(unknownFields.build());
        onChanged();
        return this;
      default: 
        if (!parseUnknownField(input, unknownFields, extensionRegistry, tag))
        {
          setUnknownFields(unknownFields.build());
          onChanged();
          return this;
        }
        break;
      case 8: 
        bitField0_ |= 0x1;
        objectID_ = input.readUInt32();
        break;
      case 18: 
        bitField0_ |= 0x2;
        elementName_ = input.readBytes();
        break;
      case 26: 
        EsdbgProtos.CssStyleDeclarations.NodeStyle.StyleDeclaration.Builder subBuilder = EsdbgProtos.CssStyleDeclarations.NodeStyle.StyleDeclaration.newBuilder();
        input.readMessage(subBuilder, extensionRegistry);
        addStyleList(subBuilder.buildPartial());
      }
    }
  }
  
  public boolean hasObjectID()
  {
    return (bitField0_ & 0x1) == 1;
  }
  
  public int getObjectID()
  {
    return objectID_;
  }
  
  public Builder setObjectID(int value)
  {
    bitField0_ |= 0x1;
    objectID_ = value;
    onChanged();
    return this;
  }
  
  public Builder clearObjectID()
  {
    bitField0_ &= 0xFFFFFFFE;
    objectID_ = 0;
    onChanged();
    return this;
  }
  
  private Object elementName_ = "";
  
  public boolean hasElementName()
  {
    return (bitField0_ & 0x2) == 2;
  }
  
  public String getElementName()
  {
    Object ref = elementName_;
    if (!(ref instanceof String))
    {
      String s = ((ByteString)ref).toStringUtf8();
      elementName_ = s;
      return s;
    }
    return (String)ref;
  }
  
  public Builder setElementName(String value)
  {
    if (value == null) {
      throw new NullPointerException();
    }
    bitField0_ |= 0x2;
    elementName_ = value;
    onChanged();
    return this;
  }
  
  public Builder clearElementName()
  {
    bitField0_ &= 0xFFFFFFFD;
    elementName_ = EsdbgProtos.CssStyleDeclarations.NodeStyle.getDefaultInstance().getElementName();
    onChanged();
    return this;
  }
  
  void setElementName(ByteString value)
  {
    bitField0_ |= 0x2;
    elementName_ = value;
    onChanged();
  }
  
  private List<EsdbgProtos.CssStyleDeclarations.NodeStyle.StyleDeclaration> styleList_ = Collections.emptyList();
  private RepeatedFieldBuilder<EsdbgProtos.CssStyleDeclarations.NodeStyle.StyleDeclaration, EsdbgProtos.CssStyleDeclarations.NodeStyle.StyleDeclaration.Builder, EsdbgProtos.CssStyleDeclarations.NodeStyle.StyleDeclarationOrBuilder> styleListBuilder_;
  
  private void ensureStyleListIsMutable()
  {
    if ((bitField0_ & 0x4) != 4)
    {
      styleList_ = new ArrayList(styleList_);
      bitField0_ |= 0x4;
    }
  }
  
  public List<EsdbgProtos.CssStyleDeclarations.NodeStyle.StyleDeclaration> getStyleListList()
  {
    if (styleListBuilder_ == null) {
      return Collections.unmodifiableList(styleList_);
    }
    return styleListBuilder_.getMessageList();
  }
  
  public int getStyleListCount()
  {
    if (styleListBuilder_ == null) {
      return styleList_.size();
    }
    return styleListBuilder_.getCount();
  }
  
  public EsdbgProtos.CssStyleDeclarations.NodeStyle.StyleDeclaration getStyleList(int index)
  {
    if (styleListBuilder_ == null) {
      return (EsdbgProtos.CssStyleDeclarations.NodeStyle.StyleDeclaration)styleList_.get(index);
    }
    return (EsdbgProtos.CssStyleDeclarations.NodeStyle.StyleDeclaration)styleListBuilder_.getMessage(index);
  }
  
  public Builder setStyleList(int index, EsdbgProtos.CssStyleDeclarations.NodeStyle.StyleDeclaration value)
  {
    if (styleListBuilder_ == null)
    {
      if (value == null) {
        throw new NullPointerException();
      }
      ensureStyleListIsMutable();
      styleList_.set(index, value);
      onChanged();
    }
    else
    {
      styleListBuilder_.setMessage(index, value);
    }
    return this;
  }
  
  public Builder setStyleList(int index, EsdbgProtos.CssStyleDeclarations.NodeStyle.StyleDeclaration.Builder builderForValue)
  {
    if (styleListBuilder_ == null)
    {
      ensureStyleListIsMutable();
      styleList_.set(index, builderForValue.build());
      onChanged();
    }
    else
    {
      styleListBuilder_.setMessage(index, builderForValue.build());
    }
    return this;
  }
  
  public Builder addStyleList(EsdbgProtos.CssStyleDeclarations.NodeStyle.StyleDeclaration value)
  {
    if (styleListBuilder_ == null)
    {
      if (value == null) {
        throw new NullPointerException();
      }
      ensureStyleListIsMutable();
      styleList_.add(value);
      onChanged();
    }
    else
    {
      styleListBuilder_.addMessage(value);
    }
    return this;
  }
  
  public Builder addStyleList(int index, EsdbgProtos.CssStyleDeclarations.NodeStyle.StyleDeclaration value)
  {
    if (styleListBuilder_ == null)
    {
      if (value == null) {
        throw new NullPointerException();
      }
      ensureStyleListIsMutable();
      styleList_.add(index, value);
      onChanged();
    }
    else
    {
      styleListBuilder_.addMessage(index, value);
    }
    return this;
  }
  
  public Builder addStyleList(EsdbgProtos.CssStyleDeclarations.NodeStyle.StyleDeclaration.Builder builderForValue)
  {
    if (styleListBuilder_ == null)
    {
      ensureStyleListIsMutable();
      styleList_.add(builderForValue.build());
      onChanged();
    }
    else
    {
      styleListBuilder_.addMessage(builderForValue.build());
    }
    return this;
  }
  
  public Builder addStyleList(int index, EsdbgProtos.CssStyleDeclarations.NodeStyle.StyleDeclaration.Builder builderForValue)
  {
    if (styleListBuilder_ == null)
    {
      ensureStyleListIsMutable();
      styleList_.add(index, builderForValue.build());
      onChanged();
    }
    else
    {
      styleListBuilder_.addMessage(index, builderForValue.build());
    }
    return this;
  }
  
  public Builder addAllStyleList(Iterable<? extends EsdbgProtos.CssStyleDeclarations.NodeStyle.StyleDeclaration> values)
  {
    if (styleListBuilder_ == null)
    {
      ensureStyleListIsMutable();
      GeneratedMessage.Builder.addAll(values, styleList_);
      onChanged();
    }
    else
    {
      styleListBuilder_.addAllMessages(values);
    }
    return this;
  }
  
  public Builder clearStyleList()
  {
    if (styleListBuilder_ == null)
    {
      styleList_ = Collections.emptyList();
      bitField0_ &= 0xFFFFFFFB;
      onChanged();
    }
    else
    {
      styleListBuilder_.clear();
    }
    return this;
  }
  
  public Builder removeStyleList(int index)
  {
    if (styleListBuilder_ == null)
    {
      ensureStyleListIsMutable();
      styleList_.remove(index);
      onChanged();
    }
    else
    {
      styleListBuilder_.remove(index);
    }
    return this;
  }
  
  public EsdbgProtos.CssStyleDeclarations.NodeStyle.StyleDeclaration.Builder getStyleListBuilder(int index)
  {
    return (EsdbgProtos.CssStyleDeclarations.NodeStyle.StyleDeclaration.Builder)getStyleListFieldBuilder().getBuilder(index);
  }
  
  public EsdbgProtos.CssStyleDeclarations.NodeStyle.StyleDeclarationOrBuilder getStyleListOrBuilder(int index)
  {
    if (styleListBuilder_ == null) {
      return (EsdbgProtos.CssStyleDeclarations.NodeStyle.StyleDeclarationOrBuilder)styleList_.get(index);
    }
    return (EsdbgProtos.CssStyleDeclarations.NodeStyle.StyleDeclarationOrBuilder)styleListBuilder_.getMessageOrBuilder(index);
  }
  
  public List<? extends EsdbgProtos.CssStyleDeclarations.NodeStyle.StyleDeclarationOrBuilder> getStyleListOrBuilderList()
  {
    if (styleListBuilder_ != null) {
      return styleListBuilder_.getMessageOrBuilderList();
    }
    return Collections.unmodifiableList(styleList_);
  }
  
  public EsdbgProtos.CssStyleDeclarations.NodeStyle.StyleDeclaration.Builder addStyleListBuilder()
  {
    return (EsdbgProtos.CssStyleDeclarations.NodeStyle.StyleDeclaration.Builder)getStyleListFieldBuilder().addBuilder(EsdbgProtos.CssStyleDeclarations.NodeStyle.StyleDeclaration.getDefaultInstance());
  }
  
  public EsdbgProtos.CssStyleDeclarations.NodeStyle.StyleDeclaration.Builder addStyleListBuilder(int index)
  {
    return (EsdbgProtos.CssStyleDeclarations.NodeStyle.StyleDeclaration.Builder)getStyleListFieldBuilder().addBuilder(index, EsdbgProtos.CssStyleDeclarations.NodeStyle.StyleDeclaration.getDefaultInstance());
  }
  
  public List<EsdbgProtos.CssStyleDeclarations.NodeStyle.StyleDeclaration.Builder> getStyleListBuilderList()
  {
    return getStyleListFieldBuilder().getBuilderList();
  }
  
  private RepeatedFieldBuilder<EsdbgProtos.CssStyleDeclarations.NodeStyle.StyleDeclaration, EsdbgProtos.CssStyleDeclarations.NodeStyle.StyleDeclaration.Builder, EsdbgProtos.CssStyleDeclarations.NodeStyle.StyleDeclarationOrBuilder> getStyleListFieldBuilder()
  {
    if (styleListBuilder_ == null)
    {
      styleListBuilder_ = new RepeatedFieldBuilder(styleList_, (bitField0_ & 0x4) == 4, getParentForChildren(), isClean());
      
      styleList_ = null;
    }
    return styleListBuilder_;
  }
}

/* Location:
 * Qualified Name:     com.opera.core.systems.scope.protos.EsdbgProtos.CssStyleDeclarations.NodeStyle.Builder
 * Java Class Version: 6 (50.0)
 * JD-Core Version:    0.7.1
 */
package com.opera.core.systems.scope.protos;

import com.google.protobuf.ByteString;
import com.google.protobuf.CodedInputStream;
import com.google.protobuf.Descriptors.Descriptor;
import com.google.protobuf.ExtensionRegistryLite;
import com.google.protobuf.GeneratedMessage.Builder;
import com.google.protobuf.GeneratedMessage.BuilderParent;
import com.google.protobuf.GeneratedMessage.FieldAccessorTable;
import com.google.protobuf.InvalidProtocolBufferException;
import com.google.protobuf.LazyStringArrayList;
import com.google.protobuf.LazyStringList;
import com.google.protobuf.Message;
import com.google.protobuf.UninitializedMessageException;
import com.google.protobuf.UnknownFieldSet;
import com.google.protobuf.UnknownFieldSet.Builder;
import com.google.protobuf.UnmodifiableLazyStringList;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public final class EsdbgProtos$CssStyleDeclarations$NodeStyle$StyleDeclaration$Builder
  extends GeneratedMessage.Builder<Builder>
  implements EsdbgProtos.CssStyleDeclarations.NodeStyle.StyleDeclarationOrBuilder
{
  private int bitField0_;
  private int origin_;
  
  public static final Descriptors.Descriptor getDescriptor()
  {
    return EsdbgProtos.access$30900();
  }
  
  protected GeneratedMessage.FieldAccessorTable internalGetFieldAccessorTable()
  {
    return EsdbgProtos.access$31000();
  }
  
  private EsdbgProtos$CssStyleDeclarations$NodeStyle$StyleDeclaration$Builder()
  {
    maybeForceBuilderInitialization();
  }
  
  private EsdbgProtos$CssStyleDeclarations$NodeStyle$StyleDeclaration$Builder(GeneratedMessage.BuilderParent parent)
  {
    super(parent);
    maybeForceBuilderInitialization();
  }
  
  private void maybeForceBuilderInitialization()
  {
    if (EsdbgProtos.CssStyleDeclarations.NodeStyle.StyleDeclaration.access$31400()) {}
  }
  
  private static Builder create()
  {
    return new Builder();
  }
  
  public Builder clear()
  {
    super.clear();
    origin_ = 0;
    bitField0_ &= 0xFFFFFFFE;
    indexList_ = Collections.emptyList();
    bitField0_ &= 0xFFFFFFFD;
    valueList_ = LazyStringArrayList.EMPTY;
    bitField0_ &= 0xFFFFFFFB;
    priorityList_ = Collections.emptyList();
    bitField0_ &= 0xFFFFFFF7;
    statusList_ = Collections.emptyList();
    bitField0_ &= 0xFFFFFFEF;
    selector_ = "";
    bitField0_ &= 0xFFFFFFDF;
    specificity_ = 0;
    bitField0_ &= 0xFFFFFFBF;
    stylesheetID_ = 0;
    bitField0_ &= 0xFF7F;
    ruleID_ = 0;
    bitField0_ &= 0xFEFF;
    ruleType_ = 0;
    bitField0_ &= 0xFDFF;
    return this;
  }
  
  public Builder clone()
  {
    return create().mergeFrom(buildPartial());
  }
  
  public Descriptors.Descriptor getDescriptorForType()
  {
    return EsdbgProtos.CssStyleDeclarations.NodeStyle.StyleDeclaration.getDescriptor();
  }
  
  public EsdbgProtos.CssStyleDeclarations.NodeStyle.StyleDeclaration getDefaultInstanceForType()
  {
    return EsdbgProtos.CssStyleDeclarations.NodeStyle.StyleDeclaration.getDefaultInstance();
  }
  
  public EsdbgProtos.CssStyleDeclarations.NodeStyle.StyleDeclaration build()
  {
    EsdbgProtos.CssStyleDeclarations.NodeStyle.StyleDeclaration result = buildPartial();
    if (!result.isInitialized()) {
      throw newUninitializedMessageException(result);
    }
    return result;
  }
  
  private EsdbgProtos.CssStyleDeclarations.NodeStyle.StyleDeclaration buildParsed()
    throws InvalidProtocolBufferException
  {
    EsdbgProtos.CssStyleDeclarations.NodeStyle.StyleDeclaration result = buildPartial();
    if (!result.isInitialized()) {
      throw newUninitializedMessageException(result).asInvalidProtocolBufferException();
    }
    return result;
  }
  
  public EsdbgProtos.CssStyleDeclarations.NodeStyle.StyleDeclaration buildPartial()
  {
    EsdbgProtos.CssStyleDeclarations.NodeStyle.StyleDeclaration result = new EsdbgProtos.CssStyleDeclarations.NodeStyle.StyleDeclaration(this, null);
    int from_bitField0_ = bitField0_;
    int to_bitField0_ = 0;
    if ((from_bitField0_ & 0x1) == 1) {
      to_bitField0_ |= 0x1;
    }
    EsdbgProtos.CssStyleDeclarations.NodeStyle.StyleDeclaration.access$31602(result, origin_);
    if ((bitField0_ & 0x2) == 2)
    {
      indexList_ = Collections.unmodifiableList(indexList_);
      bitField0_ &= 0xFFFFFFFD;
    }
    EsdbgProtos.CssStyleDeclarations.NodeStyle.StyleDeclaration.access$31702(result, indexList_);
    if ((bitField0_ & 0x4) == 4)
    {
      valueList_ = new UnmodifiableLazyStringList(valueList_);
      
      bitField0_ &= 0xFFFFFFFB;
    }
    EsdbgProtos.CssStyleDeclarations.NodeStyle.StyleDeclaration.access$31802(result, valueList_);
    if ((bitField0_ & 0x8) == 8)
    {
      priorityList_ = Collections.unmodifiableList(priorityList_);
      bitField0_ &= 0xFFFFFFF7;
    }
    EsdbgProtos.CssStyleDeclarations.NodeStyle.StyleDeclaration.access$31902(result, priorityList_);
    if ((bitField0_ & 0x10) == 16)
    {
      statusList_ = Collections.unmodifiableLi
selenium-server-standalone-2.42.2

Further reading...
