コード例 #1
0
 /* ------------------------------------------------------------ */
 public int setProps(Object obj, Map<?, ?> props) {
   int count = 0;
   for (Iterator<?> iterator = props.entrySet().iterator(); iterator.hasNext(); ) {
     Map.Entry<?, ?> entry = (Map.Entry<?, ?>) iterator.next();
     Setter setter = getSetter((String) entry.getKey());
     if (setter != null) {
       try {
         setter.invoke(obj, entry.getValue());
         count++;
       } catch (Exception e) {
         // TODO throw exception?
         LOG.warn(
             _pojoClass.getName()
                 + "#"
                 + setter.getPropertyName()
                 + " not set from "
                 + (entry.getValue().getClass().getName())
                 + "="
                 + entry.getValue().toString());
         log(e);
       }
     }
   }
   return count;
 }
コード例 #2
0
  public static Bundle convertToBundle(JSONObject jsonObject) throws JSONException {
    Bundle bundle = new Bundle();
    @SuppressWarnings("unchecked")
    Iterator<String> jsonIterator = jsonObject.keys();
    while (jsonIterator.hasNext()) {
      String key = jsonIterator.next();
      Object value = jsonObject.get(key);
      if (value == null || value == JSONObject.NULL) {
        // Null is not supported.
        continue;
      }

      // Special case JSONObject as it's one way, on the return it would be Bundle.
      if (value instanceof JSONObject) {
        bundle.putBundle(key, convertToBundle((JSONObject) value));
        continue;
      }

      Setter setter = SETTERS.get(value.getClass());
      if (setter == null) {
        throw new IllegalArgumentException("Unsupported type: " + value.getClass());
      }
      setter.setOnBundle(bundle, key, value);
    }

    return bundle;
  }
コード例 #3
0
  String setTreeFieldsAndSave(String formName, Setter... setters) throws InterruptedException {

    String currentNode = selenium.getAttribute("//input[@name='currentNode']@value");
    assertTrue(currentNode.startsWith(formName + "."));
    String prefix = currentNode.replace(formName + ".", "");

    for (Setter setter : setters) {
      setter.setField(prefix);
    }

    selenium.click("//input[contains(@onclick, '" + currentNode + "') and @value='Save']");
    return currentNode;
  }
コード例 #4
0
ファイル: RibbonCommand.java プロジェクト: generhim/zuul
  public RibbonCommand(
      String commandKey,
      RestClient restClient,
      HttpClientRequest.Verb verb,
      String uri,
      MultivaluedMap<String, String> headers,
      MultivaluedMap<String, String> params,
      InputStream requestEntity)
      throws URISyntaxException {

    super(
        Setter.withGroupKey(HystrixCommandGroupKey.Factory.asKey(commandKey))
            .andCommandPropertiesDefaults(
                // we want to default to semaphore-isolation since this wraps
                // 2 others commands that are already thread isolated
                HystrixCommandProperties.Setter()
                    .withExecutionIsolationStrategy(
                        HystrixCommandProperties.ExecutionIsolationStrategy.SEMAPHORE)
                    .withExecutionIsolationSemaphoreMaxConcurrentRequests(
                        DynamicPropertyFactory.getInstance()
                            .getIntProperty(
                                ZuulConstants.ZUUL_EUREKA + commandKey + ".semaphore.maxSemaphores",
                                100)
                            .get())));

    this.restClient = restClient;
    this.verb = verb;
    this.uri = new URI(uri);
    this.headers = headers;
    this.params = params;
    this.requestEntity = requestEntity;
  }
コード例 #5
0
 private void set(String paramName, Setter s) throws DataLinkException {
   for (int i = 0; i < params.length; i++) {
     if (params[i] != null && params[i].equals(paramName)) {
       s.set(i + 1);
     }
   }
 }
コード例 #6
0
  public TimeOutCommand(int timeout, DataBaseManager resource, String productId) {
    super(
        Setter.withGroupKey(HystrixCommandGroupKey.Factory.asKey(COMMAND_GROUP))
            .andCommandPropertiesDefaults(
                HystrixCommandProperties.Setter()
                    .withExecutionIsolationThreadTimeoutInMilliseconds((timeout))));

    this.resource = resource;
    this.productId = productId;
  }
コード例 #7
0
 private SecondaryCommand(int id) {
   super(
       Setter.withGroupKey(HystrixCommandGroupKey.Factory.asKey("SystemX"))
           .andCommandKey(HystrixCommandKey.Factory.asKey("SecondaryCommand"))
           .andThreadPoolKey(HystrixThreadPoolKey.Factory.asKey("SecondaryCommand"))
           .andCommandPropertiesDefaults(
               // we default to a 100ms timeout for secondary
               HystrixCommandProperties.Setter().withExecutionTimeoutInMilliseconds(100)));
   this.id = id;
 }
コード例 #8
0
 /**
  * A failsafe GET request which takes the client, request and response handler to use to send the
  * request and send a response
  *
  * @param client the http client
  * @param request the request to make using the client
  * @param responseHandler the response handler
  */
 public FailSafeGetRequest(
     HttpClient client, HttpGet request, ResponseHandler<Address> responseHandler) {
   super(
       Setter.withGroupKey(HystrixCommandGroupKey.Factory.asKey(PERSON_GROUP))
           .andCommandKey(HystrixCommandKey.Factory.asKey(ADDRESS_GET_COMMAND))
           .andThreadPoolKey(HystrixThreadPoolKey.Factory.asKey(ADDRESS_CLIENT_POOL)));
   this.client = client;
   this.responseHandler = responseHandler;
   this.request = request;
 }
コード例 #9
0
  public GetLogsCommand(String key) {
    super(
        Setter.withGroupKey(
                HystrixCommandGroupKey.Factory.asKey(FluxConstants.MIDDLETIER_HYSTRIX_GROUP))
            .andCommandKey(
                HystrixCommandKey.Factory.asKey(
                    FluxConstants.MIDDLETIER_HYSTRIX_GET_LOGS_COMMAND_KEY))
            .andThreadPoolKey(
                HystrixThreadPoolKey.Factory.asKey(FluxConstants.MIDDLETIER_HYSTRIX_THREAD_POOL)));

    this.key = key;
  }
コード例 #10
0
 public CommandFacadeWithPrimarySecondary(int id) {
   super(
       Setter.withGroupKey(HystrixCommandGroupKey.Factory.asKey("SystemX"))
           .andCommandKey(HystrixCommandKey.Factory.asKey("PrimarySecondaryCommand"))
           .andCommandPropertiesDefaults(
               // we want to default to semaphore-isolation since this wraps
               // 2 others commands that are already thread isolated
               HystrixCommandProperties.Setter()
                   .withExecutionIsolationStrategy(
                       HystrixCommandProperties.ExecutionIsolationStrategy.SEMAPHORE)));
   this.id = id;
 }
コード例 #11
0
  public static JSONObject convertToJSON(Bundle bundle) throws JSONException {
    JSONObject json = new JSONObject();

    for (String key : bundle.keySet()) {
      Object value = bundle.get(key);
      if (value == null) {
        // Null is not supported.
        continue;
      }

      // Special case List<String> as getClass would not work, since List is an interface
      if (value instanceof List<?>) {
        JSONArray jsonArray = new JSONArray();
        @SuppressWarnings("unchecked")
        List<String> listValue = (List<String>) value;
        for (String stringValue : listValue) {
          jsonArray.put(stringValue);
        }
        json.put(key, jsonArray);
        continue;
      }

      // Special case Bundle as it's one way, on the return it will be JSONObject
      if (value instanceof Bundle) {
        json.put(key, convertToJSON((Bundle) value));
        continue;
      }

      Setter setter = SETTERS.get(value.getClass());
      if (setter == null) {
        throw new IllegalArgumentException("Unsupported type: " + value.getClass());
      }
      setter.setOnJSON(json, key, value);
    }

    return json;
  }
  /**
   * Constructor for REST WebService HystrixCommand class, passing in all the parameters to execute
   * the call.
   *
   * @param commandName String the web service call name used to create the Hystrix Command Key
   * @param groupKeyName The group key under which this web service call falls
   * @param httpRequest Request method to be executed
   * @param httpClient HttpClient that executes the request
   * @param httpContext Http request execution context
   */
  public CommandRestResourceCall(
      final String groupKeyName,
      final String commandName,
      final HttpRequestBase httpRequest,
      final HttpClient httpClient,
      final HttpContext httpContext) {

    super(
        Setter.withGroupKey(HystrixCommandGroupKey.Factory.asKey(groupKeyName))
            .andCommandKey(HystrixCommandKey.Factory.asKey(commandName)));

    checkNullArguments(groupKeyName, commandName, httpRequest, httpClient, httpContext);

    this.commandName = commandName;
    this.httpRequest = httpRequest;
    this.httpClient = httpClient;
    this.httpContext = httpContext;
  }
 public ShedLoadInventoryRequestCommand(
     final InventoryRequester inventoryRequester, final Store store, final Product product) {
   super(
       Setter.withGroupKey(
               HystrixCommandGroupKey.Factory.asKey(
                   ShedLoadInventoryRequestCommand.class.getSimpleName()))
           .andCommandKey(
               HystrixCommandKey.Factory.asKey(
                   ShedLoadInventoryRequestCommand.class.getSimpleName()))
           .andCommandPropertiesDefaults(
               HystrixCommandProperties.Setter()
                   .withCircuitBreakerRequestVolumeThreshold(10)
                   .withCircuitBreakerForceClosed(true)
                   .withExecutionTimeoutInMilliseconds(200)),
       inventoryRequester,
       store,
       product);
 }
コード例 #14
0
 public Command(
     String commandKey,
     boolean shouldFail,
     boolean shouldFailWithBadRequest,
     long latencyToAdd,
     int sleepWindow,
     int requestVolumeThreshold) {
   super(
       Setter.withGroupKey(HystrixCommandGroupKey.Factory.asKey("Command"))
           .andCommandKey(HystrixCommandKey.Factory.asKey(commandKey))
           .andCommandPropertiesDefaults(
               HystrixCommandPropertiesTest.getUnitTestPropertiesSetter()
                   .withExecutionTimeoutInMilliseconds(500)
                   .withCircuitBreakerRequestVolumeThreshold(requestVolumeThreshold)
                   .withCircuitBreakerSleepWindowInMilliseconds(sleepWindow)));
   this.shouldFail = shouldFail;
   this.shouldFailWithBadRequest = shouldFailWithBadRequest;
   this.latencyToAdd = latencyToAdd;
 }
コード例 #15
0
 public void setValue(I obj, T value) {
   setter.set(obj, value);
 }
コード例 #16
0
ファイル: JSonMapper.java プロジェクト: amicom/test-project
  @SuppressWarnings({"unchecked", "rawtypes"})
  public Object jsonToObject(final JSonNode json, Type type) throws MapperException {
    final ClassCache cc;
    try {

      Class<?> clazz = null;
      if (type instanceof ParameterizedType) {
        Type typ = ((ParameterizedType) type).getRawType();
        if (typ instanceof Class) {
          clazz = (Class<?>) typ;
        }
      } else if (type instanceof Class) {
        clazz = (Class) type;
      } else if (type instanceof GenericArrayType) {
        // this is for 1.6
        // for 1.7 we do not get GenericArrayTypeImpl here but the
        // actual array class
        type =
            clazz =
                Array.newInstance((Class<?>) ((GenericArrayType) type).getGenericComponentType(), 0)
                    .getClass();
      }

      if (clazz == null || clazz == Object.class) {

        if (json instanceof JSonArray) {
          type = clazz = LinkedList.class;
        } else if (json instanceof JSonObject) {
          type = clazz = HashMap.class;
        } else if (json instanceof JSonValue) {
          switch (((JSonValue) json).getType()) {
            case BOOLEAN:
              type = clazz = boolean.class;
              break;
            case DOUBLE:
              type = clazz = double.class;
              break;
            case LONG:
              type = clazz = long.class;
              break;
            case NULL:
            case STRING:
              type = clazz = String.class;
          }
        }
      }
      final TypeMapper<?> tm = typeMapper.get(clazz);
      if (tm != null) {

        return tm.reverseMap(json);
      }
      if (json instanceof JSonValue) {
        if (!Clazz.isPrimitive(type)
            && !Clazz.isString(type)
            && type != Object.class
            && ((JSonValue) json).getValue() != null
            && !Clazz.isEnum(type)) {
          //
          throw new MapperException(json + " cannot be mapped to " + type);
        }
        switch (((JSonValue) json).getType()) {
          case BOOLEAN:
          case DOUBLE:
          case LONG:
            if (type instanceof Class) {
              return JSonMapper.cast(((JSonValue) json).getValue(), (Class) type);
            } else {
              return ((JSonValue) json).getValue();
            }

          case STRING:
            if (type instanceof Class && ((Class<?>) type).isEnum()) {
              try {
                return Enum.valueOf((Class<Enum>) type, ((JSonValue) json).getValue() + "");
              } catch (final IllegalArgumentException e) {
                if (isIgnoreIllegalArgumentMappings() || isIgnoreIllegalEnumMappings()) {
                  return null;
                }
                throw e;
              }
            } else {
              return ((JSonValue) json).getValue();
            }

          case NULL:
            return null;
        }
      }
      if (type instanceof ParameterizedType) {
        final ParameterizedType pType = (ParameterizedType) type;
        Type raw = pType.getRawType();
        if (raw instanceof Class && Collection.class.isAssignableFrom((Class) raw)) {
          final Collection<Object> inst =
              (Collection<Object>) mapClasses((Class) raw).newInstance();
          final JSonArray obj = (JSonArray) json;
          for (final JSonNode n : obj) {
            inst.add(this.jsonToObject(n, pType.getActualTypeArguments()[0]));
          }
          return inst;
        } else if (raw instanceof Class && Map.class.isAssignableFrom((Class) raw)) {
          final Map<String, Object> inst =
              (Map<String, Object>) mapClasses((Class) raw).newInstance();
          final JSonObject obj = (JSonObject) json;
          Entry<String, JSonNode> next;
          for (final Iterator<Entry<String, JSonNode>> it = obj.entrySet().iterator();
              it.hasNext(); ) {
            next = it.next();
            inst.put(
                next.getKey(),
                this.jsonToObject(next.getValue(), pType.getActualTypeArguments()[1]));
          }
          return inst;
        }
      }
      if (clazz != null) {
        if (clazz == Object.class) {
          // guess type
          if (json instanceof JSonArray) {
            type = LinkedList.class;
          } else if (json instanceof JSonObject) {
            type = HashMap.class;
          }
        }

        if (Collection.class.isAssignableFrom(clazz)) {
          final Collection<Object> inst = (Collection<Object>) mapClasses(clazz).newInstance();
          final JSonArray obj = (JSonArray) json;
          final Type gs = clazz.getGenericSuperclass();
          final Type gType;
          if (gs instanceof ParameterizedType) {
            gType = ((ParameterizedType) gs).getActualTypeArguments()[0];
          } else {
            gType = void.class;
          }
          for (final JSonNode n : obj) {
            inst.add(this.jsonToObject(n, gType));
          }
          return inst;
        } else if (Map.class.isAssignableFrom(clazz)) {
          final Map<String, Object> inst = (Map<String, Object>) mapClasses(clazz).newInstance();
          final JSonObject obj = (JSonObject) json;
          final Type gs = clazz.getGenericSuperclass();
          final Type gType;
          if (gs instanceof ParameterizedType) {
            gType = ((ParameterizedType) gs).getActualTypeArguments()[1];
          } else {
            gType = void.class;
          }

          Entry<String, JSonNode> next;
          for (final Iterator<Entry<String, JSonNode>> it = obj.entrySet().iterator();
              it.hasNext(); ) {
            next = it.next();
            inst.put(next.getKey(), this.jsonToObject(next.getValue(), gType));
          }

          return inst;

        } else if (clazz.isArray()) {
          final JSonArray obj = (JSonArray) json;
          final Object arr = Array.newInstance(mapClasses(clazz.getComponentType()), obj.size());
          for (int i = 0; i < obj.size(); i++) {
            final Object v = this.jsonToObject(obj.get(i), clazz.getComponentType());

            Array.set(arr, i, v);
          }
          return arr;
        } else {

          if (json instanceof JSonArray) {

            final java.util.List<Object> inst = new ArrayList<Object>();
            final JSonArray obj = (JSonArray) json;
            final Type gs = clazz.getGenericSuperclass();
            final Type gType;
            if (gs instanceof ParameterizedType) {
              gType = ((ParameterizedType) gs).getActualTypeArguments()[0];
            } else {
              gType = Object.class;
            }
            for (final JSonNode n : obj) {
              inst.add(this.jsonToObject(n, gType));
            }
            return inst;

          } else {
            final JSonObject obj = (JSonObject) json;
            if (Clazz.isPrimitive(clazz)) {
              //
              if (isIgnoreIllegalArgumentMappings()) {
                return null;
              } else {
                throw new IllegalArgumentException("Cannot Map " + obj + " to " + clazz);
              }
            }

            cc = ClassCache.getClassCache(clazz);

            final Object inst = cc.getInstance();
            JSonNode value;
            Object v;
            for (final Setter s : cc.getSetter()) {

              value = obj.get(s.getKey());
              if (value == null) {
                continue;
              }
              //
              Type fieldType = s.getType();
              // special handling for generic fields
              if (fieldType instanceof TypeVariable) {
                final Type[] actualTypes = ((ParameterizedType) type).getActualTypeArguments();
                final TypeVariable<?>[] genericTypes = clazz.getTypeParameters();
                for (int i = 0; i < genericTypes.length; i++) {
                  if (StringUtils.equals(
                      ((TypeVariable) fieldType).getName(), genericTypes[i].getName())) {

                    fieldType = actualTypes[i];
                    break;
                  }
                }
              }
              v = this.jsonToObject(value, fieldType);
              try {
                s.setValue(inst, v);
              } catch (final IllegalArgumentException e) {
                if (isIgnoreIllegalArgumentMappings()) {
                  continue;
                } else if (v == null && isIgnorePrimitiveNullMapping()) {
                  continue;
                }
                throw e;
              }
            }

            return inst;
          }
        }
      } else {
        System.err.println("TYPE?!");
      }
    } catch (final SecurityException e) {
      e.printStackTrace();
    } catch (final NoSuchMethodException e) {
      e.printStackTrace();
    } catch (final IllegalArgumentException e) {
      e.printStackTrace();
    } catch (final InstantiationException e) {
      e.printStackTrace();
    } catch (final IllegalAccessException e) {
      e.printStackTrace();
    } catch (final InvocationTargetException e) {
      e.printStackTrace();
    }
    return null;
  }
コード例 #17
0
 void testA(Setter s1, Setter s2, SelfBoundSetter sbs) {
   s1.set(s2);
   // s1.set(sbs);  // Error:
   // set(Setter) in SelfBoundSetter<Setter>
   // cannot be applied to (SelfBoundSetter)
 }
コード例 #18
0
ファイル: Decoder.java プロジェクト: comus/lookingglass-ide
  public AbstractNode decode(
      org.w3c.dom.Element xmlElement, java.util.Map<Integer, AbstractDeclaration> map) {
    AbstractNode rv;
    if (xmlElement.hasAttribute(CodecConstants.TYPE_ATTRIBUTE)) {
      String clsName = getClassName(xmlElement);
      if (clsName.equals(JavaType.class.getName())) {
        rv = JavaType.getInstance(decodeType(xmlElement, "type"));
      } else if (clsName.equals(UserArrayType.class.getName())) {
        rv = decodeUserArrayType(xmlElement, map);
      } else if (clsName.equals(JavaConstructor.class.getName())) {
        rv = JavaConstructor.getInstance(decodeConstructor(xmlElement, "constructor"));
      } else if (clsName.equals(JavaMethod.class.getName())) {
        MethodReflectionProxy methodReflectionProxy = decodeMethod(xmlElement, "method");
        MethodReflectionProxy varArgsReplacement =
            MethodReflectionProxy.getReplacementIfNecessary(methodReflectionProxy);
        if (varArgsReplacement != null) {
          edu.cmu.cs.dennisc.java.util.logging.Logger.errln(
              "replacing", methodReflectionProxy, "with", varArgsReplacement);
          methodReflectionProxy = varArgsReplacement;
        }
        rv = JavaMethod.getInstance(methodReflectionProxy);
      } else if (clsName.equals(Getter.class.getName()) || clsName.equals(Setter.class.getName())) {

        org.w3c.dom.Node xmlFirstChild = xmlElement.getFirstChild();
        if (xmlFirstChild instanceof org.w3c.dom.Element) {
          org.w3c.dom.Element xmlFirstChildElement = (org.w3c.dom.Element) xmlFirstChild;
          if (xmlFirstChildElement.hasAttribute(CodecConstants.UNIQUE_KEY_ATTRIBUTE)) {
            int getterOrSetterUniqueKey = getUniqueKey(xmlElement);
            int fieldUniqueKey = getUniqueKey(xmlFirstChildElement);
            java.util.Map<Integer, Integer> mapToFieldKey;
            if (clsName.equals(Getter.class.getName())) {
              mapToFieldKey = EPIC_HACK_mapGetterKeyToFieldKey;
            } else {
              mapToFieldKey = EPIC_HACK_mapSetterKeyToFieldKey;
            }
            mapToFieldKey.put(getterOrSetterUniqueKey, fieldUniqueKey);
          }
        }

        org.w3c.dom.NodeList nodeList = xmlElement.getChildNodes();
        assert nodeList.getLength() == 1;
        org.w3c.dom.Element xmlField = (org.w3c.dom.Element) nodeList.item(0);
        UserField field = (UserField) decode(xmlField, map);
        if (clsName.equals(Getter.class.getName())) {
          rv = field.getGetter();
        } else {
          rv = field.getSetter();
        }
      } else if (clsName.equals(SetterParameter.class.getName())) {
        org.w3c.dom.NodeList nodeList = xmlElement.getChildNodes();
        assert nodeList.getLength() == 1;
        org.w3c.dom.Element xmlSetter = (org.w3c.dom.Element) nodeList.item(0);
        Setter setter = (Setter) decode(xmlSetter, map);
        rv = setter.getRequiredParameters().get(0);
      } else if (clsName.equals(JavaField.class.getName())) {
        rv = JavaField.getInstance(decodeField(xmlElement, "field"));
      } else if (clsName.equals(AnonymousUserConstructor.class.getName())) {
        rv = decodeAnonymousConstructor(xmlElement, map);
      } else if (clsName.equals(JavaConstructorParameter.class.getName())) {
        org.w3c.dom.NodeList nodeList = xmlElement.getChildNodes();
        assert nodeList.getLength() == 2;
        org.w3c.dom.Element xmlConstructor = (org.w3c.dom.Element) nodeList.item(0);
        JavaConstructor constructorDeclaredInJava =
            (JavaConstructor) decodeValue(xmlConstructor, map);
        org.w3c.dom.Element xmlIndex = (org.w3c.dom.Element) nodeList.item(1);
        int index = Integer.parseInt(xmlIndex.getTextContent());

        final int REQUIRED_N = constructorDeclaredInJava.getRequiredParameters().size();
        if (index < REQUIRED_N) {
          rv = constructorDeclaredInJava.getRequiredParameters().get(index);
        } else {
          if (index == REQUIRED_N) {
            rv = constructorDeclaredInJava.getVariableLengthParameter();
            if (rv != null) {
              // pass;
            } else {
              rv = constructorDeclaredInJava.getKeyedParameter();
            }
          } else {
            rv = null;
          }
        }
      } else if (clsName.equals(JavaMethodParameter.class.getName())) {
        org.w3c.dom.NodeList nodeList = xmlElement.getChildNodes();
        assert nodeList.getLength() == 2;
        org.w3c.dom.Element xmlMethod = (org.w3c.dom.Element) nodeList.item(0);
        JavaMethod methodDeclaredInJava = (JavaMethod) decodeValue(xmlMethod, map);
        org.w3c.dom.Element xmlIndex = (org.w3c.dom.Element) nodeList.item(1);
        int index = Integer.parseInt(xmlIndex.getTextContent());
        final int REQUIRED_N = methodDeclaredInJava.getRequiredParameters().size();
        if (index < REQUIRED_N) {
          rv = methodDeclaredInJava.getRequiredParameters().get(index);
        } else {
          if (index == REQUIRED_N) {
            rv = methodDeclaredInJava.getVariableLengthParameter();
            if (rv != null) {
              // pass;
            } else {
              rv = methodDeclaredInJava.getKeyedParameter();
            }
          } else {
            rv = null;
          }
        }
      } else {
        rv = (AbstractNode) newInstance(xmlElement);
        assert rv != null;
      }
      if (rv instanceof AbstractDeclaration) {
        map.put(getUniqueKey(xmlElement), (AbstractDeclaration) rv);
      }
      rv.decodeNode(this, xmlElement, map);
      if (xmlElement.hasAttribute(CodecConstants.ID_ATTRIBUTE)) {
        if (this.policy.isIdPreserved()) {
          rv.setId(java.util.UUID.fromString(xmlElement.getAttribute(CodecConstants.ID_ATTRIBUTE)));
        }
      }
    } else {
      int key = getUniqueKey(xmlElement);
      rv = map.get(key);
      if (rv != null) {
        // pass
      } else {
        if (EPIC_HACK_mapArrayTypeKeyToLeafTypeKey.containsKey(key)) {
          int leafTypeKey = EPIC_HACK_mapArrayTypeKeyToLeafTypeKey.get(key);
          AbstractDeclaration leafDeclaration = map.get(leafTypeKey);
          if (leafDeclaration instanceof UserType<?>) {
            UserType<?> leafType = (UserType<?>) leafDeclaration;
            edu.cmu.cs.dennisc.java.util.logging.Logger.outln(leafTypeKey, leafType);
            rv = leafType.getArrayType();
          } else {
            assert false : leafDeclaration;
          }
        } else if (EPIC_HACK_mapGetterKeyToFieldKey.containsKey(key)) {
          int fieldKey = EPIC_HACK_mapGetterKeyToFieldKey.get(key);
          AbstractDeclaration fieldDeclaration = map.get(fieldKey);
          if (fieldDeclaration instanceof UserField) {
            UserField userField = (UserField) fieldDeclaration;
            rv = userField.getGetter();
          }
        } else if (EPIC_HACK_mapSetterKeyToFieldKey.containsKey(key)) {
          int fieldKey = EPIC_HACK_mapSetterKeyToFieldKey.get(key);
          AbstractDeclaration fieldDeclaration = map.get(fieldKey);
          if (fieldDeclaration instanceof UserField) {
            UserField userField = (UserField) fieldDeclaration;
            rv = userField.getSetter();
          }
        } else {
          assert false : Integer.toHexString(key) + " " + map;
        }
      }
    }
    return rv;
  }