// CreateColumnFamily create a new column family.
979002
func (db *DB) CreateColumnFamily(opts *Options, name string) (*ColumnFamilyHandle, error) {
	var (
		cErr  *C.char
		cName = C.CString(name)
	)
	defer C.free(unsafe.Pointer(cName))
	cHandle := C.rocksdb_create_column_family(db.c, opts.c, cName, &cErr)
	if cErr != nil {
		defer C.free(unsafe.Pointer(cErr))
		return nil, errors.New(C.GoString(cErr))
	}
	return NewNativeColumnFamilyHandle(cHandle), nil
}
31316
func (c *FakeFischers) Create(fischer *v1alpha1.Fischer) (result *v1alpha1.Fischer, err error) {
	obj, err := c.Fake.
		Invokes(testing.NewRootCreateAction(fischersResource, fischer), &v1alpha1.Fischer{})
	if obj == nil {
		return nil, err
	}
	return obj.(*v1alpha1.Fischer), err
}
693979
func (c ColumnElem) Create(d Dialect) (string, error) {
	ct, err := c.typ.Create(d)
	if err != nil {
		return "", err
	}
	return fmt.Sprintf(`"%s" %s`, c.Name(), ct), nil
}
173777
func createFromInt(data [][]int) []*TabulateRow {
	rows := make([]*TabulateRow, len(data))
	for index_1, arr := range data {
		row := make([]string, len(arr))
		for index, el := range arr {
			row[index] = strconv.Itoa(el)
		}
		rows[index_1] = &TabulateRow{Elements: row}
	}
	return rows
}
632150
func (o *PostIPAMParams) validateFamily(formats strfmt.Registry) error {

	if err := validate.Enum("family", "query", *o.Family, []interface{}{"ipv4", "ipv6"}); err != nil {
		return err
	}

	return nil
}
414953
public static ColumnFamilyDescriptor buildColumnFamilyDescriptor(ColumnFamilyOptions cfOptions,
            String cfName) {
        return cfOptions != null
                ? new ColumnFamilyDescriptor(cfName.getBytes(StandardCharsets.UTF_8), cfOptions)
                : new ColumnFamilyDescriptor(cfName.getBytes(StandardCharsets.UTF_8));
    }
1322976
func (s *ListTaskDefinitionFamiliesOutput) SetFamilies(v []*string) *ListTaskDefinitionFamiliesOutput {
	s.Families = v
	return s
}
816949
func (s *UpdateVirtualInterfaceAttributesOutput) SetAddressFamily(v string) *UpdateVirtualInterfaceAttributesOutput {
	s.AddressFamily = &v
	return s
}
751683
func (a *Driver) CreateFromTemplate(id, template string, templateIDMappings *idtools.IDMappings, parent string, parentIDMappings *idtools.IDMappings, opts *graphdriver.CreateOpts, readWrite bool) error {
	return graphdriver.NaiveCreateFromTemplate(a, id, template, templateIDMappings, parent, parentIDMappings, opts, readWrite)
}
715145
public CreateTableRequest addFamily(String familyId) {
    Preconditions.checkNotNull(familyId);
    tableRequest.putColumnFamilies(familyId, ColumnFamily.getDefaultInstance());
    return this;
  }
982376
func (t *Type) createTypeFromPropProperty(name string, apiDef *APIDefinition) {
	p := t.Properties[name]
	// only process map[interface]interface{}
	propMap, ok := p.(map[interface{}]interface{})
	if !ok {
		return
	}

	// only process if it has 'properties' field
	propsIf, ok := propMap["properties"]
	if !ok {
		return
	}

	// check validity of the properties
	props, ok := propsIf.(map[interface{}]interface{})
	if !ok {
		panic("inline properties expect properties in type:map[string]interface{}")
	}

	newName := t.Name + name
	created := apiDef.createType(newName, propMap["type"], props)

	propMap["type"] = newName

	// delete the 'properties' field
	delete(propMap, "properties")

	t.Properties[name] = propMap

	// post process the created type
	if created {
		createdType := apiDef.Types[newName]
		createdType.postProcess(newName, apiDef)
	}

}
112924
func (s *CreateClusterParameterGroupInput) SetParameterGroupFamily(v string) *CreateClusterParameterGroupInput {
	s.ParameterGroupFamily = &v
	return s
}
847458
func (s *OrganizationsStore) CreateDefault(ctx context.Context) error {
	o := chronograf.Organization{
		ID:          string(DefaultOrganizationID),
		Name:        DefaultOrganizationName,
		DefaultRole: DefaultOrganizationRole,
	}

	m := chronograf.Mapping{
		ID:                   string(DefaultOrganizationID),
		Organization:         string(DefaultOrganizationID),
		Provider:             chronograf.MappingWildcard,
		Scheme:               chronograf.MappingWildcard,
		ProviderOrganization: chronograf.MappingWildcard,
	}
	return s.client.db.Update(func(tx *bolt.Tx) error {
		b := tx.Bucket(OrganizationsBucket)
		v := b.Get(DefaultOrganizationID)
		if v != nil {
			return nil
		}
		if v, err := internal.MarshalOrganization(&o); err != nil {
			return err
		} else if err := b.Put(DefaultOrganizationID, v); err != nil {
			return err
		}

		b = tx.Bucket(MappingsBucket)
		v = b.Get(DefaultOrganizationID)
		if v != nil {
			return nil
		}
		if v, err := internal.MarshalMapping(&m); err != nil {
			return err
		} else if err := b.Put(DefaultOrganizationID, v); err != nil {
			return err
		}

		return nil
	})
}
1155564
func (s *ResultSetMetadata) SetColumnMetadata(v []*ColumnMetadata) *ResultSetMetadata {
	s.ColumnMetadata = v
	return s
}
911198
func Family(name string) (int, error) {
	s, err := newSocket()
	if err != nil {
		return -1, err
	}
	defer s.free()

	if errno := C.genl_connect(s.nls); errno != 0 {
		return -1, &Error{errno, "failed to connect to netlink"}
	}
	defer C.nl_close((*C.struct_nl_sock)(s.nls))

	cn := C.CString(name)
	defer C.free(unsafe.Pointer(cn))
	family := C.genl_ctrl_resolve(s.nls, cn)
	if family < 0 {
		return -1, errors.New("failed to resolve family name")
	}
	return int(family), nil
}
1247026
func (s *NewTransitVirtualInterface) SetAddressFamily(v string) *NewTransitVirtualInterface {
	s.AddressFamily = &v
	return s
}
1327109
func (s *CreateDBClusterParameterGroupInput) SetDBParameterGroupFamily(v string) *CreateDBClusterParameterGroupInput {
	s.DBParameterGroupFamily = &v
	return s
}