Table Map (Getter/Setter/Default)
559715
def table_map_set(map, filter=false)
      # To remove table map we can not use 'no table-map'
      # Dummy-map specified to work around this
      if filter
        attr = 'table_map_filter'
      else
        attr = 'table_map'
      end
      dummy_map = 'dummy'
      if map == default_table_map
        @set_args[:state] = 'no'
        @set_args[:map] = dummy_map
      else
        @set_args[:state] = ''
        @set_args[:map] = map
      end
      config_set('bgp_af', attr, @set_args)
      set_args_keys_default
    end
1281368
public Map<String, List<Item>> getTableItems() {
        Map<String, List<Map<String, AttributeValue>>> res = 
            result.getResponses();
        Map<String, List<Item>> map = new LinkedHashMap<String, List<Item>>(res.size());
        for (Map.Entry<String, List<Map<String, AttributeValue>>> e 
                : res.entrySet()) {
            String tableName = e.getKey();
            List<Map<String, AttributeValue>> items = e.getValue();
            map.put(tableName, InternalUtils.toItemList(items));
        }
        return map;
    }
189533
function buildRowMapping(mapping, columns, yOffset) {
  for (let i = 0; i < columns.length; i++) {
    const {icon, xOffset} = columns[i];
    const id = getIconId(icon);
    mapping[id] = Object.assign({}, icon, {
      x: xOffset,
      y: yOffset
    });
  }
}
1164432
public Map<String, Object> asJson() {
        return ImmutableMap.<String, Object>of(
                Intrinsic.TABLE, _table,
                Intrinsic.ID, _id);
    }
741172
public void initPropertyMap() {
        propertyMap = new HashMap<String, EntityColumn>(getEntityClassColumns().size());
        for (EntityColumn column : getEntityClassColumns()) {
            propertyMap.put(column.getProperty(), column);
        }
    }
364447
@Override
    public Object map(Object input) {
        Number n = (Number) input;
        if (inputSchema.getMetaData(columnNumber).isValid(new IntWritable(n.intValue()))) {
            return input;
        } else {
            return value;
        }
    }
464144
function tableFromMethods(methodsArr) {
  const headers = ["Method Name", "Type", "Parameters", "Description"]
  let rows = []

  // construct rows of table array of methods
  methodsArr.forEach((method) => {
    let cols = []

    cols.push(method["name"]) // method name
    let paramList = ''
    method["params"].forEach((param) => {
      paramList += `${param["name"]}: ${param["type"]["name"]} - ${param["description"]}\n`
    })
    cols.push(paramList) // list of method parameters
    cols.push(`${method["description"]}`) // description of the method

    rows.push(cols);
  })
  
  return rows.length > 0 ? {table: {headers, rows}} : null
}
484207
public static function buildTableMap()
    {
        $dbMap = Propel::getServiceContainer()->getDatabaseMap(UserTableMap::DATABASE_NAME);
        if (!$dbMap->hasTable(UserTableMap::TABLE_NAME)) {
            $dbMap->addTableObject(new UserTableMap());
        }
    }
1060250
public static function buildTableMap()
    {
      $dbMap = Propel::getServiceContainer()->getDatabaseMap(FeatureTypeAvMetaTableMap::DATABASE_NAME);
      if (!$dbMap->hasTable(FeatureTypeAvMetaTableMap::TABLE_NAME)) {
        $dbMap->addTableObject(new FeatureTypeAvMetaTableMap());
      }
    }
947586
private static function table()
    {
        if (!isset(self::$tableMap[static::class])) {
            if (isset(static::$table)) {
                self::$tableMap[static::class] = static::$table;
            } else {
                self::$tableMap[static::class] = strtolower((new \ReflectionClass(static::class))->getShortName());
            }
        }
        return self::$tableMap[static::class];
    }
994617
private Map<String, Class<?>> createPropertyMap(Class<?> clz) throws Exception
   {
      Map<String, Class<?>> result = new HashMap<>();

      for (Method m : clz.getMethods())
      {
         if (m.getName().startsWith("set"))
         {
            if (m.getReturnType().equals(Void.TYPE) &&
                m.getParameterCount() == 1 &&
                isSupported(m.getParameterTypes()[0]))
               result.put(m.getName().substring(3), m.getParameterTypes()[0]);
         }
      }
      
      return result;
   }
640888
@NonNull
    @Override
    public Map<String, Object> toMap() {
        final List<Object> values = toList();
        final Map<String, Object> dict = new HashMap<>();
        for (String name : rs.getColumnNames().keySet()) {
            final int index = indexForColumnName(name);
            if (index >= 0) { dict.put(name, values.get(index)); }
        }
        return dict;
    }
550474
public static function buildTableMap()
    {
        $dbMap = Propel::getServiceContainer()->getDatabaseMap(UserRoleTableMap::DATABASE_NAME);
        if (!$dbMap->hasTable(UserRoleTableMap::TABLE_NAME)) {
            $dbMap->addTableObject(new UserRoleTableMap());
        }
    }
1316070
public static function buildTableMap()
    {
      $dbMap = Propel::getDatabaseMap(BaseUserPeer::DATABASE_NAME);
      if (!$dbMap->hasTable(BaseUserPeer::TABLE_NAME)) {
        $dbMap->addTableObject(new \Slashworks\BackendBundle\Model\map\UserTableMap());
      }
    }
31047
Map<Object, Object> getFilters() {

        Map<Object, Object> result = new HashMap<Object, Object>(4);
        result.put(TableProperty.KEY, m_table.getFilterFieldValue(TableProperty.KEY));
        result.put(TableProperty.DEFAULT, m_table.getFilterFieldValue(TableProperty.DEFAULT));
        result.put(TableProperty.DESCRIPTION, m_table.getFilterFieldValue(TableProperty.DESCRIPTION));
        result.put(TableProperty.TRANSLATION, m_table.getFilterFieldValue(TableProperty.TRANSLATION));
        return result;
    }
811693
public static function buildTableMap()
    {
      $dbMap = Propel::getServiceContainer()->getDatabaseMap(PersonI18nTableMap::DATABASE_NAME);
      if (!$dbMap->hasTable(PersonI18nTableMap::TABLE_NAME)) {
        $dbMap->addTableObject(new PersonI18nTableMap());
      }
    }
129956
def get(self, key, default=None):
        """"""
        if key not in self.table:
            return default

        return self[key]