docs: public static Deferred<UIDMeta> getUIDMeta(final TSDB tsdb, 
        final UniqueIdType type, final byte[] uid) {
      
      /**
       * Callback used to verify that the UID to name mapping exists. Uses the TSD
       * for verification so the name may be cached. If the name does not exist
       * it will throw a NoSuchUniqueId and the meta data will not be returned. 
       * This helps in case the user deletes a UID but the meta data is still 
       * stored. The fsck utility can be used later to cleanup orphaned objects.
       */
      class NameCB implements Callback<Deferred<UIDMeta>, String> {
  
        /**
         * Called after verifying that the name mapping exists
         * @return The results of {@link #FetchMetaCB}
         */
        @Override
        public Deferred<UIDMeta> call(final String name) throws Exception {
          
          /**
           * Inner class called to retrieve the meta data after verifying that the
           * name mapping exists. It requires the name to set the default, hence
           * the reason it's nested.
           */
          class FetchMetaCB implements Callback<Deferred<UIDMeta>, 
            ArrayList<KeyValue>> {
    
            /**
             * Called to parse the response of our storage GET call after 
             * verification
             * @return The stored UIDMeta or a default object if the meta data
             * did not exist 
             */
            @Override
            public Deferred<UIDMeta> call(ArrayList<KeyValue> row) 
              throws Exception {
              
              if (row == null || row.isEmpty()) {
                // return the default
                final UIDMeta meta = new UIDMeta();
                meta.uid = UniqueId.uidToString(uid);
                meta.type = type;
                meta.name = name;
                return Deferred.fromResult(meta);
              }
              final UIDMeta meta = JSON.parseToObject(row.get(0).value(), 
                  UIDMeta.class);
              
              // overwrite the name and UID
              meta.name = name;
              meta.uid = UniqueId.uidToString(uid);
              
              // fix missing types
              if (meta.type == null) {
                final String qualifier = 
                  new String(row.get(0).qualifier(), CHARSET);
                meta.type = UniqueId.stringToUniqueIdType(qualifier.substring(0, 
                    qualifier.indexOf("_meta")));
              }
              meta.initializeChangedMap();
              return Deferred.fromResult(meta);
            }
            
          }
          
          final GetRequest get = new GetRequest(tsdb.uidTable(), uid);
          get.family(FAMILY);
          get.qualifier((type.toString().toLowerCase() + "_meta").getBytes(CHARSET));
          return tsdb.getClient().get(get).addCallbackDeferring(new FetchMetaCB());
        }
      }
      
      // verify that the UID is still in the map before fetching from storage
      return tsdb.getUidName(type, uid).addCallbackDeferring(new NameCB());
    }