Arduino_VScode.json

{
  "abs": {
    "body": "abs(${1:x});$0",
    "description": "Calculates the absolute value of a number.",
    "prefix": "abs"
  },
  "analogRead": {
    "body": "analogRead(${1:pin});$0",
    "description": "Reads the value from the specified analog pin.",
    "prefix": "analogRead"
  },
  "analogWrite": {
    "body": "analogWrite(${1:pin}, ${2:value});$0",
    "description": "Writes an analog value to a pin.",
    "prefix": "analogWrite"
  },
  "arduino": {
    "body": "void setup()\n{\n\t$0\n}\n\nvoid loop()\n{\n\t\n}",
    "description": "Builds the body of an arduino program.",
    "prefix": "arduino"
  },
  "byte": {
    "body": "byte(${1:x});$0",
    "description": "Converts a value to the byte data type.",
    "prefix": "byte"
  },
  "char": {
    "body": "char(${1:x});$0",
    "description": "Converts a value to the char data type.",
    "prefix": "char"
  },
  "constrain": {
    "body": "constrain(${1:x}, ${2:a}, ${3:b});$0",
    "description": "Constrains a number to be within a range.",
    "prefix": "constrain"
  },
  "define": {
    "body": "define ${1:IDENTIFIER} ${2:string}$0",
    "description": "Directive that causes the compiler to substitute token-string for each occurrence of identifier in the source file",
    "prefix": "define"
  },
  "delay": {
    "body": "delay(${1:ms});$0",
    "description": "Pauses the program for the amount of time (in milliseconds) specified as parameter. (There are 1000 milliseconds in a second.)",
    "prefix": "delay"
  },
  "delayMicroseconds": {
    "body": "delayMicroseconds(${1:us});$0",
    "description": "Pauses the program for the amount of time (in microseconds) specified as parameter.",
    "prefix": "delayMicroseconds"
  },
  "detachInterrupt": {
    "body": "detachInterrupt(${1:interrupt});$0",
    "description": "Turns off the given interrupt.",
    "prefix": "detachInterrupt"
  },
  "digitalRead": {
    "body": "digitalRead(${1:pin});$0",
    "description": "Reads the value from a specified digital pin, either HIGH or LOW.",
    "prefix": "digitalRead"
  },
  "digitalWrite": {
    "body": "digitalWrite(${1:pin}, ${2:value});$0",
    "description": "Write a HIGH or a LOW value to a digital pin.",
    "prefix": "digitalWrite"
  },
  "dowhile": {
    "body": "do{\n    ${1:// statement block}\n} while (${2:test condition});$0",
    "description": "The do…​while loop works in the same manner as the while loop, with the exception that the condition is tested at the end of the loop, so the do loop will always run at least once",
    "prefix": "dowhile"
  },
  "float": {
    "body": "float(${1:x});$0",
    "description": "Converts a value to the float data type.",
    "prefix": "float"
  },
  "for": {
    "body": "for(int ${1:i}=0; ${1:i}<${2}; ${1}++){\n    ${3}\n}$0",
    "description": "The for statement is used to repeat a block of statements enclosed in curly braces.",
    "prefix": "for"
  },
  "if": {
    "body": "if(${1}){\n    ${2}\n}$0",
    "description": "The if statement checks for a condition and executes the proceeding statement or set of statements if the condition is 'true'.",
    "prefix": "if"
  },
  "ifdef": {
    "body": "ifdef ${1:constant-expression}$0",
    "description": "The #ifdef directive checks for the existence of macro definitions.",
    "prefix": "ifdef"
  },
  "ifndef": {
    "body": "ifndef ${1:constant-expression}$0",
    "description": "The #ifdef directive checks for the inexistence of macro definitions.",
    "prefix": "ifndef"
  },
  "include": {
    "body": "include <${1:lib.h}>$0",
    "description": "#include is used to include outside libraries in your sketch.",
    "prefix": "include"
  },
  "int": {
    "body": "int(${1:x});$0",
    "description": "Converts a value to the int data type.",
    "prefix": "int"
  },
  "long": {
    "body": "long(${1:x});$0",
    "description": "Converts a value to the long data type.",
    "prefix": "long"
  },
  "loop": {
    "body": "void loop()\n{\n\t$1\n}$0",
    "description": "The loop() function does precisely what its name suggests, and loops consecutively, allowing your program to change and respond.",
    "prefix": "loop"
  },
  "map": {
    "body": "map(${1:value}, ${2:fromLow}, ${3:fromHigh}, ${4:toLow}, ${5:toHigh});$0",
    "description": "Re-maps a number from one range to another. That is, a value of fromLow would get mapped to toLow, a value of fromHigh to toHigh, values in-between to values in-between, etc.",
    "prefix": "map"
  },
  "max": {
    "body": "max(${1:x}, ${2:y});$0",
    "description": "Calculates the maximum of two numbers.",
    "prefix": "max"
  },
  "elif": {
    "body": "elif ${1:constant-expression}$0",
    "description": "Macro elif",
    "prefix": "elif"
  },
  "micros": {
    "body": "micros();$0",
    "description": "Returns the number of microseconds since the Arduino board began running the current program.",
    "prefix": "micros"
  },
  "millis": {
    "body": "millis();$0",
    "description": "Returns the number of milliseconds since the Arduino board began running the current program.",
    "prefix": "millis"
  },
  "min": {
    "body": "min(${1:x}, ${2:y});$0",
    "description": "Calculates the minimum of two numbers.",
    "prefix": "min"
  },
  "noTone": {
    "body": "noTone(${1:pin});$0",
    "description": "Stops the generation of a square wave triggered by tone(). Has no effect if no tone is being generated.",
    "prefix": "noTone"
  },
  "pinMode": {
    "body": "pinMode(${1:pin}, ${2:mode});$0",
    "description": "Configures the specified pin to behave either as an input or an output.",
    "prefix": "pinMode"
  },
  "pow": {
    "body": "pow(${1:base}, ${2:exponent});$0",
    "description": "Calculates the value of a number raised to a power. Pow() can be used to raise a number to a fractional power. This is useful for generating exponential mapping of values or curves.",
    "prefix": "pow"
  },
  "pulseIn": {
    "body": "pulseIn(${1:pin}, ${2:value}, ${3:timeout});$0",
    "description": "Reads a pulse on a pin. Waits for the pin state change, starts timing, then waits for the pin to go change again and stops timing. Returns the length of the pulse in microseconds or gives up and returns 0 if no complete pulse was received within the timeout.",
    "prefix": "pulseIn"
  },
  "random": {
    "body": "random(${1:min}, ${2:max});$0",
    "description": "The random function generates pseudo-random numbers.",
    "prefix": "random"
  },
  "randomSeed": {
    "body": "randomSeed(${1:seed});$0",
    "description": "Initializes the pseudo-random number generator. To initialize the random number generator with a fairly random input, such as analogRead() on an unconnected pin.",
    "prefix": "randomSeed"
  },
  "savailable": {
    "body": "if (Serial.available() > ${1:0}) {\n    ${2}\n}$0",
    "description": "Get the number of bytes (characters) available for reading from the serial port.",
    "prefix": "savailable"
  },
  "sbegin": {
    "body": "Serial.begin(${1:9600});$0",
    "description": "Sets the data rate in bits per second (baud) for serial data transmission. An optional second argument configures the data, parity, and stop bits. The default is 8 data bits, no parity, one stop bit.",
    "prefix": "sbegin"
  },
  "send": {
    "body": "Serial.end();$0",
    "description": "Disables serial communication, allowing the RX and TX pins to be used for general input and output. To re-enable serial communication, call Serial.begin().",
    "prefix": "send"
  },
  "sevent": {
    "body": "void serialEvent(){\n    ${1://statements}\n}$0",
    "description": "Called when data is available. Use Serial.read() to capture this data.",
    "prefix": "sevent"
  },
  "sfind": {
    "body": "Serial.find(${1:target});$0",
    "description": "Serial.find() reads data from the serial buffer until the target string of given length is found. The function returns true if target string is found, false if it times out.",
    "prefix": "sfind"
  },
  "sfindUntil": {
    "body": "Serial.findUntil(${1:target}, ${2:terminal});$0",
    "description": "Serial.findUntil() reads data from the serial buffer until a target string of given length or terminator string is found.",
    "prefix": "sfindUntil"
  },
  "sflush": {
    "body": "Serial.flush();$0",
    "description": "Waits for the transmission of outgoing serial data to complete.",
    "prefix": "sflush"
  },
  "spfloat": {
    "body": "Serial.parseFloat();$0",
    "description": "Serial.parseFloat() returns the first valid floating point number from the Serial buffer. Characters that are not digits (or the minus sign) are skipped.",
    "prefix": "spfloat"
  },
  "spint": {
    "body": "Serial.parseInt();$0",
    "description": "Looks for the next valid integer in the incoming serial stream.",
    "prefix": "spint"
  },
  "speek": {
    "body": "Serial.peek();$0",
    "description": "Returns the next byte (character) of incoming serial data without removing it from the internal serial buffer.",
    "prefix": "speek"
  },
  "sprint": {
    "body": "Serial.print(${1:val}, ${2:format});$0",
    "description": "Prints data to the serial port as human-readable ASCII text.",
    "prefix": "sprint"
  },
  "sprintln": {
    "body": "Serial.println(${1:val}, ${2:format});$0",
    "description": "Prints data to the serial port as human-readable ASCII text followed by a carriage return character and a newline character",
    "prefix": "sprint"
  },
  "sread": {
    "body": "Serial.read();$0",
    "description": "Reads incoming serial data.",
    "prefix": "sread"
  },
  "sreadBytes": {
    "body": "Serial.readBytes(${1:buffer}, ${2:length});$0",
    "description": "Serial.readBytes() reads characters from the serial port into a buffer. The function terminates if the determined length has been read, or it times out.",
    "prefix": "sreadBytes"
  },
  "sreadBytesUntil": {
    "body": "Serial.readBytesUntil(${1:character}, ${2:buffer}, ${2:length});$0",
    "description": "Serial.readBytesUntil() reads characters from the serial buffer into an array. The function terminates if the terminator character is detected, the determined length has been read, or it times out.",
    "prefix": "sreadBytesUntil"
  },
  "stimeout": {
    "body": "Serial.setTimeout(${1:time});$0",
    "description": "Serial.setTimeout() sets the maximum milliseconds to wait for serial data when using serial.readBytesUntil() or serial.readBytes(). It defaults to 1000 milliseconds.",
    "prefix": "stimeout"
  },
  "swrite": {
    "body": "Serial.write(${1:data});$0",
    "description": "Writes binary data to the serial port. This data is sent as a byte or series of bytes.",
    "prefix": "swrite"
  },
  "setup": {
    "body": "void setup()\n{\n\t$1\n}$0",
    "description": "The setup() function is called when a sketch starts.",
    "prefix": "setup"
  },
  "shiftIn": {
    "body": "shiftIn(${1:dataPin}, ${2:clockPin}, ${3:bitOrder});$0",
    "description": "Shifts in a byte of data one bit at a time. Starts from either the most (i.e. the leftmost) or least (rightmost) significant bit.",
    "prefix": "shiftIn"
  },
  "shiftOut": {
    "body": "shiftOut(${1:dataPin}, ${2:clockPin}, ${3:bitOrder}, ${4:value});$0",
    "description": "Shifts out a byte of data one bit at a time. Starts from either the most (i.e. the leftmost) or least (rightmost) significant bit.",
    "prefix": "shiftOut"
  },
  "sizeof": {
    "body": "sizeof(${1:variable});$0",
    "description": "The sizeof operator returns the number of bytes in a variable type, or the number of bytes occupied by an array.",
    "prefix": "sizeof"
  },
  "sqrt": {
    "body": "sqrt(${1:x});$0",
    "description": "Calculates the square root of a number.",
    "prefix": "sqrt"
  },
  "switch": {
    "body": "switch (${1}) {\n    case ${2}:\n      ${3:// do something}\n      break;\n    case ${4}:\n      ${5:// do something}\n      break;\n    default:\n      ${6:// do something}\n}$0",
    "description": "Switch statement",
    "prefix": "switch"
  },
  "tone": {
    "body": "tone(${1:pin}, ${2:frequency}, ${3:duration});$0",
    "description": "Generates a square wave of the specified frequency (and 50% duty cycle) on a pin. A duration can be specified, otherwise the wave continues until a call to noTone().",
    "prefix": "tone"
  },
  "undef": {
    "body": "undef ${1:constant-expression}$0",
    "description": "Macro undef",
    "prefix": "undef"
  },
  "while": {
    "body": "while(${1}){\n    ${2:// statement}\n}$0",
    "description": "While statement",
    "prefix": "while"
  },
  "sq": {
    "body": "sq(${1:x});$0",
    "description": "Calculates the square of a number: the number multiplied by itself.",
    "prefix": "sq"
  },
  "analogReadResolution": {
    "body": "analogReadResolution(${1:bits});$0",
    "description": "Sets the size (in bits) of the value returned by analogRead().",
    "prefix": "analogreadresolution"
  },
  "analogWriteResolution": {
    "body": "analogReadResolution(${1:bits});$0",
    "description": "Sets the resolution of the analogWrite() function. It defaults to 8 bits.",
    "prefix": "analogwriteresolution"
  },
  "attachInterrupt": {
    "body": "attachInterrupt(digitalPinToInterrupt(${1:pin}), ${2:function}, ${3:mode});$0",
    "description": "Digital Pins With Interrupts.",
    "prefix": "attachinterrupt"
  },
  "interrupts": {
    "body": "interrupts();$0",
    "description": "Re-enables interrupts (after they’ve been disabled by nointerrupts(). Interrupts allow certain important tasks to happen in the background and are enabled by default. Some functions will not work while interrupts are disabled, and incoming communication may be ignored. Interrupts can slightly disrupt the timing of code, however, and may be disabled for particularly critical sections of code.",
    "prefix": "interrupts"
  },
  "noInterrupts": {
    "body": "noInterrupts();$0",
    "description": "Disables interrupts (you can re-enable them with interrupts()). Interrupts allow certain important tasks to happen in the background and are enabled by default. Some functions will not work while interrupts are disabled, and incoming communication may be ignored. Interrupts can slightly disrupt the timing of code, however, and may be disabled for particularly critical sections of code.",
    "prefix": "nointerrupts"
  },
  "bit": {
    "body": "bit(${1:n});$0",
    "description": "Computes the value of the specified bit",
    "prefix": "bit"
  },
  "bitClear": {
    "body": "bitClear(${1:x}, ${2:n});$0",
    "description": "Clears (writes a 0 to) a bit of a numeric variable.",
    "prefix": "bitclear"
  },
  "bitRead": {
    "body": "bitRead(${1:x}, ${2:n});$0",
    "description": "Reads a bit of a number.",
    "prefix": "bitread"
  },
  "bitSet": {
    "body": "bitSet(${1:x}, ${2:n});$0",
    "description": "Sets (writes a 1 to) a bit of a numeric variable.",
    "prefix": "bitset"
  },
  "bitWrite": {
    "body": "bitWrite(${1:x}, ${2:n}, ${3:b});$0",
    "description": "Writes a bit of a numeric variable.",
    "prefix": "bitwrite"
  },
  "highByte": {
    "body": "highByte(${1:x});$0",
    "description": "Extracts the high-order (leftmost) byte of a word (or the second lowest byte of a larger data type).",
    "prefix": "highbyte"
  },
  "lowByte": {
    "body": "lowByte(${1:x});$0",
    "description": "Extracts the low-order (rightmost) byte of a variable (e.g. a word).",
    "prefix": "lowbyte"
  },
  "isAlpha": {
    "body": "isAlpha(${1:thisChar});$0",
    "description": "Analyse if a char is alpha (that is a letter). Returns true if thisChar contains a letter.",
    "prefix": "isalpha"
  },
  "isAlphaNumeric": {
    "body": "isAlphaNumeric(${1:thisChar});$0",
    "description": "Analyse if a char is alphanumeric (that is a letter or a numbers). Returns true if thisChar contains either a number or a letter.",
    "prefix": "isalphanumeric"
  },
  "isAscii": {
    "body": "isAscii(${1:thisChar});$0",
    "description": "Analyse if a char is Ascii. Returns true if thisChar contains an Ascii character.",
    "prefix": "isascii"
  },
  "isControl": {
    "body": "isControl(${1:thisChar});$0",
    "description": "Analyse if a char is a control character. Returns true if thisChar is a control character.",
    "prefix": "iscontrol"
  },
  "isDigit": {
    "body": "isDigit(${1:thisChar});$0",
    "description": "Analyse if a char is a digit (that is a number). Returns true if thisChar is a number.",
    "prefix": "isdigit"
  },
  "isGraph": {
    "body": "isGraph(${1:thisChar});$0",
    "description": "Analyse if a char is printable with some content (space is printable but has no content). Returns true if thisChar is printable.",
    "prefix": "isgraph"
  },
  "isHexadecimalDigit": {
    "body": "isHexadecimalDigit(${1:thisChar});$0",
    "description": "Analyse if a char is an hexadecimal digit (A-F, 0-9). Returns true if thisChar contains an hexadecimal digit.",
    "prefix": "ishexadecimaldigit"
  },
  "isLowerCase": {
    "body": "isLowerCase(${1:thisChar});$0",
    "description": "Analyse if a char is lower case (that is a letter in lower case). Returns true if thisChar contains a letter in lower case.",
    "prefix": "islowerCase"
  },
  "isPrintable": {
    "body": "isPrintable(${1:thisChar});$0",
    "description": "Analyse if a char is printable (that is any character that produces an output, even a blank space). Returns true if thisChar is printable.",
    "prefix": "isprintable"
  },
  "isPunct": {
    "body": "isPunct(${1:thisChar});$0",
    "description": "Analyse if a char is punctuation (that is a comma, a semicolon, an exlamation mark and so on). Returns true if thisChar is punctuation.",
    "prefix": "ispunct"
  },
  "isSpace": {
    "body": "isSpace(${1:thisChar});$0",
    "description": "Analyse if a char is the space character. Returns true if thisChar contains the space character.",
    "prefix": "isspace"
  },
  "isUpperCase": {
    "body": "isUpperCase(${1:thisChar});$0",
    "description": "Analyse if a char is upper case (that is, a letter in upper case). Returns true if thisChar is upper case.",
    "prefix": "isuppercase"
  },
  "isWhitespace": {
    "body": "isWhitespace(${1:thisChar});$0",
    "description": "Analyse if a char is a white space, that is space, formfeed, newline, carriage return, horizontal tab, and vertical tab. Returns true if thisChar contains a white space.",
    "prefix": "iswhitespace"
  },
  "cos": {
    "body": "cos(${1:rad});$0",
    "description": "Calculates the cosine of an angle (in radians). The result will be between -1 and 1.",
    "prefix": "cos"
  },
  "sin": {
    "body": "sin(${1:rad});$0",
    "description": "Calculates the sine of an angle (in radians). The result will be between -1 and 1.",
    "prefix": "sin"
  },
  "tan": {
    "body": "tan(${1:rad});$0",
    "description": "Calculates the tangent of an angle (in radians). The result will be between negative infinity and infinity.",
    "prefix": "tan"
  },
  "toInt": {
    "body": "toInt();$0",
    "description": "Converts a valid String to an integer. The input String should start with an integer number. If the String contains non-integer numbers, the function will stop performing the conversion.",
    "prefix": "toint"
  },
  "c_str": {
    "body": "c_str();$0",
    "description": "Converts the contents of a string as a C-style, null-terminated string. Note that this gives direct access to the internal String buffer and should be used with care. In particular, you should never modify the string through the pointer returned. When you modify the String object, or when it is destroyed, any pointer previously returned by c_str() becomes invalid and should not be used any longer.",
    "prefix": "c_str"
  },
  "charAt": {
    "body": "charAt(${1:n});$0",
    "description": "Access a particular character of the String.",
    "prefix": "charat"
  },
  "compareTo": {
    "body": "compareTo(${1:string2});$0",
    "description": "Compares two Strings, testing whether one comes before or after the other, or whether they’re equal. The strings are compared character by character, using the ASCII values of the characters. That means, for example, that 'a' comes before 'b' but after 'A'. Numbers come before letters.",
    "prefix": "compareto"
  },
  "concat": {
    "body": "concat(${1:parameter});$0",
    "description": "Appends the parameter to a String.",
    "prefix": "concat"
  },
  "endsWith": {
    "body": "endsWith(${1:string2});$0",
    "description": "Tests whether or not a String ends with the characters of another String.",
    "prefix": "endswith"
  },
  "equals": {
    "body": "equals(${1:string2});$0",
    "description": "Compares two strings for equality. The comparison is case-sensitive, meaning the String (hello) is not equal to the String (HELLO).",
    "prefix": "equals"
  },
  "equalsIgnoreCase": {
    "body": "equalsIgnoreCase(${1:string2});$0",
    "description": "Compares two Strings for equality. The comparison is not case-sensitive, meaning the String (hello) is equal to the String(HELLO).",
    "prefix": "equalsignorecase"
  },
  "getBytes": {
    "body": "getBytes(${1:buf}, ${2:len});$0",
    "description": "Copies the String’s characters to the supplied buffer.",
    "prefix": "getbytes"
  },
  "indexOf": {
    "body": "indexOf(${1:val}, ${2:from});$0",
    "description": "Locates a character or String within another String. By default, searches from the beginning of the String, but can also start from a given index, allowing for the locating of all instances of the character or String.",
    "prefix": "indexof"
  },
  "lastIndexOf": {
    "body": "lastIndexOf(${1:val}, ${2:from});$0",
    "description": "Locates a character or String within another String. By default, searches from the end of the String, but can also work backwards from a given index, allowing for the locating of all instances of the character or String.",
    "prefix": "lastindexof"
  },
  "length": {
    "body": "length();$0",
    "description": "Returns the length of the String, in characters. (Note that this doesn’t include a trailing null character.)",
    "prefix": "length"
  },
  "remove": {
    "body": "remove(${1:index}, ${2:cont});$0",
    "description": "Modify in place a String removing chars from the provided index to the end of the String or from the provided index to index plus count.",
    "prefix": "remove"
  },
  "replace": {
    "body": "replace(${1:substring1}, ${2:substring2});$0",
    "description": "The String replace() function allows you to replace all instances of a given character with another character. You can also use replace to replace substrings of a String with a different substring.",
    "prefix": "replace"
  },
  "reserve": {
    "body": "reserve(${1:size});$0",
    "description": "The String reserve() function allows you to allocate a buffer in memory for manipulating Strings.",
    "prefix": "reserve"
  },
  "setCharAt": {
    "body": "setCharAt(${1:index}, ${2:c});$0",
    "description": "Sets a character of the String. Has no effect on indices outside the existing length of the String.",
    "prefix": "setcharat"
  },
  "startsWith": {
    "body": "startsWith(${1:string2});$0",
    "description": "Tests whether or not a String starts with the characters of another String.",
    "prefix": "startswith"
  },
  "substring": {
    "body": "substring(${1:from}, ${2:to});$0",
    "description": "Get a substring of a String. The starting index is inclusive (the corresponding character is included in the substring), but the optional ending index is exclusive (the corresponding character is not included in the substring). If the ending index is omitted, the substring continues to the end of the String.",
    "prefix": "substring"
  },
  "toCharArray": {
    "body": "toCharArray(${1:buf}, ${2:len});$0",
    "description": "Copies the String’s characters to the supplied buffer.",
    "prefix": "tochararray"
  },
  "toFloat": {
    "body": "toFloat();$0",
    "description": "Converts a valid String to a float. The input String should start with a digit. If the String contains non-digit characters, the function will stop performing the conversion. For example, the Strings 123.45, 123, and 123fish are converted to 123.45, 123.00, and 123.00 respectively. Note that 123.456 is approximated with 123.46. Note too that floats have only 6-7 decimal digits of precision and that longer Strings might be truncated.",
    "prefix": "tofloat"
  },
  "toLowerCase": {
    "body": "toLowerCase();$0",
    "description": "Get a lower-case version of a String. As of 1.0, toLowerCase() modifies the String in place rather than returning a new one.",
    "prefix": "tolowercase"
  },
  "toUpperCase": {
    "body": "toUpperCase();$0",
    "description": "Get an upper-case version of a String. As of 1.0, toUpperCase() modifies the String in place rather than returning a new one.",
    "prefix": "touppercase"
  },
  "trim": {
    "body": "trim();$0",
    "description": "Get a version of the String with any leading and trailing whitespace removed. As of 1.0, trim() modifies the String in place rather than returning a new one.",
    "prefix": "trim"
  },
  "struct": {
    "body": "struct ${1:type_name} {\n\t${2:// Data members}\n\n\t}${3:// types, *types}\n;$0",
    "description": "It enables the programmer to create a variable that structures a selected set of data.",
    "prefix": "struct"
  },
  "class": {
    "body": "class ${1:type_name}\n{\n\tpublic:\n\t\t${1:type_name}(${2:type_variable});\n\t\t${3:// Data members}\n\n\tprivate:\n\t\t${4:// Data members}\n};\n\n${1:type_name} :: ${1:type_name}\n{\n\t${5:// Data members}\n}\n${6:// More Fuctions}\n$0",
    "description": " It is a user defined data type, which holds its own data members and member functions, which can be accessed and used by creating an instance of that class.",
    "prefix": "class"
  }
}