protected void checkNotExist(Class<?> entityClass) throws ObjectExistsException { if(null != entityClass){ if(classToEntityMappings.containsKey(entityClass)){ throw new ObjectExistsException("Entity class '" + entityClass.getName() + "' aleady exists"); } } } }
@Override public void registerDataSource(String name, RestDataSource ds) throws ObjectExistsException { synchronized (this) { if(allDataSources.containsKey(name)) { throw new ObjectExistsException("DataSource '" + name + "' already exists!"); } allDataSources.put(name, ds); } }
protected void checkNotExist(String entityName) throws ObjectExistsException { if(nameToEntityMappings.containsKey(entityName.toLowerCase())){ throw new ObjectExistsException("Entity '" + entityName + "' aleady exists"); } }
@Override public void addAnnotationType(Class<?> annotationType, Domain domain) throws ObjectExistsException { if(domainTypes.containsKey(annotationType)) { throw new ObjectExistsException("Annotation type '" + annotationType + "' already exists"); } domainTypes.put(annotationType, domain); }
@Override public void registerContext(OrmContext context, String alias) throws ObjectExistsException { String key = alias.toLowerCase(); if(contexts.containsKey(key)) { throw new ObjectExistsException("Orm context '" + alias + "' already exists!"); } contexts.put(key, context); }
public <T> void command(String name, Class<T> type, boolean required, Function<T,Object> handler) { if(commands.containsKey(name)) { throw new ObjectExistsException(("Command '" + name + "' already exists!")); } commands.put(name, new CliCommand(type, required, handler)); }
@Override public void registerDataSource(String name, DataSource ds) throws ObjectExistsException { synchronized (this) { if(allDataSources.containsKey(name)) { throw new ObjectExistsException("DataSource '" + name + "' already exists!"); } allDataSources.put(name, ds); notifyDataSourceCreated(name, ds, exportMBean); } }
public void addOperation(Operation op) { String key = op.getName().toLowerCase(); if(operations.containsKey(key)) { throw new ObjectExistsException("The operation '" + op.getName() + "' of model '" + name + "' already exists!"); } operations.put(key, op); } }
@Override public void addDomainAlias(String name, String alias) { Domain domain = tryGetDomain(name); if(null == domain) { throw new ObjectNotFoundException("The domain '" + name + "' not exists!"); } String key = alias.toLowerCase(); if(domainAliases.containsKey(key)) { throw new ObjectExistsException("The alias '" + alias + "' already exists!"); } domainAliases.put(key, domain); }
public void addModel(Model model) { String key = model.getName().toLowerCase(); if(models.containsKey(key)) { throw new ObjectExistsException("The configuration of model '" + model.getName() + "' already exists!"); } models.put(key, model); }
public void add(MetaEntity model) throws ObjectExistsException { String key = model.getName().toLowerCase(); if(entities.containsKey(key)) { throw new ObjectExistsException("Model '" + model.getName() + "' already exists!"); } entities.put(key, model); }
public <T> void command(String name, Class<T> type, boolean required, Consumer<T> handler) { if(commands.containsKey(name)) { throw new ObjectExistsException(("Command '" + name + "' already exists!")); } commands.put(name, new CliCommand(type, required, (params) -> { handler.accept((T)params); return null; })); }
@Override public void addSqlCommand(String key, String dbType, SqlCommand cmd) throws ObjectExistsException { TypedCommands commands = commandsMap.get(key); if(null == commands) { commands = new TypedCommands(); commandsMap.put(key, commands); } if(Strings.isEmpty(dbType)) { if(null != commands.untyped) { throw new ObjectExistsException("The sql command '" + key + "' already exists!"); } commands.untyped = cmd; }else { if(commands.typed.containsValue(dbType.toLowerCase())) { throw new ObjectExistsException("The sql command '" + key + "' for db type '" + dbType + "' already exists!"); } commands.typed.put(dbType.toLowerCase(), cmd); } }
@Override public void addSqlCommand(String key,SqlCommand cmd) throws ObjectExistsException { Args.notEmpty(key,"command key"); Args.notNull(cmd,"sql command"); synchronized (_sqlLock) { if(keyToSqlCommands.containsKey(key)){ throw new ObjectExistsException("sql command '" + key + "' aleady exists"); } keyToSqlCommands.put(key, cmd); } }
@Override public void registerCache(String name, Cache<?, ?> cache) throws ObjectExistsException { Args.notEmpty(name,"cache name"); Args.notNull(cache,"cache"); if(caches.containsKey(name)){ throw new ObjectExistsException("The cache '" + name + "' already exists"); } caches.put(name, cache); }
@Override public void registerContext(OrmContext context, boolean _default) throws ObjectExistsException { String key = context.getName().toLowerCase(); if(contexts.containsKey(key)) { throw new ObjectExistsException("Orm context '" + context.getName() + "' already exists!"); } contexts.put(key, context); if(_default) { if(null != defaultContext) { throw new ObjectExistsException("Default context '" + defaultContext.getName() + "' already exists!"); } this.defaultContext = context; } }
@Override public void addSqlFragment(String key, SqlFragment fragment) throws ObjectExistsException { Args.notEmpty(key,"fragment key"); Args.notNull(fragment,"sql fragment"); if(fragmentsMap.containsKey(key)){ throw new ObjectExistsException("The sql fragment '" + key + "' already exists"); } fragmentsMap.put(key, fragment); }
@Override public void registerEventCategory(String category) throws ObjectExistsException { Args.notEmpty(category,"category"); if(Strings.equalsIgnoreCase(category, ALL_CATEGORY)){ throw new IllegalStateException("event category '" + category + "' is reserved, can not use this category name"); } synchronized (_lock) { if(categoryListeners.containsKey(category)){ throw new ObjectExistsException("event category '" + category + "' aleady registered"); } log.debug("Event category '{}' registered",category); categoryListeners.put(category,new CopyOnWriteArrayList<EventListener>()); categoryEvents.put(category, new CopyOnWriteArrayList<String>()); } }
@Override public void addDomain(Domain domain, boolean override) throws ObjectExistsException { String key = domain.getName().toLowerCase(); if(!override) { Domain existsDomain = domains.get(key); //domain without kind can override exists domain with kind if (null != existsDomain) { throw new ObjectExistsException("The to be added domain '" + domain.getName() + "' already exists, check the source : " + domain.getSource()); } } domains.put(key, domain); }
public void addField(MetaField field) throws ObjectExistsException { if(fields.containsKey(field.getName())) { throw new ObjectExistsException("Field '" + field.getName() + "' already exists in entity '" + name + "'"); } fields.put(field.getName(), field); }