full util.Factory
}

func (f Factory) NewBuilder() *resource.Builder {
	return f.full.NewBuilder()
}

func (f Factory) ClientForMapping(mapping *meta.RESTMapping) (resource.RESTClient, error) {
	return f.full.ClientForMapping(mapping)
}

func (f Factory) UnstructuredClientForMapping(mapping *meta.RESTMapping) (resource.RESTClient, error) {
	return f.full.UnstructuredClientForMapping(mapping)
}

            return true;
        }
        if (o == null || getClass() != o.getClass()) {
            return false;
        }
        AbstractLanguageElement that = (AbstractLanguageElement) o;
        return Objects.equals(rawCommentText, that.rawCommentText) &&
            Objects.equals(annotationNames, that.annotationNames);
    }

    @Override
    public int hashCode() {

     * @throws CIFSException
     */
    long getServerTimeZoneOffset () throws CIFSException;


    /**
     * @return server reported domain name
     * @throws CIFSException
     */
    String getOEMDomainName () throws CIFSException;


    /**
     * @return the share we are connected to
     */
    String getConnectedShare ();


    /**
     * @param th

   * equal to the key.
   */
  enum KeyAbsentBehavior {
    /**
     * Return the index of the next lower element in the list, or {@code -1} if there is no such
     * element.
     */
    NEXT_LOWER {
      @Override
      int resultIndex(int higherIndex) {
        return higherIndex - 1;
      }
    },
    /**
     * Return the index of the next higher element in the list, or {@code list.size()} if there is

    }

    @Override
    protected Map<K, V> delegate() {
      return delegate;
    }

    @Override
    public Set<K> keySet() {
      return new ForwardingSet<K>() {
        @Override
        protected Set<K> delegate() {
          return delegate.keySet();
        }

        @Override
        public Iterator<K> iterator() {
          return Iterators.unmodifiableIterator(delegate.keySet().iterator());
        }

    protected byte[] decodeBase64(String base64String) {
        if (base64String == null) {
            return null;
        }
        try {
            return BASE64_DECODER.decode(base64String);
        } catch (IllegalArgumentException e) {
            if (e.getCause() instanceof DecodingException) {
                return BASE64URL_DECODER.decode(base64String.trim());
            }
            throw e;
        }
    }

        }
        if (targetClassLoader != null) {
            return targetClassLoader;
        }
        if (thisClassLoader != null) {
            return thisClassLoader;
        }

        final ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();
        if (systemClassLoader != null) {
            return systemClassLoader;
        }

    }

    public boolean hasBuildFailures() {
        return !buildFailuresByProject.isEmpty();
    }

    public boolean hasBuildFailure(MavenProject project) {
        return buildFailuresByProject.containsKey(getProjectKey(project));
    }

    public boolean hasMultipleProjects() {
        return sorter.hasMultipleProjects();
    }

    public List<MavenProject> getSortedProjects() {

		if maxkeys, err = strconv.Atoi(values.Get("max-keys")); err != nil {
			errCode = ErrInvalidMaxKeys
			return
		}
	} else {
		maxkeys = maxObjectList
	}

	prefix = values.Get("prefix")
	marker = values.Get("marker")
	delimiter = values.Get("delimiter")
	encodingType = values.Get("encoding-type")
	return
}

    @Override
    public FileConfigDbm asDBMeta() {
        return FileConfigDbm.getInstance();
    }

    @Override
    public String asTableDbName() {
        return "file_config";
    }

    @Override
    public boolean hasSpecifiedColumn() {
        return _specification != null;
    }

    @Override
    public ConditionQuery localCQ() {
        return doGetConditionQuery();
    }