Creates a lbaas_member.
543873
def create_lbaas_member(self, lbaas_pool, body=None):
        """"""
        return self.post(self.lbaas_members_path % lbaas_pool, body=body)
1312765
private void createImpl()
  {
    _systemSegment = allocateSegment(new byte[32], 1);
    
    _segmentList.add(_systemSegment);
    
    TempBuffer tBuf = TempBuffer.createLarge();
    byte []buffer = tBuf.buffer();
    
    Arrays.fill(buffer, (byte) 0);
    
    int offset = 0;
    
    BitsUtil.writeLong(buffer, offset, JOURNAL_MAGIC);
    offset += 8;
    
    BitsUtil.writeLong(buffer, offset, _segmentSize);
    offset += 8;
    
    BitsUtil.writeLong(buffer, offset, _tailAddress);
    offset += 8;
    
    BitsUtil.writeInt(buffer, offset, KEY_LENGTH);
    offset += 4;
    
    try (OutStore os = _store.openWrite(0, buffer.length)) {
      os.write(0, buffer, 0, buffer.length);
    }
    
    tBuf.free();
  }
1291826
@Override
  public MtasSpanWeight createWeight(IndexSearcher searcher,
      boolean needsScores, float boost) throws IOException {
    SpanWeight spanWeight = ((SpanQuery) searcher.rewrite(clause))
        .createWeight(searcher, needsScores, boost);
    return new SpanTermWeight(spanWeight, searcher, boost);
  }
1088619
@Override
  public MtasSpanWeight createWeight(IndexSearcher searcher,
      boolean needsScores, float boost) throws IOException {
    SpanWeight subWeight = query.createWeight(searcher, false, boost);
    SpanWeight ignoreWeight = null;
    if (ignoreQuery != null) {
      ignoreWeight = ignoreQuery.createWeight(searcher, false, boost);
    }
    return new SpanRecurrenceWeight(subWeight, ignoreWeight,
        maximumIgnoreLength, searcher,
        needsScores ? getTermContexts(subWeight) : null, boost);
  }
64062
def add_pool_member(lb, name, port, pool_name):
    '''
    
    '''
    if __opts__['load_balancers'].get(lb, None):
        (username, password) = list(__opts__['load_balancers'][lb].values())
    else:
        raise Exception('Unable to find `{0}` load balancer'.format(lb))
    F5 = F5Mgmt(lb, username, password)
    F5.add_pool_member(name, port, pool_name)
    return True
291425
def create_pool(self, name, method='ROUND_ROBIN'):
        '''
        
        '''
        lbmethods = self.bigIP.LocalLB.Pool.typefactory.create(
            'LocalLB.LBMethod'
        )

        supported_method = [i[0] for i in lbmethods if (
            i[0].split('_', 2)[-1] == method.upper()
        )]

        if supported_method and not self.check_pool(name):
            try:
                self.bigIP.LocalLB.Pool.create(pool_names=[name],
                                               lb_methods=[supported_method],
                                               members=[[]])
            except Exception as e:
                raise Exception(
                    'Unable to create `{0}` pool\n\n{1}'.format(name, e)
                )
        else:
            raise Exception('Unsupported method')
        return True
203679
def create_lxc(name, template='ubuntu', service=None):
    """"""
    service = service or LXCService
    service.create(name, template=template)
    meta = LXCMeta(initial=dict(type='LXC'))
    lxc = LXC.with_meta(name, service, meta, save=True)
    return lxc
1311256
def create(self, fname, lname, group, type, group_api):
        """"""
        self.__username(fname, lname)
        self.client.add(
            self.__distinguished_name(type, fname=fname, lname=lname),
            API.__object_class(),
            self.__ldap_attr(fname, lname, type, group, group_api))
1270955
private void createPersistentSubsets(TransactionCommon tran) throws SIResourceException
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.entry(this, tc, "createPersistentSubsets", tran);
          
    for(int i=0; i<subsets.length; i++)
    {
      createPersistentSubset(getReliability(i),tran);
    }
    
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.exit(tc, "createPersistentSubsets");
  }
814278
@Override
  public MtasSpanWeight createWeight(IndexSearcher searcher,
      boolean needsScores, float boost) throws IOException {
    SpanWeight subWeight = clause.createWeight(searcher, false, boost);
    return new SpanUniquePositionWeight(subWeight, searcher,
        needsScores ? getTermContexts(subWeight) : null, boost);
  }
226357
def create_pool(lb, name, method='ROUND_ROBIN'):
    '''
    
    '''
    if __opts__['load_balancers'].get(lb, None):
        (username, password) = list(__opts__['load_balancers'][lb].values())
    else:
        raise Exception('Unable to find `{0}` load balancer'.format(lb))
    F5 = F5Mgmt(lb, username, password)
    F5.create_pool(name, method)
    return True
1099023
@Override
  public MtasSpanWeight createWeight(IndexSearcher searcher,
      boolean needsScores, float boost) throws IOException {
    List<MtasSpanSequenceQueryWeight> subWeights = new ArrayList<>();
    SpanWeight ignoreWeight = null;
    for (MtasSpanSequenceItem item : items) {
      subWeights.add(new MtasSpanSequenceQueryWeight(
          item.getQuery().createWeight(searcher, false, boost), item.isOptional()));
    }
    if (ignoreQuery != null) {
      ignoreWeight = ignoreQuery.createWeight(searcher, false, boost);
    }
    return new SpanSequenceWeight(subWeights, ignoreWeight, maximumIgnoreLength,
        searcher, needsScores ? getTermContexts(subWeights) : null, boost);
  }
1112381
private void initNewListBasic() {
    newAdvancedValueSumList = operations.createVector1(newSize);
    newAdvancedValueSumOfLogsList = operations.createVector2(newSize);
    newAdvancedValueSumOfSquaresList = operations.createVector1(newSize);
    newAdvancedValueMinList = operations.createVector1(newSize);
    newAdvancedValueMaxList = operations.createVector1(newSize);
    newAdvancedValueNList = new long[newSize];
  }
314295
@XmlElementDecl(namespace = "http://www.opengis.net/gml", name = "member")
    public JAXBElement<AssociationType> createMember(AssociationType value) {
        return new JAXBElement<AssociationType>(_Member_QNAME, AssociationType.class, null, value);
    }
44584
private void createMembership(Session session, MembershipImpl membership, boolean broadcast)
      throws InvalidNameException, Exception
   {
      Node userNode;
      try
      {
         userNode = utils.getUserNode(session, membership.getUserName());
      }
      catch (PathNotFoundException e)
      {
         throw new InvalidNameException("The user " + membership.getUserName() + " does not exist");
      }

      Node groupNode;
      try
      {
         groupNode = utils.getGroupNode(session, membership.getGroupId());
      }
      catch (PathNotFoundException e)
      {
         throw new InvalidNameException("The group " + membership.getGroupId() + " does not exist");
      }

      Node typeNode;
      String membershipType =
         membership.getMembershipType().equals(MembershipTypeHandler.ANY_MEMBERSHIP_TYPE)
            ? JCROrganizationServiceImpl.JOS_MEMBERSHIP_TYPE_ANY : membership.getMembershipType();
      try
      {
         typeNode = utils.getMembershipTypeNode(session, membershipType);
      }
      catch (PathNotFoundException e)
      {
         throw new InvalidNameException("The membership type " + membership.getMembershipType() + " does not exist");
      }

      Node membershipStorageNode = groupNode.getNode(JCROrganizationServiceImpl.JOS_MEMBERSHIP);

      Node refUserNode;
      try
      {
         refUserNode = membershipStorageNode.addNode(membership.getUserName());
         refUserNode.setProperty(MembershipProperties.JOS_USER, userNode);
      }
      catch (ItemExistsException e)
      {
         refUserNode = membershipStorageNode.getNode(membership.getUserName());
      }

      Node refTypeNode;
      try
      {
         refTypeNode = refUserNode.addNode(membershipType);
         refTypeNode.setProperty(MembershipProperties.JOS_MEMBERSHIP_TYPE, typeNode);
      }
      catch (ItemExistsException e)
      {
         // the membership already exists
         return;
      }

      String id = utils.composeMembershipId(groupNode, refUserNode, refTypeNode);
      membership.setId(id);

      if (broadcast)
      {
         preSave(membership, true);
      }

      session.save();
      putInCache(membership);

      if (broadcast)
      {
         postSave(membership, true);
      }
   }
775161
@Override
  public SpanWeight createWeight(IndexSearcher searcher, boolean needsScores, float boost)
      throws IOException {
    return baseQuery.createWeight(searcher, needsScores, boost);
  }
1164495
def create_relational(cls, name, inst):
        
        return Attribute(
            javabridge.make_instance(
                "weka/core/Attribute", "(Ljava/lang/String;Lweka/core/Instances;)V", name, inst.jobject))