Get the conversion Map.
164565
public String[][] getPopupMap()
    {
        String string[][] = {
            {DBParams.MENU, "menu"},
            {DBParams.SCREEN, "screen"},
            {DBParams.RECORD, "record"},
            {DBParams.LINK, "link"},
            {MenuConstants.GRID, "grid"},
            {MenuConstants.FORM, "form"},
            {MenuConstants.MENUREC, "menu record"},
            {DBParams.XML, "xml"},
            {DBParams.MAIL, "mail"},
            {DBParams.APPLET, "applet"},
        };
        return string;
    }
720045
public Map<K, V> getMutableMap() {
        if (mode != StorageMode.MAP) {
            if (mode == StorageMode.LIST) {
                mapData = convertListToMap(listData);
            }
            listData = null;
            mode = StorageMode.MAP;
        }
        return mapData;
    }
120348
function mapFrom2To3() {
		if (!isset($this->{__METHOD__})) {
			$this->{__METHOD__} = array_flip($this->mapFrom3To2());
		}
		return $this->{__METHOD__};
	}
278015
protected function prepareTypeConverterMap()
    {
        $typeConverterMap = [];
        $typeConverterClassNames = static::getTypeConverterImplementationClassNames($this->objectManager);
        foreach ($typeConverterClassNames as $typeConverterClassName) {
            /** @var TypeConverterInterface $typeConverter */
            $typeConverter = $this->objectManager->get($typeConverterClassName);
            foreach ($typeConverter->getSupportedSourceTypes() as $supportedSourceType) {
                $normalizedSourceType = TypeHandling::normalizeType($supportedSourceType);
                $normalizedTargetType = TypeHandling::normalizeType($typeConverter->getSupportedTargetType());
                if (isset($typeConverterMap[$normalizedSourceType][$normalizedTargetType][$typeConverter->getPriority()])) {
                    throw new Exception\DuplicateTypeConverterException('There exist at least two converters which handle the conversion from "' . $supportedSourceType . '" to "' . $normalizedTargetType . '" with priority "' . $typeConverter->getPriority() . '": ' . $typeConverterMap[$supportedSourceType][$normalizedTargetType][$typeConverter->getPriority()] . ' and ' . get_class($typeConverter), 1297951378);
                }
                $typeConverterMap[$normalizedSourceType][$normalizedTargetType][$typeConverter->getPriority()] = $typeConverterClassName;
            }
        }

        return $typeConverterMap;
    }
679369
public List<ConversionMethod> getConversionMethods (Class<?> clazz){
		List<ConversionMethod> conversions = new ArrayList<ConversionMethod>();
		Map<String, List<ConversionMethod>> conversionsMap = this.conversionsLoad();
		for (Class<?> classToCheck : getAllsuperClasses(clazz)){
			List<ConversionMethod> methods = conversionsMap.get(classToCheck.getName());
			if(methods != null)conversions.addAll(methods);
		}
		return conversions;
	}
141359
@java.lang.Deprecated
  public java.util.Map<java.lang.String, java.lang.Long> getValues() {
    return getValuesMap();
  }
320693
public function get_supported_conversions() {
        $classname = self::get_classname($this->name);
        if (class_exists($classname)) {
            $object = new $classname();
            return $object->get_supported_conversions();
        }
        return '';
    }
1113932
private static String convertMap(String ref, TypeDef source, TypeDef target) {
        Method ctor = BuilderUtils.findBuildableConstructor(target);
        String arguments = ctor.getArguments().stream()
                .map(p -> readMapValue(ref, source, p))
                .collect(joining(",\n","\n", ""));

        StringBuilder sb = new StringBuilder();
        sb.append("new ").append(target.getFullyQualifiedName()).append("(").append(arguments).append(")");
        return sb.toString();
    }
626795
def selected_mapping(self):
        
        value_map = {}
        tree_clone = self.treeClasses.invisibleRootItem().clone()
        for tree_branch in tree_clone.takeChildren():
            value_list = []
            for tree_leaf in tree_branch.takeChildren():
                value_list += [tree_leaf.data(0, Qt.UserRole)]
            if value_list:
                value_map[tree_branch.data(0, Qt.UserRole)] = value_list
        return value_map
205977
public AffineTransform getTransform() {
        if (FloatingPointUtil.equals(this.rotation, 0.0)) {
            return null;
        }

        final Dimension rotatedMapSize = getRotatedMapSize();

        final AffineTransform transform = AffineTransform.getTranslateInstance(0.0, 0.0);
        // move to the center of the original map rectangle (this is the actual
        // size of the graphic)
        transform.translate(this.mapSize.width / 2, this.mapSize.height / 2);

        // then rotate around this center
        transform.rotate(this.rotation);

        // then move to an artificial origin (0,0) which might be outside of the actual
        // painting area. this origin still keeps the center of the original map area
        // at the center of the rotated map area.
        transform.translate(-rotatedMapSize.width / 2, -rotatedMapSize.height / 2);

        return transform;
    }
500676
public List<Convert<ElementCollection<T>>> getAllMapKeyConvert()
   {
      List<Convert<ElementCollection<T>>> list = new ArrayList<Convert<ElementCollection<T>>>();
      List<Node> nodeList = childNode.get("map-key-convert");
      for(Node node: nodeList)
      {
         Convert<ElementCollection<T>>  type = new ConvertImpl<ElementCollection<T>>(this, "map-key-convert", childNode, node);
         list.add(type);
      }
      return list;
   }
877653
def get_modifier_mapping(self):
        """"""
        r = request.GetModifierMapping(display = self.display)
        return r.keycodes
363074
public Map<T, Integer> getMap() {
    return Maps.transformEntries(this.map,
      new EntryTransformer<T, AtomicInteger, Integer>() {
        @Override
        public Integer transformEntry(final T key, final AtomicInteger value) {
          return value.get();
        }
      });
  }
1332389
public String mapTo(Vendor vendor)
    {
        String[] m = getMapping(vendor);
        return m == null ? null : m[VENDOR_MAP_RAW];
    }
777117
def from_maps(*maps):
        
        result = AnyValueMap()
        
        if maps == None or len(maps) == 0:
            return result

        for map in maps:
            for (key, value) in map.items():
                key = StringConverter.to_string(key)
                result.put(key, value)

        return result
1112594
private void convertPropertiesMap(CompilerOptions options) {
    @SuppressWarnings("unchecked")
    Map<String, Object> props = getProject().getProperties();
    for (Map.Entry<String, Object> entry : props.entrySet()) {
      String key = entry.getKey();
      Object value = entry.getValue();

      if (key.startsWith(replacePropertiesPrefix)) {
        key = key.substring(replacePropertiesPrefix.length());

        if (!setDefine(options, key, value)) {
          log("Unexpected property value for key=" + key + "; value=" + value);
        }
      }
    }
  }
869631
def get_mapping(self):  # TODO: rename to _as_dict
        
        return {
            key: val
            for key, val in self.__dict__.iteritems()
            if val
        }