com.android.ide.eclipse.gldebugger_23.0.2.1259578

eturn glScalef;
        case 296: 
          return glScalex;
        case 297: 
          return glScalexOES;
        case 298: 
          return glScissor;
        case 299: 
          return glSelectPerfMonitorCountersAMD;
        case 300: 
          return glSetFenceNV;
        case 301: 
          return glShadeModel;
        case 302: 
          return glShaderBinary;
        case 303: 
          return glShaderSource;
        case 304: 
          return glStartTilingQCOM;
        case 305: 
          return glStencilFunc;
        case 306: 
          return glStencilFuncSeparate;
        case 307: 
          return glStencilMask;
        case 308: 
          return glStencilMaskSeparate;
        case 309: 
          return glStencilOp;
        case 310: 
          return glStencilOpSeparate;
        case 311: 
          return glTestFenceNV;
        case 312: 
          return glTexCoordPointer;
        case 313: 
          return glTexEnvf;
        case 314: 
          return glTexEnvfv;
        case 315: 
          return glTexEnvi;
        case 316: 
          return glTexEnviv;
        case 317: 
          return glTexEnvx;
        case 318: 
          return glTexEnvxOES;
        case 319: 
          return glTexEnvxv;
        case 320: 
          return glTexEnvxvOES;
        case 321: 
          return glTexGenfOES;
        case 322: 
          return glTexGenfvOES;
        case 323: 
          return glTexGeniOES;
        case 324: 
          return glTexGenivOES;
        case 325: 
          return glTexGenxOES;
        case 326: 
          return glTexGenxvOES;
        case 327: 
          return glTexImage2D;
        case 328: 
          return glTexImage3DOES;
        case 329: 
          return glTexParameterf;
        case 330: 
          return glTexParameterfv;
        case 331: 
          return glTexParameteri;
        case 332: 
          return glTexParameteriv;
        case 333: 
          return glTexParameterx;
        case 334: 
          return glTexParameterxOES;
        case 335: 
          return glTexParameterxv;
        case 336: 
          return glTexParameterxvOES;
        case 337: 
          return glTexSubImage2D;
        case 338: 
          return glTexSubImage3DOES;
        case 339: 
          return glTranslatef;
        case 340: 
          return glTranslatex;
        case 341: 
          return glTranslatexOES;
        case 342: 
          return glUniform1f;
        case 343: 
          return glUniform1fv;
        case 344: 
          return glUniform1i;
        case 345: 
          return glUniform1iv;
        case 346: 
          return glUniform2f;
        case 347: 
          return glUniform2fv;
        case 348: 
          return glUniform2i;
        case 349: 
          return glUniform2iv;
        case 350: 
          return glUniform3f;
        case 351: 
          return glUniform3fv;
        case 352: 
          return glUniform3i;
        case 353: 
          return glUniform3iv;
        case 354: 
          return glUniform4f;
        case 355: 
          return glUniform4fv;
        case 356: 
          return glUniform4i;
        case 357: 
          return glUniform4iv;
        case 358: 
          return glUniformMatrix2fv;
        case 359: 
          return glUniformMatrix3fv;
        case 360: 
          return glUniformMatrix4fv;
        case 361: 
          return glUnmapBufferOES;
        case 362: 
          return glUseProgram;
        case 363: 
          return glValidateProgram;
        case 364: 
          return glVertexAttrib1f;
        case 365: 
          return glVertexAttrib1fv;
        case 366: 
          return glVertexAttrib2f;
        case 367: 
          return glVertexAttrib2fv;
        case 368: 
          return glVertexAttrib3f;
        case 369: 
          return glVertexAttrib3fv;
        case 370: 
          return glVertexAttrib4f;
        case 371: 
          return glVertexAttrib4fv;
        case 372: 
          return glVertexAttribPointer;
        case 373: 
          return glVertexPointer;
        case 374: 
          return glViewport;
        case 375: 
          return glWeightPointerOES;
        case 376: 
          return glReadBuffer;
        case 377: 
          return glDrawRangeElements;
        case 378: 
          return glTexImage3D;
        case 379: 
          return glTexSubImage3D;
        case 380: 
          return glCopyTexSubImage3D;
        case 381: 
          return glCompressedTexImage3D;
        case 382: 
          return glCompressedTexSubImage3D;
        case 383: 
          return glGenQueries;
        case 384: 
          return glDeleteQueries;
        case 385: 
          return glIsQuery;
        case 386: 
          return glBeginQuery;
        case 387: 
          return glEndQuery;
        case 388: 
          return glGetQueryiv;
        case 389: 
          return glGetQueryObjectuiv;
        case 390: 
          return glUnmapBuffer;
        case 391: 
          return glGetBufferPointerv;
        case 392: 
          return glDrawBuffers;
        case 393: 
          return glUniformMatrix2x3fv;
        case 394: 
          return glUniformMatrix3x2fv;
        case 395: 
          return glUniformMatrix2x4fv;
        case 396: 
          return glUniformMatrix4x2fv;
        case 397: 
          return glUniformMatrix3x4fv;
        case 398: 
          return glUniformMatrix4x3fv;
        case 399: 
          return glBlitFramebuffer;
        case 400: 
          return glRenderbufferStorageMultisample;
        case 401: 
          return glFramebufferTextureLayer;
        case 402: 
          return glMapBufferRange;
        case 403: 
          return glFlushMappedBufferRange;
        case 404: 
          return glBindVertexArray;
        case 405: 
          return glDeleteVertexArrays;
        case 406: 
          return glGenVertexArrays;
        case 407: 
          return glIsVertexArray;
        case 408: 
          return glGetIntegeri_v;
        case 409: 
          return glBeginTransformFeedback;
        case 410: 
          return glEndTransformFeedback;
        case 411: 
          return glBindBufferRange;
        case 412: 
          return glBindBufferBase;
        case 413: 
          return glTransformFeedbackVaryings;
        case 414: 
          return glGetTransformFeedbackVarying;
        case 415: 
          return glVertexAttribIPointer;
        case 416: 
          return glGetVertexAttribIiv;
        case 417: 
          return glGetVertexAttribIuiv;
        case 418: 
          return glVertexAttribI4i;
        case 419: 
          return glVertexAttribI4ui;
        case 420: 
          return glVertexAttribI4iv;
        case 421: 
          return glVertexAttribI4uiv;
        case 422: 
          return glGetUniformuiv;
        case 423: 
          return glGetFragDataLocation;
        case 424: 
          return glUniform1ui;
        case 425: 
          return glUniform2ui;
        case 426: 
          return glUniform3ui;
        case 427: 
          return glUniform4ui;
        case 428: 
          return glUniform1uiv;
        case 429: 
          return glUniform2uiv;
        case 430: 
          return glUniform3uiv;
        case 431: 
          return glUniform4uiv;
        case 432: 
          return glClearBufferiv;
        case 433: 
          return glClearBufferuiv;
        case 434: 
          return glClearBufferfv;
        case 435: 
          return glClearBufferfi;
        case 436: 
          return glGetStringi;
        case 437: 
          return glCopyBufferSubData;
        case 438: 
          return glGetUniformIndices;
        case 439: 
          return glGetActiveUniformsiv;
        case 440: 
          return glGetUniformBlockIndex;
        case 441: 
          return glGetActiveUniformBlockiv;
        case 442: 
          return glGetActiveUniformBlockName;
        case 443: 
          return glUniformBlockBinding;
        case 444: 
          return glDrawArraysInstanced;
        case 445: 
          return glDrawElementsInstanced;
        case 446: 
          return glFenceSync;
        case 447: 
          return glIsSync;
        case 448: 
          return glDeleteSync;
        case 449: 
          return glClientWaitSync;
        case 450: 
          return glWaitSync;
        case 451: 
          return glGetInteger64v;
        case 452: 
          return glGetSynciv;
        case 453: 
          return glGetInteger64i_v;
        case 454: 
          return glGetBufferParameteri64v;
        case 455: 
          return glGenSamplers;
        case 456: 
          return glDeleteSamplers;
        case 457: 
          return glIsSampler;
        case 458: 
          return glBindSampler;
        case 459: 
          return glSamplerParameteri;
        case 460: 
          return glSamplerParameteriv;
        case 461: 
          return glSamplerParameterf;
        case 462: 
          return glSamplerParameterfv;
        case 463: 
          return glGetSamplerParameteriv;
        case 464: 
          return glGetSamplerParameterfv;
        case 465: 
          return glVertexAttribDivisor;
        case 466: 
          return glBindTransformFeedback;
        case 467: 
          return glDeleteTransformFeedbacks;
        case 468: 
          return glGenTransformFeedbacks;
        case 469: 
          return glIsTransformFeedback;
        case 470: 
          return glPauseTransformFeedback;
        case 471: 
          return glResumeTransformFeedback;
        case 472: 
          return glGetProgramBinary;
        case 473: 
          return glProgramBinary;
        case 474: 
          return glProgramParameteri;
        case 475: 
          return glInvalidateFramebuffer;
        case 476: 
          return glInvalidateSubFramebuffer;
        case 477: 
          return glTexStorage2D;
        case 478: 
          return glTexStorage3D;
        case 479: 
          return glGetInternalformativ;
        case 502: 
          return glActiveShaderProgramEXT;
        case 503: 
          return glAlphaFuncQCOM;
        case 504: 
          return glBeginQueryEXT;
        case 505: 
          return glBindProgramPipelineEXT;
        case 506: 
          return glBlitFramebufferANGLE;
        case 507: 
          return glCreateShaderProgramvEXT;
        case 508: 
          return glDeleteProgramPipelinesEXT;
        case 509: 
          return glDeleteQueriesEXT;
        case 510: 
          return glDrawBuffersNV;
        case 511: 
          return glEndQueryEXT;
        case 512: 
          return glFramebufferTexture2DMultisampleEXT;
        case 513: 
          return glGenProgramPipelinesEXT;
        case 514: 
          return glGenQueriesEXT;
        case 515: 
          return glGetGraphicsResetStatusEXT;
        case 516: 
          return glGetObjectLabelEXT;
        case 517: 
          return glGetProgramPipelineInfoLogEXT;
        case 518: 
          return glGetProgramPipelineivEXT;
        case 519: 
          return glGetQueryObjectuivEXT;
        case 520: 
          return glGetQueryivEXT;
        case 521: 
          return glGetnUniformfvEXT;
        case 522: 
          return glInsertEventMarkerEXT;
        case 523: 
          return glIsProgramPipelineEXT;
        case 524: 
          return glIsQueryEXT;
        case 525: 
          return glLabelObjectEXT;
        case 526: 
          return glPopGroupMarkerEXT;
        case 527: 
          return glProgramParameteriEXT;
        case 528: 
          return glProgramUniform1fEXT;
        case 529: 
          return glProgramUniform1fvEXT;
        case 530: 
          return glProgramUniform1iEXT;
        case 531: 
          return glProgramUniform1ivEXT;
        case 532: 
          return glProgramUniform2fEXT;
        case 533: 
          return glProgramUniform2fvEXT;
        case 534: 
          return glProgramUniform2iEXT;
        case 535: 
          return glProgramUniform2ivEXT;
        case 536: 
          return glProgramUniform3fEXT;
        case 537: 
          return glProgramUniform3fvEXT;
        case 538: 
          return glProgramUniform3iEXT;
        case 539: 
          return glProgramUniform3ivEXT;
        case 540: 
          return glProgramUniform4fEXT;
        case 541: 
          return glProgramUniform4fvEXT;
        case 542: 
          return glProgramUniform4iEXT;
        case 543: 
          return glProgramUniform4ivEXT;
        case 544: 
          return glProgramUniformMatrix2fvEXT;
        case 545: 
          return glProgramUniformMatrix3fvEXT;
        case 546: 
          return glProgramUniformMatrix4fvEXT;
        case 547: 
          return glPushGroupMarkerEXT;
        case 548: 
          return glReadBufferNV;
        case 549: 
          return glReadnPixelsEXT;
        case 550: 
          return glRenderbufferStorageMultisampleANGLE;
        case 551: 
          return glRenderbufferStorageMultisampleAPPLE;
        case 552: 
          return glRenderbufferStorageMultisampleEXT;
        case 553: 
          return glResolveMultisampleFramebufferAPPLE;
        case 554: 
          return glTexStorage1DEXT;
        case 555: 
          return glTexStorage2DEXT;
        case 556: 
          return glTexStorage3DEXT;
        case 557: 
          return glTextureStorage1DEXT;
        case 558: 
          return glTextureStorage2DEXT;
        case 559: 
          return glTextureStorage3DEXT;
        case 560: 
          return glUseProgramStagesEXT;
        case 561: 
          return glValidateProgramPipelineEXT;
        case 2000: 
          return eglGetDisplay;
        case 2001: 
          return eglInitialize;
        case 2002: 
          return eglTerminate;
        case 2003: 
          return eglGetConfigs;
        case 2004: 
          return eglChooseConfig;
        case 2005: 
          return eglGetConfigAttrib;
        case 2006: 
          return eglCreateWindowSurface;
        case 2007: 
          return eglCreatePixmapSurface;
        case 2008: 
          return eglCreatePbufferSurface;
        case 2009: 
          return eglDestroySurface;
        case 2010: 
          return eglQuerySurface;
        case 2011: 
          return eglCreateContext;
        case 2012: 
          return eglDestroyContext;
        case 2013: 
          return eglMakeCurrent;
        case 2014: 
          return eglGetCurrentContext;
        case 2015: 
          return eglGetCurrentSurface;
        case 2016: 
          return eglGetCurrentDisplay;
        case 2017: 
          return eglQueryContext;
        case 2018: 
          return eglWaitGL;
        case 2019: 
          return eglWaitNative;
        case 2020: 
          return eglSwapBuffers;
        case 2021: 
          return eglCopyBuffers;
        case 2022: 
          return eglGetError;
        case 2023: 
          return eglQueryString;
        case 2024: 
          return eglGetProcAddress;
        case 2025: 
          return eglSurfaceAttrib;
        case 2026: 
          return eglBindTexImage;
        case 2027: 
          return eglReleaseTexImage;
        case 2028: 
          return eglSwapInterval;
        case 2029: 
          return eglBindAPI;
        case 2030: 
          return eglQueryAPI;
        case 2031: 
          return eglWaitClient;
        case 2032: 
          return eglReleaseThread;
        case 2033: 
          return eglCreatePbufferFromClientBuffer;
        case 2034: 
          return eglLockSurfaceKHR;
        case 2035: 
          return eglUnlockSurfaceKHR;
        case 2036: 
          return eglCreateImageKHR;
        case 2037: 
          return eglDestroyImageKHR;
        case 2038: 
          return eglCreateSyncKHR;
        case 2039: 
          return eglDestroySyncKHR;
        case 2040: 
          return eglClientWaitSyncKHR;
        case 2041: 
          return eglGetSyncAttribKHR;
        case 2042: 
          return eglSetSwapRectangleANDROID;
        case 2043: 
          return eglGetRenderBufferANDROID;
        case 2044: 
          return eglGetSystemTimeFrequencyNV;
        case 2045: 
          return eglGetSystemTimeNV;
        case 3000: 
          return invalid;
        case 3001: 
          return glVertexAttribPointerData;
        }
        return null;
      }
      
      public static Internal.EnumLiteMap<Function> internalGetValueMap()
      {
        return internalValueMap;
      }
      
      private static Internal.EnumLiteMap<Function> internalValueMap = new Internal.EnumLiteMap()
      {
        public GLProtoBuf.GLMessage.Function findValueByNumber(int number)
        {
          return GLProtoBuf.GLMessage.Function.valueOf(number);
        }
      };
      private final int index;
      private final int value;
      
      private Function(int index, int value)
      {
        this.index = index;
        this.value = value;
      }
    }
    
    public static final class DataType
      extends GeneratedMessageLite
    {
      private DataType()
      {
        initFields();
      }
      
      public static DataType getDefaultInstance()
      {
        return defaultInstance;
      }
      
      public DataType getDefaultInstanceForType()
      {
        return defaultInstance;
      }
      
      public static enum Type
        implements Internal.EnumLite
      {
        VOID(0, 1),  CHAR(1, 2),  BYTE(2, 3),  INT(3, 4),  FLOAT(4, 5),  BOOL(5, 6),  ENUM(6, 7),  INT64(7, 8);
        
        public final int getNumber()
        {
          return value;
        }
        
        public static Type valueOf(int value)
        {
          switch (value)
          {
          case 1: 
            return VOID;
          case 2: 
            return CHAR;
          case 3: 
            return BYTE;
          case 4: 
            return INT;
          case 5: 
            return FLOAT;
          case 6: 
            return BOOL;
          case 7: 
            return ENUM;
          case 8: 
            return INT64;
          }
          return null;
        }
        
        public static Internal.EnumLiteMap<Type> internalGetValueMap()
        {
          return internalValueMap;
        }
        
        private static Internal.EnumLiteMap<Type> internalValueMap = new Internal.EnumLiteMap()
        {
          public GLProtoBuf.GLMessage.DataType.Type findValueByNumber(int number)
          {
            return GLProtoBuf.GLMessage.DataType.Type.valueOf(number);
          }
        };
        private final int index;
        private final int value;
        
        private Type(int index, int value)
        {
          this.index = index;
          this.value = value;
        }
      }
      
      public boolean hasType()
      {
        return hasType;
      }
      
      public Type getType()
      {
        return type_;
      }
      
      private boolean isArray_ = false;
      
      public boolean hasIsArray()
      {
        return hasIsArray;
      }
      
      public boolean getIsArray()
      {
        return isArray_;
      }
      
      private List<Integer> intValue_ = Collections.emptyList();
      
      public List<Integer> getIntValueList()
      {
        return intValue_;
      }
      
      public int getIntValueCount()
      {
        return intValue_.size();
      }
      
      public int getIntValue(int index)
      {
        return ((Integer)intValue_.get(index)).intValue();
      }
      
      private List<Float> floatValue_ = Collections.emptyList();
      
      public List<Float> getFloatValueList()
      {
        return floatValue_;
      }
      
      public int getFloatValueCount()
      {
        return floatValue_.size();
      }
      
      public float getFloatValue(int index)
      {
        return ((Float)floatValue_.get(index)).floatValue();
      }
      
      private List<ByteString> charValue_ = Collections.emptyList();
      
      public List<ByteString> getCharValueList()
      {
        return charValue_;
      }
      
      public int getCharValueCount()
      {
        return charValue_.size();
      }
      
      public ByteString getCharValue(int index)
      {
        return (ByteString)charValue_.get(index);
      }
      
      private List<ByteString> rawBytes_ = Collections.emptyList();
      
      public List<ByteString> getRawBytesList()
      {
        return rawBytes_;
      }
      
      public int getRawBytesCount()
      {
        return rawBytes_.size();
      }
      
      public ByteString getRawBytes(int index)
      {
        return (ByteString)rawBytes_.get(index);
      }
      
      private List<Boolean> boolValue_ = Collections.emptyList();
      
      public List<Boolean> getBoolValueList()
      {
        return boolValue_;
      }
      
      public int getBoolValueCount()
      {
        return boolValue_.size();
      }
      
      public boolean getBoolValue(int index)
      {
        return ((Boolean)boolValue_.get(index)).booleanValue();
      }
      
      private List<Long> int64Value_ = Collections.emptyList();
      
      public List<Long> getInt64ValueList()
      {
        return int64Value_;
      }
      
      public int getInt64ValueCount()
      {
        return int64Value_.size();
      }
      
      public long getInt64Value(int index)
      {
        return ((Long)int64Value_.get(index)).longValue();
      }
      
      private void initFields()
      {
        type_ = Type.VOID;
      }
      
      public final boolean isInitialized()
      {
        if (!hasType) {
          return false;
        }
        if (!hasIsArray) {
          return false;
        }
        return true;
      }
      
      public void writeTo(CodedOutputStream output)
        throws IOException
      {
        getSerializedSize();
        if (hasType()) {
          output.writeEnum(1, getType().getNumber());
        }
        if (hasIsArray()) {
          output.writeBool(2, getIsArray());
        }
        for (Iterator localIterator1 = getIntValueList().iterator(); localIterator1.hasNext();)
        {
          int element = ((Integer)localIterator1.next()).intValue();
          output.writeInt32(3, element);
        }
        for (localIterator1 = getFloatValueList().iterator(); localIterator1.hasNext();)
        {
          float element = ((Float)localIterator1.next()).floatValue();
          output.writeFloat(4, element);
        }
        for (ByteString element : getCharValueList()) {
          output.writeBytes(5, element);
        }
        for (ByteString element : getRawBytesList()) {
          output.writeBytes(6, element);
        }
        for (localIterator1 = getBoolValueList().iterator(); localIterator1.hasNext();)
        {
          boolean element = ((Boolean)localIterator1.next()).booleanValue();
          output.writeBool(7, element);
        }
        for (Iterator localIterator2 = getInt64ValueList().iterator(); localIterator2.hasNext();)
        {
          long element = ((Long)localIterator2.next()).longValue();
          output.writeInt64(8, element);
        }
      }
      
      private int memoizedSerializedSize = -1;
      
      public int getSerializedSize()
      {
        int size = memoizedSerializedSize;
        if (size != -1) {
          return size;
        }
        size = 0;
        if (hasType()) {
          size = size + CodedOutputStream.computeEnumSize(1, getType().getNumber());
        }
        if (hasIsArray()) {
          size = size + CodedOutputStream.computeBoolSize(2, getIsArray());
        }
        int dataSize = 0;
        for (Iterator localIterator1 = getIntValueList().iterator(); localIterator1.hasNext();)
        {
          int element = ((Integer)localIterator1.next()).intValue();
          
          dataSize = dataSize + CodedOutputStream.computeInt32SizeNoTag(element);
        }
        size += dataSize;
        size += 1 * getIntValueList().size();
        
        int dataSize = 0;
        dataSize = 4 * getFloatValueList().size();
        size += dataSize;
        size += 1 * getFloatValueList().size();
        
        int dataSize = 0;
        for (ByteString element : getCharValueList()) {
          dataSize = dataSize + CodedOutputStream.computeBytesSizeNoTag(element);
        }
        size += dataSize;
        size += 1 * getCharValueList().size();
        
        int dataSize = 0;
        for (ByteString element : getRawBytesList()) {
          dataSize = dataSize + CodedOutputStream.computeBytesSizeNoTag(element);
        }
        size += dataSize;
        size += 1 * getRawBytesList().size();
        
        int dataSize = 0;
        dataSize = 1 * getBoolValueList().size();
        size += dataSize;
        size += 1 * getBoolValueList().size();
        
        int dataSize = 0;
        for (Iterator localIterator2 = getInt64ValueList().iterator(); localIterator2.hasNext();)
        {
          long element = ((Long)localIterator2.next()).longValue();
          
          dataSize = dataSize + CodedOutputStream.computeInt64SizeNoTag(element);
        }
        size += dataSize;
        size += 1 * getInt64ValueList().size();
        
        memoizedSerializedSize = size;
        return size;
      }
      
      public static DataType parseFrom(ByteString data)
        throws InvalidProtocolBufferException
      {
        return ((Builder)newBuilder().mergeFrom(data)).buildParsed();
      }
      
      public static DataType parseFrom(ByteString data, ExtensionRegistryLite extensionRegistry)
        throws InvalidProtocolBufferException
      {
        return 
          ((Builder)newBuilder().mergeFrom(data, extensionRegistry)).buildParsed();
      }
      
      public static DataType parseFrom(byte[] data)
        throws InvalidProtocolBufferException
      {
        return ((Builder)newBuilder().mergeFrom(data)).buildParsed();
      }
      
      public static DataType parseFrom(byte[] data, ExtensionRegistryLite extensionRegistry)
        throws InvalidProtocolBufferException
      {
        return 
          ((Builder)newBuilder().mergeFrom(data, extensionRegistry)).buildParsed();
      }
      
      public static DataType parseFrom(InputStream input)
        throws IOException
      {
        return ((Builder)newBuilder().mergeFrom(input)).buildParsed();
      }
      
      public static DataType parseFrom(InputStream input, ExtensionRegistryLite extensionRegistry)
        throws IOException
      {
        return 
          ((Builder)newBuilder().mergeFrom(input, extensionRegistry)).buildParsed();
      }
      
      public static DataType parseDelimitedFrom(InputStream input)
        throws IOException
      {
        Builder builder = newBuilder();
        if (builder.mergeDelimitedFrom(input)) {
          return builder.buildParsed();
        }
        return null;
      }
      
      public static DataType parseDelimitedFrom(InputStream input, ExtensionRegistryLite extensionRegistry)
        throws IOException
      {
        Builder builder = newBuilder();
        if (builder.mergeDelimitedFrom(input, extensionRegistry)) {
          return builder.buildParsed();
        }
        return null;
      }
      
      public static DataType parseFrom(CodedInputStream input)
        throws IOException
      {
        return ((Builder)newBuilder().mergeFrom(input)).buildParsed();
      }
      
      public static DataType parseFrom(CodedInputStream input, ExtensionRegistryLite extensionRegistry)
        throws IOException
      {
        return 
          newBuilder().mergeFrom(input, extensionRegistry).buildParsed();
      }
      
      public static Builder newBuilder()
      {
        return Builder.access$12();
      }
      
      public Builder newBuilderForType()
      {
        return newBuilder();
      }
      
      public static Builder newBuilder(DataType prototype)
      {
        return newBuilder().mergeFrom(prototype);
      }
      
      public Builder toBuilder()
      {
        return newBuilder(this);
      }
      
      public static final class Builder
        extends GeneratedMessageLite.Builder<GLProtoBuf.GLMessage.DataType, Builder>
      {
        private GLProtoBuf.GLMessage.DataType result;
        
        private static Builder create()
        {
          Builder builder = new Builder();
          result = new GLProtoBuf.GLMessage.DataType(null);
          return builder;
        }
        
        protected GLProtoBuf.GLMessage.DataType internalGetResult()
        {
          return result;
        }
        
        public Builder clear()
        {
          if (result == null) {
            throw new IllegalStateException(
              "Cannot call clear() after build().");
          }
          result = new GLProtoBuf.GLMessage.DataType(null);
          return this;
        }
        
        public Builder clone()
        {
          return create().mergeFrom(result);
        }
        
        public GLProtoBuf.GLMessage.DataType getDefaultInstanceForType()
        {
          return GLProtoBuf.GLMessage.DataType.getDefaultInstance();
        }
        
        public boolean isInitialized()
        {
          return result.isInitialized();
        }
        
        public GLProtoBuf.GLMessage.DataType build()
        {
          if ((result != null) && (!isInitialized())) {
            throw newUninitializedMessageException(result);
          }
          return buildPartial();
        }
        
        private GLProtoBuf.GLMessage.DataType buildParsed()
          throws InvalidProtocolBufferException
        {
          if (!isInitialized()) {
            throw 
              newUninitializedMessageException(result).asInvalidProtocolBufferException();
          }
          return buildPartial();
        }
        
        public GLProtoBuf.GLMessage.DataType buildPartial()
        {
          if (result == null) {
            throw new IllegalStateException(
              "build() has already been called on this Builder.");
          }
          if (result.intValue_ != Collections.EMPTY_LIST) {
            result.intValue_ = 
              Collections.unmodifiableList(result.intValue_);
          }
          if (result.floatValue_ != Collections.EMPTY_LIST) {
            result.floatValue_ = 
              Collections.unmodifiableList(result.floatValue_);
          }
          if (result.charValue_ != Collections.EMPTY_LIST) {
            result.charValue_ = 
              Collections.unmodifiableList(result.charValue_);
          }
          if (result.rawBytes_ != Collections.EMPTY_LIST) {
            result.rawBytes_ = 
              Collections.unmodifiableList(result.rawBytes_);
          }
          if (result.boolValue_ != Collections.EMPTY_LIST) {
            result.boolValue_ = 
              Collections.unmodifiableList(result.boolValue_);
          }
          if (result.int64Value_ != Collections.EMPTY_LIST) {
            result.int64Value_ = 
              Collections.unmodifiableList(result.int64Value_);
          }
          GLProtoBuf.GLMessage.DataType returnMe = result;
          result = null;
          return returnMe;
        }
        
        public Builder mergeFrom(GLProtoBuf.GLMessage.DataType other)
        {
          if (other == GLProtoBuf.GLMessage.DataType.getDefaultInstance()) {
            return this;
          }
          if (other.hasType()) {
            setType(other.getType());
          }
          if (other.hasIsArray()) {
            setIsArray(other.getIsArray());
          }
          if (!intValue_.isEmpty())
          {
            if (result.intValue_.isEmpty()) {
              result.intValue_ = new ArrayList();
            }
            result.intValue_.addAll(intValue_);
          }
          if (!floatValue_.isEmpty())
          {
            if (result.floatValue_.isEmpty()) {
              result.floatValue_ = new ArrayList();
            }
            result.floatValue_.addAll(floatValue_);
          }
          if (!charValue_.isEmpty())
          {
            if (result.charValue_.isEmpty()) {
              result.charValue_ = new ArrayList();
            }
            result.charValue_.addAll(charValue_);
          }
          if (!rawBytes_.isEmpty())
          {
            if (result.rawBytes_.isEmpty()) {
              result.rawBytes_ = new ArrayList();
            }
            result.rawBytes_.addAll(rawBytes_);
          }
          if (!boolValue_.isEmpty())
          {
            if (result.boolValue_.isEmpty()) {
              result.boolValue_ = new ArrayList();
            }
            result.boolValue_.addAll(boolValue_);
          }
          if (!int64Value_.isEmpty())
          {
            if (result.int64Value_.isEmpty()) {
              result.int64Value_ = new ArrayList();
            }
            result.int64Value_.addAll(int64Value_);
          }
          return this;
        }
        
        public Builder mergeFrom(CodedInputStream input, ExtensionRegistryLite extensionRegistry)
          throws IOException
        {
          for (;;)
          {
            int tag = input.readTag();
            switch (tag)
            {
            case 0: 
              return this;
            default: 
              if (!parseUnknownField(input, extensionRegistry, tag)) {
                return this;
              }
              break;
            case 8: 
              int rawValue = input.readEnum();
              GLProtoBuf.GLMessage.DataType.Type value = GLProtoBuf.GLMessage.DataType.Type.valueOf(rawValue);
              if (value != null) {
                setType(value);
              }
              break;
            case 16: 
              setIsArray(input.readBool());
              break;
            case 24: 
              addIntValue(input.readInt32());
              break;
            case 26: 
              int length = input.readRawVarint32();
              int limit = input.pushLimit(length);
              while (input.getBytesUntilLimit() > 0) {
                addIntValue(input.readInt32());
              }
              input.popLimit(limit);
              break;
            case 37: 
              addFloatValue(input.readFloat());
              break;
            case 34: 
              int length = input.readRawVarint32();
              int limit = input.pushLimit(length);
              while (input.getBytesUntilLimit() > 0) {
                addFloatValue(input.readFloat());
              }
              input.popLimit(limit);
              break;
            case 42: 
              addCharValue(input.readBytes());
              break;
            case 50: 
              addRawBytes(input.readBytes());
              break;
            case 56: 
              addBoolValue(input.readBool());
              break;
            case 58: 
              int length = input.readRawVarint32();
              int limit = input.pushLimit(length);
              while (input.getBytesUntilLimit() > 0) {
                addBoolValue(input.readBool());
              }
              input.popLimit(limit);
              break;
            case 64: 
              addInt64Value(input.readInt64());
              break;
            case 66: 
              int length = input.readRawVarint32();
              int limit = input.pushLimit(length);
              while (input.getBytesUntilLimit() > 0) {
                addInt64Value(input.readInt64());
              }
              input.popLimit(limit);
            }
          }
        }
        
        public boolean hasType()
        {
          return result.hasType();
        }
        
        public GLProtoBuf.GLMessage.DataType.Type getType()
        {
          return result.getType();
        }
        
        public Builder setType(GLProtoBuf.GLMessage.DataType.Type value)
        {
          if (value == null) {
            throw new NullPointerException();
          }
          result.hasType = true;
          result.type_ = value;
          return this;
        }
        
        public Builder clearType()
        {
          result.hasType = false;
          result.type_ = GLProtoBuf.GLMessage.DataType.Type.VOID;
          return this;
        }
        
        public boolean hasIsArray()
        {
          return result.hasIsArray();
        }
        
        public boolean getIsArray()
        {
          return result.getIsArray();
        }
        
        public Builder setIsArray(boolean value)
        {
          result.hasIsArray = true;
          result.isArray_ = value;
          return this;
        }
        
        public Builder clearIsArray()
        {
          result.hasIsArray = false;
          result.isArray_ = false;
          return this;
        }
        
        public List<Integer> getIntValueList()
        {
          return Collections.unmodifiableList(result.intValue_);
        }
        
        public int getIntValueCount()
        {
          return result.getIntValueCount();
        }
        
        public int getIntValue(int index)
        {
          return result.getIntValue(index);
        }
        
        public Builder setIntValue(int index, int value)
        {
          result.intValue_.set(index, Integer.valueOf(value));
          return this;
        }
        
        public Builder addIntValue(int value)
        {
          if (result.intValue_.isEmpty()) {
            result.intValue_ = new ArrayList();
          }
          result.intValue_.add(Integer.valueOf(value));
          return this;
        }
        
        public Builder addAllIntValue(Iterable<? extends Integer> values)
        {
          if (result.intValue_.isEmpty()) {
            result.intValue_ = new ArrayList();
          }
          GeneratedMessageLite.Builder.addAll(values, result.intValue_);
          return this;
        }
        
        public Builder clearIntValue()
        {
          result.intValue_ = Collections.emptyList();
          return this;
        }
        
        public List<Float> getFloatValueList()
        {
          return Collections.unmodifiableList(result.floatValue_);
        }
        
        public int getFloatValueCount()
        {
          return result.getFloatValueCount();
        }
        
        public float getFloatValue(int index)
        {
          return result.getFloatValue(index);
        }
        
        public Builder setFloatValue(int index, float value)
        {
          result.floatValue_.set(index, Float.valueOf(value));
          return this;
        }
        
        public Builder addFloatValue(float value)
        {
          if (result.floatValue_.isEmpty()) {
            result.floatValue_ = new ArrayList();
          }
          result.floatValue_.add(Float.valueOf(value));
          return this;
        }
        
        public Builder addAllFloatValue(Iterable<? extends Float> values)
        {
          if (result.floatValue_.isEmpty()) {
            result.floatValue_ = new ArrayList();
          }
          GeneratedMessageLite.Builder.addAll(values, result.floatValue_);
          return this;
        }
        
        public Builder clearFloatValue()
        {
          result.floatValue_ = Collections.emptyList();
          return this;
        }
        
        public List<ByteString> getCharValueList()
        {
          return Collections.unmodifiableList(result.charValue_);
        }
        
        public int getCharValueCount()
        {
          return result.getCharValueCount();
        }
        
        public ByteString getCharValue(int index)
        {
          return result.getCharValue(index);
        }
        
        public Builder setCharValue(int index, ByteString value)
        {
          if (value == null) {
            throw new NullPointerException();
          }
          result.charValue_.set(index, value);
          return this;
        }
        
        public Builder addCharValue(ByteString value)
        {
          if (value == null) {
 
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

Further reading...

For more information on Java 1.5 Tiger, you may find Java 1.5 Tiger, A developer's Notebook by D. Flanagan and B. McLaughlin from O'Reilly of interest.

New!JAR listings


Copyright 2006-2019. Infinite Loop Ltd