 ------
 Apache DirectMemory Developers centre - Commiter Environment
 ------
 Olivier Lamy
 ------
 2012-02-20
 ------

~~ Licensed to the Apache Software Foundation (ASF) under one
~~ or more contributor license agreements.  See the NOTICE file
~~ distributed with this work for additional information
~~ regarding copyright ownership.  The ASF licenses this file
~~ to you under the Apache License, Version 2.0 (the
~~ "License"); you may not use this file except in compliance
~~ with the License.  You may obtain a copy of the License at
~~
~~   http://www.apache.org/licenses/LICENSE-2.0
~~
~~ Unless required by applicable law or agreed to in writing,
~~ software distributed under the License is distributed on an
~~ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
~~ KIND, either express or implied.  See the License for the
~~ specific language governing permissions and limitations
~~ under the License.

~~ NOTE: For help with the syntax of this file, see:
~~ http://maven.apache.org/doxia/references/apt-format.html

Introduction

 This document is intended to set up the Apache DirectMemory committer environment.

{Source File Encoding}

 When editing source files, make sure you use the right file encoding. For the Apache DirectMemory project, UTF-8 has been chosen
 as the default file encoding. UTF-8 is an encoding scheme for the Unicode character set and as such allows to encode
 all characters that Java can handle. The source files should not contain the byte order mark (BOM). There can be
 exceptions to this general rule, e.g. properties files are usually encoded using ISO-8859-1 as per the JRE API, so
 please keep this in mind, too.

Subversion Configuration

 Before committing files in subversion repository, you need to read the
 {{{http://www.apache.org/dev/version-control.html#https-svn}Committer Subversion Access}}
 document and you must set your svn client with this properties file: {{{./svn-eol-style.txt}svn-eol-style.txt}}

DirectMemory Code Style

 The following sections show how to set up the code style for DirectMemory in IDEA and Eclipse.
 It is strongly preferred that patches use this style before they are supplied.

* IntelliJ IDEA 4.5+

 Download <<<{{{./directmemory-idea-codestyle.xml}directmemory-idea-codestyle.xml}}>>> and copy it to
 <<<~/.IntelliJIDEA/config/codestyles>>> then restart IDEA. On Windows, try
 <<<C:\Documents and Settings\\<username\>\.IntelliJIDEA\config\codestyles>>>

 After this, restart IDEA and open the settings to select the new code style.

* Eclipse 3.2+

 Download <<<{{{./directmemory-eclipse-codestyle.xml}directmemory-eclipse-codestyle.xml}}>>>.

 After this, select Window \> Preferences, and open up the configuration for Java \> Code
 Style \> Code Formatter. Click on the button labeled Import... and select the file you
 downloaded. Give the style a name, and click OK.