← Back to branch summary

~malept/pyexiv2/0.2-build-mt

« back to all changes in this revision

Viewing changes to src/exiv2wrapper.cpp

  • Committer: Olivier Tilloy
  • Date: 2010-01-21 19:13:48 UTC
  • mfrom: (257.1.4 update_error_codes)
  • Revision ID: olivier@tilloy.net-20100121191348-yf0m7g0abb2hqnf5
Updated error codes translation.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/exiv2wrapper.cpp
33
33
#define METADATA_NOT_READ 101
34
34
#define NON_REPEATABLE 102
35
35
#define KEY_NOT_FOUND 103
36
 
#define THUMB_ACCESS 104
37
 
#define NO_THUMBNAIL 105
38
36
 
39
37
// Custom macros
40
38
#define CHECK_METADATA_READ \
732
730
}
733
731
 
734
732
 
735
 
// TODO: update the errors code to reflect changes from src/error.cpp in libexiv2
736
733
void translateExiv2Error(Exiv2::Error const& error)
737
734
{
738
735
    // Use the Python 'C' API to set up an exception object
739
 
 
740
 
    // Building a C++ string first allows this code to compile with all
741
 
    // versions of libexiv2 (< 0.13 and >= 0.13), because the way exceptions
742
 
    // are handled in libexiv2 was changed in 0.13.
743
 
    const std::string sMessage(error.what());
744
 
    const char* message = sMessage.c_str();
 
736
    const char* message = error.what();
745
737
 
746
738
    // The type of the Python exception depends on the error code
747
739
    // Warning: this piece of code should be updated in case the error codes
748
740
    // defined by Exiv2 (file 'src/error.cpp') are changed
749
741
    switch (error.code())
750
742
    {
751
 
        case -2:
752
 
        case -1:
753
 
        case 1:
 
743
        // Exiv2 error codes
754
744
        case 2:
 
745
            // {path}: Call to `{function}' failed: {strerror}
 
746
            // May be raised when reading a file
755
747
            PyErr_SetString(PyExc_RuntimeError, message);
756
748
            break;
757
749
        case 3:
 
750
            // This does not look like a {image type} image
 
751
            // May be raised by readMetadata()
 
752
            PyErr_SetString(PyExc_IOError, message);
 
753
            break;
 
754
        case 4:
 
755
            // Invalid dataset name `{dataset name}'
 
756
            // May be raised when instantiating an IptcKey from a string
 
757
            PyErr_SetString(PyExc_KeyError, message);
 
758
            break;
 
759
        case 5:
 
760
            // Invalid record name `{record name}'
 
761
            // May be raised when instantiating an IptcKey from a string
 
762
            PyErr_SetString(PyExc_KeyError, message);
 
763
            break;
 
764
        case 6:
 
765
            // Invalid key `{key}'
 
766
            // May be raised when instantiating an ExifKey, an IptcKey or an
 
767
            // XmpKey from a string
 
768
            PyErr_SetString(PyExc_KeyError, message);
 
769
            break;
 
770
        case 7:
 
771
            // Invalid tag name or ifdId `{tag name}', ifdId {ifdId}
 
772
            // May be raised when instantiating an ExifKey from a string
 
773
            PyErr_SetString(PyExc_KeyError, message);
 
774
            break;
 
775
        case 8:
 
776
            // Value not set
 
777
            // May be raised when calling value() on a datum
 
778
            PyErr_SetString(PyExc_ValueError, message);
 
779
            break;
758
780
        case 9:
 
781
            // {path}: Failed to open the data source: {strerror}
 
782
            // May be raised by readMetadata()
 
783
            PyErr_SetString(PyExc_IOError, message);
 
784
            break;
759
785
        case 10:
 
786
            // {path}: Failed to open file ({mode}): {strerror}
 
787
            // May be raised by writeMetadata()
 
788
            PyErr_SetString(PyExc_IOError, message);
 
789
            break;
760
790
        case 11:
 
791
            // {path}: The file contains data of an unknown image type
 
792
            // May be raised when opening an image
 
793
            PyErr_SetString(PyExc_IOError, message);
 
794
            break;
761
795
        case 12:
 
796
            // The memory contains data of an unknown image type
 
797
            // May be raised when instantiating an image from a data buffer
 
798
            PyErr_SetString(PyExc_IOError, message);
 
799
            break;
762
800
        case 13:
 
801
            // Image type {image type} is not supported
 
802
            // May be raised when creating a new image
 
803
            PyErr_SetString(PyExc_IOError, message);
 
804
            break;
763
805
        case 14:
 
806
            // Failed to read image data
 
807
            // May be raised by readMetadata()
 
808
            PyErr_SetString(PyExc_IOError, message);
 
809
            break;
764
810
        case 15:
 
811
            // This does not look like a JPEG image
 
812
            // May be raised by readMetadata()
 
813
            PyErr_SetString(PyExc_IOError, message);
 
814
            break;
765
815
        case 17:
 
816
            // {old path}: Failed to rename file to {new path}: {strerror}
 
817
            // May be raised by writeMetadata()
 
818
            PyErr_SetString(PyExc_IOError, message);
 
819
            break;
766
820
        case 18:
 
821
            // {path}: Transfer failed: {strerror}
 
822
            // May be raised by writeMetadata()
 
823
            PyErr_SetString(PyExc_IOError, message);
 
824
            break;
 
825
        case 19:
 
826
            // Memory transfer failed: {strerror}
 
827
            // May be raised by writeMetadata()
 
828
            PyErr_SetString(PyExc_IOError, message);
 
829
            break;
767
830
        case 20:
 
831
            // Failed to read input data
 
832
            // May be raised by writeMetadata()
 
833
            PyErr_SetString(PyExc_IOError, message);
 
834
            break;
768
835
        case 21:
 
836
            // Failed to write image
 
837
            // May be raised by writeMetadata()
 
838
            PyErr_SetString(PyExc_IOError, message);
 
839
            break;
 
840
        case 22:
 
841
            // Input data does not contain a valid image
 
842
            // May be raised by writeMetadata()
 
843
            PyErr_SetString(PyExc_IOError, message);
 
844
            break;
769
845
        case 23:
770
 
        case 31:
771
 
        case 32:
772
 
        case 33:
773
 
        case 36:
774
 
        case 37:
775
 
            PyErr_SetString(PyExc_IOError, message);
776
 
            break;
777
 
        case 4:
778
 
        case 5:
779
 
        case 6:
780
 
        case 7:
781
 
            PyErr_SetString(PyExc_IndexError, message);
782
 
            break;
783
 
        case 8:
784
 
        case 22:
785
 
        case 24:
786
 
        case 25:
 
846
            // Invalid ifdId {ifdId}
 
847
            // May be raised when instantiating an ExifKey from a tag and
 
848
            // IFD item string
 
849
            PyErr_SetString(PyExc_KeyError, message);
 
850
            break;
787
851
        case 26:
 
852
            // Offset out of range
 
853
            // May be raised by writeMetadata() (TIFF)
 
854
            PyErr_SetString(PyExc_IOError, message);
 
855
            break;
788
856
        case 27:
 
857
            // Unsupported data area offset type
 
858
            // May be raised by writeMetadata() (TIFF)
 
859
            PyErr_SetString(PyExc_IOError, message);
 
860
            break;
789
861
        case 28:
 
862
            // Invalid charset: `{charset name}'
 
863
            // May be raised when instantiating a CommentValue from a string
 
864
            PyErr_SetString(PyExc_ValueError, message);
 
865
            break;
790
866
        case 29:
 
867
            // Unsupported date format
 
868
            // May be raised when instantiating a DateValue from a string
 
869
            PyErr_SetString(PyExc_ValueError, message);
 
870
            break;
791
871
        case 30:
792
 
        case 34:
793
 
            PyErr_SetString(PyExc_ValueError, message);
794
 
            break;
795
 
        case 16:
796
 
        case 19:
 
872
            // Unsupported time format
 
873
            // May be raised when instantiating a TimeValue from a string
 
874
            PyErr_SetString(PyExc_ValueError, message);
 
875
            break;
 
876
        case 31:
 
877
            // Writing to {image format} images is not supported
 
878
            // May be raised by writeMetadata() for certain image types
 
879
            PyErr_SetString(PyExc_IOError, message);
 
880
            break;
 
881
        case 32:
 
882
            // Setting {metadata type} in {image format} images is not supported
 
883
            // May be raised when setting certain types of metadata for certain
 
884
            // image types that don't support them
 
885
            PyErr_SetString(PyExc_ValueError, message);
 
886
            break;
 
887
        case 33:
 
888
            // This does not look like a CRW image
 
889
            // May be raised by readMetadata() (CRW)
 
890
            PyErr_SetString(PyExc_IOError, message);
 
891
            break;
797
892
        case 35:
798
 
            PyErr_SetString(PyExc_MemoryError, message);
 
893
            // No namespace info available for XMP prefix `{prefix}'
 
894
            // May be raised when retrieving property info for an XmpKey
 
895
            PyErr_SetString(PyExc_KeyError, message);
 
896
            break;
 
897
        case 36:
 
898
            // No prefix registered for namespace `{namespace}', needed for
 
899
            // property path `{property path}'
 
900
            // May be raised by readMetadata() when reading the XMP data
 
901
            PyErr_SetString(PyExc_KeyError, message);
 
902
            break;
 
903
        case 37:
 
904
            // Size of {type of metadata} JPEG segment is larger than
 
905
            // 65535 bytes
 
906
            // May be raised by writeMetadata() (JPEG)
 
907
            PyErr_SetString(PyExc_ValueError, message);
 
908
            break;
 
909
        case 38:
 
910
            // Unhandled Xmpdatum {key} of type {value type}
 
911
            // May be raised by readMetadata() when reading the XMP data
 
912
            PyErr_SetString(PyExc_TypeError, message);
 
913
            break;
 
914
        case 39:
 
915
            // Unhandled XMP node {key} with opt={XMP Toolkit option flags}
 
916
            // May be raised by readMetadata() when reading the XMP data
 
917
            PyErr_SetString(PyExc_TypeError, message);
 
918
            break;
 
919
        case 40:
 
920
            // XMP Toolkit error {error id}: {error message}
 
921
            // May be raised by readMetadata() when reading the XMP data
 
922
            PyErr_SetString(PyExc_RuntimeError, message);
 
923
            break;
 
924
        case 41:
 
925
            // Failed to decode Lang Alt property {property path}
 
926
            // with opt={XMP Toolkit option flags}
 
927
            // May be raised by readMetadata() when reading the XMP data
 
928
            PyErr_SetString(PyExc_ValueError, message);
 
929
            break;
 
930
        case 42:
 
931
            // Failed to decode Lang Alt qualifier {qualifier path}
 
932
            // with opt={XMP Toolkit option flags}
 
933
            // May be raised by readMetadata() when reading the XMP data
 
934
            PyErr_SetString(PyExc_ValueError, message);
 
935
            break;
 
936
        case 43:
 
937
            // Failed to encode Lang Alt property {key}
 
938
            // May be raised by writeMetadata()
 
939
            PyErr_SetString(PyExc_ValueError, message);
 
940
            break;
 
941
        case 44:
 
942
            // Failed to determine property name from path {property path},
 
943
            // namespace {namespace}
 
944
            // May be raised by readMetadata() when reading the XMP data
 
945
            PyErr_SetString(PyExc_KeyError, message);
 
946
            break;
 
947
        case 45:
 
948
            // Schema namespace {namespace} is not registered with
 
949
            // the XMP Toolkit
 
950
            // May be raised by readMetadata() when reading the XMP data
 
951
            PyErr_SetString(PyExc_ValueError, message);
 
952
            break;
 
953
        case 46:
 
954
            // No namespace registered for prefix `{prefix}'
 
955
            // May be raised when instantiating an XmpKey from a string
 
956
            PyErr_SetString(PyExc_KeyError, message);
 
957
            break;
 
958
        case 47:
 
959
            // Aliases are not supported. Please send this XMP packet
 
960
            // to ahuggel@gmx.net `{namespace}', `{property path}', `{value}'
 
961
            // May be raised by readMetadata() when reading the XMP data
 
962
            PyErr_SetString(PyExc_ValueError, message);
 
963
            break;
 
964
        case 48:
 
965
            // Invalid XmpText type `{type}'
 
966
            // May be raised when instantiating an XmpTextValue from a string
 
967
            PyErr_SetString(PyExc_TypeError, message);
 
968
            break;
 
969
        case 49:
 
970
            // TIFF directory {TIFF directory name} has too many entries
 
971
            // May be raised by writeMetadata() (TIFF)
 
972
            PyErr_SetString(PyExc_IOError, message);
799
973
            break;
800
974
 
801
 
        // custom error codes
 
975
        // Custom error codes
802
976
        case METADATA_NOT_READ:
803
977
            PyErr_SetString(PyExc_IOError, "Image metadata has not been read yet");
804
978
            break;
808
982
        case KEY_NOT_FOUND:
809
983
            PyErr_SetString(PyExc_KeyError, "Tag not set");
810
984
            break;
811
 
        case THUMB_ACCESS:
812
 
            PyErr_SetString(PyExc_IOError, "Cannot access image thumbnail");
813
 
            break;
814
 
        case NO_THUMBNAIL:
815
 
            PyErr_SetString(PyExc_IOError, "The EXIF data does not contain a thumbnail");
816
 
            break;
817
985
 
 
986
        // Default handler
818
987
        default:
819
988
            PyErr_SetString(PyExc_RuntimeError, message);
820
989
    }