string_coordinate_conversions.h

Go to the documentation of this file.

// found in the LICENSE file.
 
#ifndef SDK_BASE_STRING_COORDINATES_CONVERSIONS_H_
#define SDK_BASE_STRING_COORDINATES_CONVERSIONS_H_
 
#include <string.h>
#include <string>
#include <vector>
#include <stdio.h>
#include <stdarg.h>
#include <base/inc/platform.h>
#include <base/inc/base_types.h>
 
namespace sdk {
namespace conversions {
 
inline SDKUInt32 MulDivUInt32(SDKUInt32 number, SDKUInt32 numerator,
  SDKUInt32 denominator) {
  SDKUInt64 intermediate = static_cast<SDKUInt64>(number) * numerator;
  return denominator ? ((intermediate /= denominator) <= SDK_MAX_UINT32 ?
    static_cast<SDKUInt32>(intermediate) : SDK_MAX_UINT32) :
      static_cast<SDKUInt32>(intermediate >> 32);
}
 
inline std::string CoordStrPrintf(const std::string& format,
  char* coord_str, size_t coord_str_size,...) {
 
  va_list dividers;
  va_start(dividers, coord_str_size);
 
#if defined(SDK_CC_MSVC)
  vsprintf_s(coord_str, coord_str_size, format.c_str(), dividers);
#else
  vsprintf(coord_str, format.c_str(), dividers);
#endif
  va_end(dividers);
  return coord_str;
}
 
static inline std::string GeoIntToString(SDKUInt32 coord,
  const std::string& format, char positive, char negative, SDKUInt32 max_value,
  const SDKUInt32* dividers, SDKUInt32 divider_count) {
 
  bool sign = true;
  if (static_cast<SDKInt32>(coord) < 0) {
    coord = static_cast<SDKUInt32>(-static_cast<SDKInt32>(coord));
    sign = false;
  }
 
  if (coord > max_value)
    return "";
 
  typedef std::vector<SDKUInt32> Dividers;
  Dividers dividers_vec(dividers, &dividers[divider_count]);
 
  SDKUInt32 scale = 1;
  for (Dividers::const_iterator it = dividers_vec.begin();
    it != dividers_vec.end(); ++it) {
    scale = scale * static_cast<SDKUInt32>(*it);
  }
 
  coord += (0x20000000UL / scale);
 
  scale = 1;
 
  for (Dividers::iterator it = dividers_vec.begin();
    it != dividers_vec.end(); ++it) {
    scale = scale * static_cast<SDKUInt32>(*it);
    SDKUInt32 tmp = MulDivUInt32(coord, scale, 0x40000000UL);
    coord -= MulDivUInt32(tmp, 0x40000000UL, scale);
    (*it) = tmp;
  }
 
  char coord_str[32] = {0};
  switch(dividers_vec.size()) {
    case 3:
      CoordStrPrintf(format, coord_str, sizeof(coord_str),
      dividers_vec[0], dividers_vec[1], dividers_vec[2]);
    break;
   default:
    break;
  }
 
  char* sign_pos = strchr(coord_str, '\\');
 
  if (sign_pos)
    *sign_pos = sign ? positive : negative;
 
  return std::string(coord_str);
}
 
static const char* kLatHemispherePostfix ="%02u#%02u.%04u\'\\";
static const char* kLonHemispherePostfix = "%03u#%02u.%04u\'\\";
static const char* kLatHemispherePrefix = "\\ %02u#%02u.%04u\'";
static const char* kLonHemispherePrefix = "\\ %03u#%02u.%04u\'";
static const char* kLatHemispherePostfixSpaced = "%02u# %02u.%04u\' \\";
static const char* kLonHemispherePostfixSpaced = "%03u# %02u.%04u\' \\";
static const char* kLatHemispherePrefixSpaced = "\\ %02u# %02u.%04u\'";
static const char* kLonHemispherePrefixSpaced = "\\ %03u# %02u.%04u\'";
static const SDKUInt32 kDividers[3] = { 90, 60, 10000 };
 
static const char* kLatHemispherePostfix3 = "%02u#%02u.%03u\'\\";
static const char* kLonHemispherePostfix3 = "%03u#%02u.%03u\'\\";
static const char* kLatHemispherePrefix3 = "\\ %02u#%02u.%03u\'";
static const char* kLonHemispherePrefix3 = "\\ %03u#%02u.%03u\'";
static const char* kLatHemispherePostfix3Spaced = "%02u# %02u.%03u\' \\";
static const char* kLonHemispherePostfix3Spaced = "%03u# %02u.%03u\' \\";
static const char* kLatHemispherePrefix3Spaced = "\\ %02u# %02u.%03u\'";
static const char* kLonHemispherePrefix3Spaced = "\\ %03u# %02u.%03u\'";
static const SDKUInt32 kDividers3[3] = { 90, 60, 1000 };
 
static const unsigned char kDegreeSignB = 0xB0;
static const std::wstring::value_type kDegreeSignW = 0xB0;
 
inline std::string LatToString(SDKInt32 lat) {
  std::string res = GeoIntToString(static_cast<SDKUInt32>(lat),
    kLatHemispherePostfix,
    'N',
    'S',
    0x40000000UL,
    kDividers,
    sizeof(kDividers)/sizeof(kDividers[0]));
  size_t pos = res.find_first_of("#");
  if (pos != std::string::npos) {
    res[pos] = kDegreeSignB;
  }
  return res;
}
 
inline std::string LonToString(SDKInt32 lon) {
  std::string res = GeoIntToString(static_cast<SDKUInt32>(lon),
    kLonHemispherePostfix,
    'E',
    'W',
    0x80000000UL,
    kDividers,
    sizeof(kDividers)/sizeof(kDividers[0]));
  size_t pos = res.find_first_of("#");
  if (pos != std::string::npos) {
    res[pos] = kDegreeSignB;
  }
  return res;
}
 
inline std::wstring LatToWString(SDKInt32 lat) {
  std::string ascii = GeoIntToString(static_cast<SDKUInt32>(lat),
    kLatHemispherePostfix,
    'N',
    'S',
    0x40000000UL,
    kDividers,
    sizeof(kDividers)/sizeof(kDividers[0]));
 
  std::wstring res = std::wstring(ascii.begin(), ascii.end());
  size_t pos = res.find_first_of(L"#");
  if (pos != std::wstring::npos) {
    res[pos] = kDegreeSignW;
  }
  return res;
}
 
inline std::wstring LonToWString(SDKInt32 lon) {
  std::string ascii = GeoIntToString(static_cast<SDKUInt32>(lon),
    kLonHemispherePostfix,
    'E',
    'W',
    0x80000000UL,
    kDividers,
    sizeof(kDividers)/sizeof(kDividers[0]));
 
  std::wstring res = std::wstring(ascii.begin(), ascii.end());
  size_t pos = res.find_first_of(L"#");
  if (pos != std::wstring::npos) {
    res[pos] = kDegreeSignW;
  }
  return res;
}
 
} // conversions
} // namespace sdk
 
#endif