Manish K. Agarwal - Professional Profile

FORMAT(DateField, 'dd\"/\"MM\"/\"yy hh:mm:ss AM/PM') AS MyDate

public static String normalizeFileSeparator(String path)
{

    //Convert all file separator with single OS file separator.
    //e.g. on Win OS "a\\\b\\c/d//e" will be converted to "a\b\c\d\e"

    return path.replaceAll("(\\\\|/){1,}", Matcher.quoteReplacement(File.separator));

}


public static int getFileSeparatorCount(String path){
    //Convert all file separator with single OS file separator.
    //e.g. on Win OS "a\\\b\\c/d//e" will be converted to "a\b\c\d\e"

    //path = path.replaceAll("(\\\\|/){1,}", Matcher.quoteReplacement(File.separator));
    //path = path.replaceAll("(\\\\|/){1,}", Matcher.quoteReplacement(File.separator));

    //Remove all char except file separator and return count.
    //e.g. on Win OS "a\b\c\d\e" will be converted to "\\\\"

    return path.replaceAll("[^\\\\|/]{1,}", "").length();
}

_tsetlocale(LC_NUMERIC, _T("German_Germany.1252"));

CString GetLocaleStr()
{
	CString localeStrBuf;
	TCHAR strBuf[128];
	memset(strBuf, 0, sizeof(strBuf));
	
	// Load the English name of the locale
	GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_SENGLANGUAGE, strBuf, 127);
	localeStrBuf = strBuf;

	memset(strBuf, 0, sizeof(strBuf));

        // Load the English name for the country/region
	GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_SENGCOUNTRY, strBuf, 127);
	if (*strBuf)
	{
		localeStrBuf += _T("_");
		localeStrBuf += strBuf;
	}

	memset(strBuf, 0, sizeof(strBuf));

        // Load the code page
	if ((GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_IDEFAULTANSICODEPAGE, strBuf, 127)
		|| GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_IDEFAULTCODEPAGE, strBuf, 127))
		&& *strBuf)
        {
		localeStrBuf += _T(".");
		localeStrBuf += strBuf;
	}

	return localeStrBuf;
}

TCHAR* lcl = _tcsdup(::_tsetlocale(LC_NUMERIC, NULL)); //Save the current locale
::_tsetlocale(LC_NUMERIC, _T(""));  //Set the locale to the environment locale

// your code

::_tsetlocale(LC_NUMERIC, lcl); //restore the original locale
free(lcl);

BOOL CheckPattern(LPTSTR pattern, LPTSTR str)
{
   LPTSTR pStrCurPos = NULL;
   LPTSTR pPatCurPos = NULL;
   LPTSTR pStrMatchPos =  NULL;
   LPTSTR pPatMatchPos = NULL;
   BOOL fIsAsterisk  = FALSE;


   pStrMatchPos = pStrCurPos = str;
   pPatMatchPos = pPatCurPos = pattern;



   while (*pStrCurPos != '\0')
   {
      if (*pPatCurPos == _T('*'))
      {
         fIsAsterisk = TRUE;

         
         // Set matched string to cur position
         pStrMatchPos = pStrCurPos;

         // Move to the next position in the pattern
         pPatMatchPos = ++pPatCurPos;

         if (*pPatMatchPos == '\0')
         {
            return TRUE;
         }

         continue;
      }
      else if (*pPatCurPos == _T('?'))
      {
        // do nothing just move to next char
      }
      else if (*pStrCurPos != *pPatCurPos)
      {
         if (fIsAsterisk == FALSE)
         {
             // Not processing wildcard
            return FALSE;
         }

         // Move to next position in String
         pStrCurPos = ++pStrMatchPos;

         // Reset pattern in matched position
         pPatCurPos = pPatMatchPos;

         continue;
      }

      // Move current position forward
      ++pStrCurPos;
      ++pPatCurPos;
   } // while


   if (*pPatCurPos == _T('*'))
      ++pPatCurPos;

   return (*pPatCurPos == _T('\0'));
}

class MySingleton
{
public:
	static MySingleton *GetInstance(){
		if (mMySingletonP == NULL) {
			mMySingletonP = new MySingleton;
		}

		return mMySingletonP;
	}

private:
	MySingleton(){
	}

	MySingleton(const MySingleton & ){
	}

	MySingleton & operator=(const MySingleton & ) {
		// Wrong but we just want a private implementation
		// We simply want no one call this.
		return *((MySingleton *)NULL);
	}

	~MySingleton(){
	}

	static MySingleton *mMySingletonP;

};

class Singleton
{
public:
	static Singleton &GetInstance(){
		static Singleton instance;

		return instance;
	}

private:
	Singleton(){
	}

	Singleton(const Singleton & ){
	}

	Singleton & operator=(const Singleton & ) {
		// We simply want no one call this.
		return *this;
	}

	~Singleton(){
	}

};

static MySingleton *GetInstance() {

     if (mMySingletonP == NULL) {
           // Aquire a lock here
           if (mMySingletonP == NULL) {
                mMySingletonP = new MySingleton;
           }
           // relase lock here
     }

     return mMySingletonP;
}

int _tmain(int argc, _TCHAR* argv[])
{
	int nTmp1 = 10;
	Singleton &firstRef = Singleton::GetInstance();

	Singleton &otherRef = Singleton::GetInstance();

	return 0;
}

int sprintf_s1(char* buffer, size_t bufferSize, const char *formattingString, ...)
{
  int size = -1;

  if (bufferSize < 1 || buffer == NULL) {
	  return size;
  }
  va_list argptr;

  va_start(argptr, formattingString);

  //FILE *nul = fopen("nul", "w");
  
  // calculate the size of output by nul device.
  size = vfprintf(stderr, formattingString, argptr);
  //fclose(nul);

  if (size > bufferSize) {
    return -1;
  }

  size = vsprintf(buffer, formattingString, argptr);
  // ensure null termination.
  buffer[(size > 0) ? (size-1) : 0] = '\0';

  va_end(argptr);

   return size;
}