public void deleteService(CFSecurityAuthorization Authorization, CFSecurityServiceBuff Buff) {
    final String S_ProcName = "CFBamRamServiceTable.deleteService() ";
    CFSecurityServicePKey pkey = schema.getFactoryService().newPKey();
    pkey.setRequiredClusterId(Buff.getRequiredClusterId());
    pkey.setRequiredServiceId(Buff.getRequiredServiceId());
    CFSecurityServiceBuff existing = dictByPKey.get(pkey);
    if (existing == null) {
      return;
    }
    if (existing.getRequiredRevision() != Buff.getRequiredRevision()) {
      throw CFLib.getDefaultExceptionFactory()
          .newCollisionDetectedException(getClass(), "deleteService", pkey);
    }
    CFSecurityServiceByClusterIdxKey keyClusterIdx = schema.getFactoryService().newClusterIdxKey();
    keyClusterIdx.setRequiredClusterId(existing.getRequiredClusterId());

    CFSecurityServiceByHostIdxKey keyHostIdx = schema.getFactoryService().newHostIdxKey();
    keyHostIdx.setRequiredClusterId(existing.getRequiredClusterId());
    keyHostIdx.setRequiredHostNodeId(existing.getRequiredHostNodeId());

    CFSecurityServiceByTypeIdxKey keyTypeIdx = schema.getFactoryService().newTypeIdxKey();
    keyTypeIdx.setRequiredServiceTypeId(existing.getRequiredServiceTypeId());

    CFSecurityServiceByUTypeIdxKey keyUTypeIdx = schema.getFactoryService().newUTypeIdxKey();
    keyUTypeIdx.setRequiredClusterId(existing.getRequiredClusterId());
    keyUTypeIdx.setRequiredHostNodeId(existing.getRequiredHostNodeId());
    keyUTypeIdx.setRequiredServiceTypeId(existing.getRequiredServiceTypeId());

    CFSecurityServiceByUHostPortIdxKey keyUHostPortIdx =
        schema.getFactoryService().newUHostPortIdxKey();
    keyUHostPortIdx.setRequiredClusterId(existing.getRequiredClusterId());
    keyUHostPortIdx.setRequiredHostNodeId(existing.getRequiredHostNodeId());
    keyUHostPortIdx.setRequiredHostPort(existing.getRequiredHostPort());

    // Validate reverse foreign keys

    // Delete is valid

    Map<CFSecurityServicePKey, CFSecurityServiceBuff> subdict;

    dictByPKey.remove(pkey);

    subdict = dictByClusterIdx.get(keyClusterIdx);
    subdict.remove(pkey);

    subdict = dictByHostIdx.get(keyHostIdx);
    subdict.remove(pkey);

    subdict = dictByTypeIdx.get(keyTypeIdx);
    subdict.remove(pkey);

    dictByUTypeIdx.remove(keyUTypeIdx);

    dictByUHostPortIdx.remove(keyUHostPortIdx);
  }
 public void deleteServiceByUHostPortIdx(
     CFSecurityAuthorization Authorization,
     long argClusterId,
     long argHostNodeId,
     short argHostPort) {
   CFSecurityServiceByUHostPortIdxKey key = schema.getFactoryService().newUHostPortIdxKey();
   key.setRequiredClusterId(argClusterId);
   key.setRequiredHostNodeId(argHostNodeId);
   key.setRequiredHostPort(argHostPort);
   deleteServiceByUHostPortIdx(Authorization, key);
 }
  public CFSecurityServiceBuff readDerivedByUHostPortIdx(
      CFSecurityAuthorization Authorization, long ClusterId, long HostNodeId, short HostPort) {
    final String S_ProcName = "CFBamRamService.readDerivedByUHostPortIdx";
    CFSecurityServiceByUHostPortIdxKey key = schema.getFactoryService().newUHostPortIdxKey();
    key.setRequiredClusterId(ClusterId);
    key.setRequiredHostNodeId(HostNodeId);
    key.setRequiredHostPort(HostPort);

    CFSecurityServiceBuff buff;
    if (dictByUHostPortIdx.containsKey(key)) {
      buff = dictByUHostPortIdx.get(key);
    } else {
      buff = null;
    }
    return (buff);
  }
 public void deleteServiceByUHostPortIdx(
     CFSecurityAuthorization Authorization, CFSecurityServiceByUHostPortIdxKey argKey) {
   CFSecurityServiceBuff cur;
   LinkedList<CFSecurityServiceBuff> matchSet = new LinkedList<CFSecurityServiceBuff>();
   Iterator<CFSecurityServiceBuff> values = dictByPKey.values().iterator();
   while (values.hasNext()) {
     cur = values.next();
     if (argKey.equals(cur)) {
       matchSet.add(cur);
     }
   }
   Iterator<CFSecurityServiceBuff> iterMatch = matchSet.iterator();
   while (iterMatch.hasNext()) {
     cur = iterMatch.next();
     deleteService(Authorization, cur);
   }
 }
  public void createService(CFSecurityAuthorization Authorization, CFSecurityServiceBuff Buff) {
    final String S_ProcName = "createService";
    CFSecurityServicePKey pkey = schema.getFactoryService().newPKey();
    pkey.setRequiredClusterId(Buff.getRequiredClusterId());
    pkey.setRequiredServiceId(
        ((CFBamRamClusterTable) schema.getTableCluster())
            .nextServiceIdGen(Authorization, Buff.getRequiredClusterId()));
    Buff.setRequiredClusterId(pkey.getRequiredClusterId());
    Buff.setRequiredServiceId(pkey.getRequiredServiceId());
    CFSecurityServiceByClusterIdxKey keyClusterIdx = schema.getFactoryService().newClusterIdxKey();
    keyClusterIdx.setRequiredClusterId(Buff.getRequiredClusterId());

    CFSecurityServiceByHostIdxKey keyHostIdx = schema.getFactoryService().newHostIdxKey();
    keyHostIdx.setRequiredClusterId(Buff.getRequiredClusterId());
    keyHostIdx.setRequiredHostNodeId(Buff.getRequiredHostNodeId());

    CFSecurityServiceByTypeIdxKey keyTypeIdx = schema.getFactoryService().newTypeIdxKey();
    keyTypeIdx.setRequiredServiceTypeId(Buff.getRequiredServiceTypeId());

    CFSecurityServiceByUTypeIdxKey keyUTypeIdx = schema.getFactoryService().newUTypeIdxKey();
    keyUTypeIdx.setRequiredClusterId(Buff.getRequiredClusterId());
    keyUTypeIdx.setRequiredHostNodeId(Buff.getRequiredHostNodeId());
    keyUTypeIdx.setRequiredServiceTypeId(Buff.getRequiredServiceTypeId());

    CFSecurityServiceByUHostPortIdxKey keyUHostPortIdx =
        schema.getFactoryService().newUHostPortIdxKey();
    keyUHostPortIdx.setRequiredClusterId(Buff.getRequiredClusterId());
    keyUHostPortIdx.setRequiredHostNodeId(Buff.getRequiredHostNodeId());
    keyUHostPortIdx.setRequiredHostPort(Buff.getRequiredHostPort());

    // Validate unique indexes

    if (dictByPKey.containsKey(pkey)) {
      throw CFLib.getDefaultExceptionFactory()
          .newPrimaryKeyNotNewException(getClass(), S_ProcName, pkey);
    }

    if (dictByUTypeIdx.containsKey(keyUTypeIdx)) {
      throw CFLib.getDefaultExceptionFactory()
          .newUniqueIndexViolationException(getClass(), S_ProcName, "ServiceUTypeIdx", keyUTypeIdx);
    }

    if (dictByUHostPortIdx.containsKey(keyUHostPortIdx)) {
      throw CFLib.getDefaultExceptionFactory()
          .newUniqueIndexViolationException(
              getClass(), S_ProcName, "ServiceUHostPort", keyUHostPortIdx);
    }

    // Validate foreign keys

    {
      boolean allNull = true;
      allNull = false;
      if (!allNull) {
        if (null
            == schema
                .getTableCluster()
                .readDerivedByIdIdx(Authorization, Buff.getRequiredClusterId())) {
          throw CFLib.getDefaultExceptionFactory()
              .newUnresolvedRelationException(
                  getClass(), S_ProcName, "Owner", "ServiceCluster", "Cluster", null);
        }
      }
    }

    // Proceed with adding the new record

    dictByPKey.put(pkey, Buff);

    Map<CFSecurityServicePKey, CFSecurityServiceBuff> subdictClusterIdx;
    if (dictByClusterIdx.containsKey(keyClusterIdx)) {
      subdictClusterIdx = dictByClusterIdx.get(keyClusterIdx);
    } else {
      subdictClusterIdx = new HashMap<CFSecurityServicePKey, CFSecurityServiceBuff>();
      dictByClusterIdx.put(keyClusterIdx, subdictClusterIdx);
    }
    subdictClusterIdx.put(pkey, Buff);

    Map<CFSecurityServicePKey, CFSecurityServiceBuff> subdictHostIdx;
    if (dictByHostIdx.containsKey(keyHostIdx)) {
      subdictHostIdx = dictByHostIdx.get(keyHostIdx);
    } else {
      subdictHostIdx = new HashMap<CFSecurityServicePKey, CFSecurityServiceBuff>();
      dictByHostIdx.put(keyHostIdx, subdictHostIdx);
    }
    subdictHostIdx.put(pkey, Buff);

    Map<CFSecurityServicePKey, CFSecurityServiceBuff> subdictTypeIdx;
    if (dictByTypeIdx.containsKey(keyTypeIdx)) {
      subdictTypeIdx = dictByTypeIdx.get(keyTypeIdx);
    } else {
      subdictTypeIdx = new HashMap<CFSecurityServicePKey, CFSecurityServiceBuff>();
      dictByTypeIdx.put(keyTypeIdx, subdictTypeIdx);
    }
    subdictTypeIdx.put(pkey, Buff);

    dictByUTypeIdx.put(keyUTypeIdx, Buff);

    dictByUHostPortIdx.put(keyUHostPortIdx, Buff);
  }
  public void updateService(CFSecurityAuthorization Authorization, CFSecurityServiceBuff Buff) {
    CFSecurityServicePKey pkey = schema.getFactoryService().newPKey();
    pkey.setRequiredClusterId(Buff.getRequiredClusterId());
    pkey.setRequiredServiceId(Buff.getRequiredServiceId());
    CFSecurityServiceBuff existing = dictByPKey.get(pkey);
    if (existing == null) {
      throw CFLib.getDefaultExceptionFactory()
          .newStaleCacheDetectedException(
              getClass(), "updateService", "Existing record not found", "Service", pkey);
    }
    if (existing.getRequiredRevision() != Buff.getRequiredRevision()) {
      throw CFLib.getDefaultExceptionFactory()
          .newCollisionDetectedException(getClass(), "updateService", pkey);
    }
    Buff.setRequiredRevision(Buff.getRequiredRevision() + 1);
    CFSecurityServiceByClusterIdxKey existingKeyClusterIdx =
        schema.getFactoryService().newClusterIdxKey();
    existingKeyClusterIdx.setRequiredClusterId(existing.getRequiredClusterId());

    CFSecurityServiceByClusterIdxKey newKeyClusterIdx =
        schema.getFactoryService().newClusterIdxKey();
    newKeyClusterIdx.setRequiredClusterId(Buff.getRequiredClusterId());

    CFSecurityServiceByHostIdxKey existingKeyHostIdx = schema.getFactoryService().newHostIdxKey();
    existingKeyHostIdx.setRequiredClusterId(existing.getRequiredClusterId());
    existingKeyHostIdx.setRequiredHostNodeId(existing.getRequiredHostNodeId());

    CFSecurityServiceByHostIdxKey newKeyHostIdx = schema.getFactoryService().newHostIdxKey();
    newKeyHostIdx.setRequiredClusterId(Buff.getRequiredClusterId());
    newKeyHostIdx.setRequiredHostNodeId(Buff.getRequiredHostNodeId());

    CFSecurityServiceByTypeIdxKey existingKeyTypeIdx = schema.getFactoryService().newTypeIdxKey();
    existingKeyTypeIdx.setRequiredServiceTypeId(existing.getRequiredServiceTypeId());

    CFSecurityServiceByTypeIdxKey newKeyTypeIdx = schema.getFactoryService().newTypeIdxKey();
    newKeyTypeIdx.setRequiredServiceTypeId(Buff.getRequiredServiceTypeId());

    CFSecurityServiceByUTypeIdxKey existingKeyUTypeIdx =
        schema.getFactoryService().newUTypeIdxKey();
    existingKeyUTypeIdx.setRequiredClusterId(existing.getRequiredClusterId());
    existingKeyUTypeIdx.setRequiredHostNodeId(existing.getRequiredHostNodeId());
    existingKeyUTypeIdx.setRequiredServiceTypeId(existing.getRequiredServiceTypeId());

    CFSecurityServiceByUTypeIdxKey newKeyUTypeIdx = schema.getFactoryService().newUTypeIdxKey();
    newKeyUTypeIdx.setRequiredClusterId(Buff.getRequiredClusterId());
    newKeyUTypeIdx.setRequiredHostNodeId(Buff.getRequiredHostNodeId());
    newKeyUTypeIdx.setRequiredServiceTypeId(Buff.getRequiredServiceTypeId());

    CFSecurityServiceByUHostPortIdxKey existingKeyUHostPortIdx =
        schema.getFactoryService().newUHostPortIdxKey();
    existingKeyUHostPortIdx.setRequiredClusterId(existing.getRequiredClusterId());
    existingKeyUHostPortIdx.setRequiredHostNodeId(existing.getRequiredHostNodeId());
    existingKeyUHostPortIdx.setRequiredHostPort(existing.getRequiredHostPort());

    CFSecurityServiceByUHostPortIdxKey newKeyUHostPortIdx =
        schema.getFactoryService().newUHostPortIdxKey();
    newKeyUHostPortIdx.setRequiredClusterId(Buff.getRequiredClusterId());
    newKeyUHostPortIdx.setRequiredHostNodeId(Buff.getRequiredHostNodeId());
    newKeyUHostPortIdx.setRequiredHostPort(Buff.getRequiredHostPort());

    // Check unique indexes

    if (!existingKeyUTypeIdx.equals(newKeyUTypeIdx)) {
      if (dictByUTypeIdx.containsKey(newKeyUTypeIdx)) {
        throw CFLib.getDefaultExceptionFactory()
            .newUniqueIndexViolationException(
                getClass(), "updateService", "ServiceUTypeIdx", newKeyUTypeIdx);
      }
    }

    if (!existingKeyUHostPortIdx.equals(newKeyUHostPortIdx)) {
      if (dictByUHostPortIdx.containsKey(newKeyUHostPortIdx)) {
        throw CFLib.getDefaultExceptionFactory()
            .newUniqueIndexViolationException(
                getClass(), "updateService", "ServiceUHostPort", newKeyUHostPortIdx);
      }
    }

    // Validate foreign keys

    {
      boolean allNull = true;

      if (allNull) {
        if (null
            == schema
                .getTableCluster()
                .readDerivedByIdIdx(Authorization, Buff.getRequiredClusterId())) {
          throw CFLib.getDefaultExceptionFactory()
              .newUnresolvedRelationException(
                  getClass(), "updateService", "Owner", "ServiceCluster", "Cluster", null);
        }
      }
    }

    // Update is valid

    Map<CFSecurityServicePKey, CFSecurityServiceBuff> subdict;

    dictByPKey.remove(pkey);
    dictByPKey.put(pkey, Buff);

    subdict = dictByClusterIdx.get(existingKeyClusterIdx);
    if (subdict != null) {
      subdict.remove(pkey);
    }
    if (dictByClusterIdx.containsKey(newKeyClusterIdx)) {
      subdict = dictByClusterIdx.get(newKeyClusterIdx);
    } else {
      subdict = new HashMap<CFSecurityServicePKey, CFSecurityServiceBuff>();
      dictByClusterIdx.put(newKeyClusterIdx, subdict);
    }
    subdict.put(pkey, Buff);

    subdict = dictByHostIdx.get(existingKeyHostIdx);
    if (subdict != null) {
      subdict.remove(pkey);
    }
    if (dictByHostIdx.containsKey(newKeyHostIdx)) {
      subdict = dictByHostIdx.get(newKeyHostIdx);
    } else {
      subdict = new HashMap<CFSecurityServicePKey, CFSecurityServiceBuff>();
      dictByHostIdx.put(newKeyHostIdx, subdict);
    }
    subdict.put(pkey, Buff);

    subdict = dictByTypeIdx.get(existingKeyTypeIdx);
    if (subdict != null) {
      subdict.remove(pkey);
    }
    if (dictByTypeIdx.containsKey(newKeyTypeIdx)) {
      subdict = dictByTypeIdx.get(newKeyTypeIdx);
    } else {
      subdict = new HashMap<CFSecurityServicePKey, CFSecurityServiceBuff>();
      dictByTypeIdx.put(newKeyTypeIdx, subdict);
    }
    subdict.put(pkey, Buff);

    dictByUTypeIdx.remove(existingKeyUTypeIdx);
    dictByUTypeIdx.put(newKeyUTypeIdx, Buff);

    dictByUHostPortIdx.remove(existingKeyUHostPortIdx);
    dictByUHostPortIdx.put(newKeyUHostPortIdx, Buff);
  }