cpp.snippets

extends c


# comments
snippet cmt1
  /**
   * ${1:"Write your comment here.."}
   *
   */

snippet cmt2
  /* ${1:"Write your comment here.."} */


############ Ace related ##############
snippet trc
  ACE_TRACE ("${1:your text}");

snippet aa
  #include "ace/${1:your desired ACE header file}"

snippet adef1
  #include "ace/OS_NS_string.h"
  #include "ace/Log_Msg.h"
  #include "ace/SString.h"
  
  ${1}

snippet adef2
  #include "ace/Log_Msg.h"
  #include "ace/INET_Addr.h"
  #include "ace/SOCK_Connector.h"
  #include "ace/SOCK_Stream.h"
  #include "ace/SOCK_Acceptor.h"

snippet cchst
  const ACE_TCHAR *text = ACE_TEXT("${1}") ;

snippet tmain
  int ACE_TMAIN (${1})
  {
    ${2}
    return 0 ;
  }

snippet ntrace0
  #if defined (ACE_NTRACE)
  #undef ACE_NTRACE
  #endif
  #define ACE_NTRACE 0

snippet atx 
  ACE_TEXT ("${1:Write your text here}")${2}

snippet adb1
  ACE_DEBUG ((LM_DEBUG,
              ACE_TEXT("[%T] ${1:your text here..}")${2}
              ));

snippet adb2
  ACE_DEBUG ((LM_DEBUG,
              ACE_TEXT("[%T] ${1:Write your text here}")${2}));

snippet adb3
  ACE_DEBUG ((LM_DEBUG, ACE_TEXT("[%T] ${1:Write your text here}")${2}));

snippet adb4
  ACE_DEBUG ((LM_DEBUG, "${1:Write your text here}"${2}));

snippet adb5
  ACE_DEBUG ((LM_DEBUG, 
              "${1:Write your text here}"${2}));

snippet aer1
  ACE_ERROR ((LM_ERROR,
              ACE_TEXT("${1:your text..}")${2:}));

snippet aern1
  ACE_ERROR_RETURN ((LM_ERROR,
                     "[%T] ${1:your text here..}"),
                     ${2:}),${3:your_return_value});

##
## Preprocessor
# #include <...>
snippet incc
  #include <${1:iostream}>
snippet binc
  #include <boost/${1:shared_ptr}.hpp>
##
## STL Collections
# std::array
snippet array
  std::array<${1:T}, ${2:N}> ${3};
# std::vector
snippet vector
  std::vector<${1:T}> ${2};
# std::deque
snippet deque
  std::deque<${1:T}> ${2};
# std::forward_list
snippet flist
  std::forward_list<${1:T}> ${2};
# std::list
snippet list
  std::list<${1:T}> ${2};
# std::set
snippet set
  std::set<${1:T}> ${2};
# std::map
snippet map
  std::map<${1:Key}, ${2:T}> ${3};
# std::multiset
snippet mset
  std::multiset<${1:T}> ${2};
# std::multimap
snippet mmap
  std::multimap<${1:Key}, ${2:T}> ${3};
# std::unordered_set
snippet uset
  std::unordered_set<${1:T}> ${2};
# std::unordered_map
snippet umap
  std::unordered_map<${1:Key}, ${2:T}> ${3};
# std::unordered_multiset
snippet umset
  std::unordered_multiset<${1:T}> ${2};
# std::unordered_multimap
snippet ummap
  std::unordered_multimap<${1:Key}, ${2:T}> ${3};
# std::stack
snippet stack
  std::stack<${1:T}> ${2};
# std::queue
snippet queue
  std::queue<${1:T}> ${2};
# std::priority_queue
snippet pqueue
  std::priority_queue<${1:T}> ${2};
##
## Access Modifiers
# private
snippet pri
  private
# protected
snippet pro
  protected
# public
snippet pub
  public
# friend
snippet fr
  friend
# mutable
snippet mu
  mutable
##
## Class
# class
snippet cl
  /*! \class $1
   *  \brief ${3:Brief class description}
   *
   *  ${4:Detailed description}
   */
  class ${1:`vim_snippets#Filename('$1', 'name')`}
  {
  public:
    $1(${2});
    virtual ~$1();

  protected:
    m_${5}; /*!< ${6:Member description} */
  };
# member function implementation
snippet mfun
  ${4:void} ${1:`vim_snippets#Filename('$1', 'ClassName')`}::${2:memberFunction}(${3}) {
    ${0}
  }
# member function implementation without parameters
snippet dmfun0
  /*! \brief ${4:Brief function description here}
   *
   *  ${5:Detailed description}
   *
   * \return ${6:Return parameter description}
   */
  ${3:void} ${1:`vim_snippets#Filename('$1', 'ClassName')`}::${2:memberFunction}() {
    ${0}
  }
# member function implementation with one parameter
snippet dmfun1
  /*! \brief ${6:Brief function description here}
   *
   *  ${7:Detailed description}
   *
   * \param $4 ${8:Parameter description}
   * \return ${9:Return parameter description}
   */
  ${5:void} ${1:`vim_snippets#Filename('$1', 'ClassName')`}::${2:memberFunction}(${3:Type} ${4:Parameter}) {
    ${0}
  }
# member function implementation with two parameter
snippet dmfun2
  /*! \brief ${8:Brief function description here}
   *
   *  ${9:Detailed description}
   *
   * \param $4 ${10:Parameter description}
   * \param $6 ${11:Parameter description}
   * \return ${12:Return parameter description}
   */
  ${7:void} ${1:`vim_snippets#Filename('$1', 'ClassName')`}::${2:memberFunction}(${3:Type} ${4:Parameter},${5:Type} ${6:Parameter}) {
    ${0}
  }
# namespace
snippet ns
  namespace ${1:`vim_snippets#Filename('', 'my')`} {
    ${0}
  } /* namespace $1 */
snippet ans
  namespace {
    ${0}
  }
##
## Input/Output
# std::cout
snippet cout
  std::cout << ${1} << std::endl;
# std::cin
snippet cin
  std::cin >> ${1};
##
## Casts
# static
snippet sca
  static_cast<${1:unsigned}>(${2:expr})${3}
# dynamic
snippet dca
  dynamic_cast<${1:unsigned}>(${2:expr})${3}
# reinterpret
snippet rca
  reinterpret_cast<${1:unsigned}>(${2:expr})${3}
# const
snippet cca
  const_cast<${1:unsigned}>(${2:expr})${3}
## Iteration
# for i
snippet fori
  for (int ${2:i} = 0; $2 < ${1:count}; $2${3:++}) {
    ${4}
  }

# foreach
snippet fore
  for (${1:auto} ${2:i} : ${3:container}) {
    ${4}
  }
# iterator
snippet iter
  for (${1:std::vector}<${2:type}>::${3:const_iterator} ${4:i} = ${5:container}.begin(); $4 != $5.end(); ++$4) {
    ${6}
  }

# auto iterator
snippet itera
  for (auto ${1:i} = ${2:container}.begin(); $1 != $2.end(); ++$1) {
    ${3:std::cout << *$1 << std::endl;}
  }
##
## Lambdas
# lamda (one line)
snippet ld
  [${1}](${2}){${3}};
# lambda (multi-line)
snippet lld
  [${1}](${2}){
    ${3}
  };
# snippets exception
snippet try
  try {

  }catch(${1}) {

  }
snippet af auto function
  auto ${1:name}(${2}) -> ${3:void}
  {
    ${0}
  };