OLD | NEW |
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #ifndef IPC_IPC_MESSAGE_UTILS_H_ | 5 #ifndef IPC_IPC_MESSAGE_UTILS_H_ |
6 #define IPC_IPC_MESSAGE_UTILS_H_ | 6 #define IPC_IPC_MESSAGE_UTILS_H_ |
7 | 7 |
8 #include <limits.h> | 8 #include <limits.h> |
9 #include <stddef.h> | 9 #include <stddef.h> |
10 #include <stdint.h> | 10 #include <stdint.h> |
(...skipping 706 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
717 static void Write(base::Pickle* m, const param_type& p) {} | 717 static void Write(base::Pickle* m, const param_type& p) {} |
718 static bool Read(const base::Pickle* m, | 718 static bool Read(const base::Pickle* m, |
719 base::PickleIterator* iter, | 719 base::PickleIterator* iter, |
720 param_type* r) { | 720 param_type* r) { |
721 return true; | 721 return true; |
722 } | 722 } |
723 static void Log(const param_type& p, std::string* l) { | 723 static void Log(const param_type& p, std::string* l) { |
724 } | 724 } |
725 }; | 725 }; |
726 | 726 |
727 template <class A> | 727 template <typename T, int index, int count> |
728 struct ParamTraits<std::tuple<A>> { | 728 struct TupleParamTraitsHelper { |
729 typedef std::tuple<A> param_type; | 729 using Next = TupleParamTraitsHelper<T, index + 1, count>; |
| 730 |
| 731 static void GetSize(base::PickleSizer* sizer, const T& p) { |
| 732 GetParamSize(sizer, std::get<index>(p)); |
| 733 Next::GetSize(sizer, p); |
| 734 } |
| 735 |
| 736 static void Write(base::Pickle* m, const T& p) { |
| 737 WriteParam(m, std::get<index>(p)); |
| 738 Next::Write(m, p); |
| 739 } |
| 740 |
| 741 static bool Read(const base::Pickle* m, base::PickleIterator* iter, T* r) { |
| 742 return ReadParam(m, iter, &std::get<index>(*r)) && Next::Read(m, iter, r); |
| 743 } |
| 744 |
| 745 static void Log(const T& p, std::string* l) { |
| 746 LogParam(std::get<index>(p), l); |
| 747 if (index < count - 1) |
| 748 l->append(", "); |
| 749 Next::Log(p, l); |
| 750 } |
| 751 }; |
| 752 |
| 753 template <typename T, int index> |
| 754 struct TupleParamTraitsHelper<T, index, index> { |
| 755 static void GetSize(base::PickleSizer* sizer, const T& p) {} |
| 756 static void Write(base::Pickle* m, const T& p) {} |
| 757 static bool Read(const base::Pickle* m, base::PickleIterator* iter, T* r) { |
| 758 return true; |
| 759 } |
| 760 static void Log(const T& p, std::string* l) {} |
| 761 }; |
| 762 |
| 763 template <typename... Args> |
| 764 struct ParamTraits<std::tuple<Args...>> { |
| 765 using param_type = std::tuple<Args...>; |
| 766 using Helper = |
| 767 TupleParamTraitsHelper<param_type, 0, std::tuple_size<param_type>::value>; |
| 768 |
730 static void GetSize(base::PickleSizer* sizer, const param_type& p) { | 769 static void GetSize(base::PickleSizer* sizer, const param_type& p) { |
731 GetParamSize(sizer, std::get<0>(p)); | 770 Helper::GetSize(sizer, p); |
732 } | 771 } |
| 772 |
733 static void Write(base::Pickle* m, const param_type& p) { | 773 static void Write(base::Pickle* m, const param_type& p) { |
734 WriteParam(m, std::get<0>(p)); | 774 Helper::Write(m, p); |
735 } | 775 } |
| 776 |
736 static bool Read(const base::Pickle* m, | 777 static bool Read(const base::Pickle* m, |
737 base::PickleIterator* iter, | 778 base::PickleIterator* iter, |
738 param_type* r) { | 779 param_type* r) { |
739 return ReadParam(m, iter, &std::get<0>(*r)); | 780 return Helper::Read(m, iter, r); |
740 } | 781 } |
741 static void Log(const param_type& p, std::string* l) { | |
742 LogParam(std::get<0>(p), l); | |
743 } | |
744 }; | |
745 | 782 |
746 template <class A, class B> | 783 static void Log(const param_type& p, std::string* l) { Helper::Log(p, l); } |
747 struct ParamTraits<std::tuple<A, B>> { | |
748 typedef std::tuple<A, B> param_type; | |
749 static void GetSize(base::PickleSizer* sizer, const param_type& p) { | |
750 GetParamSize(sizer, std::get<0>(p)); | |
751 GetParamSize(sizer, std::get<1>(p)); | |
752 } | |
753 static void Write(base::Pickle* m, const param_type& p) { | |
754 WriteParam(m, std::get<0>(p)); | |
755 WriteParam(m, std::get<1>(p)); | |
756 } | |
757 static bool Read(const base::Pickle* m, | |
758 base::PickleIterator* iter, | |
759 param_type* r) { | |
760 return (ReadParam(m, iter, &std::get<0>(*r)) && | |
761 ReadParam(m, iter, &std::get<1>(*r))); | |
762 } | |
763 static void Log(const param_type& p, std::string* l) { | |
764 LogParam(std::get<0>(p), l); | |
765 l->append(", "); | |
766 LogParam(std::get<1>(p), l); | |
767 } | |
768 }; | |
769 | |
770 template <class A, class B, class C> | |
771 struct ParamTraits<std::tuple<A, B, C>> { | |
772 typedef std::tuple<A, B, C> param_type; | |
773 static void GetSize(base::PickleSizer* sizer, const param_type& p) { | |
774 GetParamSize(sizer, std::get<0>(p)); | |
775 GetParamSize(sizer, std::get<1>(p)); | |
776 GetParamSize(sizer, std::get<2>(p)); | |
777 } | |
778 static void Write(base::Pickle* m, const param_type& p) { | |
779 WriteParam(m, std::get<0>(p)); | |
780 WriteParam(m, std::get<1>(p)); | |
781 WriteParam(m, std::get<2>(p)); | |
782 } | |
783 static bool Read(const base::Pickle* m, | |
784 base::PickleIterator* iter, | |
785 param_type* r) { | |
786 return (ReadParam(m, iter, &std::get<0>(*r)) && | |
787 ReadParam(m, iter, &std::get<1>(*r)) && | |
788 ReadParam(m, iter, &std::get<2>(*r))); | |
789 } | |
790 static void Log(const param_type& p, std::string* l) { | |
791 LogParam(std::get<0>(p), l); | |
792 l->append(", "); | |
793 LogParam(std::get<1>(p), l); | |
794 l->append(", "); | |
795 LogParam(std::get<2>(p), l); | |
796 } | |
797 }; | |
798 | |
799 template <class A, class B, class C, class D> | |
800 struct ParamTraits<std::tuple<A, B, C, D>> { | |
801 typedef std::tuple<A, B, C, D> param_type; | |
802 static void GetSize(base::PickleSizer* sizer, const param_type& p) { | |
803 GetParamSize(sizer, std::get<0>(p)); | |
804 GetParamSize(sizer, std::get<1>(p)); | |
805 GetParamSize(sizer, std::get<2>(p)); | |
806 GetParamSize(sizer, std::get<3>(p)); | |
807 } | |
808 static void Write(base::Pickle* m, const param_type& p) { | |
809 WriteParam(m, std::get<0>(p)); | |
810 WriteParam(m, std::get<1>(p)); | |
811 WriteParam(m, std::get<2>(p)); | |
812 WriteParam(m, std::get<3>(p)); | |
813 } | |
814 static bool Read(const base::Pickle* m, | |
815 base::PickleIterator* iter, | |
816 param_type* r) { | |
817 return (ReadParam(m, iter, &std::get<0>(*r)) && | |
818 ReadParam(m, iter, &std::get<1>(*r)) && | |
819 ReadParam(m, iter, &std::get<2>(*r)) && | |
820 ReadParam(m, iter, &std::get<3>(*r))); | |
821 } | |
822 static void Log(const param_type& p, std::string* l) { | |
823 LogParam(std::get<0>(p), l); | |
824 l->append(", "); | |
825 LogParam(std::get<1>(p), l); | |
826 l->append(", "); | |
827 LogParam(std::get<2>(p), l); | |
828 l->append(", "); | |
829 LogParam(std::get<3>(p), l); | |
830 } | |
831 }; | |
832 | |
833 template <class A, class B, class C, class D, class E> | |
834 struct ParamTraits<std::tuple<A, B, C, D, E>> { | |
835 typedef std::tuple<A, B, C, D, E> param_type; | |
836 static void GetSize(base::PickleSizer* sizer, const param_type& p) { | |
837 GetParamSize(sizer, std::get<0>(p)); | |
838 GetParamSize(sizer, std::get<1>(p)); | |
839 GetParamSize(sizer, std::get<2>(p)); | |
840 GetParamSize(sizer, std::get<3>(p)); | |
841 GetParamSize(sizer, std::get<4>(p)); | |
842 } | |
843 static void Write(base::Pickle* m, const param_type& p) { | |
844 WriteParam(m, std::get<0>(p)); | |
845 WriteParam(m, std::get<1>(p)); | |
846 WriteParam(m, std::get<2>(p)); | |
847 WriteParam(m, std::get<3>(p)); | |
848 WriteParam(m, std::get<4>(p)); | |
849 } | |
850 static bool Read(const base::Pickle* m, | |
851 base::PickleIterator* iter, | |
852 param_type* r) { | |
853 return (ReadParam(m, iter, &std::get<0>(*r)) && | |
854 ReadParam(m, iter, &std::get<1>(*r)) && | |
855 ReadParam(m, iter, &std::get<2>(*r)) && | |
856 ReadParam(m, iter, &std::get<3>(*r)) && | |
857 ReadParam(m, iter, &std::get<4>(*r))); | |
858 } | |
859 static void Log(const param_type& p, std::string* l) { | |
860 LogParam(std::get<0>(p), l); | |
861 l->append(", "); | |
862 LogParam(std::get<1>(p), l); | |
863 l->append(", "); | |
864 LogParam(std::get<2>(p), l); | |
865 l->append(", "); | |
866 LogParam(std::get<3>(p), l); | |
867 l->append(", "); | |
868 LogParam(std::get<4>(p), l); | |
869 } | |
870 }; | 784 }; |
871 | 785 |
872 template <class P, size_t stack_capacity> | 786 template <class P, size_t stack_capacity> |
873 struct ParamTraits<base::StackVector<P, stack_capacity> > { | 787 struct ParamTraits<base::StackVector<P, stack_capacity> > { |
874 typedef base::StackVector<P, stack_capacity> param_type; | 788 typedef base::StackVector<P, stack_capacity> param_type; |
875 static void GetSize(base::PickleSizer* sizer, const param_type& p) { | 789 static void GetSize(base::PickleSizer* sizer, const param_type& p) { |
876 GetParamSize(sizer, static_cast<int>(p->size())); | 790 GetParamSize(sizer, static_cast<int>(p->size())); |
877 for (size_t i = 0; i < p->size(); i++) | 791 for (size_t i = 0; i < p->size(); i++) |
878 GetParamSize(sizer, p[i]); | 792 GetParamSize(sizer, p[i]); |
879 } | 793 } |
(...skipping 316 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1196 template <class ReplyParamType> | 1110 template <class ReplyParamType> |
1197 inline void LogReplyParamsToMessage(const ReplyParamType& reply_params, | 1111 inline void LogReplyParamsToMessage(const ReplyParamType& reply_params, |
1198 const Message* msg) {} | 1112 const Message* msg) {} |
1199 | 1113 |
1200 inline void ConnectMessageAndReply(const Message* msg, Message* reply) {} | 1114 inline void ConnectMessageAndReply(const Message* msg, Message* reply) {} |
1201 #endif | 1115 #endif |
1202 | 1116 |
1203 } // namespace IPC | 1117 } // namespace IPC |
1204 | 1118 |
1205 #endif // IPC_IPC_MESSAGE_UTILS_H_ | 1119 #endif // IPC_IPC_MESSAGE_UTILS_H_ |
OLD | NEW |