src/lib/ASN1ContentHandler.h
branchv_0
changeset 20 fac034e3e867
parent 19 b7431bc6069b
child 21 705036445672
equal deleted inserted replaced
19:b7431bc6069b 20:fac034e3e867
   110 			return value;
   110 			return value;
   111 		}
   111 		}
   112 
   112 
   113 	};
   113 	};
   114 
   114 
       
   115 	class ObjectIdentifier {
       
   116 	private:
       
   117 		// TODO: use std::string (of octets, not ASCII) instead of std::vector?
       
   118 		// TODO: use this class across Relational pipes as one of basic types?
       
   119 		std::vector<uint8_t> data;
       
   120 
       
   121 	public:
       
   122 
       
   123 		/**
       
   124 		 * @param data integer octets as in BER encoding
       
   125 		 */
       
   126 		ObjectIdentifier(std::vector<uint8_t> data) : data(data) {
       
   127 			// TODO: cache size and element values?
       
   128 		}
       
   129 
       
   130 		virtual ~ObjectIdentifier() {
       
   131 		}
       
   132 
       
   133 		/**
       
   134 		 * @return number of elements, not octets
       
   135 		 */
       
   136 		size_t size() const {
       
   137 			return 0; // FIXME: correct OID size
       
   138 		}
       
   139 
       
   140 		/**
       
   141 		 * @param index 0 = root element
       
   142 		 * @return value of the element at given position
       
   143 		 */
       
   144 		const uint8_t& operator[](std::size_t index) const {
       
   145 			return data[index]; // FIXME: correct OID value
       
   146 		}
       
   147 
       
   148 		const std::string toString() const {
       
   149 			if (data.size() == 0) return "";
       
   150 
       
   151 			std::stringstream result;
       
   152 
       
   153 			result << (data[0] / 40) << "." << (data[0] % 40); // first two elements are encoded in the first octet
       
   154 
       
   155 			for (size_t i = 1, limit = data.size(), octet = 0, element = 0; i < limit; i++) {
       
   156 				octet = data[i];
       
   157 				element = element << 7 | (octet & 0xFF >> 1);
       
   158 				// TODO: throw exception if the element value overflows? (should not happen) or format even longer values
       
   159 				if ((octet & 1 << 7) == 0) {
       
   160 					result << "." << element;
       
   161 					element = 0;
       
   162 				}
       
   163 			}
       
   164 
       
   165 			return result.str();
       
   166 		}
       
   167 
       
   168 	};
       
   169 
   115 	virtual ~ASN1ContentHandler() = default;
   170 	virtual ~ASN1ContentHandler() = default;
   116 	
   171 
   117 	// TODO: more metadata, support OID decoding and ASN.1 modules (schema), probably through a plug-in
   172 	// TODO: more metadata, support OID decoding and ASN.1 modules (schema), probably through a plug-in
   118 
   173 
   119 	virtual void writeStreamStart() = 0;
   174 	virtual void writeStreamStart() = 0;
   120 	virtual void writeStreamEnd() = 0;
   175 	virtual void writeStreamEnd() = 0;
   121 
   176 
   123 	virtual void writeCollectionEnd() = 0;
   178 	virtual void writeCollectionEnd() = 0;
   124 	virtual void writeBoolean(bool value) = 0;
   179 	virtual void writeBoolean(bool value) = 0;
   125 	virtual void writeNull() = 0;
   180 	virtual void writeNull() = 0;
   126 	virtual void writeInteger(Integer value) = 0;
   181 	virtual void writeInteger(Integer value) = 0;
   127 	virtual void writeString(StringType type, std::string value) = 0;
   182 	virtual void writeString(StringType type, std::string value) = 0;
   128 	// virtual void writeOID(std::string value) = 0;
   183 	virtual void writeOID(ObjectIdentifier value) = 0;
   129 	// Object descriptor
   184 	// Object descriptor
   130 	// virtual void writeReal(float value) = 0;
   185 	// virtual void writeReal(float value) = 0;
   131 	// Enumerated
   186 	// Enumerated
   132 	// Embedded PVD
   187 	// Embedded PVD
   133 	// Relative OID
   188 	// Relative OID
   184 
   239 
   185 	void writeString(StringType type, std::string value) override {
   240 	void writeString(StringType type, std::string value) override {
   186 		handler->writeString(type, value);
   241 		handler->writeString(type, value);
   187 	}
   242 	}
   188 
   243 
       
   244 	void writeOID(ObjectIdentifier value) override {
       
   245 		handler->writeOID(value);
       
   246 	}
       
   247 
       
   248 
   189 #undef handler
   249 #undef handler
   190 
   250 
   191 };
   251 };
   192 
   252 
   193 
   253