Adds a new namespace
@return the current instance of <code>PersistenceDescriptor</code>
171848
public PersistenceDescriptor addNamespace(String name, String value)
   {
      model.attribute(name, value);
      return this;
   }
1360401
@Override
    public void createNamespace() {
        // Use a temporary, no-keyspace session
        try (DBConn dbConn = createAndConnectConn(null)) {
            synchronized (m_schemaLock) {
                if (!m_schemaMgr.keyspaceExists(dbConn, m_keyspace)) {
                    m_schemaMgr.createKeyspace(dbConn, m_keyspace);
                }
            }
        }
    }
922513
public WebAppDescriptor addNamespace(String name, String value)
   {
      model.attribute(name, value);
      return this;
   }
652334
public void useNamespace(SerializerContext serializerContext, String namespace)
	{
		if (namespace != null && namespace.length() > 0)
		{
			if (serializerContext.knownNamespaces == null)
			{
				serializerContext.knownNamespaces = new HashSet<String>(8);
			}
			serializerContext.knownNamespaces.add(namespace);
		}
	}
1111989
def add_namespace(html, namespace)    
      html.gsub!(/(class=")([a-zA-Z0-9\-_ ]*)(")/) do |m|
        classes = m.to_s.split('"')[1].split(' ')
        classes.map! { |c| c = namespace + c }
        'class="' + classes.join(' ') + '"'
      end
      html
    end
256213
private void createNamespace(boolean isUpdate)
    {
        boolean isNameSpaceAvailable = isNamespaceAvailable(databaseName);
        if (isNameSpaceAvailable && !isUpdate)
        {
            drop();
        }
        if (!(isNameSpaceAvailable && isUpdate))
        {
            try
            {
                NamespaceDescriptor descriptor = NamespaceDescriptor.create(databaseName).build();
                admin.createNamespace(descriptor);
            }
            catch (IOException ioex)
            {
                logger.error("Either table isn't in enabled state or some network problem, Caused by: ", ioex);
                throw new SchemaGenerationException(ioex, "Hbase");
            }
        }
    }
590254
public function AddNameSpace() {
        $output = "";
        if ($this->isFrameworkClass) {
            $output = strtr(CodeSnippets\ClassFileSnippets::SNIPPET_NAMESPACE_FRAMEWORK, $this->placeholders);
        } else {
            $output = strtr(CodeSnippets\ClassFileSnippets::SNIPPET_NAMESPACE_APP, $this->placeholders);
        }
        fwrite($this->writer, $output);
    }
17786
protected Serializer serializer() {
    Serializer serializer = this.serializer;
    if (serializer == null) {
      synchronized (this) {
        serializer = this.serializer;
        if (serializer == null) {
          NamespaceConfig config = this.config.getNamespaceConfig();
          if (config == null) {
            serializer = Serializer.using(Namespaces.BASIC);
          } else {
            serializer = Serializer.using(Namespace.builder()
                .register(Namespaces.BASIC)
                .nextId(Namespaces.BEGIN_USER_CUSTOM_ID)
                .register(new Namespace(config))
                .build());
          }
          this.serializer = serializer;
        }
      }
    }
    return serializer;
  }
1233436
public static NamespaceDto transformToDto(Namespace namespace) {
        if (namespace == null) {
            throw new WebApplicationException("Null entity object cannot be converted to Dto object.", Status.INTERNAL_SERVER_ERROR);
        }

        NamespaceDto result = createDtoObject(NamespaceDto.class, namespace);

        for (PrincipalUser user : namespace.getUsers()) {
            result.addUsername(user.getUserName());
        }
        return result;
    }
756267
public Parameters copyNamespaceIfPresent(final String requestedNamespace) {
    // checkArgument ensures namespaces are specified consistently
    checkArgument(!requestedNamespace.isEmpty());
    checkArgument(!requestedNamespace.endsWith(DELIM));
    if (isNamespacePresent(requestedNamespace)) {
      return copyNamespace(requestedNamespace);
    } else {
      return copy();
    }
  }
153880
private void addNameSpaceStorage(int nsID, NameSpaceSliceStorage nsStorage)
      throws IOException {
    if (!this.nsStorageMap.containsKey(nsID)) {
      this.nsStorageMap.put(nsID, nsStorage);
    }   
  }
85542
public String getNameSpace() {
        if (nameSpace == null) {
            nameSpace = new StringBuilder().append(catalog).append(".").append(table).toString();
        }
        return nameSpace;

    }
751569
public OrmDescriptor addNamespace(String name, String value)
   {
      model.attribute(name, value);
      return this;
   }
319316
public static org.openbel.framework.common.model.Namespace convert(
            final Namespace ws) {
        return new org.openbel.framework.common.model.Namespace(
                ws.getPrefix(), ws.getResourceLocation());
    }
1363289
@Override
    public InjectionBinding<JMSDestinationDefinition> createInjectionBinding(JMSDestinationDefinition annotation, Class<?> instanceClass, Member member, String jndiName) throws InjectionException {
        InjectionBinding<JMSDestinationDefinition> injectionBinding =
                        new JMSDestinationDefinitionInjectionBinding(jndiName, ivNameSpaceConfig);
        injectionBinding.merge(annotation, instanceClass, null);
        return injectionBinding;
    }
583093
public WebFacesUIComponentDescriptor addNamespace(String name, String value)
   {
      model.attribute(name, value);
      return this;
   }
1223671
public MgcpEndpoint registerEndpoint(String namespace) throws UnrecognizedMgcpNamespaceException {
        // Get correct endpoint provider
        MgcpEndpointProvider<?> provider = this.providers.get(namespace);
        if (provider == null) {
            throw new UnrecognizedMgcpNamespaceException("Namespace " + namespace + " is unrecognized");
        }

        // Create the endpoint and register it
        MgcpEndpoint endpoint = provider.provide();
        endpoint.observe((MgcpEndpointObserver) this);
        endpoint.observe((MgcpMessageObserver) this);
        this.endpoints.put(endpoint.getEndpointId().toString(), endpoint);
        
        if (log.isDebugEnabled()) {
            log.debug("Registered endpoint " + endpoint.getEndpointId().toString() + ". Count: " + this.endpoints.size());
        }
        
        return endpoint;
    }