src/lib/ASN1ContentHandler.h
branchv_0
changeset 27 d9cc2d356cdb
parent 26 e39de9b8b3a1
child 35 bf2c546f49d1
equal deleted inserted replaced
26:e39de9b8b3a1 27:d9cc2d356cdb
    89 		TagClass tagClass;
    89 		TagClass tagClass;
    90 		PC pc;
    90 		PC pc;
    91 		uint64_t tag;
    91 		uint64_t tag;
    92 	};
    92 	};
    93 
    93 
    94 	enum class StringType : uint64_t {
       
    95 		UTF8String = 0xC,
       
    96 		NumericString = 0x12,
       
    97 		PrintableString = 0x13,
       
    98 		T61String = 0x14,
       
    99 		VideotexString = 0x15,
       
   100 		IA5String = 0x16,
       
   101 		GraphicString = 0x19,
       
   102 		VisibleString = 0x1A,
       
   103 		GeneralString = 0x1B,
       
   104 		UniversalString = 0x1C,
       
   105 		CharacterString = 0x1D,
       
   106 		BMPString = 0x1E,
       
   107 	};
       
   108 
       
   109 	enum class DateTimeType : uint64_t {
       
   110 		UTCTime,
       
   111 		GeneralizedTime,
       
   112 		Time,
       
   113 		Date,
       
   114 		TimeOfDay,
       
   115 		DateTime,
       
   116 		Duration,
       
   117 		// TODO: review date/time types
       
   118 	};
       
   119 
       
   120 
       
   121 	// TODO: separate implementation of particular types from the interface, separate SPI from API?
    94 	// TODO: separate implementation of particular types from the interface, separate SPI from API?
   122 
    95 
   123 	class Integer {
    96 	class Integer {
   124 	private:
    97 	private:
   125 		// TODO: use std::string (of octets, not ASCII) instead of std::vector?
    98 		// TODO: use std::string (of octets, not ASCII) instead of std::vector?
   290 	virtual void writeStreamStart() = 0;
   263 	virtual void writeStreamStart() = 0;
   291 	virtual void writeStreamEnd() = 0;
   264 	virtual void writeStreamEnd() = 0;
   292 
   265 
   293 	virtual void writeCollectionStart(const Header& header) = 0;
   266 	virtual void writeCollectionStart(const Header& header) = 0;
   294 	virtual void writeCollectionEnd() = 0;
   267 	virtual void writeCollectionEnd() = 0;
   295 	virtual void writeBoolean(bool value) = 0;
   268 	virtual void writeBoolean(const Header& header, bool value) = 0;
   296 	virtual void writeNull() = 0;
   269 	virtual void writeNull(const Header& header) = 0;
   297 	virtual void writeInteger(Integer value) = 0;
   270 	virtual void writeInteger(const Header& header, Integer value) = 0;
   298 	/**
   271 	/**
   299 	 * @param type original type in ASN.1
   272 	 * @param type original type in ASN.1
   300 	 * @param value original text converted to UTF-8
   273 	 * @param value original text converted to UTF-8
   301 	 */
   274 	 */
   302 	virtual void writeTextString(StringType type, std::string value) = 0;
   275 	virtual void writeTextString(const Header& header, std::string value) = 0;
   303 	/**
   276 	/**
   304 	 * @param value arbitrary sequence of octets (bytes), usually not a human-readable text
   277 	 * @param value arbitrary sequence of octets (bytes), usually not a human-readable text
   305 	 */
   278 	 */
   306 	virtual void writeOctetString(std::string value) = 0;
   279 	virtual void writeOctetString(const Header& header, std::string value) = 0;
   307 	/**
   280 	/**
   308 	 * @param value arbitrary sequence of bits (booleans), usually not a human-readable text
   281 	 * @param value arbitrary sequence of bits (booleans), usually not a human-readable text
   309 	 */
   282 	 */
   310 	virtual void writeBitString(std::vector<bool> value) = 0;
   283 	virtual void writeBitString(const Header& header, std::vector<bool> value) = 0;
   311 	virtual void writeOID(ObjectIdentifier value) = 0;
   284 	virtual void writeOID(const Header& header, ObjectIdentifier value) = 0;
   312 	virtual void writeDateTime(DateTimeType type, DateTime value) = 0;
   285 	virtual void writeDateTime(const Header& header, DateTime value) = 0;
   313 	// Object descriptor
   286 	// Object descriptor
   314 	// virtual void writeReal(float value) = 0;
   287 	// virtual void writeReal(float value) = 0;
   315 	// Enumerated
   288 	// Enumerated
   316 	// Embedded PVD
   289 	// Embedded PVD
   317 	// Relative OID
   290 	// Relative OID
   343 
   316 
   344 	void writeCollectionEnd() override {
   317 	void writeCollectionEnd() override {
   345 		handlers.forward(&ASN1ContentHandler::writeCollectionEnd);
   318 		handlers.forward(&ASN1ContentHandler::writeCollectionEnd);
   346 	}
   319 	}
   347 
   320 
   348 	void writeBoolean(bool value) override {
   321 	void writeBoolean(const Header& header, bool value) override {
   349 		handlers.forward(&ASN1ContentHandler::writeBoolean, value);
   322 		handlers.forward(&ASN1ContentHandler::writeBoolean, header, value);
   350 	}
   323 	}
   351 
   324 
   352 	void writeNull() override {
   325 	void writeNull(const Header& header) override {
   353 		handlers.forward(&ASN1ContentHandler::writeNull);
   326 		handlers.forward(&ASN1ContentHandler::writeNull, header);
   354 	}
   327 	}
   355 
   328 
   356 	void writeInteger(Integer value) override {
   329 	void writeInteger(const Header& header, Integer value) override {
   357 		handlers.forward(&ASN1ContentHandler::writeInteger, value);
   330 		handlers.forward(&ASN1ContentHandler::writeInteger, header, value);
   358 	}
   331 	}
   359 
   332 
   360 	void writeTextString(StringType type, std::string value) override {
   333 	void writeTextString(const Header& header, std::string value) override {
   361 		handlers.forward(&ASN1ContentHandler::writeTextString, type, value);
   334 		handlers.forward(&ASN1ContentHandler::writeTextString, header, value);
   362 	}
   335 	}
   363 
   336 
   364 	void writeOctetString(std::string value) override {
   337 	void writeOctetString(const Header& header, std::string value) override {
   365 		handlers.forward(&ASN1ContentHandler::writeOctetString, value);
   338 		handlers.forward(&ASN1ContentHandler::writeOctetString, header, value);
   366 	}
   339 	}
   367 
   340 
   368 	void writeBitString(std::vector<bool> value) override {
   341 	void writeBitString(const Header& header, std::vector<bool> value) override {
   369 		handlers.forward(&ASN1ContentHandler::writeBitString, value);
   342 		handlers.forward(&ASN1ContentHandler::writeBitString, header, value);
   370 	}
   343 	}
   371 
   344 
   372 	void writeOID(ObjectIdentifier value) override {
   345 	void writeOID(const Header& header, ObjectIdentifier value) override {
   373 		handlers.forward(&ASN1ContentHandler::writeOID, value);
   346 		handlers.forward(&ASN1ContentHandler::writeOID, header, value);
   374 	}
   347 	}
   375 
   348 
   376 	void writeDateTime(DateTimeType type, DateTime value) override {
   349 	void writeDateTime(const Header& header, DateTime value) override {
   377 		handlers.forward(&ASN1ContentHandler::writeDateTime, type, value);
   350 		handlers.forward(&ASN1ContentHandler::writeDateTime, header, value);
   378 	}
   351 	}
   379 
   352 
   380 };
   353 };
   381 
   354 
   382 
   355