@Override
public void writetoParcel(Parcel out,int flags) {
    if (mRelroFd >= 0) {
        out.writeLong(mloadAddress);
        out.writeLong(mloadSize);
        out.writeLong(mRelroStart);
        out.writeLong(mRelroSize);
        try {
            ParcelFileDescriptor fd = ParcelFileDescriptor.fromFd(mRelroFd);
            fd.writetoParcel(out,0);
            fd.close();
        } catch (java.io.IOException e) {
            Log.e(TAG,"Can't write LibInfo file descriptor to parcel",e);
        }
    }
}

private ParcelFileDescriptor openReadInternal(String name) throws IOException {
    assertPreparedAndNotSealed("openRead");

    try {
        if (!FileUtils.isValidExtFilename(name)) {
            throw new IllegalArgumentException("Invalid name: " + name);
        }
        final File target = new File(resolveStageDir(),name);

        final FileDescriptor targetFd = Os.open(target.getAbsolutePath(),O_RDONLY,0);
        return ParcelFileDescriptor.dup(targetFd);

    } catch (ErrnoException e) {
        throw new IOException(e);
    }
}

@Rpc(description = "Compute MD5 hash on a content URI. Return the MD5 has has a hex string.")
public String fileMd5Hash(String uri) throws IOException,NoSuchAlgorithmException {
    Uri uri_ = Uri.parse(uri);
    ParcelFileDescriptor pfd = mContext.getContentResolver().openFileDescriptor(uri_,"r");
    MessageDigest md = MessageDigest.getInstance("MD5");
    int length = (int) pfd.getStatSize();
    byte[] buf = new byte[length];
    ParcelFileDescriptor.AutoCloseInputStream stream =
            new ParcelFileDescriptor.AutoCloseInputStream(pfd);
    DigestInputStream dis = new DigestInputStream(stream,md);
    try {
        dis.read(buf,length);
        return Utils.bytesToHexString(md.digest());
    } finally {
        dis.close();
        stream.close();
    }
}

protected AssetFileDescriptor openVideoThumbnailCleared(long id,CancellationSignal signal)
        throws FileNotFoundException {
    final ContentResolver resolver = getContext().getContentResolver();
    Cursor cursor = null;
    try {
        cursor = resolver.query(Video.Thumbnails.EXTERNAL_CONTENT_URI,VideoThumbnailQuery.PROJECTION,Video.Thumbnails.VIDEO_ID + "=" + id,null,null);
        if (cursor.movetoFirst()) {
            final String data = cursor.getString(VideoThumbnailQuery._DATA);
            return new AssetFileDescriptor(ParcelFileDescriptor.open(
                    new File(data),ParcelFileDescriptor.MODE_READ_ONLY),AssetFileDescriptor.UNKNowN_LENGTH);
        }
    } finally {
        IoUtils.closeQuietly(cursor);
    }
    return null;
}

public FileDescriptorFactory() {
  super(new FileOpener<ParcelFileDescriptor>() {
    @Override
    public ParcelFileDescriptor open(File file) throws FileNotFoundException {
      return ParcelFileDescriptor.open(file,ParcelFileDescriptor.MODE_READ_ONLY);
    }

    @Override
    public void close(ParcelFileDescriptor parcelFileDescriptor) throws IOException {
      parcelFileDescriptor.close();
    }

    @Override
    public Class<ParcelFileDescriptor> getDataClass() {
      return ParcelFileDescriptor.class;
    }
  });
}

/**
 * copied from ContentResolver.java
 */
private static int modetoMode(String mode) {
    int modeBits;
    if ("r".equals(mode)) {
        modeBits = ParcelFileDescriptor.MODE_READ_ONLY;
    } else if ("w".equals(mode) || "wt".equals(mode)) {
        modeBits = ParcelFileDescriptor.MODE_WRITE_ONLY
                | ParcelFileDescriptor.MODE_CREATE
                | ParcelFileDescriptor.MODE_TruncATE;
    } else if ("wa".equals(mode)) {
        modeBits = ParcelFileDescriptor.MODE_WRITE_ONLY
                | ParcelFileDescriptor.MODE_CREATE
                | ParcelFileDescriptor.MODE_APPEND;
    } else if ("rw".equals(mode)) {
        modeBits = ParcelFileDescriptor.MODE_READ_WRITE
                | ParcelFileDescriptor.MODE_CREATE;
    } else if ("rwt".equals(mode)) {
        modeBits = ParcelFileDescriptor.MODE_READ_WRITE
                | ParcelFileDescriptor.MODE_CREATE
                | ParcelFileDescriptor.MODE_TruncATE;
    } else {
        throw new IllegalArgumentException("Invalid mode: " + mode);
    }
    return modeBits;
}

protected ParcelFileDescriptor openImageThumbnailCleared(long id,CancellationSignal signal)
        throws FileNotFoundException {
    final ContentResolver resolver = getContext().getContentResolver();

    Cursor cursor = null;
    try {
        cursor = resolver.query(Images.Thumbnails.EXTERNAL_CONTENT_URI,ImageThumbnailQuery.PROJECTION,Images.Thumbnails.IMAGE_ID + "=" + id,null);
        if (cursor.movetoFirst()) {
            final String data = cursor.getString(ImageThumbnailQuery._DATA);
            return ParcelFileDescriptor.open(
                    new File(data),ParcelFileDescriptor.MODE_READ_ONLY);
        }
    } finally {
        IoUtils.closeQuietly(cursor);
    }
    return null;
}

protected ParcelFileDescriptor openImageThumbnailCleared(long id,ParcelFileDescriptor.MODE_READ_ONLY);
        }
    } finally {
        IoUtils.closeQuietly(cursor);
    }
    return null;
}

@Test
public void testLoadResource_returnsFileDescriptor() throws Exception {
  Context context = RuntimeEnvironment.application;
  Uri uri = Uri.parse("file://nothing");

  ContentResolver contentResolver = context.getContentResolver();
  ContentResolverShadow shadow = Shadow.extract(contentResolver);

  AssetFileDescriptor assetFileDescriptor = mock(AssetFileDescriptor.class);
  ParcelFileDescriptor parcelFileDescriptor = mock(ParcelFileDescriptor.class);
  when(assetFileDescriptor.getParcelFileDescriptor()).thenReturn(parcelFileDescriptor);
  shadow.registerFileDescriptor(uri,assetFileDescriptor);

  FileDescriptorLocalUriFetcher fetcher =
      new FileDescriptorLocalUriFetcher(context.getContentResolver(),uri);
  fetcher.loadData(Priority.norMAL,callback);
  verify(callback).onDataReady(eq(parcelFileDescriptor));
}

@Override
public android.os.ParcelFileDescriptor openFile(android.net.Uri uri,java.lang.String mode)
        throws java.io.FileNotFoundException {

    Pair<UUID,String> callIdAndAttachmentName = parseCallIdAndAttachmentName(uri);
    if (callIdAndAttachmentName == null) {
        throw new FileNotFoundException();
    }

    try {
        File file = NativeAppCallAttachmentStore.openAttachment(
                callIdAndAttachmentName.first,callIdAndAttachmentName.second);

        return ParcelFileDescriptor.open(file,ParcelFileDescriptor.MODE_READ_ONLY);
    } catch (FileNotFoundException exception) {
        Log.e(TAG,"Got unexpected exception:" + exception);
        throw exception;
    }
}

private void initialize()
        throws FileNotFoundException {
    ParcelFileDescriptor fileDescriptor = null;
    try {
        if (Utility.isFileUri(videoUri)) {
            fileDescriptor = ParcelFileDescriptor.open(
                    new File(videoUri.getPath()),ParcelFileDescriptor.MODE_READ_ONLY);
            videoSize = fileDescriptor.getStatSize();
            videoStream = new ParcelFileDescriptor.AutoCloseInputStream(fileDescriptor);
        } else if (Utility.isContentUri(videoUri)) {
            videoSize = Utility.getContentSize(videoUri);
            videoStream = FacebookSdk
                    .getApplicationContext()
                    .getContentResolver()
                    .openInputStream(videoUri);
        } else {
            throw new FacebookException("Uri must be a content:// or file:// uri");
        }
    } catch (FileNotFoundException e) {
        Utility.closeQuietly(videoStream);

        throw e;
    }
}

@Override
public ParcelFileDescriptor openFile(@NonNull Uri uri,@NonNull String mode) throws FileNotFoundException {
  final MasterSecret masterSecret = KeyCachingService.getMasterSecret(getContext());
  Log.w(TAG,"openFile() called!");

  if (masterSecret == null) {
    Log.w(TAG,"masterSecret was null,abandoning.");
    return null;
  }

  switch (uriMatcher.match(uri)) {
  case SINGLE_ROW:
    Log.w(TAG,"Parting out a single row...");
    try {
      final PartUriParser partUri = new PartUriParser(uri);
      return getParcelStreamForAttachment(masterSecret,partUri.getPartId());
    } catch (IOException ioe) {
      Log.w(TAG,ioe);
      throw new FileNotFoundException("Error opening file");
    }
  }

  throw new FileNotFoundException("Request for bad part.");
}

protected AssetFileDescriptor openVideoThumbnailCleared(long id,AssetFileDescriptor.UNKNowN_LENGTH);
        }
    } finally {
        IoUtils.closeQuietly(cursor);
    }
    return null;
}

@Override
public ParcelFileDescriptor opendocument(String docId,String mode,CancellationSignal signal)
        throws FileNotFoundException {

    if (!"r".equals(mode)) {
        throw new IllegalArgumentException("Media is read-only");
    }

    final Uri target = getUriForDocumentId(docId);

    // Delegate to real provider
    final long token = Binder.clearCallingIdentity();
    try {
        return getContext().getContentResolver().openFileDescriptor(target,mode);
    } finally {
        Binder.restoreCallingIdentity(token);
    }
}

public static int parseMode(String mode) {
    final int modeBits;
    if ("r".equals(mode)) {
        modeBits = ParcelFileDescriptor.MODE_READ_ONLY;
    } else if ("w".equals(mode) || "wt".equals(mode)) {
        modeBits = ParcelFileDescriptor.MODE_WRITE_ONLY
                | ParcelFileDescriptor.MODE_CREATE
                | ParcelFileDescriptor.MODE_TruncATE;
    } else if ("wa".equals(mode)) {
        modeBits = ParcelFileDescriptor.MODE_WRITE_ONLY
                | ParcelFileDescriptor.MODE_CREATE
                | ParcelFileDescriptor.MODE_APPEND;
    } else if ("rw".equals(mode)) {
        modeBits = ParcelFileDescriptor.MODE_READ_WRITE
                | ParcelFileDescriptor.MODE_CREATE;
    } else if ("rwt".equals(mode)) {
        modeBits = ParcelFileDescriptor.MODE_READ_WRITE
                | ParcelFileDescriptor.MODE_CREATE
                | ParcelFileDescriptor.MODE_TruncATE;
    } else {
        throw new IllegalArgumentException("Bad mode '" + mode + "'");
    }
    return modeBits;
}

@Override
public ParcelFileDescriptor opendocument(String docId,mode);
    } finally {
        Binder.restoreCallingIdentity(token);
    }
}

@Override
public ParcelFileDescriptor openFile(Uri uri,String mode)
        throws FileNotFoundException {
       initIfNecessary();
    AssetFileDescriptor af = openAssetFile(uri,mode);
    if ( null != af ) {
        return af.getParcelFileDescriptor();
    }
    return null;
}

private void openRenderer( )  {
    // In this sample,we read a PDF from the assets directory.
    File f = new File(uri.getPath());
    try {
        mFileDescriptor = ParcelFileDescriptor.open(f,ParcelFileDescriptor.MODE_READ_ONLY);
        mPdfRenderer = new PdfRenderer(mFileDescriptor);
        cnt=mPdfRenderer.getPageCount();
    } catch (Exception e) {
        log.e(e);
    }
}

@Override
public ParcelFileDescriptor openFile(@NonNull Uri uri,@NonNull String mode) throws FileNotFoundException {
    List<String> segments = uri.getPathSegments();
    String accountUuid = segments.get(0);
    String attachmentId = segments.get(1);

    ParcelFileDescriptor parcelFileDescriptor = openAttachment(accountUuid,attachmentId);
    if (parcelFileDescriptor == null) {
        throw new FileNotFoundException("Attachment missing or cannot be opened!");
    }
    return parcelFileDescriptor;
}

/**
 * Return album artwork given the id
 * if nothing is found,we try a downloaded one
 *
 * @param context
 * @param album_id
 * @return
 */
public static Bitmap getArtworkQuick_Base1(Context context,long album_id) {
    if (album_id != -1) {
        ContentResolver res = context.getContentResolver();
        Uri uri = ContentUris.withAppendedId(MusicUtils.sArtworkUri,album_id);
        if (uri != null) {
            // ParcelFileDescriptor fd = null;
            try {

                ParcelFileDescriptor fd = res.openFileDescriptor(uri,"r");

                BitmapFactory.Options o2 = new BitmapFactory.Options();

                o2.inSampleSize = 2;
                o2.inDither = false;
                o2.inPreferredConfig = Bitmap.Config.RGB_565;

                Bitmap b = BitmapFactory.decodeFileDescriptor(
                        fd.getFileDescriptor(),o2);

                if (b != null) {
                    return b;
                } else {
                    b = getArtworkDownloadedResized(context,album_id);
                    if (b != null) {
                        return b;
                    } else {
                        return null;
                    }
                }
            } catch (FileNotFoundException e) {
                return null;
            }
        }
    }
    return null;
}

private int transferIncrementalRestoreData(String packageName,ParcelFileDescriptor outputFileDescriptor)
        throws IOException,InvalidAlgorithmParameterException,InvalidKeyException {

    ParcelFileDescriptor inputFileDescriptor = buildInputFileDescriptor();
    ZipInputStream inputStream = buildInputStream(inputFileDescriptor);
    BackupDataOutput backupDataOutput = new BackupDataOutput(outputFileDescriptor.getFileDescriptor());

    Optional<ZipEntry> zipEntryOptional = seekToEntry(inputStream,configuration.getIncrementalBackupDirectory() + packageName);
    while (zipEntryOptional.isPresent()) {
        String fileName = new File(zipEntryOptional.get().getName()).getName();
        String blobKey = new String(Base64.decode(fileName,Base64.DEFAULT));

        byte[] backupData = Streams.readFullyNoClose(inputStream);
        backupDataOutput.writeEntityHeader(blobKey,backupData.length);
        backupDataOutput.writeEntityData(backupData,backupData.length);
        inputStream.closeEntry();

        zipEntryOptional = seekToEntry(inputStream,configuration.getIncrementalBackupDirectory() + packageName);
    }

    IoUtils.closeQuietly(inputFileDescriptor);
    IoUtils.closeQuietly(outputFileDescriptor);
    return TRANSPORT_OK;
}

public static <T> DataSinkTransferThread<T> asyncPipetoDataSink(
        SMimeDataSink<T> dataSink,ParcelFileDescriptor output) throws IOException {
    InputStream inputStream = new BufferedInputStream(new AutoCloseInputStream(output));
    DataSinkTransferThread<T> dataSinkTransferThread =
            new DataSinkTransferThread<T>(dataSink,inputStream);
    dataSinkTransferThread.start();
    return dataSinkTransferThread;
}

public final int startActivity(IApplicationThread caller,String callingPackage,Intent intent,String resolvedType,IBinder resultTo,String resultWho,int requestCode,int startFlags,String profileFile,ParcelFileDescriptor profileFd,Bundle options) {
    return PreventRunningUtils.onStartActivity(
            startActivity$Pr(caller,callingPackage,intent,resolvedType,resultTo,resultWho,requestCode,startFlags,profileFile,profileFd,options),caller,intent);
}

public static ParcelFileDescriptor pipeFrom(InputStream inputStream)
        throws IOException {
    ParcelFileDescriptor[] pipe = ParcelFileDescriptor.createPipe();
    ParcelFileDescriptor readSide = pipe[0];
    ParcelFileDescriptor writeSide = pipe[1];

    new TransferThread(inputStream,new ParcelFileDescriptor.AutoCloSEOutputStream(writeSide))
            .start();

    return readSide;
}

public static TransferThread pipeto(OutputStream outputStream,ParcelFileDescriptor output)
        throws IOException {

    AutoCloseInputStream InputStream = new AutoCloseInputStream(output);
    TransferThread t = new TransferThread(InputStream,outputStream);

    t.start();
    return t;
}

private ParcelFileDescriptor openWriteInternal(String name,long offsetBytes,long lengthBytes)
        throws IOException {
    // Quick sanity check of state,and allocate a pipe for ourselves. We
    // then do heavy disk allocation outside the lock,but this open pipe
    // will block any attempted install transitions.
    final FileBridge bridge;
    synchronized (mlock) {
        assertPreparedAndNotSealed("openWrite");

        bridge = new FileBridge();
        mBridges.add(bridge);
    }
    try {
        final File target = new File(resolveStageDir(),name);
        // Todo: this should delegate to DCS so the system process avoids
        // holding open FDs into containers.
        final FileDescriptor targetFd = Os.open(target.getAbsolutePath(),O_CREAT | O_WRONLY,0644);
        // If caller specified a total length,allocate it for them. Free up
        // cache space to grow,if needed.
        if (lengthBytes > 0) {
            Os.posix_fallocate(targetFd,lengthBytes);
        }
        if (offsetBytes > 0) {
            Os.lseek(targetFd,offsetBytes,OsConstants.SEEK_SET);
        }
        bridge.setTargetFile(targetFd);
        bridge.start();
        return ParcelFileDescriptor.dup(bridge.getClientSocket());

    } catch (ErrnoException e) {
        throw new IOException(e);
    }
}

/**
 * Implementation is provided by the parent class. Cannot be overriden.
 *
 * @see #opendocument(String,String,CancellationSignal)
 */
@Override
public final AssetFileDescriptor openAssetFile(Uri uri,CancellationSignal signal)
        throws FileNotFoundException {
    enforceTree(uri);
    final ParcelFileDescriptor fd = opendocument(getDocumentId(uri),mode,signal);
    return fd != null ? new AssetFileDescriptor(fd,-1) : null;
}

private static void closeLoudly(ParcelFileDescriptor input) {
    if (input != null) {
        try {
            input.close();
        } catch (IOException e) {
            Log.e(OpenPgpApi.TAG,"IOException when closing ParcelFileDescriptor!",e);
        }
    }
}

private boolean loadFromTag() {
    Uri imgLink = getIntent().getParcelableExtra(EXTRA_ParaM_P2P_VAL);
    try {
        ParcelFileDescriptor pfd = getContentResolver().openFileDescriptor(imgLink,"r");
        if (pfd == null) {
            return false;
        }

        Bitmap raw = BitmapFactory.decodeFileDescriptor(pfd.getFileDescriptor());
        if (raw == null) {
            return false;
        }

        setCoverImage(raw);
        return true;
    } catch (FileNotFoundException e) {
        Log.e(LOG_TAG,"Passed Uri points to invalid fd! " + imgLink,e);
    }
    return false;
}

@Override
public ParcelFileDescriptor openFile(Uri uri,String mode)
        throws FileNotFoundException {

    ParcelFileDescriptor pfd = null;
    int match = URI_MATCHER.match(uri);

    // let scraper handle it's part
    if (ScraperProvider.handles(match))
        return mScraperProvider.openFile(uri,mode);

    try {
        pfd = openFileHelper(uri,mode);
    } catch (FileNotFoundException ex) {
        if (mode.contains("w")) {
            // if the file Couldn't be created,we shouldn't extract album art
            throw ex;
        }

        if (pfd == null) {
            throw ex;
        }
    }
    return pfd;
}

/**
 * Write out the new state file:  the version number,followed by the
 * three bits of data as we sent them off to the backup transport.
 */
void writeStateFile(ParcelFileDescriptor stateFile) throws IOException {
    FileOutputStream outstream = new FileOutputStream(stateFile.getFileDescriptor());
    DataOutputStream out = new DataOutputStream(outstream);

    out.writeInt(AGENT_VERSION);
    out.writeInt(mFilling);
    out.writeBoolean(mAddMayo);
    out.writeBoolean(mAddTomato);
}

@Override
protected ParcelFileDescriptor loadResource(Uri uri,ContentResolver contentResolver)
    throws FileNotFoundException {
  AssetFileDescriptor assetFileDescriptor = contentResolver.openAssetFileDescriptor(uri,"r");
  if (assetFileDescriptor == null) {
    throw new FileNotFoundException("FileDescriptor is null for: " + uri);
  }
  return assetFileDescriptor.getParcelFileDescriptor();
}

ReadFileTask(String uri,SmbClient client,ParcelFileDescriptor pfd,ByteBufferPool bufferPool) {
  mUri = uri;
  mClient = client;
  mPfd = pfd;
  mBufferPool = bufferPool;
}

protected ParcelFileDescriptor openAudioThumbnailCleared(long id,CancellationSignal signal)
        throws FileNotFoundException {
    final ContentResolver resolver = getContext().getContentResolver();

    Cursor cursor = null;
    try {
        cursor = resolver.query(Audio.Albums.EXTERNAL_CONTENT_URI,AudioThumbnailQuery.PROJECTION,Audio.Albums._ID + "=" + id,null);
        if (cursor.movetoFirst()) {
            final String data = cursor.getString(AudioThumbnailQuery._DATA);
            return ParcelFileDescriptor.open(
                    new File(data),ParcelFileDescriptor.MODE_READ_ONLY);
        }
    } finally {
        IoUtils.closeQuietly(cursor);
    }
    return null;
}

public static void closeSilently(ParcelFileDescriptor c) {
    if (c == null)
        return;
    try {
        c.close();
    } catch (Throwable t) {
        Log.w(TAG,"fail to close",t);
    }
}

/**
 * Executes a statement that returns a single BLOB result as a
 * file descriptor to a shared memory region.
 *
 * @param sql                The sql statement to execute.
 * @param bindArgs           The arguments to bind,or null if none.
 * @param connectionFlags    The connection flags to use if a connection must be
 *                           acquired by this operation.  Refer to {@link sqliteConnectionPool}.
 * @param cancellationSignal A signal to cancel the operation in progress,or null if none.
 * @return The file descriptor for a shared memory region that contains
 * the value of the first column in the first row of the result set as a BLOB,* or null if none.
 * @throws sqliteException            if an error occurs,such as a Syntax error
 *                                    or invalid number of bind arguments.
 * @throws OperationCanceledException if the operation was canceled.
 */
public ParcelFileDescriptor executeForBlobFileDescriptor(String sql,Object[] bindArgs,int connectionFlags,CancellationSignal cancellationSignal) {
    if (sql == null) {
        throw new IllegalArgumentException("sql must not be null.");
    }

    if (executeSpecial(sql,bindArgs,connectionFlags,cancellationSignal)) {
        return null;
    }

    acquireConnection(sql,cancellationSignal); // might throw
    try {
        return mConnection.executeForBlobFileDescriptor(sql,cancellationSignal); // might throw
    } finally {
        releaseConnection(); // might throw
    }
}

private int transferFullRestoreData(ParcelFileDescriptor outputFileDescriptor) {
    ZipInputStream inputStream = restoreState.getInputStream();
    OutputStream outputStream = new FileOutputStream(outputFileDescriptor.getFileDescriptor());

    byte[] buffer = new byte[DEFAULT_BUFFER_SIZE];
    int bytesRead = NO_MORE_DATA;

    try {
        bytesRead = inputStream.read(buffer);

        if (bytesRead <= 0) {
            bytesRead = NO_MORE_DATA;
        } else {
            outputStream.write(buffer,bytesRead);
        }

    } catch (Exception e) {
        Log.e(TAG,"Exception while streaming restore data: ",e);
        return TRANSPORT_ERROR;

    } finally {
        if (bytesRead == NO_MORE_DATA) {

            if (restoreState.getInputFileDescriptor() != null) {
                IoUtils.closeQuietly(restoreState.getInputFileDescriptor());
            }

            restoreState.setInputFileDescriptor(null);
            restoreState.setInputStream(null);
        }

        IoUtils.closeQuietly(outputFileDescriptor);
    }

    return bytesRead;
}

public static void closeSilently(ParcelFileDescriptor c) {
    if (c == null)
        return;
    try {
        c.close();
    } catch (Throwable t) {
        Log.w(TAG,t);
    }
}

protected ParcelFileDescriptor openImageThumbnailCleared(long id,ParcelFileDescriptor.MODE_READ_ONLY);
        }
    } finally {
        IoUtils.closeQuietly(cursor);
    }
    return null;
}

private void handleVideo(MediaInfo mVideoInfo) {
        mCurrentVideoInfo = mVideoInfo;
        String assetpath = mVideoInfo.getAssetcover();
        File srcFile = new File(assetpath);
        int dotindex = assetpath.lastIndexOf(".");
        if (dotindex != -1) {
            String type = assetpath.substring(dotindex,assetpath.length());
            String compresspath = mSession.getCompresspath();
            if (Build.VERSION.SDK_INT >= 18) {
                FileOutputStream fos = null;
                try {
                    mCacheVideoPath = compresspath + (compresspath.endsWith(File.separator) ? "" : File.separator) + "savorVideo" + type;
                    Uri uriForFile = FileProvider.getUriForFile(this,"com.savor.savorphone.fileprovider",srcFile);
                    ContentResolver contentResolver = getContentResolver();
                    ParcelFileDescriptor pFileDesCripter = contentResolver.openFileDescriptor(uriForFile,"r");
                    FileDescriptor fileDesCripter = pFileDesCripter.getFileDescriptor();
//                    MediaTranscoder.getInstance().transcodeVideo(fileDesCripter,mCacheVideoPath,//                            MediaFormatStrategyPresets.createExportPreset960x540Strategy(),listener);
                    future = MediaTranscoder.getInstance().transcodeVideo(fileDesCripter,MediaFormatStrategyPresets.createAndroid720pStrategy(8000 * 1000,128 * 1000,1),listener);
                } catch (Exception e) {
                    e.printstacktrace();
                    handleFilecopy(mVideoInfo,srcFile,type,compresspath);
                }
            } else {
                handleFilecopy(mVideoInfo,compresspath);
            }
        }
    }

protected void decompileOptions(MessageOrBuilder options) throws IOException {
    for (Map.Entry<FieldDescriptor,Object> entry : options.getAllFields().entrySet()) {
        FieldDescriptor field = entry.getKey();
        Object value = entry.getValue();
        String fieldName = field.getName();
        if (field.isExtension()) {
            fieldName = "(" + fieldName + ")";
        }
        if (field.getType() == FieldDescriptor.Type.MESSAGE) {
            for (Map.Entry<FieldDescriptor,Object> subentry : ((MessageOrBuilder)value).getAllFields().entrySet()) {
                FieldDescriptor subfield = subentry.getKey();
                Object subvalue = subentry.getValue();
                indentedFormat("option %s.%s = %s;",fieldName,subfield.getName(),literal(subvalue,subfield.getType()));
            }
        }
        else {
            indentedFormat("option %s = %s;",literal(value,field.getType()));
        }
    }
}

private FieldDescriptorProto createFieldDescriptorProto(String name,int index,Type type,String typeName,Label label,String defaultValue,String extendee,UnkNownFieldSet unkNownFields,FieldOptions options) {
  FieldDescriptorProto.Builder fieldBuilder = FieldDescriptorProto.newBuilder();
  return fieldBuilder
      .setName(name)
      .setNumber(index)
      .setType(type)
      .setTypeName(typeName)
      .setLabel(label)
      .setDefaultValue(defaultValue)
      .setExtendee(extendee)
      .setUnkNownFields(unkNownFields)
      .setoptions(options)
      .build(); 
}

/**
 * Resolve the additional type specified besides those that can be reached transitively from
 * service deFinition. It resolves the typeName into a {@link TypeRef} object. If typeName ends
 * with wildcard ".*",all the {@link TypeRef}s that is under typeName pattern path are added to
 * the root.
 */
private void addAdditionalType(
    Model model,Location location,final String typeName,final Type kind) {
  if (!SELECTOR_PATTERN.matcher(typeName).matches()) {
    model
        .getDiagReporter()
        .report(
            Diag.error(
                location,"Type selector '%s' specified in the config has bad Syntax. "
                    + "Valid format is \"<segment>('.' <segment>)*('.' '*')?\"",typeName));
    return;
  }

  List<TypeRef> typeRefs = model.getSymbolTable().lookupMatchingTypes(typeName,kind);

  if (typeRefs == null || typeRefs.isEmpty()) {
    model
        .getDiagReporter()
        .report(
            Diag.error(
                location,"Cannot resolve additional %s type '%s' specified in the config.",kind,typeName));
  } else {
    for (TypeRef typeRef : typeRefs) {
      if (typeRef.isMessage()) {
        model.addRoot(typeRef.getMessageType());
      } else if (typeRef.isEnum()) {
        model.addRoot(typeRef.getEnumType());
      }
    }
  }
}

private TypeRef(Type protoType,Cardinality card,@Nullable MessageType messageType,@Nullable EnumType enumType) {
  this.kind = Preconditions.checkNotNull(protoType);
  this.card = Preconditions.checkNotNull(card);
  this.messageType = messageType;
  this.enumType = enumType;
}

@Test public void testResolveType() {
  Assert.assertSame(TypeRef.of(Type.TYPE_INT32),table.resolveType("a.b","int32"));
  Assert.assertSame(m1,"m"));
  Assert.assertSame(m2,"m.m"));
  Assert.assertSame(m2,table.resolveType("a.b.m","m"));
  Assert.assertSame(m1,".a.b.m"));
  Assert.assertSame(m3,table.resolveType("a.b.a","a.m")); // Note: different from resolveType()
}

@Test public void testResolveType2() {
  Mockito.when(message1.getFullName()).thenReturn(m1Name);
  Mockito.when(message2.getFullName()).thenReturn(m2Name);
  Mockito.when(message3.getFullName()).thenReturn(m3Name);
  Mockito.when(message4.getFullName()).thenReturn(m4Name);

  Assert.assertSame(TypeRef.of(Type.TYPE_INT32),table.resolveType2("a.b",table.resolveType2("a.b.m",".a.b.m"));
  Assert.assertSame(m4,table.resolveType2("a.b.a","a.n"));
  Assert.assertNull(table.resolveType2("a.b.a","a.m")); // Note: different from resolveType()
}

protected void findGroups(List<FieldDescriptorProto> fieldDescriptors,Map<String,DescriptorProto> groups) {
    for (FieldDescriptorProto fieldDescriptor : fieldDescriptors) {
        if (fieldDescriptor.getType() == Type.TYPE_GROUP) {
            groups.put(fieldDescriptor.getTypeName(),null);
        }
    }
}

protected void decompileFields(List<FieldDescriptorProto> fieldDescriptors,DescriptorProto> groups)
        throws IOException {
    for (FieldDescriptorProto fieldDescriptor : fieldDescriptors) {
        String label = LABELS.get(fieldDescriptor.getLabel());
        String type = TYPES.get(fieldDescriptor.getType());
        String name = fieldDescriptor.getName();
        if (fieldDescriptor.hasTypeName()) {
            type = fieldDescriptor.getTypeName();
            if ((absolutePackage != null) && type.startsWith(absolutePackage)) {
                type = type.substring(absolutePackage.length());
            }
        }
        DescriptorProto groupDescriptor = null;
        if (fieldDescriptor.getType() == Type.TYPE_GROUP) {
            groupDescriptor = groups.get(type);
            if (groupDescriptor != null) {
                name = type;
                type = "group";
            }
        }
        indentedFormat("%s %s %s = %d",label,type,name,fieldDescriptor.getNumber());
        if (fieldDescriptor.hasOptions() || fieldDescriptor.hasDefaultValue()) {
            write(defaultAndOptions(fieldDescriptor.hasOptions() ? fieldDescriptor.getoptions() : null,fieldDescriptor.hasDefaultValue() ? fieldDescriptor.getDefaultValue() : null));
        }
        if (groupDescriptor == null) {
            write(";");
        }
        else {
            decompileMessageBody(groupDescriptor);
        }
    }
}

protected String literal(Object value,FieldDescriptor.Type type) {
    switch (type) {
    case STRING:
        return quotedString((String)value);
    default:
        return value.toString();
    }
}

protected void addNullForField(String columnName,int forField) {
    String fieldName = uniqueIdent("_" + ident(columnName,false) + "_is_null",fieldNames);
    fieldBuilder = messageBuilder.addFieldBuilder();
    fieldBuilder.setName(fieldName);
    fieldBuilder.setType(Type.TYPE_BOOL);
    fieldBuilder.setLabel(Label.LABEL_OPTIONAL);
    FieldOptions.Builder fieldBuilderOptions = FieldOptions.newBuilder();
    Columnoptions.Builder columnoptions = Columnoptions.newBuilder();
    columnoptions.setNullForField(forField);
    priorField = null;
    if (priorMessage != null) {
        for (FieldDescriptorProto field : priorMessage.getFieldList()) {
            FieldOptions options = field.getoptions();
            if ((options != null) &&
                (options.hasExtension(Columnoptions.fdbsql))) {
                Columnoptions coptions = options.getExtension(Columnoptions.fdbsql);
                if (coptions.hasNullForField() &&
                    (coptions.getNullForField() == forField)) {
                    priorField = field;
                    break;
                }
            }
        }
    }
    setFieldNumber();
    fieldBuilderOptions.setExtension(Columnoptions.fdbsql,columnoptions.build());
    fieldBuilder.setoptions(fieldBuilderOptions);
}

protected void addChildTable(Table table) {
    String fieldName = uniqueIdent(ident(table.getName().getTableName(),false),fieldNames);
    fieldBuilder = messageBuilder.addFieldBuilder();
    fieldBuilder.setName(fieldName);
    fieldBuilder.setLabel(Label.LABEL_REPEATED);
    fieldBuilder.setType(Type.TYPE_MESSAGE);
    fieldBuilder.setTypeName(tableMessageNames.get(table));
    FieldOptions.Builder fieldBuilderOptions = FieldOptions.newBuilder();
    Columnoptions.Builder columnoptions = Columnoptions.newBuilder();
    columnoptions.setUuid(table.getUuid().toString());
    priorField = null;
    if (priorMessage != null) {
        for (FieldDescriptorProto field : priorMessage.getFieldList()) {
            FieldOptions options = field.getoptions();
            if ((options != null) &&
                (options.hasExtension(Columnoptions.fdbsql))) {
                Columnoptions coptions = options.getExtension(Columnoptions.fdbsql);
                if (coptions.getUuid().equals(columnoptions.getUuid())) {
                    priorField = field;
                    break;
                }
            }
        }
    }
    setFieldNumber();
    fieldBuilderOptions.setExtension(Columnoptions.fdbsql,columnoptions.build());
    fieldBuilder.setoptions(fieldBuilderOptions);
}

static public String getTypeName(FieldDescriptorProto proto) {
    Type t = proto.getType();
    if (t==Type.TYPE_MESSAGE || t==Type.TYPE_ENUM) {
        String name = proto.getTypeName();
        if (name.startsWith(".")) {
            return name.replaceFirst("\\.","");
        } else {
            return name;
        }
    }

    return typeMap.get(t);
}

@Override
public void exitGroup(final GroupContext ctx) {
  scopes.popScope();
  final String groupName = ctx.groupIdentifier().getText();

  // add group's field
  final FieldDescriptorProto.Builder fieldBuilder = scopes.addField();
  setFieldBuilder(fieldBuilder,groupName.toLowerCase(),ctx.fieldNumber().getText(),ctx.label().getText(),FieldDescriptorProto.Type.TYPE_GROUP).setTypeName(groupName);

  scopes.popScope();
  contextLookup.addGroup(fieldBuilder,ctx);
  scopes.addIfUnresolved(fieldBuilder);
  scopes.verifyField(fieldBuilder);
}

@Override
public void exitOneofGroup(final OneofGroupContext ctx) {
  scopes.popScope();
  final String groupName = ctx.groupIdentifier().getText();

  // add group's field
  final FieldDescriptorProto.Builder fieldBuilder = scopes.addField();
  setFieldBuilder(fieldBuilder,"optional",ctx);
  scopes.addIfUnresolved(fieldBuilder);
  scopes.verifyField(fieldBuilder);
}

private FieldDescriptorProto.Builder setFieldBuilder(
    final FieldDescriptorProto.Builder fieldBuilder,final String name,final String number,final String label,final FieldDescriptorProto.Type type) {
  return fieldBuilder.setName(name)
      .setLabel(FieldDescriptorProto.Label.valueOf("LABEL_" + label.toupperCase()))
      .setNumber(Integer.decode(number)).setType(type);
}

/**
 * Creates a reference to a primitive type,with default cardinality optional.
 */
public static TypeRef of(Type primitiveType) {
  Preconditions.checkArgument(
      primitiveType != Type.TYPE_MESSAGE && primitiveType != Type.TYPE_ENUM);
  return interner.intern(new TypeRef(primitiveType,Cardinality.OPTIONAL,null,null));
}

/**
 * Creates a reference to a message type,with default cardinality optional.
 */
public static TypeRef of(MessageType messageType) {
  return interner.intern(new TypeRef(Type.TYPE_MESSAGE,messageType,null));
}

/**
 * Creates a reference to an enum type,with default cardinality optional.
 */
public static TypeRef of(EnumType enumType) {
  return interner.intern(new TypeRef(Type.TYPE_ENUM,enumType));
}

/**
 * Creates a reference to a primitive type based on its name in the protocol buffer language,* with default cardinality optional.
 */
@Nullable
public static TypeRef fromPrimitiveName(String name) {
  Type kind = PRIMITIVE_TYPE_MAP.get(name);
  return kind == null ? null : of(kind);
}

/**
 * Returns the type kind.
 */
public Type getKind() {
  return kind;
}

/**
 * Return trues if this type represents a map.
 */
public boolean isMap() {
  return card == Cardinality.REPEATED && kind == Type.TYPE_MESSAGE
      && messageType.getProto().getoptions().getMapEntry();
}

/**
 * Return true of this is a cyclic message type.
 */
public boolean isCyclic() {
  return getKind() == Type.TYPE_MESSAGE && getMessageType().isCyclic();
}

/**
 * Returns true of this is a message type.
 */
public boolean isMessage() {
  return kind == Type.TYPE_MESSAGE;
}

/**
 * Returns true of this is an enum type.
 */
public boolean isEnum() {
  return kind == Type.TYPE_ENUM;
}

protected String defaultAndOptions(MessageOrBuilder options,String defaultValue) {
    StringBuilder str = new StringBuilder();
    boolean first = true;
    if (defaultValue != null) {
        str.append(" [default = ");
        str.append(defaultValue); // Todo: quote
        first = false;
    }
    if (options != null) {
        for (Map.Entry<FieldDescriptor,Object> entry : options.getAllFields().entrySet()) {
            FieldDescriptor field = entry.getKey();
            Object value = entry.getValue();
            String fieldName = field.getName();
            if (field.isExtension()) {
                fieldName = "(" + fieldName + ")";
            }
            if (field.getType() == FieldDescriptor.Type.MESSAGE) {
                for (Map.Entry<FieldDescriptor,Object> subentry : ((MessageOrBuilder)value).getAllFields().entrySet()) {
                    FieldDescriptor subfield = subentry.getKey();
                    Object subvalue = subentry.getValue();
                    if (first) {
                        str.append(" [");
                        first = false;
                    }
                    else {
                        str.append(",");
                    }
                    str.append(fieldName).append(".").append(subfield.getName()).append(" = ").append(literal(subvalue,subfield.getType()));
                }
            }
            else {
                if (first) {
                    str.append(" [");
                    first = false;
                }
                else {
                    str.append(",");
                }
                str.append(fieldName).append(" = ").append(literal(value,field.getType()));
            }
        }
    }
    if (!first) {
        str.append("]");
    }
    return str.toString();
}

public AISToProtobuf(ProtobufRowFormat.Type formatType) {
    this(formatType,null);
}

public AISToProtobuf(ProtobufRowFormat.Type formatType,FileDescriptorSet priorSet) {
    this.formatType = formatType;
    this.priorSet = priorSet;
    setBuilder = FileDescriptorSet.newBuilder();
}

/** Get the Protobuf field type. */
public abstract Type getType();

public CompatibleConversion(Type type,UnderlyingType underlying) {
    this.type = type;
    this.underlying = underlying;
}

@Override
public Type getType() {
    return type;
}

public IntegerConversion(Type type,UnderlyingType underlying) {
    this.type = type;
    this.underlying = underlying;
}

@Override
public Type getType() {
    return Type.TYPE_BYTES;
}

@Override
public Type getType() {
    return Type.TYPE_STRING;
}

@Override
public Type getType() {
    return Type.TYPE_SINT32;
}

@Override
public Type getType() {
    return Type.TYPE_SINT64;
}

private String getMessageJavaType(String packageName,DescriptorProto sourceMessageDesc,FieldDescriptorProto field) {
  String fieldType = CommonUtils.findnotincludePackageType(field.getTypeName());
  Map<String,Pair<DescriptorProto,List<FieldDescriptorProto>>> nestedFieldType =
      transform(sourceMessageDesc);
  // isMap
  if (nestedFieldType.containsKey(fieldType)) {
    Pair<DescriptorProto,List<FieldDescriptorProto>> nestedFieldPair =
        nestedFieldType.get(fieldType);
    if (nestedFieldPair.getRight().size() == 2) {
      DescriptorProto mapSourceMessageDesc = nestedFieldPair.getLeft();
      List<FieldDescriptorProto> mapFieldList = nestedFieldPair.getRight();
      String nestedJavaType =
          "java.util.Map<" + findJavaType(packageName,mapSourceMessageDesc,mapFieldList.get(0))
              + "," + findJavaType(packageName,mapFieldList.get(1)) + ">";
      return nestedJavaType;
    } else {
      return null;
    }
  } else {
    return CommonUtils.findPojoTypeFromCache(field.getTypeName(),pojoTypeCache);
  }
}

/**
 * Resolves a type based on the given partial name. This does not assume that the name,as
 * obtained from the descriptor,is in absolute form.
 */
private TypeRef resolveType(Location location,FieldDescriptorProto.Type kind,String name) {
  TypeRef type;
  switch (kind) {
    case TYPE_MESSAGE:
    case TYPE_ENUM:
    case TYPE_GROUP:
      type = symbolTable.resolveType(namespaces.peek(),name);
      break;
    default:
      type = TypeRef.of(kind);
  }
  if (type == null) {
    model.getDiagReporter().report(Diag.error(location,"Unresolved type '%s'",name));
  }
  return type;
}

private boolean checkCyclic(Set<MessageType> visited,MessageType message) {
  if (!visited.add(this)) {
    return false;
  }
  for (Field field : fields) {
    TypeRef type = field.getType();
    if (type.getKind() == FieldDescriptorProto.Type.TYPE_MESSAGE) {
      if (message == type.getMessageType()) {
        return true;
      }
      if (type.getMessageType().checkCyclic(visited,message)) {
        // If there is a cycle to message via this,then this is also cyclic. That's the nature
        // of a cycle.
        return true;
      }
    }
  }
  return false;
}

private void add(List<FieldDescriptorProto> extensions) {
  for (int i = 0; i < extensions.size(); i++) {
    pathSegments.push(i);
    FieldDescriptorProto extensionProto = extensions.get(i);
    String extendee = resolve(extensionProto.getExtendee());
    Multimap<String,Extension> messageExtensions = builder.get(extendee);
    if (messageExtensions == null) {
      messageExtensions = ArrayListMultimap.create();
      builder.put(extendee,messageExtensions);
    }
    String path = DOT_JOINER.join(pathSegments.descendingIterator());
    DescriptorProtos.sourceCodeInfo.Location location = locationMap.get(path).get(0);
    // Since paths are only unique within a file,we need a synthetic path to make them unique,// given that paths are used to uniquely identify elements in a ProtoFile,and we're
    // stuffing elements from another file into it.
    path = currentFile.getName() + ":" + path;
    Location fileLocation = new SimpleLocation(String.format(
        "%s:%d:%d",currentFile.getName(),location.getSpan(0) + 1,location.getSpan(1) + 1));
    Extension extension = new Extension(extensionProto,location,path,fileLocation);
    messageExtensions.put(getExtensionFieldName(extensionProto.getName()),extension);
    pathSegments.pop();
  }
}

public void decompile(FileDescriptorProto fileDescriptor) throws IOException {
    if (fileDescriptor.hasPackage()) {
        indentedFormat("package %s;",fileDescriptor.getPackage());
        absolutePackage = "." + fileDescriptor.getPackage() + ".";
    }
    for (String dependency : fileDescriptor.getDependencyList()) {
        indentedFormat("import \"%s\";",dependency);
    }
    if (fileDescriptor.hasOptions()) {
        decompileOptions(fileDescriptor.getoptions());
    }
    decompileMembers(fileDescriptor.getEnumTypeList(),fileDescriptor.getMessageTypeList(),Collections.<FieldDescriptorProto>emptyList(),Collections.<DescriptorProto.ExtensionRange>emptyList(),fileDescriptor.getExtensionList());
    for (ServiceDescriptorProto serviceDescriptor : fileDescriptor.getServiceList()) {
        decompile(serviceDescriptor);
    }
    newline();
    flush();
}

public void testPackedEnumField() throws Exception {
  FileDescriptorProto fileDescriptorProto = FileDescriptorProto.newBuilder()
      .setName("foo.proto")
      .addEnumType(EnumDescriptorProto.newBuilder()
        .setName("Enum")
        .addValue(EnumValueDescriptorProto.newBuilder()
          .setName("FOO")
          .setNumber(1)
          .build())
        .build())
      .addMessageType(DescriptorProto.newBuilder()
        .setName("Message")
        .addField(FieldDescriptorProto.newBuilder()
          .setName("foo")
          .setTypeName("Enum")
          .setNumber(1)
          .setLabel(FieldDescriptorProto.Label.LABEL_REPEATED)
          .setoptions(DescriptorProtos.FieldOptions.newBuilder()
            .setPacked(true)
            .build())
          .build())
        .build())
      .build();
  Descriptors.FileDescriptor.buildFrom(
      fileDescriptorProto,new FileDescriptor[0]);
}

private static Optional<String> appendToFullName(
        DescriptorProto messageDescriptor,List<Integer> path,String fullNameSoFar) {
    switch (path.get(0)) {
        case DescriptorProto.nesTED_TYPE_FIELD_NUMBER:
            DescriptorProto nestedMessage = messageDescriptor.getnestedType(path.get(1));
            return appendMessagetoFullName(nestedMessage,fullNameSoFar);
        case DescriptorProto.ENUM_TYPE_FIELD_NUMBER:
            EnumDescriptorProto enumDescriptor = messageDescriptor.getEnumType(path.get(1));
            return Optional.of(appendEnumToFullName(enumDescriptor,fullNameSoFar));
        case DescriptorProto.FIELD_FIELD_NUMBER:
            FieldDescriptorProto fieldDescriptor = messageDescriptor.getField(path.get(1));
            return Optional.of(appendFieldComponent(fullNameSoFar,fieldDescriptor.getName()));
        default:
            return Optional.empty();
    }
}

private FileDescriptorProto makeCanonicalProto(final FileDescriptor fileDescriptor) {
  final FileDescriptorProto.Builder protoBuilder =
      FileDescriptorProto.newBuilder(fileDescriptor.toProto());

  for (final FieldDescriptorProto.Builder field : protoBuilder.getExtensionBuilderList()) {
    makeCanonicalField(field,fileDescriptor.findExtensionByName(field.getName()));
  }

  for (final DescriptorProto.Builder message : protoBuilder.getMessageTypeBuilderList()) {
    makeCanonicalMessage(message,fileDescriptor.findMessageTypeByName(message.getName()));
  }

  // for (EnumDescriptorProto.Builder enumProto :
  // protoBuilder.getEnumTypeBuilderList()) {
  // makeCanonicalEnum(enumProto,// fileDescriptor.findEnumTypeByName(enumProto.getName()));
  // }

  for (final ServiceDescriptorProto.Builder serviceProto : protoBuilder.getServiceBuilderList()) {
    makeCanonicalService(serviceProto,fileDescriptor.findServiceByName(serviceProto.getName()));
  }

  // Todo: incorporate options' tree walking into canonicalization to eliminate double walking
  return OptionResolver.newBuilder().setCustomOptionsAsExtensions(false)
      .resolveAllOptionsFor(fileDescriptor,protoBuilder).build();
}

@Override
public void exitBytesFieldOption(final BytesFieldOptionContext ctx) {
  if (ctx.getChildCount() == 3) {
    verifyOptionNameUnique("default",ctx.getStart());
    final FieldDescriptorProto.Builder fieldBuilder =
        FieldDescriptorProto.Builder.class.cast(scopes.getProtoBuilder());
    final String input = ctx.getChild(2).getText();

    try {
      final String result =
          protoEscapeBytes(unescapeBytes(input.substring(1,input.length() - 1)));
      fieldBuilder.setDefaultValue(result);
    } catch (final InvalidEscapeSequenceException e) {
      contextLookup.reportInvalidDefaultValue((ParserRuleContext) ctx.getChild(2),e);
    }
  }
}

@Override
public void exitStringFieldOption(final StringFieldOptionContext ctx) {
  // Todo: what to do about '\?'
  if (ctx.getChildCount() == 3) {
    verifyOptionNameUnique("default",ctx.getStart());
    final FieldDescriptorProto.Builder fieldBuilder =
        FieldDescriptorProto.Builder.class.cast(scopes.getProtoBuilder());
    final String input = ctx.getChild(2).getText();

    try {
      final String result =
          unescapeText(input.substring(1,input.length() - 1).replaceAll("\\\\[?]","?"));
      fieldBuilder.setDefaultValue(result);
    } catch (final InvalidEscapeSequenceException e) {
      contextLookup.reportInvalidDefaultValue((ParserRuleContext) ctx.getChild(2),e);
    }
  }
}

private ParsedContext(final FileDescriptorProto.Builder proto,final List<FieldDescriptorProto.Builder> unresolved,final ContextLookup lookup) {
  this.proto = proto;

  if ((unresolved == null) || unresolved.isEmpty()) {
    this.unresolved = Collections.emptyList();
  } else {
    if (lookup == null) {
      throw new NullPointerException();
    }

    this.unresolved = new ArrayList<Map.Entry<FieldDescriptorProto.Builder,FieldContext>>();

    for (final FieldDescriptorProto.Builder field : unresolved) {
      final FieldContext context = (FieldContext) lookup.getContext(field,false);

      if (context == null) {
        throw new IllegalStateException("field context must not be null");
      }

      this.unresolved.add(new SimpleEntry<FieldDescriptorProto.Builder,FieldContext>(field,context));
    }
  }
}

public boolean resolveAllRefs(final Collection<FileDescriptor> dependencies,final IProtoErrorListener errorListener) {
  if (isBuilt()) {
    throw new IllegalStateException("not supported when proto is already built");
  }

  final Map<String,NameContext> cache = new HashMap<String,NameContext>();

  if (resolveAllRefs(dependencies,errorListener,cache)) {
    return true;
  }

  for (final Entry<FieldDescriptorProto.Builder,FieldContext> entry : unresolved) {
    reportUnresolvedTypeNameError(entry.getKey(),entry.getValue(),errorListener);
  }

  return false;
}

private void buildAllOptions(final FileDescriptorProto.Builder proto) {
  if (!buildOptions(proto.getoptionsBuilder())) {
    proto.clearOptions();
  }

  for (final FieldDescriptorProto.Builder extensionProto : proto.getExtensionBuilderList()) {
    if (!buildOptions(extensionProto.getoptionsBuilder())) {
      extensionProto.clearOptions();
    }
  }

  for (final EnumDescriptorProto.Builder enumProto : proto.getEnumTypeBuilderList()) {
    buildAllOptions(enumProto);
  }

  for (final ServiceDescriptorProto.Builder serviceProto : proto.getServiceBuilderList()) {
    buildAllOptions(serviceProto);
  }

  for (final DescriptorProto.Builder messageProto : proto.getMessageTypeBuilderList()) {
    buildAllOptions(messageProto);
  }
}

private void buildAllOptions(final DescriptorProto.Builder proto) {
  if (!buildOptions(proto.getoptionsBuilder())) {
    proto.clearOptions();
  }

  for (final FieldDescriptorProto.Builder fieldProto : proto.getFieldBuilderList()) {
    if (!buildOptions(fieldProto.getoptionsBuilder())) {
      fieldProto.clearOptions();
    }
  }

  for (final FieldDescriptorProto.Builder extensionProto : proto.getExtensionBuilderList()) {
    if (!buildOptions(extensionProto.getoptionsBuilder())) {
      extensionProto.clearOptions();
    }
  }

  for (final EnumDescriptorProto.Builder enumProto : proto.getEnumTypeBuilderList()) {
    buildAllOptions(enumProto);
  }

  for (final DescriptorProto.Builder messageProto : proto.getnestedTypeBuilderList()) {
    buildAllOptions(messageProto);
  }
}

private FileDescriptorProto makeCanonicalProto(final FileDescriptor file) {
  final FileDescriptorProto.Builder protoBuilder = FileDescriptorProto.newBuilder(file.toProto());

  for (final FieldDescriptorProto.Builder field : protoBuilder.getExtensionBuilderList()) {
    makeCanonicalField(field,file.findExtensionByName(field.getName()));
  }

  for (final DescriptorProto.Builder message : protoBuilder.getMessageTypeBuilderList()) {
    makeCanonicalMessage(message,file.findMessageTypeByName(message.getName()));
  }

  // for (EnumDescriptorProto.Builder enumProto :
  // protoBuilder.getEnumTypeBuilderList()) {
  // makeCanonicalEnum(enumProto,// file.findEnumTypeByName(enumProto.getName()));
  // }

  for (final ServiceDescriptorProto.Builder serviceProto : protoBuilder.getServiceBuilderList()) {
    makeCanonicalService(serviceProto,file.findServiceByName(serviceProto.getName()));
  }

  return OptionResolver.newBuilder().setCustomOptionsAsExtensions(reparseCustomOptions)
      .resolveAllOptionsFor(file,protoBuilder).build();
}

@SuppressWarnings("null")
public static FileDescriptorProto.Builder makeProtoRefsRelative(final FileDescriptorProto proto,final FieldTypeRefsMode fieldTypeRefsMode) {
  if (fieldTypeRefsMode == FieldTypeRefsMode.AS_IS) {
    return FileDescriptorProto.newBuilder(proto);
  }

  final FileDescriptorProto.Builder protoBuilder = FileDescriptorProto.newBuilder(proto);
  final String packagePath = "." + proto.getPackage();

  for (final FieldDescriptorProto.Builder field : protoBuilder.getExtensionBuilderList()) {
    makeFieldRefsRelative(packagePath,field,fieldTypeRefsMode,packagePath);
  }

  for (final DescriptorProto.Builder message : protoBuilder.getMessageTypeBuilderList()) {
    makeMessageRefsRelative(packagePath,message,packagePath);
  }

  return protoBuilder;
}

@SuppressWarnings("null")
private static void makeFieldRefsRelative(final String packagePath,final FieldDescriptorProto.Builder field,final FieldTypeRefsMode fieldTypeRefsMode,final String parentFullName) {
  if (field.hasExtendee() && field.getExtendee().startsWith(".")) {
    field.setExtendee(getRelativeName(packagePath,field.getExtendee(),parentFullName));
  }

  if (field.hasTypeName() && field.getTypeName().startsWith(".")) {
    field.setTypeName(getRelativeName(packagePath,field.getTypeName(),parentFullName));

    if (field.hasType()) {
      field.clearType();
    }
  }
}

private void assertEqualDescriptorprotofields(final int messageIndex,final boolean isProtocCompatible) throws URISyntaxException,IOException {
  // given
  final List<FieldDescriptorProto> expected =
      protocProto.getMessageType(messageIndex).getFieldList();

  // when
  final Builder protoBuilder =
      filesBuilder.setProtocCompatible(isProtocCompatible)
          .addFiles(baseDir,DEFAULT_VALUES_PROTO);
  final List<FieldDescriptorProto> actual =
      protoBuilder.buildProtos().get(0).getMessageType(messageIndex).getFieldList();

  // then
  // no errors logged!
  verify(mockerrorListener,never()).validationError(anyInt(),anyInt(),anyString(),any(RuntimeException.class));
  verify(mockerrorListener,never()).SyntaxError(any(Recognizer.class),any(),any(RecognitionException.class));

  assertthat(actual).as("check nullness,duplicates,size").isNotNull().doesNotContainNull()
      .doesNotHaveDuplicates().hasSameSizeAs(expected);
  assertthat(actual).as("check fields equality").containsOnlyElementsOf(expected);
}

private FieldDescriptorProto createFieldDescriptorProto(String name,int index,Type type,String typeName,Label label,String defaultValue,String extendee,UnkNownFieldSet unkNownFields,FieldOptions options) {
  FieldDescriptorProto.Builder fieldBuilder = FieldDescriptorProto.newBuilder();
  return fieldBuilder
      .setName(name)
      .setNumber(index)
      .setType(type)
      .setTypeName(typeName)
      .setLabel(label)
      .setDefaultValue(defaultValue)
      .setExtendee(extendee)
      .setUnkNownFields(unkNownFields)
      .setoptions(options)
      .build(); 
}

public void testUnkNownFieldsDenied() throws Exception {
  FileDescriptorProto fooProto = FileDescriptorProto.newBuilder()
      .setName("foo.proto")
      .addMessageType(DescriptorProto.newBuilder()
          .setName("Foo")
          .addField(FieldDescriptorProto.newBuilder()
              .setLabel(FieldDescriptorProto.Label.LABEL_OPTIONAL)
              .setTypeName("Bar")
              .setName("bar")
              .setNumber(1)))
      .build();

  try {
    Descriptors.FileDescriptor.buildFrom(fooProto,new FileDescriptor[0]);
    fail("DescriptorValidationException expected");
  } catch (DescriptorValidationException e) {
    assertTrue(e.getMessage().indexOf("Bar") != -1);
    assertTrue(e.getMessage().indexOf("is not defined") != -1);
  }
}

public void testPackedEnumField() throws Exception {
  FileDescriptorProto fileDescriptorProto = FileDescriptorProto.newBuilder()
      .setName("foo.proto")
      .addEnumType(EnumDescriptorProto.newBuilder()
        .setName("Enum")
        .addValue(EnumValueDescriptorProto.newBuilder()
          .setName("FOO")
          .setNumber(1)
          .build())
        .build())
      .addMessageType(DescriptorProto.newBuilder()
        .setName("Message")
        .addField(FieldDescriptorProto.newBuilder()
          .setName("foo")
          .setTypeName("Enum")
          .setNumber(1)
          .setLabel(FieldDescriptorProto.Label.LABEL_REPEATED)
          .setoptions(DescriptorProtos.FieldOptions.newBuilder()
            .setPacked(true)
            .build())
          .build())
        .build())
      .build();
  Descriptors.FileDescriptor.buildFrom(
      fileDescriptorProto,new FileDescriptor[0]);
}

public void testFieldTypeEnumMapping() throws Exception {
  assertEquals(FieldDescriptor.Type.values().length,FieldDescriptorProto.Type.values().length);
  for (FieldDescriptor.Type type : FieldDescriptor.Type.values()) {
    FieldDescriptorProto.Type protoType = type.toProto();
    assertEquals("TYPE_" + type.name(),protoType.name());
    assertEquals(type,FieldDescriptor.Type.valueOf(protoType));
  }
}

/**
 * Tests that the DescriptorValidationException works as intended.
 */
public void testDescriptorValidatorException() throws Exception {
  FileDescriptorProto fileDescriptorProto = FileDescriptorProto.newBuilder()
    .setName("foo.proto")
    .addMessageType(DescriptorProto.newBuilder()
    .setName("Foo")
      .addField(FieldDescriptorProto.newBuilder()
        .setLabel(FieldDescriptorProto.Label.LABEL_OPTIONAL)
        .setType(FieldDescriptorProto.Type.TYPE_INT32)
        .setName("foo")
        .setNumber(1)
        .setDefaultValue("invalid")
        .build())
      .build())
    .build();
  try {
    Descriptors.FileDescriptor.buildFrom(fileDescriptorProto,new FileDescriptor[0]);
    fail("DescriptorValidationException expected");
  } catch (DescriptorValidationException e) {
    // Expected; check that the error message contains some useful hints
    assertTrue(e.getMessage().indexOf("foo") != -1);
    assertTrue(e.getMessage().indexOf("Foo") != -1);
    assertTrue(e.getMessage().indexOf("invalid") != -1);
    assertTrue(e.getCause() instanceof NumberFormatException);
    assertTrue(e.getCause().getMessage().indexOf("invalid") != -1);
  }
}

public void testFieldTypeEnumMapping() throws Exception {
  assertEquals(FieldDescriptor.Type.values().length,FieldDescriptor.Type.valueOf(protoType));
  }
}

/**
 * Tests that the DescriptorValidationException works as intended.
 */
public void testDescriptorValidatorException() throws Exception {
  FileDescriptorProto fileDescriptorProto = FileDescriptorProto.newBuilder()
    .setName("foo.proto")
    .addMessageType(DescriptorProto.newBuilder()
    .setName("Foo")
      .addField(FieldDescriptorProto.newBuilder()
        .setLabel(FieldDescriptorProto.Label.LABEL_OPTIONAL)
        .setType(FieldDescriptorProto.Type.TYPE_INT32)
        .setName("foo")
        .setNumber(1)
        .setDefaultValue("invalid")
        .build())
      .build())
    .build();
  try {
    Descriptors.FileDescriptor.buildFrom(fileDescriptorProto,new FileDescriptor[0]);
    fail("DescriptorValidationException expected");
  } catch (DescriptorValidationException e) {
    // Expected; check that the error message contains some useful hints
    assertTrue(e.getMessage().indexOf("foo") != -1);
    assertTrue(e.getMessage().indexOf("Foo") != -1);
    assertTrue(e.getMessage().indexOf("invalid") != -1);
    assertTrue(e.getCause() instanceof NumberFormatException);
    assertTrue(e.getCause().getMessage().indexOf("invalid") != -1);
  }
}

private Map<String,List<FieldDescriptorProto>>> transform(
    DescriptorProto sourceMessageDesc) {
  Map<String,List<FieldDescriptorProto>>> nestedFieldMap =
      Maps.newHashMap();
  sourceMessageDesc.getnestedTypeList().forEach(new Consumer<DescriptorProto>() {

    @Override
    public void accept(DescriptorProto t) {
      nestedFieldMap.put(t.getName(),new ImmutablePair<DescriptorProto,List<FieldDescriptorProto>>(t,t.getFieldList()));
    }

  });
  return nestedFieldMap;
}

public CausalOrderProtobufSerializer(@NotNull final Serializer<T> objectSerializer) {
    this.objectSerializer = objectSerializer;
    try {
        final FileDescriptorProto timestampedMessageFile = FileDescriptorProto.newBuilder()
            .addMessageType(
                DescriptorProto.newBuilder()
                    .setName(MESSAGE_NAME)
                    .addField(
                        FieldDescriptorProto.newBuilder()
                            .setLabel(FieldDescriptorProto.Label.LABEL_REPEATED)
                            .setName(IDS_FIELD_NAME)
                            .setNumber(IDS_FIELD_NUMBER)
                            .setType(FieldDescriptorProto.Type.TYPE_BYTES))
                    .addField(
                        FieldDescriptorProto.newBuilder()
                            .setLabel(FieldDescriptorProto.Label.LABEL_REPEATED)
                            .setName(TIMESTAMPS_FIELD_NAME)
                            .setNumber(TIMESTAMPS_FIELD_NUMBER)
                            .setoptions(FieldOptions.newBuilder()
                                .setPacked(true))
                            .setType(FieldDescriptorProto.Type.TYPE_UINT64))
                    .addField(
                        FieldDescriptorProto.newBuilder()
                            .setName(VALUE_FIELD_NAME)
                            .setNumber(VALUE_FIELD_NUMBER)
                            .setType(FieldDescriptorProto.Type.TYPE_BYTES)))
            .build();
        this.messageDescriptor = FileDescriptor
            .buildFrom(timestampedMessageFile,new FileDescriptor[0])
            .findMessageTypeByName(MESSAGE_NAME);
        this.ids = messageDescriptor.findFieldByName(IDS_FIELD_NAME);
        this.timestamps = messageDescriptor.findFieldByName(TIMESTAMPS_FIELD_NAME);
        this.value = messageDescriptor.findFieldByName(VALUE_FIELD_NAME);
        this.messageParser = Dynamicmessage.newBuilder(messageDescriptor)
            .buildPartial()
            .getParserForType();
    } catch (final DescriptorValidationException e) {
        throw new RuntimeException(e);
    }
}

public SingleSourceFifoOrderProtobufSerializer(@NotNull final Serializer<T> objectSerializer) {
    this.objectSerializer = objectSerializer;
    try {
        final FileDescriptorProto timestampedMessageFile = FileDescriptorProto.newBuilder()
            .addMessageType(
                DescriptorProto.newBuilder()
                    .setName(MESSAGE_NAME)
                    .addField(
                        FieldDescriptorProto.newBuilder()
                            .setName(TIMESTAMP_FIELD_NAME)
                            .setNumber(TIMESTAMP_FIELD_NUMBER)
                            .setType(FieldDescriptorProto.Type.TYPE_INT64))
                    .addField(
                        FieldDescriptorProto.newBuilder()
                            .setName(VALUE_FIELD_NAME)
                            .setNumber(VALUE_FIELD_NUMBER)
                            .setType(FieldDescriptorProto.Type.TYPE_BYTES)))
            .build();
        final Descriptor message = FileDescriptor
            .buildFrom(timestampedMessageFile,new FileDescriptor[0])
            .findMessageTypeByName(MESSAGE_NAME);
        this.timestampedMessageField = message.findFieldByName(TIMESTAMP_FIELD_NAME);
        this.valueMessageField = message.findFieldByName(VALUE_FIELD_NAME);
        this.messageBuilder = Dynamicmessage.newBuilder(message);
        this.messageParser = messageBuilder.buildPartial().getParserForType();
    } catch (final DescriptorValidationException e) {
        throw new RuntimeException(e);
    }
}

private FieldDescriptorProto generateField(Field field) {
  FieldDescriptorProto.Builder builder = FieldDescriptorProto.newBuilder();
  builder.setName(getFieldName(field));
  builder.setNumber(field.getNumber());
  builder.setLabel(toLabel(field.getCardinality()));
  builder.setType(toType(field.getKind()));
  if (field.getKind() == Kind.TYPE_ENUM
      || field.getKind() == Kind.TYPE_MESSAGE
      || field.getKind() == Kind.TYPE_GROUP) {
    builder.setTypeName(getTypeName(field.getTypeUrl()));
  }
  // NOTE: extendee not supported
  // NOTE: default_value not supported
  if (field.getoneofIndex() != 0) {
    // Index in the containing type's oneof_decl is zero-based.
    // Index in google.protobuf.type.Field.oneof_index is one-based.
    builder.setoneofIndex(field.getoneofIndex() - 1);
  }
  if (!Strings.isNullOrEmpty(field.getDefaultValue())) {
    builder.setDefaultValue(field.getDefaultValue());
  }
  FieldOptions options = getFieldOptions(field);
  if (!options.equals(FieldOptions.getDefaultInstance())) {
    builder.setoptions(options);
  }
  return builder.build();
}

/** In proto3,repeated fields of scalar numeric types use packed encoding by default */
private boolean isDefaultPackedEncoding(Field field) {
  if (field.getSyntax() == Syntax.Syntax_PROTO3 && field.isRepeated()) {
    FieldDescriptorProto.Type fieldType = field.getProto().getType();
    if (fieldType != FieldDescriptorProto.Type.TYPE_GROUP
        && fieldType != FieldDescriptorProto.Type.TYPE_BYTES
        && fieldType != FieldDescriptorProto.Type.TYPE_STRING
        && fieldType != FieldDescriptorProto.Type.TYPE_MESSAGE) {
      return true;
    }
  }
  return false;
}

@VisitsBefore
void visit(Method method) {
  // Resolve input and output type of this method.
  TypeRef inputType = resolveType(method.getLocation(),FieldDescriptorProto.Type.TYPE_MESSAGE,method.getDescriptor().getInputTypeName());
  if (inputType != null) {
    method.setInputType(inputType);
  }
  TypeRef outputType = resolveType(method.getLocation(),method.getDescriptor().getoutputTypeName());
  if (outputType != null) {
    method.setoutputType(outputType);
  }
  findOptionTypes(method.getoptionFields());
}

private Extension(FieldDescriptorProto proto,DescriptorProtos.sourceCodeInfo.Location location,String path,Location fileLocation) {
  this.proto = proto;
  this.location = location;
  this.path = path;
  this.fileLocation = fileLocation;
}

/**
 * Todo (guptasu): only needed to create hard coded Types (Struct,ListValue,and Value). Check
 * if this can be removed. Create the Protobuf.Type instance from descriptorProto.
 */
private static Type createType(String typeName,DescriptorProto descriptorProto,String fileName) {
  Type.Builder coreTypeBuilder = Type.newBuilder().setName(typeName);

  int count = 1;
  for (FieldDescriptorProto fieldProto : descriptorProto.getFieldList()) {
    Field.Kind fieldKind = Field.Kind.valueOf(fieldProto.getType().getNumber());
    Cardinality cardinality = Cardinality.CARDINALITY_OPTIONAL;
    if (fieldProto.getLabel() == Label.LABEL_REPEATED) {
      cardinality = Cardinality.CARDINALITY_REPEATED;
    }
    Field.Builder coreFieldBuilder = Field
        .newBuilder()
        .setName(fieldProto.getName())
        .setNumber(count++)
        .setKind(fieldKind)
        .setCardinality(cardinality);
    if (fieldKind == Kind.TYPE_MESSAGE || fieldKind == Kind.TYPE_ENUM) {
      String typeFullName =
          fieldProto.getTypeName().startsWith(".") ? fieldProto.getTypeName().substring(1)
              : fieldProto.getTypeName();
      coreFieldBuilder.setTypeUrl(TYPE_SERVICE_BASE_URL + typeFullName);
    }
    coreTypeBuilder.addFields(coreFieldBuilder.build());
  }
  coreTypeBuilder.setSourceContext(SourceContext.newBuilder().setFileName(fileName));
  coreTypeBuilder.setSyntax(Syntax.Syntax_PROTO3);
  return coreTypeBuilder.build();
}

protected void addFieldToMessageAncestor(
    int generationsToSkip,FieldDescriptorProto.Builder fieldDesc,SourceCodeInfo.Location location) {
  BuilderVisitorNodeInfo ancestorInfo = getAncestorInfo(generationsToSkip);
  if (ancestorInfo instanceof MessageNodeInfo) {
    ((MessageNodeInfo) ancestorInfo).addNewField(fieldDesc,location);
    setModified(true);
  } else {
    throw new RuntimeException(
        String.format(
            "Tried to add a field to a %s,but can only add to %s",ancestorInfo.node().getClass(),DescriptorProto.Builder.class));
  }
}

protected void findGroups(List<FieldDescriptorProto> fieldDescriptors,Map<String,DescriptorProto> groups) {
    for (FieldDescriptorProto fieldDescriptor : fieldDescriptors) {
        if (fieldDescriptor.getType() == Type.TYPE_GROUP) {
            groups.put(fieldDescriptor.getTypeName(),null);
        }
    }
}

protected void decompileFields(List<FieldDescriptorProto> fieldDescriptors,DescriptorProto> groups)
        throws IOException {
    for (FieldDescriptorProto fieldDescriptor : fieldDescriptors) {
        String label = LABELS.get(fieldDescriptor.getLabel());
        String type = TYPES.get(fieldDescriptor.getType());
        String name = fieldDescriptor.getName();
        if (fieldDescriptor.hasTypeName()) {
            type = fieldDescriptor.getTypeName();
            if ((absolutePackage != null) && type.startsWith(absolutePackage)) {
                type = type.substring(absolutePackage.length());
            }
        }
        DescriptorProto groupDescriptor = null;
        if (fieldDescriptor.getType() == Type.TYPE_GROUP) {
            groupDescriptor = groups.get(type);
            if (groupDescriptor != null) {
                name = type;
                type = "group";
            }
        }
        indentedFormat("%s %s %s = %d",label,type,name,fieldDescriptor.getNumber());
        if (fieldDescriptor.hasOptions() || fieldDescriptor.hasDefaultValue()) {
            write(defaultAndOptions(fieldDescriptor.hasOptions() ? fieldDescriptor.getoptions() : null,fieldDescriptor.hasDefaultValue() ? fieldDescriptor.getDefaultValue() : null));
        }
        if (groupDescriptor == null) {
            write(";");
        }
        else {
            decompileMessageBody(groupDescriptor);
        }
    }
}

protected void addColumn(Column column) {
    String fieldName = uniqueIdent(ident(column.getName(),false),fieldNames);
    fieldBuilder = messageBuilder.addFieldBuilder();
    fieldBuilder.setName(fieldName);
    fieldBuilder.setLabel(Label.LABEL_OPTIONAL);
    FieldOptions.Builder fieldBuilderOptions = FieldOptions.newBuilder();
    Columnoptions.Builder columnoptions = Columnoptions.newBuilder();
    if (!fieldName.equals(column.getName())) {
        columnoptions.setName(column.getName());
    }
    columnoptions.setsqlType(column.getTypeDescription().toupperCase());
    columnoptions.setUuid(column.getUuid().toString());
    priorField = null;
    if (priorMessage != null) {
        for (FieldDescriptorProto field : priorMessage.getFieldList()) {
            FieldOptions options = field.getoptions();
            if ((options != null) &&
                (options.hasExtension(Columnoptions.fdbsql))) {
                Columnoptions coptions = options.getExtension(Columnoptions.fdbsql);
                if (coptions.getUuid().equals(columnoptions.getUuid())) {
                    priorField = field;
                    break;
                }
            }
        }
    }
    setColumnType(column,columnoptions);
    setFieldNumber();
    fieldBuilderOptions.setExtension(Columnoptions.fdbsql,columnoptions.build());
    fieldBuilder.setoptions(fieldBuilderOptions);
    if (column.getNullable() && 
        ((column.getDefaultValue() != null) ||
         (column.getDefaultFunction() != null))) {
        addNullForField(column.getName(),fieldBuilder.getNumber());
    }
}

protected void addNullForField(String columnName,int forField) {
    String fieldName = uniqueIdent("_" + ident(columnName,false) + "_is_null",fieldNames);
    fieldBuilder = messageBuilder.addFieldBuilder();
    fieldBuilder.setName(fieldName);
    fieldBuilder.setType(Type.TYPE_BOOL);
    fieldBuilder.setLabel(Label.LABEL_OPTIONAL);
    FieldOptions.Builder fieldBuilderOptions = FieldOptions.newBuilder();
    Columnoptions.Builder columnoptions = Columnoptions.newBuilder();
    columnoptions.setNullForField(forField);
    priorField = null;
    if (priorMessage != null) {
        for (FieldDescriptorProto field : priorMessage.getFieldList()) {
            FieldOptions options = field.getoptions();
            if ((options != null) &&
                (options.hasExtension(Columnoptions.fdbsql))) {
                Columnoptions coptions = options.getExtension(Columnoptions.fdbsql);
                if (coptions.hasNullForField() &&
                    (coptions.getNullForField() == forField)) {
                    priorField = field;
                    break;
                }
            }
        }
    }
    setFieldNumber();
    fieldBuilderOptions.setExtension(Columnoptions.fdbsql,columnoptions.build());
    fieldBuilder.setoptions(fieldBuilderOptions);
}

protected void addChildTable(Table table) {
    String fieldName = uniqueIdent(ident(table.getName().getTableName(),fieldNames);
    fieldBuilder = messageBuilder.addFieldBuilder();
    fieldBuilder.setName(fieldName);
    fieldBuilder.setLabel(Label.LABEL_REPEATED);
    fieldBuilder.setType(Type.TYPE_MESSAGE);
    fieldBuilder.setTypeName(tableMessageNames.get(table));
    FieldOptions.Builder fieldBuilderOptions = FieldOptions.newBuilder();
    Columnoptions.Builder columnoptions = Columnoptions.newBuilder();
    columnoptions.setUuid(table.getUuid().toString());
    priorField = null;
    if (priorMessage != null) {
        for (FieldDescriptorProto field : priorMessage.getFieldList()) {
            FieldOptions options = field.getoptions();
            if ((options != null) &&
                (options.hasExtension(Columnoptions.fdbsql))) {
                Columnoptions coptions = options.getExtension(Columnoptions.fdbsql);
                if (coptions.getUuid().equals(columnoptions.getUuid())) {
                    priorField = field;
                    break;
                }
            }
        }
    }
    setFieldNumber();
    fieldBuilderOptions.setExtension(Columnoptions.fdbsql,columnoptions.build());
    fieldBuilder.setoptions(fieldBuilderOptions);
}

private List<ServiceContext> findServices(List<FileDescriptorProto> protos,ProtoTypeMap typeMap) {
    List<ServiceContext> contexts = new ArrayList<>();

    protos.forEach(fileProto -> {
        List<Location> locations = fileProto.getSourceCodeInfo().getLocationList();
        locations.stream()
                .filter(location -> location.getPathCount() == 2 && location.getPath(0) == FileDescriptorProto.SERVICE_FIELD_NUMBER)
                .forEach(location -> {
                    int serviceNumber = location.getPath(1);
                    ServiceContext serviceContext = buildServiceContext(fileProto.getService(serviceNumber),typeMap,locations,serviceNumber);
                    serviceContext.javaDoc = getJavaDoc(getComments(location),getServiceJavaDocPrefix());
                    serviceContext.protoName = fileProto.getName();
                    serviceContext.packageName = extractPackageName(fileProto);
                    contexts.add(serviceContext);
                });
    });

    return contexts;
}

private ServiceContext buildServiceContext(ServiceDescriptorProto serviceProto,ProtoTypeMap typeMap,List<Location> locations,int serviceNumber) {
    ServiceContext serviceContext = new ServiceContext();
    serviceContext.fileName = getClassprefix() + serviceProto.getName() + "Grpc.java";
    serviceContext.className = getClassprefix() + serviceProto.getName() + "Grpc";
    serviceContext.serviceName = serviceProto.getName();
    serviceContext.deprecated = serviceProto.getoptions() != null && serviceProto.getoptions().getDeprecated();

    locations.stream()
            .filter(location -> location.getPathCount() == METHOD_NUMBER_OF_PATHS &&
                    location.getPath(0) == FileDescriptorProto.SERVICE_FIELD_NUMBER &&
                    location.getPath(1) == serviceNumber &&
                    location.getPath(2) == ServiceDescriptorProto.METHOD_FIELD_NUMBER)
            .forEach(location -> {
                int methodNumber = location.getPath(METHOD_NUMBER_OF_PATHS - 1);
                MethodContext methodContext = buildMethodContext(serviceProto.getmethod(methodNumber),typeMap);
                methodContext.methodNumber = methodNumber;
                methodContext.javaDoc = getJavaDoc(getComments(location),getmethodJavaDocPrefix());
                serviceContext.methods.add(methodContext);
            });
    return serviceContext;
}

public void generateFile(String protoPath) {
  try {
    if (pojoTypes == null) {
      pojoTypes = Maps.newHashMap();
    }
  } finally {
    if (!new File(protoPath).exists()) {
      logger.warn("protoPath:" + protoPath
          + " not exist,it may be in the third party jars,so it can't be generate");
      return;
    }
    FileDescriptorSet fileDescriptorSet = commondProtoc.invoke(protoPath);
    for (FileDescriptorProto fdp : fileDescriptorSet.getFileList()) {
      Pair<String,String> packageClassName = this.packageClassName(fdp.getoptions());
      if (packageClassName == null) {
        continue;
      }
      ProtocolStringList dependencyList = fdp.getDependencyList();
      for (Iterator<String> it = dependencyList.iterator(); it.hasNext();) {
        String dependencyPath = discoveryRoot + "/" + it.next();
        generateFile(dependencyPath);
      }
      doPrint(fdp,packageClassName.getLeft(),packageClassName.getRight());
    }
  }
}

/** Creates a resolver which searches the supplied {@link FileDescriptorSet}. */
public static ServiceResolver fromFileDescriptorSet(FileDescriptorSet descriptorSet) {
  ImmutableMap<String,FileDescriptorProto> descriptorProtoIndex =
      computeDescriptorProtoIndex(descriptorSet);
  Map<String,FileDescriptor> descriptorCache = new HashMap<>();

  ImmutableList.Builder<FileDescriptor> result = ImmutableList.builder();
  for (FileDescriptorProto descriptorProto : descriptorSet.getFileList()) {
    try {
      result.add(descriptorFromProto(descriptorProto,descriptorProtoIndex,descriptorCache));
    } catch (DescriptorValidationException e) {
      logger.warn("Skipped descriptor " + descriptorProto.getName() + " due to error",e);
      continue;
    }
  }
  return new ServiceResolver(result.build());
}

/**
 * Recursively constructs file descriptors for all dependencies of the supplied proto and returns
 * a {@link FileDescriptor} for the supplied proto itself. For maximal efficiency,reuse the
 * descriptorCache argument across calls.
 */
private static FileDescriptor descriptorFromProto(
    FileDescriptorProto descriptorProto,ImmutableMap<String,FileDescriptorProto> descriptorProtoIndex,Map<String,FileDescriptor> descriptorCache) throws DescriptorValidationException {
  // First,check the cache.
  String descritorName = descriptorProto.getName();
  if (descriptorCache.containsKey(descritorName)) {
    return descriptorCache.get(descritorName);
  }

  // Then,fetch all the required dependencies recursively.
  ImmutableList.Builder<FileDescriptor> dependencies = ImmutableList.builder();
  for (String dependencyName : descriptorProto.getDependencyList()) {
    if (!descriptorProtoIndex.containsKey(dependencyName)) {
      throw new IllegalArgumentException("Could not find dependency: " + dependencyName);
    }
    FileDescriptorProto dependencyProto = descriptorProtoIndex.get(dependencyName);
    dependencies.add(descriptorFromProto(dependencyProto,descriptorCache));
  }

  // Finally,construct the actual descriptor.
  FileDescriptor[] empty = new FileDescriptor[0];
  return FileDescriptor.buildFrom(descriptorProto,dependencies.build().toArray(empty));
}

private void processDependencies(FileDescriptorProto fileDescriptor) {
  logger.debug("Processing deps of descriptor: " + fileDescriptor.getName());
  fileDescriptor.getDependencyList().forEach(dep -> {
    if (!resolvedDescriptors.containsKey(dep) && !requestedDescriptors.contains(dep)) {
      requestedDescriptors.add(dep);
      ++outstandingRequests;
      requestStream.onNext(requestForDescriptor(dep));
    }
  });

  --outstandingRequests;
  if (outstandingRequests == 0) {
    logger.debug("Retrieved service deFinition for [{}] by reflection",serviceName);
    resultFuture.set(FileDescriptorSet.newBuilder()
        .addAllFile(resolvedDescriptors.values())
        .build());
    requestStream.onCompleted();
  }
}

private void loadService() {

    LOG.info("Load service deFinition is starting...");
    InputStream in = null;
    FileDescriptorSet descriptorSet;
    try {
      in = ClassHelper.getClassLoader().getResourceAsstream(GrpcConstants.PROTO_DESC_FILENAME);
      descriptorSet = FileDescriptorSet.parseFrom(in);
      for (FileDescriptorProto fdp : descriptorSet.getFileList()) {
        FileDescriptor fd = FileDescriptor.buildFrom(fdp,new FileDescriptor[] {},true);
        for (com.google.protobuf.Descriptors.ServiceDescriptor service : fd.getServices()) {
          addServiceDenifition(service.getName(),fd.getoptions().getJavaPackage() + '.' + service.getFullName());
        }
      }
      LOG.info("Load service denifition is finished,total {} service are found.",services.size());
    } catch (Exception ex) {
      LOG.error("Load service denifition error happened.",ex);
      throw new RuntimeException(ex);

    } finally {
      IoUtils.closeInputStream(in);
    }
  }

private FileDescriptorProto generateFile(String name,FileContents contents) {
  FileDescriptorProto.Builder fileBuilder = FileDescriptorProto.newBuilder();
  fileBuilder.setName(name);
  if (!Strings.isNullOrEmpty(contents.packageName)) {
    fileBuilder.setPackage(contents.packageName);
  }
  for (Api api : contents.apis) {
    fileBuilder.addService(generateApi(api));
  }
  for (Type type : contents.types.values()) {
    fileBuilder.addMessageType(generateType(type,contents));
  }
  for (Enum e : contents.enums) {
    fileBuilder.addEnumType(generateEnum(e));
  }
  if (imports.containsKey(name)) {
    for (String imported : imports.get(name)) {
      fileBuilder.addDependency(imported);
    }
  }
  return fileBuilder.build();
}

private void add(FileDescriptorProto file) {
  currentFile = file;
  fullNameSegments.push(file.getPackage());
  locationMap = buildLocationMap(file);
  pathSegments.push(FileDescriptorProto.EXTENSION_FIELD_NUMBER);
  add(file.getExtensionList());
  pathSegments.pop();
  pathSegments.push(FileDescriptorProto.MESSAGE_TYPE_FIELD_NUMBER);
  for (int i = 0; i < file.getMessageTypeCount(); i++) {
    pathSegments.push(i);
    add(file.getMessageType(i));
    pathSegments.pop();
  }
  pathSegments.pop();
  fullNameSegments.pop();
}

/**
 * Construct a {@code FileDescriptor}.
 *
 * @param proto The protocol message form of the FileDescriptor.
 * @param dependencies {@code FileDescriptor}s corresponding to all of
 *                     the file's dependencies.
 * @param allowUnkNownDependencies If true,non-exist dependenncies will be
 *           ignored and undefined message types will be replaced with a
 *           placeholder type.
 * @throws DescriptorValidationException {@code proto} is not a valid
 *           descriptor.  This can occur for a number of reasons,e.g.
 *           because a field has an undefined type or because two messages
 *           were defined with the same name.
 */
public static FileDescriptor buildFrom(
    final FileDescriptorProto proto,final FileDescriptor[] dependencies,final boolean allowUnkNownDependencies)
    throws DescriptorValidationException {
  // Building descriptors involves two steps:  translating and linking.
  // In the translation step (implemented by FileDescriptor's
  // constructor),we build an object tree mirroring the
  // FileDescriptorProto's tree and put all of the descriptors into the
  // DescriptorPool's lookup tables.  In the linking step,we look up all
  // type references in the DescriptorPool,so that,for example,a
  // FieldDescriptor for an embedded message contains a pointer directly
  // to the Descriptor for that message's type.  We also detect undefined
  // types in the linking step.
  final DescriptorPool pool = new DescriptorPool(
      dependencies,allowUnkNownDependencies);
  final FileDescriptor result = new FileDescriptor(
      proto,dependencies,pool,allowUnkNownDependencies);
  result.crossLink();
  return result;
}

/**
 * Create a placeholder FileDescriptor for a message Descriptor.
 */
FileDescriptor(String packageName,Descriptor message)
    throws DescriptorValidationException {
  this.pool = new DescriptorPool(new FileDescriptor[0],true);
  this.proto = FileDescriptorProto.newBuilder()
      .setName(message.getFullName() + ".placeholder.proto")
      .setPackage(packageName).addMessageType(message.toProto()).build();
  this.dependencies = new FileDescriptor[0];
  this.publicDependencies = new FileDescriptor[0];

  messageTypes = new Descriptor[] {message};
  enumTypes = new EnumDescriptor[0];
  services = new ServiceDescriptor[0];
  extensions = new FieldDescriptor[0];

  pool.addPackage(packageName,this);
  pool.addSymbol(message);
}

/**
 * Replace our {@link FileDescriptorProto} with the given one,which is
 * identical except that it might contain extensions that weren't present
 * in the original.  This method is needed for bootstrapping when a file
 * defines custom options.  The options may be defined in the file itself,* so we can't actually parse them until we've constructed the descriptors,* but to construct the descriptors we have to have parsed the descriptor
 * protos.  So,we have to parse the descriptor protos a second time after
 * constructing the descriptors.
 */
private void setProto(final FileDescriptorProto proto) {
  this.proto = proto;

  for (int i = 0; i < messageTypes.length; i++) {
    messageTypes[i].setProto(proto.getMessageType(i));
  }

  for (int i = 0; i < enumTypes.length; i++) {
    enumTypes[i].setProto(proto.getEnumType(i));
  }

  for (int i = 0; i < services.length; i++) {
    services[i].setProto(proto.getService(i));
  }

  for (int i = 0; i < extensions.length; i++) {
    extensions[i].setProto(proto.getExtension(i));
  }
}

public void decompile(FileDescriptorProto fileDescriptor) throws IOException {
    if (fileDescriptor.hasPackage()) {
        indentedFormat("package %s;",fileDescriptor.getPackage());
        absolutePackage = "." + fileDescriptor.getPackage() + ".";
    }
    for (String dependency : fileDescriptor.getDependencyList()) {
        indentedFormat("import \"%s\";",dependency);
    }
    if (fileDescriptor.hasOptions()) {
        decompileOptions(fileDescriptor.getoptions());
    }
    decompileMembers(fileDescriptor.getEnumTypeList(),fileDescriptor.getMessageTypeList(),Collections.<FieldDescriptorProto>emptyList(),Collections.<DescriptorProto.ExtensionRange>emptyList(),fileDescriptor.getExtensionList());
    for (ServiceDescriptorProto serviceDescriptor : fileDescriptor.getServiceList()) {
        decompile(serviceDescriptor);
    }
    newline();
    flush();
}

public void testDependencyOrder() throws Exception {
  FileDescriptorProto fooProto = FileDescriptorProto.newBuilder()
      .setName("foo.proto").build();
  FileDescriptorProto barProto = FileDescriptorProto.newBuilder()
      .setName("bar.proto")
      .addDependency("foo.proto")
      .build();
  FileDescriptorProto bazProto = FileDescriptorProto.newBuilder()
      .setName("baz.proto")
      .addDependency("foo.proto")
      .addDependency("bar.proto")
      .addPublicDependency(0)
      .addPublicDependency(1)
      .build();
  FileDescriptor fooFile = Descriptors.FileDescriptor.buildFrom(fooProto,new FileDescriptor[0]);
  FileDescriptor barFile = Descriptors.FileDescriptor.buildFrom(barProto,new FileDescriptor[] {fooFile});

  // Items in the FileDescriptor array can be in any order. 
  Descriptors.FileDescriptor.buildFrom(bazProto,new FileDescriptor[] {fooFile,barFile});
  Descriptors.FileDescriptor.buildFrom(bazProto,new FileDescriptor[] {barFile,fooFile});
}

public void testInvalidPublicDependency() throws Exception {
  FileDescriptorProto fooProto = FileDescriptorProto.newBuilder()
      .setName("foo.proto").build();
  FileDescriptorProto barProto = FileDescriptorProto.newBuilder()
      .setName("boo.proto")
      .addDependency("foo.proto")
      .addPublicDependency(1)  // Error,should be 0.
      .build();
  FileDescriptor fooFile = Descriptors.FileDescriptor.buildFrom(fooProto,new FileDescriptor[0]);
  try {
    Descriptors.FileDescriptor.buildFrom(barProto,new FileDescriptor[] {fooFile});
    fail("DescriptorValidationException expected");
  } catch (DescriptorValidationException e) {
    assertTrue(
        e.getMessage().indexOf("Invalid public dependency index.") != -1);
  }
}

public void testPackedEnumField() throws Exception {
  FileDescriptorProto fileDescriptorProto = FileDescriptorProto.newBuilder()
      .setName("foo.proto")
      .addEnumType(EnumDescriptorProto.newBuilder()
        .setName("Enum")
        .addValue(EnumValueDescriptorProto.newBuilder()
          .setName("FOO")
          .setNumber(1)
          .build())
        .build())
      .addMessageType(DescriptorProto.newBuilder()
        .setName("Message")
        .addField(FieldDescriptorProto.newBuilder()
          .setName("foo")
          .setTypeName("Enum")
          .setNumber(1)
          .setLabel(FieldDescriptorProto.Label.LABEL_REPEATED)
          .setoptions(DescriptorProtos.FieldOptions.newBuilder()
            .setPacked(true)
            .build())
          .build())
        .build())
      .build();
  Descriptors.FileDescriptor.buildFrom(
      fileDescriptorProto,new FileDescriptor[0]);
}

private static Optional<String> getFullName(FileDescriptorProto descriptor,List<Integer> path) {
    String fullNameSoFar = descriptor.getPackage();
    switch (path.get(0)) {
        case FileDescriptorProto.MESSAGE_TYPE_FIELD_NUMBER:
            DescriptorProto message = descriptor.getMessageType(path.get(1));
            return appendMessagetoFullName(message,path,fullNameSoFar);
        case FileDescriptorProto.ENUM_TYPE_FIELD_NUMBER:
            EnumDescriptorProto enumDescriptor = descriptor.getEnumType(path.get(1));
            return Optional.of(appendEnumToFullName(enumDescriptor,fullNameSoFar));
        case FileDescriptorProto.SERVICE_FIELD_NUMBER:
            ServiceDescriptorProto serviceDescriptor = descriptor.getService(path.get(1));
            fullNameSoFar = appendNameComponent(fullNameSoFar,serviceDescriptor.getName());
            if (path.size() > 2) {
                fullNameSoFar = appendFieldComponent(
                        fullNameSoFar,serviceDescriptor.getmethod(path.get(3)).getName());
            }
            return Optional.of(fullNameSoFar);
        default:
            return Optional.empty();
    }
}

/**
 * Construct a {@code FileDescriptor}.
 *
 * @param proto The protocol message form of the FileDescriptor.
 * @param dependencies {@code FileDescriptor}s corresponding to all of
 * the file's dependencies.
 * @param allowUnkNownDependencies If true,non-exist dependenncies will
 * be ignored and undefined message types will be replaced with a
 * placeholder type.
 *
 * @throws DescriptorValidationException {@code proto} is not a valid
 * descriptor. This can occur for a number of reasons,e.g. because a
 * field has an undefined type or because two messages were defined with
 * the same name.
 */
private static FileDescriptor buildFrom (
        final FileDescriptorProto proto,final boolean allowUnkNownDependencies)
        throws DescriptorValidationException {
    // Building descriptors involves two steps:  translating and linking.
    // In the translation step (implemented by FileDescriptor's
    // constructor),we build an object tree mirroring the
    // FileDescriptorProto's tree and put all of the descriptors into the
    // DescriptorPool's lookup tables.  In the linking step,we look up all
    // type references in the DescriptorPool,a
    // FieldDescriptor for an embedded message contains a pointer directly
    // to the Descriptor for that message's type.  We also detect undefined
    // types in the linking step.
    final DescriptorPool pool = new DescriptorPool (
            dependencies,allowUnkNownDependencies);
    final FileDescriptor result = new FileDescriptor (
            proto,allowUnkNownDependencies);
    result.crossLink ();
    return result;
}

/**
 * Create a placeholder FileDescriptor for a message Descriptor.
 */
FileDescriptor (String packageName,Descriptor message)
        throws DescriptorValidationException {
    this.pool = new DescriptorPool (new FileDescriptor[0],true);
    this.proto = FileDescriptorProto.newBuilder ()
            .setName (message.getFullName () + ".placeholder.proto")
            .setPackage (packageName).addMessageType (message.toProto ()).build ();
    this.dependencies = new FileDescriptor[0];
    this.publicDependencies = new FileDescriptor[0];

    messageTypes = new Descriptor[] {message};
    enumTypes = new EnumDescriptor[0];
    services = new ServiceDescriptor[0];
    extensions = new FieldDescriptor[0];

    pool.addPackage (packageName,this);
    pool.addSymbol (message);
}

/**
 * Replace our {@link FileDescriptorProto} with the given one,which is
 * identical except that it might contain extensions that weren't
 * present in the original. This method is needed for bootstrapping when
 * a file defines custom options. The options may be defined in the file
 * itself,so we can't actually parse them until we've constructed the
 * descriptors,but to construct the descriptors we have to have parsed
 * the descriptor protos. So,we have to parse the descriptor protos a
 * second time after constructing the descriptors.
 */
private void setProto (final FileDescriptorProto proto) {
    this.proto = proto;

    for (int i = 0; i < messageTypes.length; i++) {
        messageTypes[i].setProto (proto.getMessageType (i));
    }

    for (int i = 0; i < enumTypes.length; i++) {
        enumTypes[i].setProto (proto.getEnumType (i));
    }

    for (int i = 0; i < services.length; i++) {
        services[i].setProto (proto.getService (i));
    }

    for (int i = 0; i < extensions.length; i++) {
        extensions[i].setProto (proto.getExtension (i));
    }
}

@Override
public void exitPublicImport(final PublicImportContext ctx) {
  super.exitPublicImport(ctx);
  // locationBuilder.addLocation()
  // .setAllSpan(ctx.Public())
  // .addpath(FileDescriptorProto.PUBLIC_DEPENDENCY_FIELD_NUMBER)
  // .addpath(fileBuilder.getPublicDependencyCount() - 1)
  //
  // .addLocation()
  // .comments(ctx)
  // .setAllSpan(ctx.importPath())
  // .addpath(FileDescriptorProto.DEPENDENCY_FIELD_NUMBER)
  // .addpath(fileBuilder.getDependencyCount() - 1);

  locationBuilder.addLocationForPrimitive(FileDescriptorProto.PUBLIC_DEPENDENCY_FIELD_NUMBER)
      .setAllSpan((TerminalNode) ctx.getChild(1))

      .addLocationForPrimitive(FileDescriptorProto.DEPENDENCY_FIELD_NUMBER).comments(ctx)
      .setAllSpan(ctx.importPath());
}

private FileDescriptorProto makeCanonicalProto(final FileDescriptor fileDescriptor) {
  final FileDescriptorProto.Builder protoBuilder =
      FileDescriptorProto.newBuilder(fileDescriptor.toProto());

  for (final FieldDescriptorProto.Builder field : protoBuilder.getExtensionBuilderList()) {
    makeCanonicalField(field,fileDescriptor.findExtensionByName(field.getName()));
  }

  for (final DescriptorProto.Builder message : protoBuilder.getMessageTypeBuilderList()) {
    makeCanonicalMessage(message,fileDescriptor.findMessageTypeByName(message.getName()));
  }

  // for (EnumDescriptorProto.Builder enumProto :
  // protoBuilder.getEnumTypeBuilderList()) {
  // makeCanonicalEnum(enumProto,// fileDescriptor.findEnumTypeByName(enumProto.getName()));
  // }

  for (final ServiceDescriptorProto.Builder serviceProto : protoBuilder.getServiceBuilderList()) {
    makeCanonicalService(serviceProto,fileDescriptor.findServiceByName(serviceProto.getName()));
  }

  // Todo: incorporate options' tree walking into canonicalization to eliminate double walking
  return OptionResolver.newBuilder().setCustomOptionsAsExtensions(false)
      .resolveAllOptionsFor(fileDescriptor,protoBuilder).build();
}

private ParsedContext(final FileDescriptorProto.Builder proto,final List<FieldDescriptorProto.Builder> unresolved,final ContextLookup lookup) {
  this.proto = proto;

  if ((unresolved == null) || unresolved.isEmpty()) {
    this.unresolved = Collections.emptyList();
  } else {
    if (lookup == null) {
      throw new NullPointerException();
    }

    this.unresolved = new ArrayList<Map.Entry<FieldDescriptorProto.Builder,FieldContext>>();

    for (final FieldDescriptorProto.Builder field : unresolved) {
      final FieldContext context = (FieldContext) lookup.getContext(field,false);

      if (context == null) {
        throw new IllegalStateException("field context must not be null");
      }

      this.unresolved.add(new SimpleEntry<FieldDescriptorProto.Builder,FieldContext>(field,context));
    }
  }
}

private void buildAllOptions(final FileDescriptorProto.Builder proto) {
  if (!buildOptions(proto.getoptionsBuilder())) {
    proto.clearOptions();
  }

  for (final FieldDescriptorProto.Builder extensionProto : proto.getExtensionBuilderList()) {
    if (!buildOptions(extensionProto.getoptionsBuilder())) {
      extensionProto.clearOptions();
    }
  }

  for (final EnumDescriptorProto.Builder enumProto : proto.getEnumTypeBuilderList()) {
    buildAllOptions(enumProto);
  }

  for (final ServiceDescriptorProto.Builder serviceProto : proto.getServiceBuilderList()) {
    buildAllOptions(serviceProto);
  }

  for (final DescriptorProto.Builder messageProto : proto.getMessageTypeBuilderList()) {
    buildAllOptions(messageProto);
  }
}

private FileDescriptor getDeepCanonicalFileDescriptor(final FileDescriptor file,final boolean forceRebuild) throws DescriptorValidationException {
  if (!forceRebuild && isDeeplyCanonical(file)) {
    return file;
  }

  final FileDescriptor[] dependencies = new FileDescriptor[file.getDependencies().size()];
  int i = 0;

  for (final FileDescriptor dependency : file.getDependencies()) {
    dependencies[i++] = getDeepCanonicalFileDescriptor(dependency,forceRebuild);
  }

  final FileDescriptorProto proto = isCanonical(file) ? file.toProto() : makeCanonicalProto(file);
  return buildFileDescriptorWithReserializedProto(proto,dependencies);
}

private FileDescriptorProto makeCanonicalProto(final FileDescriptor file) {
  final FileDescriptorProto.Builder protoBuilder = FileDescriptorProto.newBuilder(file.toProto());

  for (final FieldDescriptorProto.Builder field : protoBuilder.getExtensionBuilderList()) {
    makeCanonicalField(field,file.findExtensionByName(field.getName()));
  }

  for (final DescriptorProto.Builder message : protoBuilder.getMessageTypeBuilderList()) {
    makeCanonicalMessage(message,file.findMessageTypeByName(message.getName()));
  }

  // for (EnumDescriptorProto.Builder enumProto :
  // protoBuilder.getEnumTypeBuilderList()) {
  // makeCanonicalEnum(enumProto,// file.findEnumTypeByName(enumProto.getName()));
  // }

  for (final ServiceDescriptorProto.Builder serviceProto : protoBuilder.getServiceBuilderList()) {
    makeCanonicalService(serviceProto,file.findServiceByName(serviceProto.getName()));
  }

  return OptionResolver.newBuilder().setCustomOptionsAsExtensions(reparseCustomOptions)
      .resolveAllOptionsFor(file,protoBuilder).build();
}

@SuppressWarnings("null")
public static List<FileDescriptorProto> getFileDescriptorProtos(final Pattern protoNamePattern,final boolean includeSourceInfo,final FieldTypeRefsMode fieldTypeRefsMode,final String fileDescriptorSetPath,final Class<?> baseResourceClass) {
  final List<FileDescriptorProto> fdProtos =
      getFileDescriptorProtos(protoNamePattern,fileDescriptorSetPath,baseResourceClass);

  if (!includeSourceInfo && (fieldTypeRefsMode != FieldTypeRefsMode.AS_IS)) {
    for (final ListIterator<FileDescriptorProto> iterator = fdProtos.listIterator(); iterator
        .hasNext();) {
      final FileDescriptorProto fd = iterator.next();
      iterator.set(makeProtoRefsRelative(fd,fieldTypeRefsMode).build());
    }
  }

  return fdProtos;
}

@SuppressWarnings("null")
public static FileDescriptorProto.Builder makeProtoRefsRelative(final FileDescriptorProto proto,final FieldTypeRefsMode fieldTypeRefsMode) {
  if (fieldTypeRefsMode == FieldTypeRefsMode.AS_IS) {
    return FileDescriptorProto.newBuilder(proto);
  }

  final FileDescriptorProto.Builder protoBuilder = FileDescriptorProto.newBuilder(proto);
  final String packagePath = "." + proto.getPackage();

  for (final FieldDescriptorProto.Builder field : protoBuilder.getExtensionBuilderList()) {
    makeFieldRefsRelative(packagePath,field,fieldTypeRefsMode,packagePath);
  }

  for (final DescriptorProto.Builder message : protoBuilder.getMessageTypeBuilderList()) {
    makeMessageRefsRelative(packagePath,message,packagePath);
  }

  return protoBuilder;
}

@Ignore
@Test
public void viewFileDescriptors() throws Exception {
  final FileDescriptorProto child1 =
      getProtocFileDescriptorProto("nonTreeChild1.proto",false,FieldTypeRefsMode.AS_IS);
  final FileDescriptorProto parent1 =
      getProtocFileDescriptorProto("nonTreeParent1.proto",FieldTypeRefsMode.AS_IS);
  final FileDescriptorProto parent2 =
      getProtocFileDescriptorProto("nonTreeParent2.proto",FieldTypeRefsMode.AS_IS);

  final FileDescriptor fileParent2 = FileDescriptor.buildFrom(parent2,new FileDescriptor[0]);
  final FileDescriptor fileChild1 =
      FileDescriptor.buildFrom(child1,new FileDescriptor[] {fileParent2});
  final FileDescriptor fileParent1 =
      FileDescriptor.buildFrom(parent1,new FileDescriptor[] {fileChild1});

  log.info(fileParent1.toProto().toString());
  log.info(fileChild1.toProto().toString());
  log.info(fileParent2.toProto().toString());

  log.info("messages: {}",fileParent1.getMessageTypes());
  log.info("messages: {}",fileParent1.getEnumTypes());

  assertthat(fileParent1.findMessageTypeByName("Child1"),nullValue());
  assertthat(fileParent1.findEnumTypeByName("Parent2"),not(nullValue()));
}

@Test
public void testUnresolvednamesPostBuildFileProto() throws Exception {
  final FileDescriptorProto child1 =
      getProtocFileDescriptorProto("nonTreeChild1.proto",FieldTypeRefsMode.AS_IS);
  final FileDescriptorProto child2 =
      getProtocFileDescriptorProto("nonTreeChild2.proto",FieldTypeRefsMode.AS_IS);
  final FileDescriptorProto originalParent1 =
      getProtocFileDescriptorProto("nonTreeParent1.proto",FieldTypeRefsMode.AS_IS);

  final Builder parentBuilder = FileDescriptorProto.newBuilder(originalParent1);
  parentBuilder.getMessageTypeBuilder(0).getFieldBuilder(2).clearType().setTypeName("Child2");
  final FileDescriptorProto parent1 = parentBuilder.build();


  final FileDescriptor fileChild2 = FileDescriptor.buildFrom(child2,new FileDescriptor[0]);
  final FileDescriptor fileParent2 =
      FileDescriptor.buildFrom(parent2,new FileDescriptor[] {fileChild2});
  final FileDescriptor fileChild1 =
      FileDescriptor.buildFrom(child1,new FileDescriptor[] {fileChild1});

  log.info(fileParent1.toProto().toString());
}

public void testUnkNownFieldsDenied() throws Exception {
  FileDescriptorProto fooProto = FileDescriptorProto.newBuilder()
      .setName("foo.proto")
      .addMessageType(DescriptorProto.newBuilder()
          .setName("Foo")
          .addField(FieldDescriptorProto.newBuilder()
              .setLabel(FieldDescriptorProto.Label.LABEL_OPTIONAL)
              .setTypeName("Bar")
              .setName("bar")
              .setNumber(1)))
      .build();

  try {
    Descriptors.FileDescriptor.buildFrom(fooProto,new FileDescriptor[0]);
    fail("DescriptorValidationException expected");
  } catch (DescriptorValidationException e) {
    assertTrue(e.getMessage().indexOf("Bar") != -1);
    assertTrue(e.getMessage().indexOf("is not defined") != -1);
  }
}

@Test
public final void testParsed() throws Exception {
  try {
    walker.walk(protoParser,tree);
    final FileDescriptorProto.Builder protoBuilder =
        (FileDescriptorProto.Builder) protoParser.getParsed().getProto();
    final FileDescriptor fileDescriptor =
        FileDescriptor.buildFrom(protoBuilder.build(),new FileDescriptor[0]);
    fail(String.format("expected exception type %s with message containg '%s',but got none!",exception,exceptionExtra));
  } catch (final Exception e) {
    log.debug("expected exception with message '{}'",e.getMessage());
    assertthat(e,instanceOf(exception));
    assertthat(e.getMessage(),containsstring(exceptionExtra));
  }
}

public void testDependencyOrder() throws Exception {
  FileDescriptorProto fooProto = FileDescriptorProto.newBuilder()
      .setName("foo.proto").build();
  FileDescriptorProto barProto = FileDescriptorProto.newBuilder()
      .setName("bar.proto")
      .addDependency("foo.proto")
      .build();
  FileDescriptorProto bazProto = FileDescriptorProto.newBuilder()
      .setName("baz.proto")
      .addDependency("foo.proto")
      .addDependency("bar.proto")
      .addPublicDependency(0)
      .addPublicDependency(1)
      .build();
  FileDescriptor fooFile = Descriptors.FileDescriptor.buildFrom(fooProto,new FileDescriptor[] {fooFile});

  // Items in the FileDescriptor array can be in any order.
  Descriptors.FileDescriptor.buildFrom(bazProto,fooFile});
}

@Test
public void testtextformatWithDescriptor() throws Exception {
  //TestUtil.getAllSet();
  String allSet = textformat.printToString(TestUtil.getAllSet());
  final DescriptorProto expectedAllSetProto = TestAllTypes.getDescriptor().toProto();
  String allSetProto = textformat.printToString(expectedAllSetProto);
  log.debug("the message: {}",allSet);
  log.debug("the proto: {}",allSetProto);

  Dynamicmessage.Builder builder = Dynamicmessage.newBuilder(DescriptorProto.getDescriptor());
  textformat.merge(allSetProto,builder);
  Message actualAllSetProto = builder.build();

  assertthat(actualAllSetProto).isEqualTo(expectedAllSetProto);

  FieldDescriptor field = FileDescriptorProto.getDescriptor()
      .findFieldByNumber(FileDescriptorProto.MESSAGE_TYPE_FIELD_NUMBER);
  FileDescriptorProto fileProto = FileDescriptorProto.newBuilder().setName("my file1")
      .addRepeatedField(field,actualAllSetProto)
      .build();
  FileDescriptor fileDescriptor = FileDescriptor.buildFrom(fileProto,new FileDescriptor[0]);
  Descriptor actualAllTypesDescriptor = fileDescriptor.findMessageTypeByName(
      TestAllTypes.getDescriptor().getFullName());

  assertthat(actualAllTypesDescriptor,equalTo(TestAllTypes.getDescriptor()));
}

private FileDescriptorProto.Builder addDeepMessageTypetoFile(
    FileDescriptorProto.Builder builder,Message descriptorProto) {
  //Todo delete this method!!!
  final FieldDescriptor field = FileDescriptorProto.getDescriptor()
      .findFieldByNumber(FileDescriptorProto.MESSAGE_TYPE_FIELD_NUMBER);
  final FieldDescriptor nestedTypeField = DescriptorProto.getDescriptor().findFieldByNumber(
      DescriptorProto.nesTED_TYPE_FIELD_NUMBER);
  builder.addRepeatedField(field,descriptorProto);

  for (Message nestedMessageType : (List<Message>) descriptorProto.getField(nestedTypeField)) {
    // builder.addRepeatedField(field,nestedMessageType);
    addDeepMessageTypetoFile(builder,nestedMessageType);
  }

  return builder;
}

private FileDescriptorSet.Builder addDescriptorToFileSet(FileDescriptorSet.Builder builder,Descriptor descriptor,Set<FileDescriptorProto> fileProtoSet) {
  List<? extends FileDescriptorProtoOrBuilder> fileList = builder.getFileOrBuilderList();
  final FileDescriptor file = descriptor.getFile();
  FileDescriptorProto proto = file.toProto();

  if (fileList.contains(proto)) {
    return builder;
  }

  builder.addFile(proto);

  for (FileDescriptor dependency : file.getDependencies()) {
    proto = dependency.toProto();

    if (!fileList.contains(proto)) {
      builder.addFile(proto);
    }
  }

  return builder;
}

private void assertReserializationInvariant(final FileDescriptor fileWithUnkNownFieldsProto,final ExtensionRegistry registry) throws InvalidProtocolBufferException {
  final FileDescriptorProto expectedProtoWithUnkNownFields = fileWithUnkNownFieldsProto.toProto();

  final FileDescriptorProto actualProtoWithExtensions =
      FileDescriptorProto.parseFrom(expectedProtoWithUnkNownFields.toByteString(),registry);
  final FileDescriptorProto actualProtoWithUnkNownFields =
      FileDescriptorProto.parseFrom(actualProtoWithExtensions.toByteString());

  softly
      .assertthat(actualProtoWithUnkNownFields.toString())
      .as("check reserialization invariant textual equality for %s",fileWithUnkNownFieldsProto.getName())
      .isEqualTo(expectedProtoWithUnkNownFields.toString());

  softly.assertthat(actualProtoWithUnkNownFields)
      .as("check reserialization invariant for %s",fileWithUnkNownFieldsProto.getName())
      .isEqualTo(expectedProtoWithUnkNownFields);
}

public void testPackedEnumField() throws Exception {
  FileDescriptorProto fileDescriptorProto = FileDescriptorProto.newBuilder()
      .setName("foo.proto")
      .addEnumType(EnumDescriptorProto.newBuilder()
        .setName("Enum")
        .addValue(EnumValueDescriptorProto.newBuilder()
          .setName("FOO")
          .setNumber(1)
          .build())
        .build())
      .addMessageType(DescriptorProto.newBuilder()
        .setName("Message")
        .addField(FieldDescriptorProto.newBuilder()
          .setName("foo")
          .setTypeName("Enum")
          .setNumber(1)
          .setLabel(FieldDescriptorProto.Label.LABEL_REPEATED)
          .setoptions(DescriptorProtos.FieldOptions.newBuilder()
            .setPacked(true)
            .build())
          .build())
        .build())
      .build();
  Descriptors.FileDescriptor.buildFrom(
      fileDescriptorProto,new FileDescriptor[0]);
}