Quantcast
Jump to content

Welcome to HeLLsGamers

Welcome to HeLLsGamers, like most online communities you must register to view or post in our community, but don't worry this is a simple free process that requires minimal information for you to signup. Be apart of HeLLsGamers by signing in or creating an account.
  • Start new topics and reply to others
  • Subscribe to topics and forums to get email updates
  • Get your own profile page and make new friends
  • Send personal messages to other members.
Sign in to follow this  
Hydranix_

Steamid C++ Class Source Code

Recommended Posts

Here's a SteamID C++ class I wrote to make handling SteamIDs extremely easy.

 

Constructed with from std::string of a Steam ID in either legacy (STEAM_0:1:xxxxxx) or ID3 (U:1:xxxxxx) format.

 

Can also be constructed from an 64 bit ID struct, aka the long number in steam community profile urls.

 

The class takes up only 4 bytes ( sizeof(uint32_t) ) of memory for each SteamID object.

 

operator== for equality checking against other SteamIDs

operator<< and operator>> for serialization (saving to file or database) and is human readable (std::cout)

 

SteamIDs constructed from any format can easily be converted with the id() id3() id_i32() and if_i64() functions.

The conversion is built on each function call making the object itself have a footprint of only 4 bytes since based on my observation, the account id (32bits) is the only meaningful part of a SteamID.

 

The Code:

 

Header

#pragma once
#include <string>
#include <vector>
#include <cstdint>

// For splitting strings
std::vector<std::string> &split(const std::string &s, char delim, std::vector<std::string> &elems);
std::vector<std::string> split(const std::string &s, char delim);

// https://developer.valvesoftware.com/wiki/SteamID
// When representing a SteamID in a program you only need
//   32bits to hold the actual account ID. Although valve
//   says that a 64bit data struct is required, the upper
//   32 bits of that struct are always identical for every
//   SteamID
class SteamID {
public:
 // Default constructor for empty SteamID
 SteamID();
 // Construct from either SteamID or SteamID3
 SteamID(std::string &strSteamID);
 // Construct from SteadID64
 SteamID(uint64_t &_steamID64);
 // Construct copy
 SteamID(const SteamID& from);
~SteamID();
// serialization, for human readable output use id() or id3()
friend std::ostream& operator<<(std::ostream &os, const SteamID& s);
friend std::istream& operator>>(std::istream &is, SteamID& s);
// returns legacy SteamID
std::string id() const;
// returns SteamID3
std::string id3() const;
// returns SteamID64
uint64_t id_i64() const;
// returns account id
uint32_t id_i32() const;
private:
// The internal lower 32bits of SteamID64 (account ID)
uint32_t _ID;
};

 

 

Source

#include "SteamID.hpp"
#include <sstream>
#define ID64_HIGHPART 0x0110000100000000
SteamID::SteamID()
 : _ID(0)
{}
SteamID::SteamID(std::string &strSteamID)
 : _ID(0)
{
 std::vector<std::string> IDTokens = split(strSteamID, ':');
 if (IDTokens.size() == 3)
 {
   if (strSteamID[0] == 'S')
   {
  _ID += strtoll(IDTokens[1].c_str(), nullptr, 10);
  _ID += (strtoll(IDTokens[2].c_str(), nullptr, 10) * 2);
   }
   else if (strSteamID[0] == 'U')
   {
  _ID += strtoll(IDTokens[2].c_str(), nullptr, 10);
  if (!(_ID % 2))
    _ID++;
   }
   else
   { // failed
  _ID = 0;
   }
 }
 else
 { // failed
   _ID = 0;
 }
}
SteamID::SteamID(uint64_t &_steamID64)
{
 if ((_steamID64 & ID64_HIGHPART) == ID64_HIGHPART)
 {
   // cast away upper 32 bits
   _ID = static_cast<uint32_t>(_steamID64);
 }
 else
 { // failed
   _ID = 0;
 }
}
SteamID::SteamID(const SteamID & from)
: _ID(from._ID)
{}
SteamID::~SteamID(){}
std::string SteamID::id() const
{
 std::string strID("STEAM_0:");
 if (_ID % 2)
 {
   strID.append("1:");
 }
 else
 {
   strID.append("0:");
 }
 strID.append(std::to_string(_ID / 2));
 return strID;
}
std::string SteamID::id3() const
{
 std::string strID3("U:1:");
 strID3.append(std::to_string(_ID));
 return strID3;
}
uint64_t SteamID::id_i64() const
{ return (static_cast<uint64_t>(_ID) | ID64_HIGHPART); }
uint32_t SteamID::id_i32() const
{ return uint32_t(_ID); }
std::ostream& operator<<(std::ostream& os, const SteamID& s)
{
 os << s._ID;
 return os;
}
std::istream & operator >> (std::istream & is, SteamID & s)
{
 is >> s._ID;
 return is;
}

std::vector<std::string> &split(const std::string &s, char delim, std::vector<std::string> &elems)
{
 std::stringstream ss(s);
 std::string item;
 while (std::getline(ss, item, delim))
   elems.push_back(item);
 return elems;
}

std::vector<std::string> split(const std::string &s, char delim)
{
 std::vector<std::string> elems;
 split(s, delim, elems);
 return elems;
}

  • Like 1

Share this post


Link to post
Share on other sites

If you're interested in any HGDC Development please let me or thomasjosif know. You seem to know how to code well enough, and I'm sure your skills can be used to help the HGDC team. If you'd like to learn sourcemod let me know as well.

  • Like 1

Share this post


Link to post
Share on other sites
Awards

Create an account or sign in to comment

You need to be a member in order to leave a comment

Create an account

Sign up for a new account in our community. It's easy!

Register a new account

Sign in

Already have an account? Sign in here.

Sign In Now
Sign in to follow this  

Important Information

We have placed cookies on your device to help make this website better. You can adjust your cookie settings, otherwise we'll assume you're okay to continue. Privacy Policy