RhodeCode

/* -*- C++ -*-

 *

 * This file is a part of LEMON, a generic C++ optimization library

 *

 * Copyright (C) 2003-2008

 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport

 * (Egervary Research Group on Combinatorial Optimization, EGRES).

 *

 * Permission to use, modify and distribute this software is granted

 * provided that this copyright notice appears in all copies. For

 * precise terms see the accompanying LICENSE file.

 *

 * This software is provided "AS IS" with no warranty of any kind,

 * express or implied, and with no claim as to its suitability for any

 * purpose.

 *

 */

/*!

\page coding_style LEMON Coding Style 

\section naming_conv Naming Conventions

In order to make development easier we have made some conventions

according to coding style. These include names of types, classes,

functions, variables, constants and exceptions. If these conventions

are met in one's code then it is easier to read and maintain

it. Please comply with these conventions if you want to contribute

developing LEMON library.

\note When the coding style requires the capitalization of an abbreviation,

only the first letter should be upper case.

\code

XmlReader

\endcode

\warning In some cases we diverge from these rules.

in certain cases

it is beneficial to provide STL compatible interface.

\subsection cs-files File Names

The header file names should look like the following.

\code

header_file.h

\endcode

Note that all standard LEMON headers are located in the \c lemon subdirectory,

so you should include them from C++ source like this:

\code

#include <lemon/header_file.h>

\endcode

The source code files use the same style and they have '.cc' extension.

\code

source_code.cc

\endcode

\subsection cs-class Classes and other types

The name of a class or any type should look like the following.

\code

AllWordsCapitalizedWithoutUnderscores 

\endcode

\subsection cs-func Methods and other functions

The name of a function should look like the following.

\code

firstWordLowerCaseRestCapitalizedWithoutUnderscores 

\endcode

\subsection cs-funcs Constants, Macros

The names of constants and macros should look like the following.

\code

ALL_UPPER_CASE_WITH_UNDERSCORES 

\endcode

\subsection cs-loc-var Class and instance member variables, auto variables 

The names of class and instance member variables and auto variables (=variables used locally in methods) should look like the following.

\code

all_lower_case_with_underscores 

\endcode

\subsection cs-excep Exceptions

When writing exceptions please comply the following naming conventions.

\code

ClassNameEndsWithException

\endcode

or

\code

ClassNameEndsWithError

\endcode

\section header-template Template Header File

Each LEMON header file should look like this:

\include template.h

*/

@defgroup approx Approximation algorithms

\brief Approximation algorithms

Approximation and heuristic algorithms

*/

/**

@defgroup gen_opt_group General Optimization Tools

\brief This group describes some general optimization frameworks

implemented in LEMON.

This group describes some general optimization frameworks

implemented in LEMON.

*/

/**

@defgroup lp_group Lp and Mip solvers

@ingroup gen_opt_group

\brief Lp and Mip solver interfaces for LEMON.

This group describes Lp and Mip solver interfaces for LEMON. The

various LP solvers could be used in the same manner with this

interface.

*/

/** 

@defgroup lp_utils Tools for Lp and Mip solvers 

@ingroup lp_group

\brief This group adds some helper tools to the Lp and Mip solvers

implemented in LEMON.

This group adds some helper tools to general optimization framework

implemented in LEMON.

*/

/**

@defgroup metah Metaheuristics

@ingroup gen_opt_group

\brief Metaheuristics for LEMON library.

This group contains some metaheuristic optimization tools.

*/

/**

@defgroup utils Tools and Utilities 

\brief Tools and Utilities for Programming in LEMON

Tools and Utilities for Programming in LEMON

*/

/**

@defgroup gutils Basic Graph Utilities

@ingroup utils

\brief This group describes some simple basic graph utilities.

This group describes some simple basic graph utilities.

*/

/**

@defgroup misc Miscellaneous Tools

@ingroup utils

Here you can find several useful tools for development,

debugging and testing.

*/

/**

@defgroup timecount Time measuring and Counting

@ingroup misc

Here you can find simple tools for measuring the performance

of algorithms.

*/

/**

@defgroup graphbits Tools for Graph Implementation

@ingroup utils

\brief Tools to Make It Easier to Make Graphs.

This group describes the tools that makes it easier to make graphs and

the maps that dynamically update with the graph changes.

*/

/**

@defgroup exceptions Exceptions

@ingroup utils

This group contains the exceptions thrown by LEMON library

*/

/**

@defgroup io_group Input-Output

\brief Several Graph Input-Output methods

Here you can find tools for importing and exporting graphs 

and graph related data. Now it supports the LEMON format, the

\c DIMACS format and the encapsulated postscript format.

*/

/**

@defgroup lemon_io Lemon Input-Output

@ingroup io_group

\brief Reading and writing LEMON format

Methods for reading and writing LEMON format. More about this

format you can find on the \ref graph-io-page "Graph Input-Output"

tutorial pages.

*/

/**

@defgroup section_io Section readers and writers

@ingroup lemon_io

\brief Section readers and writers for lemon Input-Output.

Here you can find which section readers and writers can attach to

the LemonReader and LemonWriter.

*/

/**

@defgroup item_io Item Readers and Writers

@ingroup lemon_io

\brief Item readers and writers for lemon Input-Output.

The Input-Output classes can handle more data type by example

as map or attribute value. Each of these should be written and

read some way. The module make possible to do this.  

*/

/**

@defgroup eps_io Postscript exporting

@ingroup io_group

\brief General \c EPS drawer and graph exporter

This group contains general \c EPS drawing methods and special

graph exporting tools. 

*/

/**

@defgroup concept Concepts

\brief Skeleton classes and concept checking classes

This group describes the data/algorithm skeletons and concept checking

classes implemented in LEMON.

The purpose of the classes in this group is fourfold.

- These classes contain the documentations of the concepts. In order

  to avoid document multiplications, an implementation of a concept

  simply refers to the corresponding concept class.

- These classes declare every functions, <tt>typedef</tt>s etc. an

  implementation of the concepts should provide, however completely

  without implementations and real data structures behind the

  interface. On the other hand they should provide nothing else. All

  the algorithms working on a data structure meeting a certain concept

  should compile with these classes. (Though it will not run properly,

  of course.) In this way it is easily to check if an algorithm

  doesn't use any extra feature of a certain implementation.

- The concept descriptor classes also provide a <em>checker class</em>

  that makes it possible check whether a certain implementation of a

  concept indeed provides all the required features.

- Finally, They can serve as a skeleton of a new implementation of a concept.

*/

/**

@defgroup graph_concepts Graph Structure Concepts

@ingroup concept

\brief Skeleton and concept checking classes for graph structures

This group contains the skeletons and concept checking classes of LEMON's

graph structures and helper classes used to implement these.

*/

/* --- Unused group

@defgroup experimental Experimental Structures and Algorithms

This group contains some Experimental structures and algorithms.

The stuff here is subject to change.

*/

/**

\anchor demoprograms

@defgroup demos Demo programs

Some demo programs are listed here. Their full source codes can be found in

the \c demo subdirectory of the source tree.

*/

/**

@defgroup tools Standalone utility applications

Some utility applications are listed here. 

The standard compilation procedure (<tt>./configure;make</tt>) will compile

them, as well. 

*/