Convert complex representation containing "indexNames" and "values"
496336
private TabularData convertTabularDataFromFullRepresentation(JSONObject pValue, TabularType pType) {
        JSONAware jsonVal;
        jsonVal = (JSONAware) pValue.get("values");
        if (!(jsonVal instanceof JSONArray)) {
            throw new IllegalArgumentException("Values for tabular data of type " +
                                               pType + " must given as JSON array, not " + jsonVal.getClass());
        }

        TabularDataSupport tabularData = new TabularDataSupport(pType);
        for (Object val : (JSONArray) jsonVal) {
            if (!(val instanceof JSONObject)) {
                throw new IllegalArgumentException("Tabular-Data values must be given as JSON objects, not " + val.getClass());
            }
            tabularData.put((CompositeData) getDispatcher().convertToObject(pType.getRowType(), val));
        }
        return tabularData;
    }
246385
def _index_list_of_values(d, k):
    """"""
    v = d[k]
    if isinstance(v, list):
        return v
    return [v]
613480
def ColumnToIndex (col):
        """"""
        ndx = 0
        for c in col:
                ndx = ndx * 26 + ord(c.upper()) - 64
        return ndx
338017
def pivot(self, attrlist):
        
        if isinstance(attrlist, basestring):
            attrlist = attrlist.split()
        if all(a in self._indexes for a in attrlist):
            return PivotTable(self, [], attrlist)
        else:
            raise ValueError("pivot can only be called using indexed attributes")
1020005
function(indexes) {
      var isArray;
      isArray = Array.isArray(indexes);
      if (!isArray) {
        indexes = [indexes];
      }
      indexes.forEach(function(index, i) {
        var k, v;
        if (i === 0) {
          indexes = {};
        }
        [k, v] = index.split(' ');
        return indexes[k] = v;
      });
      if (isArray) {
        return indexes;
      } else {
        return indexes[0];
      }
    }
979618
def process_column(self, idx, value):
        ""
        if value is not None:
            value = str(value).decode(self.encoding)
        return value
557809
def convert_column(column, index)
      value = if converter_arity == 1
                @converter.call(column)
              else
                @converter.call(column, index)
              end
      value.to_sym
    end
622408
function transform(index, source) {

        var prefix = depsPoolName + "[" + index + "]",
            pattern = /(?:\/\*(?:[\s\S](?!\*\/))*?[\s\S]?\*\/\s*$)|(?:\/\/[^\n]*\s*$)/,
            lastIndex = -1,
            tailSource = null,
            tmpSource = null,
            match = null;

        source = source.replace(/\bdefine\s*\(\s*(?:("|')([\s\S]+?)\1\s*,\s*)?/g, prefix + "={\nvalue: ");

        tmpSource = source;
        while (pattern.test(tmpSource)) {
            tmpSource = tmpSource.replace(pattern, '');
        }

        lastIndex = tmpSource.lastIndexOf(')');

        tailSource = source.substring(lastIndex);

        source = source.substring(0, lastIndex);

        return source + tailSource.replace(/\)\s*;?/, '};');

    }
340962
protected void convertToColumnMajor(ZMatrixRMaj A) {
        for( int x = 0; x < numCols; x++ ) {
            double colQ[] = dataQR[x];
            int indexCol = 0;
            for( int y = 0; y < numRows; y++ ) {
                int index = (y*numCols+x)*2;
                colQ[indexCol++] = A.data[index];
                colQ[indexCol++] = A.data[index+1];
            }
        }
    }
142305
def convert(obj, ids, attr_type, item_func, cdata, parent='root'):
    """"""
    
    LOG.info('Inside convert(). obj type is: "%s", obj="%s"' % (type(obj).__name__, unicode_me(obj)))
    
    item_name = item_func(parent)
    
    if isinstance(obj, numbers.Number) or type(obj) in (str, unicode):
        return convert_kv(item_name, obj, attr_type, cdata)
        
    if hasattr(obj, 'isoformat'):
        return convert_kv(item_name, obj.isoformat(), attr_type, cdata)
        
    if type(obj) == bool:
        return convert_bool(item_name, obj, attr_type, cdata)
        
    if obj is None:
        return convert_none(item_name, '', attr_type, cdata)
        
    if isinstance(obj, dict):
        return convert_dict(obj, ids, parent, attr_type, item_func, cdata)
        
    if isinstance(obj, collections.Iterable):
        return convert_list(obj, ids, parent, attr_type, item_func, cdata)
        
    raise TypeError('Unsupported data type: %s (%s)' % (obj, type(obj).__name__))
1101616
private static String toColumnName(String fieldName) {
        int lastDot = fieldName.indexOf('.');
        if (lastDot > -1) {
            return fieldName.substring(lastDot + 1);
        } else {
            return fieldName;
        }
    }
164316
def _nice_fieldnames(all_columns, index_columns):
    ""
    non_index_columns = set(all_columns).difference(index_columns)
    return index_columns + sorted(non_index_columns)
938586
def _rows_from_json(values, schema):
    """"""
    from google.cloud.bigquery import Row

    field_to_index = _field_to_index_mapping(schema)
    return [Row(_row_tuple_from_json(r, schema), field_to_index) for r in values]
714157
def columnNameAt( self, index ):
        
        columns = self.columns()
        if ( 0 <= index and index < len(columns) ):
            return columns[index]
        return ''
962944
def to_representation(self, value):
        
        return {
            six.text_type(key): self.child.to_representation(val)
            for key, val in value.items()
        }
340109
def __toString(self, values):
		
		for key in values:
			if not values[key] is str:
				values[key] = str(values[key])
		return values
85414
def multi_index_to_frame(index):
    
    return pandas.DataFrame(index.tolist(), index=index, columns=index.names)