c++以太坊访问：封装编码数据类型（二）

最新推荐文章于 2022-05-19 19:53:04 发布
最新推荐文章于 2022-05-19 19:53:04 发布
阅读量365 收藏
点赞数
分类专栏： 区块链 文章标签： c++ 区块链
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fallinlove520/article/details/115184832
版权

需要对solidity的应用二进制接口进行编码，因此简单的模仿json库的类型格式进行封装。

头文件如下：

#pragma once
#include "define.h"
enum ValueType {
	nullValue = 0, ///< 'null' value
	intValue,      ///< signed integer value
	uintValue,     ///< unsigned integer value
	longlongValue,
	realValue,     ///< double value
	stringValue,   ///< UTF-8 string value
	booleanValue,  ///< bool value
	ListStringValue,    ///< array value (ordered list)
	ListDoubleValue,
	ListIntValue,
	AddressValue,
	ListAddressValue,
	ByteValue    ///< object value (collection of name/value pairs).
};

const int INTMAX = 2147483647;
const int INTMIN = -2147483647;
const unsigned int TOTALMIN = 4294967295;
typedef list<string> listStr;
typedef list<int> listInt;
typedef list<double> listDouble;
typedef list<Address*> listAddress;

class EthType
{
public:
	EthType(ValueType type = nullValue);
	EthType(int value);
	EthType(unsigned int value);
	EthType(int64_t value);
	EthType(uint64_t value);
	EthType(Address *value);
	EthType(float value);
	EthType(double value);
	EthType(const string& value);
	EthType(const char *value);
	EthType(bool value);
	EthType(const EthType& other);
	EthType(listStr *value);
	EthType(listAddress *value);
	EthType(list<double> *value);
	EthType(list<int> *value);
	EthType(byte *value);
	~EthType();

	int asInt()const;
	unsigned int asUint()const;
	int64_t asInt64()const;
	uint64_t asUint64()const;
	float asFloat()const;
	double asDouble()const;
	bool asBool()const;
	string asString()const;
	listStr asListString();
	list<double> asListDouble();
	list<int> asListint();
	byte* asBytes();
	Address* asAddress()const;
	listAddress asListAddress()const;
	bool isNull() const;
	bool isBool() const;
	bool isInt() const;
	bool isInt64() const;
	bool isUInt() const;
	bool isUInt64() const;
	bool isDouble() const;
	bool isString() const;
	bool isBytes() const;
	bool isListString()const;
	bool isListDouble()const;
	bool isListint()const;
	bool isAddress()const;
	bool isListAddress()const;
	bool empty() const;

	void setType(ValueType type_);
	ValueType getType()const;

	void setStringValue(const string& value);
	void setAddressValue(Address* value);
	void setIntValue(int value);
	void setUIntValue(unsigned int value);
	void setInt64Value(int64_t value);
	void setUInt64Value(uint64_t value);
	void setFloatValue(float value);
	void setDoubleValue(double value);
	void setCharsValue(const char *value);
	void setBoolValue(bool value);
	void setListStringValue(listStr *value);
	void setListDoubleValue(list<double> *value);
	void setListIntValue(list<int> *value);
	void setBytesValue(byte *value);
	void setListAddressValue(listAddress *value);

private:
	union ValueHolder {
		long long int_;
		unsigned long long uint_;
		double real_;
		bool bool_;
		char* string_; // if allocated_, ptr to { unsigned, char[] }.
		listStr *l_str;
		listInt *l_int;
		listDouble *l_double;
		byte *bytes;
		Address* addr;
		listAddress*l_addr;
	} value_;
    //此处使用联合体来进行存储数据（占用同一空间）


	bool isAllocated = false;
	ValueType type;
};

cpp文件：

#include "TypeValue.h"

static inline char* duplicateAndPrefixStringValue(const char* value,
	unsigned int length) {	
	if (value == nullptr) return nullptr;
	auto newString = (char *)malloc(length + 1);
	memcpy(newString, value, length + 1);

	return newString;
}
EthType::EthType(ValueType type)
{
	this->type = type;
}

EthType::EthType(int value)
{
	setIntValue(value);
}
void EthType::setIntValue(int value)
{
	type = intValue;
	value_.int_ = value;
}
EthType::EthType(unsigned int value)
{
	setUIntValue(value);
}
void EthType::setUIntValue(unsigned int value)
{
	type = uintValue;
	value_.uint_ = value;
}
EthType::EthType(int64_t value)
{
	setInt64Value(value);
}
void EthType::setInt64Value(int64_t value)
{
	type = longlongValue;
	value_.int_ = value;
}
void EthType::setUInt64Value(uint64_t value)
{
	type = uintValue;
	value_.uint_ = value;
}

EthType::EthType(uint64_t value)
{
	setUInt64Value(value);
}
EthType::EthType(float value)
{
	setFloatValue(value);
}
EthType::EthType(double value)
{
	setDoubleValue(value);
}
void EthType::setFloatValue(float value)
{
	type = realValue;
	value_.real_ = value;
}
void EthType::setDoubleValue(double value)
{
	type = realValue;
	value_.real_ = value;
}
EthType::EthType(const string& value)
{
	setStringValue(value);
}
void EthType::setStringValue(const string &value)
{
	type = stringValue;
	if (value_.string_ != nullptr && isAllocated)
	{
		free(value_.string_);
		value_.string_ = nullptr;
	}

	value_.string_ = duplicateAndPrefixStringValue(value.data(), static_cast<unsigned>(value.length()));
	isAllocated = true;
}

EthType::EthType(const char *value)
{
	setCharsValue(value);
}
void EthType::setCharsValue(const char *value)
{
	type = stringValue;
	if (value_.string_ != nullptr&& isAllocated)
	{
		free(value_.string_);
		value_.string_ = nullptr;
	}

	value_.string_ = duplicateAndPrefixStringValue(value, static_cast<unsigned>(strlen(value)));
	isAllocated = true;
}
void EthType::setBoolValue(bool value)
{
	type = booleanValue;
	value_.bool_ = value;
}
EthType::EthType(bool value)
{
	setBoolValue(value);
}
EthType::EthType(const EthType& other)
{
	this->type = other.type;
	if (type == stringValue)
	{
		string cc = other.asString();
		if (value_.string_ != nullptr&& isAllocated)
		{
			free(value_.string_);
			value_.string_ = nullptr;
		}
			
		value_.string_ = duplicateAndPrefixStringValue(cc.data(), static_cast<unsigned>(cc.length()));
		isAllocated = true;
	}
}
void EthType::setType(ValueType type_)
{
	type = type_;
}
ValueType EthType::getType()const
{
	return type;
}
EthType::~EthType()
{
	if (value_.string_ != nullptr && type == stringValue)
		free(value_.string_);
//	value_.uint_ = 0;
}

int EthType::asInt()const
{
	switch (type)
	{
	case intValue:
		return value_.int_;
	case uintValue:
		return (unsigned int)value_.int_;
	case realValue:
		return (int)value_.real_;
	case booleanValue:
		return value_.bool_ ? 1 : 0;
	default:
		break;
	}
	return false;
}
unsigned int EthType::asUint()const
{
	switch (type)
	{
	case intValue:
		return (unsigned int)value_.int_;
	case uintValue:
		return value_.int_;
	case realValue:
		return (unsigned int)value_.real_;
	case booleanValue:
		return value_.bool_ ? 1 : 0;
	default:
		break;
	}
	return false;
}
int64_t EthType::asInt64()const
{
	switch (type)
	{
	case intValue:
		return value_.int_;
	case uintValue:
		return value_.int_;
	case realValue:
		return (int64_t)value_.real_;
	case longlongValue:
		return (int64_t)value_.int_;
	case booleanValue:
		return value_.bool_ ? 1 : 0;
	default:
		break;
	}
	return false;
}
uint64_t EthType::asUint64()const
{
	switch (type)
	{
	case intValue:
		return value_.int_;
	case uintValue:
		return value_.int_;
	case realValue:
		return (uint64_t)value_.real_;
	case longlongValue:
		return (uint64_t)value_.int_;
	case booleanValue:
		return value_.bool_ ? 1 : 0;
	default:
		break;
	}
	return false;
}
float EthType::asFloat()const
{
	switch (type)
	{
	case intValue:
		return (float)value_.int_;
	case uintValue:
		return (float)value_.uint_;
	case longlongValue:
		return (float)value_.int_;
	case realValue:
		return value_.real_;
	default:
		break;
	}
	return false;
}
double EthType::asDouble()const
{
	switch (type)
	{
	case intValue:
		return (double)value_.int_;
	case uintValue:
		return (double)value_.uint_;
	case longlongValue:
		return (double)value_.int_;
	case realValue:
		return value_.real_;
	default:
		break;
	}
	return false;
}
bool EthType::asBool()const
{
	switch (type)
	{
	case intValue:
		return value_.int_;
	case uintValue:
		return value_.uint_;
	case longlongValue:
		return value_.int_;
	case realValue:
		return value_.real_;
	case stringValue:
		return value_.string_;
	case booleanValue:
		return value_.bool_;
	default:
		break;
	}
	return false;
}
string EthType::asString()const
{
	switch (type) {
	case nullValue:
		return "";
	case stringValue:
	{
		if (value_.string_ == nullptr)
			return "";	
		return string(value_.string_);
	}
	case booleanValue:
		return value_.bool_ ? "true" : "false";
	case intValue:
		return to_string(value_.int_);
	case uintValue:
		return to_string(value_.uint_);
	case realValue:
		return to_string(value_.real_);
	default:
		cout << "type is not convertible to string";
	}
	return "";
}


bool EthType::isNull() const
{
	return type == nullValue;
}
bool EthType::isBool() const
{
	return type == booleanValue;
}
bool EthType::isInt() const
{
	switch (type)
	{
	case nullValue:
		break;
	case intValue:
		return value_.int_ > INTMIN && value_.int_ <= INTMAX;
	case uintValue:
		return value_.int_ >= 0 && value_.int_ <= INTMAX;
	case longlongValue:
		return  value_.int_ < INTMAX;
	case realValue:	
		break;
	default:
		break;
	}
	return false;
}
bool EthType::isInt64() const
{
	return type == intValue;
}
bool EthType::isUInt() const
{
	return type == uintValue;
}
bool EthType::isUInt64() const
{
	return type == uintValue; 
}
bool EthType::isDouble() const
{
	return type == intValue || type == uintValue || type == realValue;
}
bool EthType::isString() const
{
	return type == stringValue;
}

bool EthType::empty() const
{
	return type == nullValue;
}
listStr EthType::asListString()
{
	if (type == ListStringValue)
	{
		return *value_.l_str;
	}
	else
		return listStr();
}
EthType::EthType(listStr *value)
{
	setListStringValue(value);
}

EthType::EthType(list<double> *value)
{
	setListDoubleValue(value);
}
EthType::EthType(list<int> *value)
{
	setListIntValue(value);
}
list<double> EthType::asListDouble()
{
	if (type == ListDoubleValue)
	{
		return *value_.l_double;
	}
	else
		return list<double>();
}
list<int> EthType::asListint()
{
	if (type == ListIntValue)
	{
		return *value_.l_int;
	}
	else
		return list<int>();

}
void EthType::setListStringValue(listStr *value)
{
	type = ListStringValue;

	value_.l_str = value;
}
void EthType::setListDoubleValue(list<double> *value)
{
	type = ListDoubleValue;

	value_.l_double = value;
}
void EthType::setListIntValue(list<int> *value)
{
	type = ListIntValue;

	value_.l_int = value;
}
void EthType::setBytesValue(byte *value)
{
	type = ByteValue;
	if (value_.bytes != nullptr && isAllocated)
	{
		free(value_.bytes);
		value_.bytes = nullptr;
	}
	value_.bytes = value;
	isAllocated = true;
}
EthType::EthType(byte *value)
{
	setBytesValue(value);
}
byte* EthType::asBytes()
{
	return value_.bytes;
}
bool EthType::isBytes() const
{
	return type == ByteValue;
}
bool EthType::isListString()const
{
	return type == ListStringValue;
}
bool EthType::isListDouble()const
{
	return type == ListDoubleValue;
}
bool EthType::isListint()const
{
	return type == ListIntValue;
}
EthType::EthType(Address *value)
{
	setAddressValue(value);
}
void EthType::setAddressValue(Address* value)
{
	type = AddressValue;
	if (value != nullptr)
	{
		value_.addr = value;
	}
}
bool EthType::isAddress()const
{
	return type == AddressValue;
}
Address* EthType::asAddress()const
{
	if (type == AddressValue)
	{
		return value_.addr;
	}
	else
		return nullptr;
}
EthType::EthType(listAddress *value)
{
	setListAddressValue(value);
}

listAddress EthType::asListAddress()const
{
	if (type == ListAddressValue)
		return *value_.l_addr;
	return listAddress();
}
bool EthType::isListAddress()const
{
	return type == ListAddressValue;
}
void EthType::setListAddressValue(listAddress * value)
{
	type = ListAddressValue;
	value_.l_addr = value;
}

为什么要进行类型的封装呢？主要是方便于后期对应用二进制接口编码时好进行相关的操作。（代码比较粗糙，没有进行优化）

对于address类型的封装，我用得比较笨的方式去实现（类里面存储一个string变量），为什么不直接存储string的原因是，address 和 string应用二进制接口编码不一样，所以才进行这样的封装。

class Address
{
public:
	Address(std::string hexVal);
	std::string getValue();
	std::string getType();
	
	
private:
	std::string value;

};

Address::Address(std::string hexVal)
{
	value = hexVal;
}

std::string Address::getValue()
{
	return value;
}

std::string Address::getType() {
	return "Address";
}

在这里只是为了实现功能，达到相关的目的，没有对其进行重构优化等。

Tjmies
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
VC++实现以太网通讯
12-21
在VC++平台上实现以太网通讯，包括服务器端的实现和客户端的实现。
C++ Redis mset二进制数据接口封装方案
12-22
C++ Redis mset 二进制数据接口封装方案 　需求 　C++中使用hiredis客户端接口访问redis； 　需要使用mset一次设置多个二进制数据 　以下给出三种封装实现方案； 　简单拼接方案 　在redis-cli中，mset的语法...
Linux网卡配置解释
黑司机墨寒
06-03 1386
vim /etc/sysconfig/network-scripts/eth0 DEVICE=eth0 //网卡名称 TYPE=Ethernet //网卡类型为以太网 ONBOOT=yes //开机自启该网卡 NM_CONTROLLED=no //关闭NetworkManager BOOTPROTO=static //网卡设置为静态方式 ...
jsoncpp v0.5中的一个bug
weixin_33709609的博客
12-28 117
本文目的 今天在使用jsoncpp 0.5的时候很偶然的发现了一个bug，由于jsoncpp在业界被广泛使用，所以有必要将这个bug指出。   一个例子 /* * bug_demo.cpp * * Created on: 2011-11-22 * Author: bourneli */ #include "json/json.h" #include &l...
linux查看网卡是什么类型,检测Linux中的网络连接类型
weixin_34014076的博客
05-01 956
如何在C Linux应用程序中检测网络连接类型,即它是有线还是无线？如果设备有多个网络接口,我想检测正在使用的接口的连接类型.谢谢,解决方法:我一直在寻找那个答案.我在opensuse gitorious中找到了一段有趣的代码.显然,他们使用以下代码来获取接口类型：get_iface_type () {local IF=$1 TYPEtest -n "$IF" || return 1test -d...
jsoncpp库常用源码解析及使用介绍（一）
Hearz的博客
02-09 4474
       JSON(JavaScript Object Notation, JS 对象简谱) 是一种轻量级的数据交换格式。它基于ECMAScript (欧洲计算机协会制定的js规范)的一个子集，采用完全独立于编程语言的文本格式来存储和表示数据。简洁和清晰的层次结构使得 JSON 成为理想的数据交换语言。 易于人阅读和编写，同时也易于机器解析和生成，并有效地提升网络传输效率。JSON的应用场景非...
c++封装数据结构，使数据结构具有元信息，方便实现数据流的解码与编码.rar
最新发布
11-22
在这个场景中，"c++封装数据结构，使数据结构具有元信息"指的是通过创建C++类来包装特定的数据结构，并为其添加元信息，以便更高效地进行数据流的解码与编码。 元信息（Metadata）通常是指关于数据的数据，如数据的...
详细分析C++ 数据封装和数据抽象
01-19
C++ 数据封装 所有的 C++ 程序都有以下两个基本要素： 程序语句（代码）：这是程序中执行动作的部分，它们被称为函数。 程序数据：数据是程序的信息，会受到程序函数的影响。 封装是面向对象编程中的把数据和操作...
C++进程共享数据封装成类实例
01-01
本文实例讲述了C++进程共享数据封装成类的方法，分享给大家供大家参考。具体方法如下： ShareMemory.cpp源文件如下： 代码如下:#include “ShareMemory.h”    CShareMemory::CShareMemory(const char* ...
C++ rapidjson 对类序列化(完美二次封装)下载
02-02
本工程源码，基于rapidjson实现二次封装，使C++序列化一个类的变得代码非常小，耦合性非常低，且不损失原有序列化性能。详细使用可关联本人博客:http://blog.csdn.net/lightspear/article/details/54836656
JsonCpp源码，不使用编译库方式，直接运用到项目中
11-16
使用Jsoncpp包中的.cpp和.h文件放入项目中用，新建项目之后，将jsoncpp-master\include\json下的json目录直接复制到项目目录下，将jsoncpp-master\src\lib_json下面的json_reader.cpp、json_tool.h、json_value.cpp、json_writer.cpp复制到项目目录下
[json]C++读取json文件
08-20 839
封装的接口 JsonConfig.h。测试代码配置 games.json。资源信息有json库。
QT中Json的使用方法(类和json字符串相互转换的方法)
u011555996的博客
05-19 7323
在QT5.0版本以后支持对Json的使用，直接使用QT提供的json类进行数据的组织和解析。 Json类 介绍 QJsonDoucument 它封装了一个完整的 JSON 文档，并且可以从 UTF-8 编码的基于文本的表示以及 Qt 自己的二进制格式读取和写入该文档。 QJsonArray JSON 数组是一个值列表。可以通过从数组中插入和删除 QJsonValue 来操作该列表。 QJsonObject JSON 对象是键值对的列表，其中键是唯一的字符串，值由 QJs
Type ‘string | string[]‘ is not assignable to type ‘string | undefined‘.
热门推荐
weixin_48786946的博客
07-27 5万+
在我用react + typescript写项目的时候，ts总会报一些类型的错误，比如下图的错误：Type ‘string | string[]’ is not assignable to type ‘string | undefined’. 在我确定我的类型是正确的情况下不理解为啥报这样一个错，在网上找了很久，就是加类型断言，解决方法如下图：（值 as 类型） 这样就不会报错拉。 关于typescript类型断言，整理知识点如下： typescript很强大，但是用不好时也会很头痛，开发遇到类型错误的
Json的解析和生成
Junei110的博客
12-01 261
json: { "shemename":"方案"， "eventname":"事件"， "name":"lucy" "lucy": { "age":17, "gender":"female" } "course": [ "math", "chinese", "English" ] } //读取 bool readJson() { bool res; JSONCPP_STRING errs; Json::Value root; Json::Ch
Type mismatch: cannot convert from Object to String
zhongguobaobao43的博客
01-07 2万+
Type mismatch: cannot convert from Object to String

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值